lock_jar 0.6.2 → 0.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -17,16 +17,22 @@ require 'rubygems'
17
17
  require "yaml"
18
18
  require 'singleton'
19
19
  require 'lock_jar/resolver'
20
- require 'lock_jar/dsl'
21
20
  require 'lock_jar/runtime'
22
21
  require 'lock_jar/registry'
22
+ require 'lock_jar/domain/dsl'
23
+ require 'lock_jar/domain/lockfile'
23
24
 
24
25
  module LockJar
26
+
25
27
  class Runtime
26
28
  include Singleton
27
29
 
28
30
  attr_reader :current_resolver
29
31
 
32
+ def initialize
33
+ @current_resolver = nil
34
+ end
35
+
30
36
  def resolver( opts = {} )
31
37
 
32
38
  # XXX: Caches the resolver by the options. Passing in nil opts will replay
@@ -51,11 +57,11 @@ module LockJar
51
57
  @current_resolver
52
58
  end
53
59
 
54
- def install( jarfile_lock, scopes = ['compile', 'runtime'], opts = {}, &blk )
55
- deps = list( jarfile_lock, scopes, opts, &blk )
60
+ def install( jarfile_lock, groups = ['default'], opts = {}, &blk )
61
+ deps = list( jarfile_lock, groups, opts, &blk )
56
62
 
57
- lock_data = read_lockfile( jarfile_lock )
58
- lock_data['repositories'].each do |repo|
63
+ lockfile = LockJar::Domain::Lockfile.read( jarfile_lock )
64
+ lockfile.remote_repositories.each do |repo|
59
65
  resolver(opts).add_remote_repository( repo )
60
66
  end
61
67
 
@@ -64,205 +70,264 @@ module LockJar
64
70
  files
65
71
  end
66
72
 
67
- def lock( jarfile, opts = {}, &blk )
73
+ def lock( jarfile_or_dsl, opts = {}, &blk )
68
74
 
69
- opts = {:download => true }.merge( opts )
75
+ opts = {:download => true }.merge( opts )
76
+
77
+ jarfile = nil
70
78
 
71
- lock_jar_file = nil
72
-
73
- if jarfile
74
- if jarfile.is_a? LockJar::Dsl
75
- lock_jar_file = jarfile
76
- else
77
- lock_jar_file = LockJar::Dsl.evaluate( jarfile )
78
- end
79
+ if jarfile_or_dsl
80
+ if jarfile_or_dsl.is_a? LockJar::Domain::Dsl
81
+ jarfile = jarfile_or_dsl
82
+ else
83
+ jarfile = LockJar::Domain::Dsl.create( jarfile_or_dsl )
79
84
  end
80
-
81
- unless blk.nil?
82
- dsl = LockJar::Dsl.evaluate(&blk)
83
- if lock_jar_file.nil?
84
- lock_jar_file = dsl
85
- else
86
- lock_jar_file.merge( dsl )
87
- end
85
+ end
86
+
87
+ unless blk.nil?
88
+ dsl = LockJar::Domain::Dsl.create(&blk)
89
+ if jarfile.nil?
90
+ jarfile = dsl
91
+ else
92
+ jarfile.merge( dsl )
88
93
  end
94
+ end
89
95
 
90
-
91
- # If not set in opts, and is set in dsl
92
- if opts[:local_repo].nil? && lock_jar_file.local_repository
93
- opts[:local_repo] = lock_jar_file.local_repository
94
- end
95
-
96
- lock_jar_file.repositories.each do |repo|
97
- resolver(opts).add_remote_repository( repo )
98
- end
99
-
100
- lock_data = { }
96
+
97
+ # If not set in opts, and is set in dsl
98
+ if opts[:local_repo].nil? && jarfile.local_repository
99
+ opts[:local_repo] = jarfile.local_repository
100
+ end
101
+
102
+ lockfile = LockJar::Domain::Lockfile.new
103
+
104
+ jarfile.remote_repositories.each do |repo|
105
+ resolver(opts).add_remote_repository( repo )
106
+ end
101
107
 
