1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
|
require 'pathname'
if defined?(Gem::QuickLoader)
# Gem Prelude makes me a sad panda :'(
Gem::QuickLoader.load_full_rubygems_library
end
require 'rubygems'
require 'rubygems/specification'
module Gem
@loaded_stacks = Hash.new { |h,k| h[k] = [] }
class Specification
attr_accessor :source, :location, :relative_loaded_from
alias_method :rg_full_gem_path, :full_gem_path
alias_method :rg_loaded_from, :loaded_from
def full_gem_path
source.respond_to?(:path) ?
Pathname.new(loaded_from).dirname.expand_path.to_s :
rg_full_gem_path
end
def loaded_from
relative_loaded_from ?
source.path.join(relative_loaded_from).to_s :
rg_loaded_from
end
def load_paths
require_paths.map do |require_path|
if require_path.include?(full_gem_path)
require_path
else
File.join(full_gem_path, require_path)
end
end
end
def groups
@groups ||= []
end
def git_version
if @loaded_from && File.exist?(File.join(full_gem_path, ".git"))
sha = Dir.chdir(full_gem_path){ `git rev-parse HEAD`.strip }
" #{sha[0..6]}"
end
end
def to_gemfile(path = nil)
gemfile = "source :gemcutter\n"
gemfile << dependencies_to_gemfile(nondevelopment_dependencies)
unless development_dependencies.empty?
gemfile << "\n"
gemfile << dependencies_to_gemfile(development_dependencies, :development)
end
gemfile
end
def nondevelopment_dependencies
dependencies - development_dependencies
end
def add_bundler_dependencies(*groups)
Bundler.ui.warn "#add_bundler_dependencies is deprecated and will " \
"be removed in Bundler 1.0. Instead, please use the #gemspec method " \
"in your Gemfile, which will pull in any dependencies specified in " \
"your gemspec"
groups = [:default] if groups.empty?
Bundler.definition.dependencies.each do |dep|
if dep.groups.include?(:development)
self.add_development_dependency(dep.name, dep.requirement.to_s)
elsif (dep.groups & groups).any?
self.add_dependency(dep.name, dep.requirement.to_s)
end
end
end
private
def dependencies_to_gemfile(dependencies, group = nil)
gemfile = ''
if dependencies.any?
gemfile << "group :#{group} do\n" if group
dependencies.each do |dependency|
gemfile << ' ' if group
gemfile << %|gem "#{dependency.name}"|
req = dependency.requirements_list.first
gemfile << %|, "#{req}"| if req
gemfile << "\n"
end
gemfile << "end\n" if group
end
gemfile
end
end
class Dependency
attr_accessor :source, :groups
alias eql? ==
def encode_with(coder)
to_yaml_properties.each do |ivar|
coder[ivar.to_s.sub(/^@/, '')] = instance_variable_get(ivar)
end
end
def to_yaml_properties
instance_variables.reject { |p| ["@source", "@groups"].include?(p.to_s) }
end
def to_lock
out = " #{name}"
unless requirement == Gem::Requirement.default
out << " (#{requirement.to_s})"
end
out
end
def matches_spec?(spec)
# name can be a Regexp, so use ===
return false unless name === spec.name
return true if requirement.none?
requirement.satisfied_by?(spec.version)
end unless allocate.respond_to?(:matches_spec?)
end
class Requirement
def none?
@none ||= (to_s == ">= 0")
end unless allocate.respond_to?(:none?)
end
class Platform
JAVA = Gem::Platform.new('java')
MSWIN = Gem::Platform.new('mswin32')
MINGW = Gem::Platform.new('x86-mingw32')
def hash
@cpu.hash ^ @os.hash ^ @version.hash
end
alias eql? ==
end
end
module Bundler
class DepProxy
attr_reader :required_by, :__platform, :dep
def initialize(dep, platform)
@dep, @__platform, @required_by = dep, platform, []
end
def hash
@hash ||= dep.hash
end
def ==(o)
dep == o.dep && __platform == o.__platform
end
alias eql? ==
def type
@dep.type
end
def to_s
@dep.to_s
end
private
def method_missing(*args)
@dep.send(*args)
end
end
module GemHelpers
GENERIC_CACHE = {}
GENERICS = [
Gem::Platform::JAVA,
Gem::Platform::MSWIN,
Gem::Platform::MINGW,
Gem::Platform::RUBY
]
def generic(p)
return p if p == Gem::Platform::RUBY
GENERIC_CACHE[p] ||= begin
found = GENERICS.find do |p2|
p2.is_a?(Gem::Platform) && p.os == p2.os
end
found || Gem::Platform::RUBY
end
end
end
module MatchPlatform
include GemHelpers
def match_platform(p)
Gem::Platform::RUBY == platform or
platform.nil? or p == platform or
generic(Gem::Platform.new(platform)) == p
end
end
end
module Gem
class Specification
include Bundler::MatchPlatform
end
end
|