102
- unless lock_jar_file.local_repository.nil?
103
- lock_data['local_repository'] = lock_jar_file.local_repository
104
-
105
- if needs_force_encoding
106
- lock_data['local_repository'] = lock_data['local_repository'].force_encoding("UTF-8")
107
- end
108
- end
109
-
110
- if lock_jar_file.maps.size > 0
111
- lock_data['maps'] = lock_jar_file.maps
108
+ unless jarfile.local_repository.nil?
109
+ lockfile.local_repository = jarfile.local_repository
110
+ end
111
+
112
+ if jarfile.maps.size > 0
113
+ lockfile.maps = jarfile.maps
114
+ end
115
+
116
+ if jarfile.excludes.size > 0
117
+ lockfile.excludes = jarfile.excludes
118
+ end
119
+
120
+ artifacts = []
121
+ jarfile.artifacts.each do |group, group_artifacts|
122
+ group_artifacts.each do |artifact|
123
+ artifacts += group_artifacts
112
124
  end
125
+ end
126
+
127
+ if !jarfile.merged.empty?
128
+ lockfile.merged = jarfile.merged
129
+ end
130
+
131
+ if !artifacts.empty?
132
+ resolved_notations = resolver(opts).resolve( artifacts.map(&:to_dep), opts[:download] == true )
113
133
 
114
- if lock_jar_file.excludes.size > 0
115
- lock_data['excludes'] = lock_jar_file.excludes
116
-
117
- if needs_force_encoding
118
- lock_data['excludes'].map! { |exclude| exclude.force_encoding("UTF-8") }
119
- end
120
- end
134
+ lockfile.remote_repositories = resolver(opts).remote_repositories - ['http://repo1.maven.org/maven2/']
121
135
 
122
- lock_data['scopes'] = {}
123
-
124
- lock_jar_file.notations.each do |scope, notations|
136
+ jarfile.artifacts.each do |group_name, group_artifacts|
137
+ group = {'dependencies' => [], 'artifacts' => []}
125
138
 
126
- if needs_force_encoding
127
- notations.map! { |notation| notation.force_encoding("UTF-8") }
128
- end
139
+ group_artifacts.each do |artifact|
129
140
 
130
- dependencies = []
131
- notations.each do |notation|
132
- dependencies << {notation => scope}
133
- end
134
-
135
- if dependencies.size > 0
136
- resolved_notations = resolver(opts).resolve( dependencies, opts[:download] == true )
137
-
138
- lock_data['repositories'] = resolver(opts).remote_repositories.uniq
139
- if needs_force_encoding
140
- lock_data['repositories'].map! { |repo| repo.force_encoding("UTF-8") }
141
- end
141
+ artifact_data = {}
142
142
 
143
- if lock_data['excludes']
144
- lock_data['excludes'].each do |exclude|
145
- resolved_notations.delete_if { |dep| dep =~ /#{exclude}/ }
143
+ if artifact.is_a? LockJar::Domain::Jar
144
+ group['dependencies'] << artifact.notation
145
+ artifact_data["transitive"] = resolver(opts).dependencies_graph[artifact.notation].to_hash
146
+
147
+ elsif artifact.is_a? LockJar::Domain::Pom
148
+ artifact_data['scopes'] = artifact.scopes
149
+
150
+ # iterate each dependency in Pom to map transitive dependencies
151
+ transitive = {}
152
+ artifact.notations.each do |notation|
153
+ transitive.merge!( notation => resolver(opts).dependencies_graph[notation] )
146
154
  end
155
+ artifact_data["transitive"] = transitive
156
+
157
+ elsif artifact.is_a? LockJar::Domain::Local
158
+ # xXX: support local artifacts
159
+ else
160
+ # XXX: handle unsupported artifact
161
+
147
162
  end
163
+
164
+ # flatten the graph of nested hashes
165
+ dep_merge = lambda do |graph|
166
+ deps = graph.keys
167
+ graph.values.each do |next_step|
168
+ deps += dep_merge.call(next_step)
169
+ end
170
+ deps
171
+ end
172
+
173
+ group['dependencies'] += dep_merge.call( artifact_data["transitive"] )
148
174
 
149
- lock_data['scopes'][scope] = {
150
- 'dependencies' => notations,
151
- 'resolved_dependencies' => resolved_notations }
175
+ # xxX: set required_by ?
176
+
177
+ group['artifacts'] << { artifact.to_urn => artifact_data }
152
178
  end
153
- end
154
-
155
- File.open( opts[:lockfile] || "Jarfile.lock", "w") do |f|
156
- f.write( lock_data.to_yaml )
157
- end
158
-
159
- lock_data
179
+
180
+ if lockfile.excludes
181
+ lockfile.excludes.each do |exclude|
182
+ group['dependencies'].delete_if { |dep| dep =~ /#{exclude}/ }
183
+ end
184
+ end
185
+
186
+ group['dependencies'].sort!
187
+
188
+ lockfile.groups[group_name] = group
189
+ end
160
190
  end
161
-
162
- def list( jarfile_lock, scopes = ['compile', 'runtime'], opts = {}, &blk )
163
- dependencies = []
164
- maps = []
165
-
166
- if jarfile_lock
167
- lockfile = read_lockfile( jarfile_lock)
168
- dependencies += lockfile_dependencies( lockfile, scopes )
169
- maps = lockfile['maps']
191
+
192
+
193
+ lockfile.write( opts[:lockfile] || "Jarfile.lock" )
194
+
195
+ lockfile
196
+ end
197
+
198
+ def list( lockfile_or_path, groups = ['default'], opts = {}, &blk )
199
+
200
+ lockfile = nil
201
+ dependencies = []
202
+ maps = []
203
+
204
+ if lockfile_or_path
205
+ if lockfile_or_path.is_a? LockJar::Domain::Lockfile
206
+ lockfile = lockfile_or_path
207
+ elsif lockfile_or_path
208
+ lockfile = LockJar::Domain::Lockfile.read( lockfile_or_path )
170
209
  end
171
210
 
172
- unless blk.nil?
173
- dsl = LockJar::Dsl.evaluate(&blk)
174
- dependencies += dsl_dependencies( dsl, scopes )
175
- maps = dsl.maps
176
- end
211
+ dependencies = lockfile_dependencies( lockfile, groups )
212
+ maps = lockfile.maps
213
+ end
214
+
215
+ # Support limited DSL from block
216
+ unless blk.nil?
217
+ dsl = LockJar::Domain::Dsl.create(&blk)
218
+ dependencies += dsl_dependencies( dsl, groups ).map(&:to_dep)
219
+ maps = dsl.maps
220
+ end
221
+
222
+ if maps && maps.size > 0
223
+ mapped_dependencies = []
177
224
 
178
- if maps && maps.size > 0
179
- mapped_dependencies = []
180
-
181
- maps.each do |notation, replacements|
182
- dependencies.each do |dep|
183
- if dep =~ /#{notation}/
184
- replacements.each do |replacement|
185
- mapped_dependencies << replacement
186
- end
187
- else
188
- mapped_dependencies << dep
225
+ maps.each do |notation, replacements|
226
+ dependencies.each do |dep|
227
+ if dep =~ /#{notation}/
228
+ replacements.each do |replacement|
229
+ mapped_dependencies << replacement
189
230
  end
231
+ else
232
+ mapped_dependencies << dep
190
233
  end
191
234
  end
192
-
193
- dependencies = mapped_dependencies
194
- end
195
-
196
- if opts[:resolve]
197
- dependencies = resolver(opts).resolve( dependencies )
198
235
  end
236
+
237
+ dependencies = mapped_dependencies
238
+ end
239
+
240
+ if opts[:resolve]
241
+ dependencies = resolver(opts).resolve( dependencies )
242
+ end
243
+
244
+ if opts[:local_paths]
245
+ opts.delete( :local_paths ) # remove list opts so resolver is not reset
246
+ resolver(opts).to_local_paths( dependencies )
199
247
 
200
- if opts[:local_paths]
201
- opts.delete( :local_paths ) # remove list opts so resolver is not reset
202
- resolver(opts).to_local_paths( dependencies.uniq )
248
+ else
249
+ dependencies
250
+ end
251
+ end
252
+
253
+ # Load paths from a lockfile or block. Paths are loaded once per lockfile.
254
+ #
255
+ # @param [String] lockfile_path the lockfile
256
+ # @param [Array] groups to load into classpath
257
+ # @param [Hash] opts
258
+ # @param [Block] blk
259
+ def load( lockfile_or_path, groups = ['default'], opts = {}, &blk )
260
+
261
+ lockfile = nil
262
+
263
+ # lockfile is only loaded once
264
+ unless lockfile_or_path.nil?
265
+ # loaded a Lockfile instance
266
+ if lockfile_or_path.is_a? LockJar::Domain::Lockfile
267
+ lockfile = lockfile_or_path
268
+
269
+ # check if lockfile path is already loaded
270
+ elsif LockJar::Registry.instance.lockfile_registered?( lockfile_or_path )
271
+ return
203
272
 
273
+ # convert lockfile path to a Lockfile instance
204
274
  else
205
- dependencies.uniq
275
+ lockfile = LockJar::Domain::Lockfile.read( lockfile_or_path )
206
276
  end
207
- end
208
277
 
209
- def load( jarfile_lock, scopes = ['compile', 'runtime'], opts = {}, &blk )
210
- if jarfile_lock
211
- lockfile = read_lockfile( jarfile_lock )
212
-
213
- if opts[:local_repo].nil? && lockfile['local_repo']
214
- opts[:local_repo] = lockfile['local_repo']
215
- end
278
+
279
+ if opts[:local_repo].nil? && lockfile.local_repository
280
+ opts[:local_repo] = lockfile.local_repository
216
281
  end
282
+ end
283
+
284
+ # set local_repo if passed in the block
285
+ unless blk.nil?
286
+ dsl = LockJar::Domain::Dsl.create(&blk)
217
287
 
218
- unless blk.nil?
219
- dsl = LockJar::Dsl.evaluate(&blk)
220
-
221
- if opts[:local_repo].nil? && dsl.local_repository
222
- opts[:local_repo] = dsl.local_repository
223
- end
288
+ # set local_repo from block
289
+ if opts[:local_repo].nil? && dsl.local_repository
290
+ opts[:local_repo] = dsl.local_repository
224
291
  end
225
-
226
- dependencies = LockJar::Registry.instance.register_jars( list( jarfile_lock, scopes, opts, &blk ) )
227
-
228
- resolver(opts).load_to_classpath( dependencies )
229
292
  end
230
293
 
231
- def read_lockfile( jarfile_lock )
232
- YAML.load_file( jarfile_lock )
294
+ # registered merged lockfiles for lockfile
295
+ if lockfile && !lockfile.merged.empty?
296
+ lockfile.merged.each do |path|
297
+ LockJar::Registry.instance.register_lockfile( path )
298
+ end
233
299
  end
234
300
 
235
- private
236
-
237
- def lockfile_dependencies( lockfile, scopes)
238
- dependencies = []
239
-
240
- scopes.each do |scope|
241
- if lockfile['scopes'][scope]
242
- dependencies += lockfile['scopes'][scope]['resolved_dependencies']
243
- end
301
+ dependencies = LockJar::Registry.instance.register_jars( list( lockfile, groups, opts, &blk ) )
302
+
303
+ resolver(opts).load_to_classpath( dependencies )
304
+ end
305
+
306
+ private
307
+
308
+ def lockfile_dependencies( lockfile, groups)
309
+ dependencies = []
310
+
311
+ groups.each do |group|
312
+ if lockfile.groups[group.to_s]
313
+ dependencies += lockfile.groups[group.to_s]['dependencies']
244
314
  end
245
-
246
- dependencies
247
315
  end
248
316
 
249
- def dsl_dependencies( dsl, scopes )
250
-
251
- dependencies = []
252
-
253
- dsl.notations.each do |scope,notations|
254
- if notations && notations.size > 0
255
- dependencies += notations
256
- end
317
+ dependencies
318
+ end
319
+
320
+ def dsl_dependencies( dsl, groups )
321
+
322
+ dependencies = []
323
+
324
+ groups.each do |group|
325
+ if dsl.artifacts[group.to_s]
326
+ dependencies += dsl.artifacts[group.to_s]
257
327
  end
258
-
259
- dependencies
260
- end
261
-
262
- private
263
- def needs_force_encoding
264
- @needs_force_encoding || @needs_force_encoding = RUBY_VERSION =~ /^1.9/
265
328
  end
329
+
330
+ dependencies
331
+ end
266
332
  end
267
-
268
- end
333
+ end
data/lib/lock_jar.rb CHANGED
@@ -16,10 +16,10 @@
16
16
  require "yaml"
17
17
  require 'rubygems'
18
18
  require 'lock_jar/resolver'
19
- require 'lock_jar/dsl'
20
19
  require 'lock_jar/runtime'
21
20
  require 'lock_jar/version'
22
- require 'lock_jar/rubygems'
21
+ require 'lock_jar/domain/lockfile'
22
+ require 'lock_jar/domain/dsl'
23
23
 
24
24
  #
25
25
  # LockJar manages Java Jars for Ruby.
@@ -38,7 +38,7 @@ module LockJar
38
38
  def self.install( *args, &blk )
39
39
  lockfile = nil
40
40
  opts = {}
41
- scopes = ['compile', 'runtime']
41
+ groups = ['default']
42
42
 
43
43
  args.each do |arg|
44
44
  if arg.is_a?(Hash)
@@ -46,7 +46,7 @@ module LockJar
46
46
  elsif arg.is_a?( String )
47
47
  lockfile = arg
48
48
  elsif arg.is_a?( Array )
49
- scopes = arg
49
+ groups = arg
50
50
  end
51
51
  end
52
52
 
@@ -55,14 +55,14 @@ module LockJar
55
55
  lockfile = 'Jarfile.lock'
56
56
  end
57
57
 
58
- Runtime.instance.install( lockfile, scopes, opts, &blk )
58
+ Runtime.instance.install( lockfile, groups, opts, &blk )
59
59
  end
60
60
 
61
61
 
62
- # Lists all dependencies as notations for scopes from the Jarfile.lock. Depending on the type of arg, a different configuration is set.
62
+ # Lists all dependencies as notations for groups from the Jarfile.lock. Depending on the type of arg, a different configuration is set.
63
63
  #
64
64
  # * An arg of a String will set the Jarfile.lock, e.g. 'Better.lock'. Default lock file is *Jarfile.lock*.
65
- # * An arg of an Array will set the scopes, e.g. ['compile','test']. Defaults scopes are *compile* and *runtime*
65
+ # * An arg of an Array will set the groups, e.g. ['development','test']. Defaults group is *default*
66
66
  # * An arg of a Hash will set the options, e.g. { :local_repo => 'path' }
67
67
  # * :local_repo [String] sets the local repo path
68
68
  # * :local_paths [Boolean] to true converts the notations to paths to jars in the local repo path
@@ -74,7 +74,7 @@ module LockJar
74
74
  def self.list( *args, &blk )
75
75
  lockfile = nil
76
76
  opts = {}
77
- scopes = ['compile', 'runtime']
77
+ groups = ['default']
78
78
 
79
79
  args.each do |arg|
80
80
  if arg.is_a?(Hash)
@@ -82,7 +82,9 @@ module LockJar
82
82
  elsif arg.is_a?( String )
83
83
  lockfile = arg
84
84
  elsif arg.is_a?( Array )
85
- scopes = arg
85
+ groups = arg
86
+ elsif arg.is_a?( LockJar::Domain::Lockfile )
87
+ lockfile = arg
86
88
  end
87
89
  end
88
90
 
@@ -91,12 +93,12 @@ module LockJar
91
93
  lockfile = 'Jarfile.lock'
92
94
  end
93
95
 
94
- Runtime.instance.list( lockfile, scopes, opts, &blk )
96
+ Runtime.instance.list( lockfile, groups, opts, &blk )
95
97
  end
96
98
 
97
- # LockJar.load(*args): Loads all dependencies to the classpath for scopes from the Jarfile.lock. Depending on the type of arg, a different configuration is set.
99
+ # LockJar.load(*args): Loads all dependencies to the classpath for groups from the Jarfile.lock. Depending on the type of arg, a different configuration is set.
98
100
  # * An arg of a String will set the Jarfile.lock, e.g. 'Better.lock'. Default lock file is *Jarfile.lock*.
99
- # * An arg of an Array will set the scopes, e.g. ['compile','test'].Defaults scopes are *compile* and *runtime*.
101
+ # * An arg of an Array will set the groups, e.g. ['development','test'].Defaults group is *default*.
100
102
  # * An arg of a Hash will set the options, e.g. { :local_repo => 'path' }
101
103
  # * :local_repo sets the local repo path
102
104
  # * :resolve to true will make transitive dependences resolve before loading to classpath
@@ -107,7 +109,7 @@ module LockJar
107
109
  def self.load( *args, &blk )
108
110
  lockfile = nil
109
111
  opts = {}
110
- scopes = ['compile', 'runtime']
112
+ groups = ['default']
111
113
 
112
114
  args.each do |arg|
113
115
  if arg.is_a?(Hash)
@@ -115,7 +117,9 @@ module LockJar
115
117
  elsif arg.is_a?( String )
116
118
  lockfile = arg
117
119
  elsif arg.is_a?( Array )
118
- scopes = arg
120
+ groups = arg
121
+ elsif arg.is_a?( LockJar::Domain::Lockfile )
122
+ lockfile = arg
119
123
  end
120
124
  end
121
125
 
@@ -124,7 +128,7 @@ module LockJar
124
128
  lockfile = 'Jarfile.lock'
125
129
  end
126
130
 
127
- Runtime.instance.load( lockfile, scopes, opts, &blk )
131
+ Runtime.instance.load( lockfile, groups, opts, &blk )
128
132
  end
129
133
 
130
134
  # Lock a Jarfile and generate a Jarfile.lock.
@@ -147,7 +151,7 @@ module LockJar
147
151
  args.each do |arg|
148
152
  if arg.is_a?(Hash)
149
153
  opts.merge!( arg )
150
- elsif arg.is_a?( String ) || arg.is_a?( LockJar::Dsl )
154
+ elsif arg.is_a?( String ) || arg.is_a?( LockJar::Domain::Dsl )
151
155
  jarfile = arg
152
156
  end
153
157
  end
@@ -161,14 +165,13 @@ module LockJar
161
165
  end
162
166
 
163
167
  #
164
- # Read a Jafile.lock and convert it to a Hash
168
+ # Read a Jafile.lock and convert it to a LockJar::Domain::Lockfile
165
169
  #
166
170
  # @param [String] lockfile path to lockfile
167
171
  # @return [Hash] Lock Data
168
172
  def self.read( lockfile )
169
- Runtime.instance.read_lockfile( lockfile )
173
+ LockJar::Domain::Lockfile.read( lockfile )
170
174
  end
171
175
 
172
176
  end
173
177
 
174
- #include LockJar::Rubygems::Kernel
data/lock_jar.gemspec CHANGED
@@ -5,11 +5,11 @@
5
5
 
6
6
  Gem::Specification.new do |s|
7
7
  s.name = "lock_jar"
8
- s.version = "0.6.2"
8
+ s.version = "0.7.0"
9
9
 
10
10
  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
11
11
  s.authors = ["Michael Guymon"]
12
- s.date = "2012-09-28"
12
+ s.date = "2012-10-17"
13
13
  s.description = "Manage Jar files for Ruby. In the spirit of Bundler, a Jarfile\n is used to generate a Jarfile.lock that contains all the resolved jar dependencies for scopes runtime, compile, and test.\n The Jarfile.lock can be used to populate the classpath"
14
14
  s.email = "michael@tobedevoured.com"
15
15
  s.executables = ["lockjar"]
@@ -27,22 +27,27 @@ Gem::Specification.new do |s|
27
27
  "bin/lockjar",
28
28
  "lib/lock_jar.rb",
29
29
  "lib/lock_jar/buildr.rb",
30
+ "lib/lock_jar/bundler.rb",
30
31
  "lib/lock_jar/class_loader.rb",
31
32
  "lib/lock_jar/cli.rb",
32
- "lib/lock_jar/dsl.rb",
33
+ "lib/lock_jar/domain/artifact.rb",
34
+ "lib/lock_jar/domain/dsl.rb",
35
+ "lib/lock_jar/domain/dsl_helper.rb",
36
+ "lib/lock_jar/domain/gem_dsl.rb",
37
+ "lib/lock_jar/domain/jarfile_dsl.rb",
38
+ "lib/lock_jar/domain/lockfile.rb",
33
39
  "lib/lock_jar/maven.rb",
34
40
  "lib/lock_jar/registry.rb",
35
41
  "lib/lock_jar/resolver.rb",
36
- "lib/lock_jar/rubygems.rb",
37
42
  "lib/lock_jar/runtime.rb",
38
43
  "lib/lock_jar/version.rb",
39
44
  "lock_jar.gemspec",
40
45
  "spec/Jarfile",
41
46
  "spec/lock_jar/class_loader_spec.rb",
42
- "spec/lock_jar/dsl_spec.rb",
47
+ "spec/lock_jar/domain/dsl_helper_spec.rb",
48
+ "spec/lock_jar/domain/dsl_spec.rb",
43
49
  "spec/lock_jar/maven_spec.rb",
44
50
  "spec/lock_jar/resolver_spec.rb",
45
- "spec/lock_jar/rubygems_spec.rb",
46
51
  "spec/lock_jar/runtime_spec.rb",
47
52
  "spec/lock_jar_spec.rb",
48
53
  "spec/pom.xml",
@@ -58,29 +63,29 @@ Gem::Specification.new do |s|
58
63
  s.specification_version = 3
59
64
 
60
65
  if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
61
- s.add_runtime_dependency(%q<naether>, ["~> 0.9.0"])
66
+ s.add_runtime_dependency(%q<naether>, ["~> 0.10.0"])
62
67
  s.add_runtime_dependency(%q<thor>, ["~> 0.14.6"])
63
68
  s.add_development_dependency(%q<rspec>, ["~> 2.9.0"])
64
69
  s.add_development_dependency(%q<jeweler>, ["~> 1.8.4"])
65
70
  s.add_development_dependency(%q<yard>, ["~> 0.8.0"])
66
- s.add_development_dependency(%q<solr_sail>, ["~> 0.0.6"])
71
+ s.add_development_dependency(%q<solr_sail>, ["~> 0.1.0"])
67
72
  s.add_development_dependency(%q<jruby-openssl>, [">= 0"])
68
73
  else
69
- s.add_dependency(%q<naether>, ["~> 0.9.0"])
74
+ s.add_dependency(%q<naether>, ["~> 0.10.0"])
70
75
  s.add_dependency(%q<thor>, ["~> 0.14.6"])
71
76
  s.add_dependency(%q<rspec>, ["~> 2.9.0"])
72
77
  s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
73
78
  s.add_dependency(%q<yard>, ["~> 0.8.0"])
74
- s.add_dependency(%q<solr_sail>, ["~> 0.0.6"])
79
+ s.add_dependency(%q<solr_sail>, ["~> 0.1.0"])
75
80
  s.add_dependency(%q<jruby-openssl>, [">= 0"])
76
81
  end
77
82
  else
78
- s.add_dependency(%q<naether>, ["~> 0.9.0"])
83
+ s.add_dependency(%q<naether>, ["~> 0.10.0"])
79
84
  s.add_dependency(%q<thor>, ["~> 0.14.6"])
80
85
  s.add_dependency(%q<rspec>, ["~> 2.9.0"])
81
86
  s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
82
87
  s.add_dependency(%q<yard>, ["~> 0.8.0"])
83
- s.add_dependency(%q<solr_sail>, ["~> 0.0.6"])
88
+ s.add_dependency(%q<solr_sail>, ["~> 0.1.0"])
84
89
  s.add_dependency(%q<jruby-openssl>, [">= 0"])
85
90
  end
86
91
  end