lock_jar 0.0.3 → 0.1.0

data/Gemfile

@@ -5,7 +5,7 @@ gem "naether", "~> 0.6.0"
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.
 group :development do
-  gem "rspec", ">= 0"
+  gem "rspec", "~> 2.9.0"
   gem "bundler", "> 1.0.0"
   gem "jeweler", "~> 1.6.4"
 end

data/README.rdoc

@@ -1,8 +1,9 @@
 = LockJar
 
-LockJar manages Java Jars for Ruby. A Jarfile ({example}[https://github.com/mguymon/lock_jar/blob/master/spec/Jarfile])
-is used to generate a Jarfile.lock that contains all the resolved jar dependencies for scopes runtime, compile, and test. The Jarfile.lock can be used to populate 
-the classpath.
+LockJar manages Java Jars for Ruby. Powered by {Naether}[https://github.com/mguymon/naether] to create a frankenstein of 
+Bundler and Maven. A Jarfile ({example}[https://github.com/mguymon/lock_jar/blob/master/spec/Jarfile]) is used to 
+generate a Jarfile.lock that contains all the resolved jar dependencies for scopes runtime, compile, and test. 
+The Jarfile.lock can be used to populate the classpath.
 
 https://github.com/mguymon/lock_jar
 
@@ -18,9 +19,10 @@ gem install lock_jar
 A Jarfile is a simple file using a Ruby DSL for defining a project's Jar dependencies using the following 
 methods:
 
-* repository: url of additional Maven repository to use.
-* jar: artifact notation of Jar dependency
-* pom: local path to a Maven pom
+* local: Set the local Maven repository
+* repository: Add url of additional Maven repository to use.
+* jar: Add Jar dependency in artifact notation
+* pom: Add local path to a Maven pom
 * scope: set the scope for a jar or pom declaration. Default scope is compile
 
 Example Jarfile
@@ -43,10 +45,8 @@ Example Jarfile
 
 When the Jarfile is locked, the transitive dependencies for the Jars and Pom are resolved and saved to the Jarfile.lock file.
 
-Example of locking
+Example of locking a Jarfile to a Jarfile.lock
 
-    require 'lock_jar'
-    
     LockJar.lock
   
  
@@ -58,6 +58,8 @@ the additional Maven repositories.
 The Jarfile.lock
 
   --- 
+  repositories: 
+    - http://repository.jboss.org/nexus/content/groups/public-jboss
   scopes: 
     compile: 
       dependencies: 
@@ -85,26 +87,56 @@ The Jarfile.lock
       resolved_dependencies: 
         - junit:junit:jar:4.10
         - org.hamcrest:hamcrest-core:jar:1.1
-  repositories: 
-    - http://repository.jboss.org/nexus/content/groups/public-jboss
   
   
 ==== Accessing Jars
 
 Once a Jarfile.lock is generated, you can list all resolved jars by
-
-  require 'lock_jars'
   
   jars = LockJar.list
   
 or directly load all Jars into the classpath
-
-  require 'lock_jars'
   
   jars = LockJar.load  
 
 Do not forget, if you change your Jarfile, you have to re-generate the Jarfile.lock.
   
+=== Skipping the Jarfile
+
+You can skip the Jarfile and directly load dependencies by passing a block to LockJar.load
+    
+    LockJar.load do
+      jar 'org.eclipse.jetty:example-jetty-embedded:jar:8.1.2.v20120308'
+    end
+
+=== Bundler Integration
+
+LockJar integrates with {Bundler}[https://github.com/carlhuda/bundler/] by {modifying}[https://github.com/mguymon/lock_jar/blob/master/lib/lock_jar/bundler.rb] the Bundler
+DSL to include LockJar's DSL, generating a Jarfile.lock when Bundler locks, and populating the classpath
+when Bundler requires.
+
+==== Example
+
+The following Gemfile with LockJar
+
+  require 'lock_jar/bundler'
+  
+  gem "naether"
+        
+  # lockjar dsl that is used to generate Jarfile.lock
+  lock_jar do
+    scope :test do
+	  jar 'junit:junit:jar:4.10'
+	end
+	  
+    pom 'spec/pom.xml', :scope => :compile
+  end
+
+Will produce a Gemfile.lock and Jarfile.lock for
+
+  bundle install
+  
+When Bundle.setup or Bundle.require is called, the jars from the Jarfile.lock are loaded into the classpath.
   
 === Buildr Integration
 
@@ -161,9 +193,6 @@ Generated the following lock files using lock_jar:lock
 * project1.lock - contains junit and mina jars.
 * project2.lock - contains junit and pom.xml jars.
   
-=== About
-
-Power by {Naether}[https://github.com/mguymon/naether] to create a frankenstein of Bundler and Maven.
 
 == License
 

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.1.0

data/lib/lock_jar/bundler.rb

@@ -0,0 +1,98 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership. The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+require 'rubygems'
+require 'bundler/dsl'
+require 'lock_jar'
+require 'lock_jar/dsl'
+
+module Bundler
+  class Dsl
+    def lock_jar(&blk)
+      @lock_jar_blk = blk
+    end
+    
+    def to_definition(lockfile, unlock)
+      @sources << @rubygems_source unless @sources.include?(@rubygems_source)
+      definition = LockJarDefinition.new(lockfile, @dependencies, @sources, unlock)
+      
+      if @lock_jar_blk
+        definition.lock_jar = LockJar::Dsl.evaluate( nil, &@lock_jar_blk )
+      end
+      
+      definition
+    end
+  end
+  
+  class Environment
+    def lock_jar
+      @definition.lock_jar
+    end
+  end
+  
+  class LockJarDefinition < Bundler::Definition
+    alias :lockjar_replaced_lock :lock
+    attr_accessor :lock_jar
+    
+    def lock( file )
+      LockJar.lock( lock_jar )
+      
+      lockjar_replaced_lock( file )
+    end
+  end
+  
+  class Runtime
+    alias :lockjar_replaced_setup :setup
+    alias :lockjar_replaced_require :require
+    
+    def setup(*groups)
+      scopes = []
+      if groups && groups.size == 0
+        scopes = ["compile","runtime"]
+      else
+        groups.each do |group|
+          if "development" == group.to_s 
+            scopes << "compile"
+          elsif "default" == group.to_s
+            scopes << "compile"  << "runtime"
+          end
+        end
+      end
+      
+      LockJar.load( scopes.uniq )
+      
+      lockjar_replaced_setup( *groups )
+    end
+    
+    def require(*groups)
+      scopes = []
+        
+      if groups && groups.size == 0
+        scopes = ["compile","runtime"]
+      else
+        groups.each do |group|
+          if "development" == group.to_s 
+            scopes << "compile"
+          elsif "default" == group.to_s
+            scopes << "compile"  << "runtime"
+          end
+        end
+      end
+      LockJar.load( scopes.uniq )
+      
+      lockjar_replaced_require( *groups )
+    end
+  end
+end

data/lib/lock_jar/dsl.rb

@@ -18,6 +18,7 @@ module LockJar
 
     attr_reader :notations
     attr_reader :repositories
+    attr_reader :local_repository
     attr_reader :scopes
     
     class << self
@@ -58,23 +59,37 @@ module LockJar
       end
         
       @present_scope = 'compile'
+      
+      @local_repository = nil
+    end
+    
+    def local( path )
+      @local_repository = path
     end
     
     def jar(notation, *args)
-      if notation
-        @notations[@present_scope] << notation
+      opts = {}
+      if args.last.is_a? Hash
+        opts.merge!( args.last )
       end
+      
+      artifact( notation, opts )
     end
     
     # Pom default to all scopes, unless nested in a scope
     def pom(path, *args)
-      if @scope_changed
-        @notations[@present_scope] << path
-      else
-        LockJar::Dsl.scopes.each do |scope|
-          @notations[scope] << path
-        end
+      opts = { }
+        
+      if args.last.is_a? Hash
+        opts.merge!( args.last )
+      end
+      
+      # if not scope opts and default scope, set to all
+      unless opts[:scope] || opts[:scopes] || @scope_changed
+        opts[:scope] = Dsl.scopes
       end
+      
+      artifact( path, opts )
     end
     
     def repository( url, opts = {} )
@@ -104,5 +119,37 @@ module LockJar
       
       self
     end
+   
+    private 
+    def artifact(artifact, opts)
+      
+      scopes = opts[:scope] || opts[:scopes] || opts[:group]
+      if scopes
+        
+        unless scopes.is_a? Array
+          scopes = [scopes]
+        end
+        
+        # include present scope if within a scope block
+        if @scope_changed
+          scopes << @present_scope
+        end
+        
+      else
+        scopes = [@present_scope]
+      end
+      
+      if artifact
+        scopes.each do |scope|
+          scope = 'compile' if scope.to_s == 'development'
+          
+          if @notations[scope.to_s]
+            @notations[scope.to_s] << artifact
+          end
+        end
+      end
+      
+    end
+    
   end
 end

data/lib/lock_jar/maven.rb

@@ -1,27 +1,39 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership. The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
 
+require 'lock_jar/runtime'
 
 module LockJar
   class Maven
     
     class << self
-      def runtime( opts = {} )
-        Runtime.new( opts )
-      end
       
       def pom_version( pom_path, opts = {} )
-        runtime(opts).resolver.naether.pom_version( pom_path )
+        Runtime.instance.resolver(opts).naether.pom_version( pom_path )
       end
       
       def write_pom( notation, file_path, opts = {} )
-        runtime(opts).resolver.naether.write_pom( notation, file_path )
+        Runtime.instance.resolver(opts).naether.write_pom( notation, file_path )
       end
       
       def deploy_artifact( notation, file_path, url, deploy_opts = {}, lockjar_opts = {} )
-        runtime(lockjar_opts).resolver.naether.deploy_artifact( notation, file_path, url, deploy_opts )
+        Runtime.instance.resolver(lockjar_opts).naether.deploy_artifact( notation, file_path, url, deploy_opts )
       end
       
       def install( notation, pom_path, jar_path, opts = {} )
-        runtime(opts).resolver.naether.install( notation, pom_path, jar_path )
+        Runtime.instance.resolver(opts).naether.install( notation, pom_path, jar_path )
       end
     end
   end

data/lib/lock_jar/resolver.rb

@@ -20,9 +20,11 @@ require 'tmpdir'
 module LockJar
   class Resolver
     
+    attr_reader :opts
     attr_reader :naether
     
     def initialize( opts = {} )
+      @opts = opts
       local_repo = opts[:local_repo]
         
       # Bootstrap Naether

data/lib/lock_jar/runtime.rb

@@ -13,22 +13,28 @@
 # License for the specific language governing permissions and limitations under
 # the License.
 
-require "yaml"
 require 'rubygems'
+require "yaml"
+require 'singleton'
 require 'lock_jar/resolver'
 require 'lock_jar/dsl'
 require 'lock_jar/runtime'
 
 module LockJar
   class Runtime
+    include Singleton
     
-    attr_reader :resolver
+    attr_reader :current_resolver
     
-    def initialize( opts = {} )
-      @resolver = LockJar::Resolver.new( opts )
+    def resolver( opts = {} )
+      if @current_resolver.nil? || opts != @current_resolver.opts
+        @current_resolver = LockJar::Resolver.new( opts )
+      end
+      
+      @current_resolver
     end
     
-    def lock( jarfile = "Jarfile", opts = {} )
+    def lock( jarfile, opts = {} )
         lock_jar_file = nil
         
         if jarfile.is_a? LockJar::Dsl
@@ -37,16 +43,27 @@ module LockJar
           lock_jar_file = LockJar::Dsl.evaluate( jarfile )
         end
         
+        # If not set in opts, and is set in  dsl
+        if opts[:local_repo].nil? && lock_jar_file.local_repository
+          opts[:local_repo] = lock_jar_file.local_repository 
+        end
+        
         lock_jar_file.repositories.each do |repo|
-          @resolver.add_remote_repository( repo )
+          resolver(opts).add_remote_repository( repo )
         end
-    
-        lock_data = { 'scopes' => {} }
-    
+        
+        lock_data = { }
+
+        unless lock_jar_file.local_repository.nil?
+          lock_data['local_repository'] = lock_jar_file.local_repository
+        end
+          
         if lock_jar_file.repositories.size > 0
           lock_data['repositories'] = lock_jar_file.repositories
         end
           
+        lock_data['scopes'] = {} 
+          
         lock_jar_file.notations.each do |scope, notations|
           
           dependencies = []
@@ -54,10 +71,12 @@ module LockJar
             dependencies << {notation => scope}
           end
           
-          resolved_notations = @resolver.resolve( dependencies )
-          lock_data['scopes'][scope] = { 
-            'dependencies' => notations,
-            'resolved_dependencies' => resolved_notations } 
+          if dependencies.size > 0
+            resolved_notations = resolver(opts).resolve( dependencies )
+            lock_data['scopes'][scope] = { 
+              'dependencies' => notations,
+              'resolved_dependencies' => resolved_notations } 
+          end
         end
     
         File.open( opts[:lockfile] || "Jarfile.lock", "w") do |f|
@@ -65,57 +84,65 @@ module LockJar
         end
       end
     
-      def list( jarfile_lock = "Jarfile.lock", scopes = ['compile', 'runtime'] )
-        lock_data = YAML.load_file( jarfile_lock )
-                
+      def list( jarfile_lock, scopes = ['compile', 'runtime'], opts = {}, &blk )
         dependencies = []
-          
-        scopes.each do |scope|
-          if lock_data['scopes'][scope]
-            dependencies += lock_data['scopes'][scope]['resolved_dependencies']
-          end
+                
+        if jarfile_lock
+          dependencies += lockfile_dependencies( read_lockfile( jarfile_lock), scopes )
         end
         
-        dependencies
+        unless blk.nil?
+          dsl = LockJar::Dsl.evaluate(&blk)
+          dependencies += dsl_dependencies( dsl, scopes )
+        end
+        
+        dependencies.uniq
       end
       
-      def load( jarfile_lock = "Jarfile.lock", scopes = ['compile', 'runtime'], &blk )
-        dependencies = []
-        
+      def load( jarfile_lock, scopes = ['compile', 'runtime'], opts = {}, &blk )
         if jarfile_lock
-          if File.exists?(jarfile_lock)
-            dependencies += read_jarfile( jarfile_lock, scopes )
-          else
-            warn( "LockJar jarfile_lock not found: #{jarfile_lock}" )
+          lockfile = read_lockfile( jarfile_lock )
+  
+          if opts[:local_repo].nil? && lockfile['local_repo']
+            opts[:local_repo] = lockfile['local_repo']
           end
         end
-                
-        if blk
+        
+        unless blk.nil?
           dsl = LockJar::Dsl.evaluate(&blk)
-          dependencies += read_dsl( dsl, scopes )
+          
+          if opts[:local_repo].nil? && dsl.local_repository
+            opts[:local_repo] = dsl.local_repository
+          end
         end
         
-        dependencies.uniq!
+        dependencies = list( jarfile_lock, scopes, &blk )
+        
+        if opts[:resolve]
+          dependencies = resolver(opts).resolve( dependencies )
+        end
         
-        @resolver.load_jars_to_classpath( dependencies )
+        resolver(opts).load_jars_to_classpath( dependencies )
       end
       
       private
-      def read_jarfile( jarfile_lock, scopes )
-        lock_data = YAML.load_file( jarfile_lock )
-        
+      def read_lockfile( jarfile_lock )
+        YAML.load_file( jarfile_lock )
+      end
+      
+      def lockfile_dependencies( lockfile, scopes)
         dependencies = []
          
         scopes.each do |scope|
-          if lock_data['scopes'][scope]
-            dependencies += lock_data['scopes'][scope]['resolved_dependencies']
+          if lockfile['scopes'][scope]
+            dependencies += lockfile['scopes'][scope]['resolved_dependencies']
           end
         end
         
         dependencies
       end
       
-      def read_dsl( dsl, scopes )
+      def dsl_dependencies( dsl, scopes )
         
         dependencies = []
          
@@ -125,7 +152,7 @@ module LockJar
           end
         end
         
-        @resolver.resolve( dependencies )
+        dependencies
       end
   end
 end

data/lib/lock_jar.rb

@@ -25,21 +25,60 @@ module LockJar
   #
   # Accepts path to the jarfile and hash of options to configure LockJar
   def self.lock( jarfile = 'Jarfile', opts = {} )
-    Runtime.new( opts ).lock( jarfile, opts )
+    Runtime.instance.lock( jarfile, opts )
   end
   
   # List jars for an array of scope in a lockfile
   #
   # Accepts path to the lockfile, array of scopes, and hash of options to configure LockJar
-  def self.list( lockfile = 'Jarfile.lock', scopes = ['compile', 'runtime'], opts = {}, &blk )
-      Runtime.new( opts ).list( lockfile, scopes )
+  def self.list( *args, &blk )
+      lockfile = nil
+      opts = {}
+      scopes = ['compile', 'runtime']
+        
+      args.each do |arg|
+        if arg.is_a?(Hash)
+          opts.merge!( arg )
+        elsif arg.is_a?( String )
+          lockfile = arg
+        elsif arg.is_a?( Array )
+          scopes = arg
+        end
+      end
+      
+      # default to Jarfile.lock
+      if blk.nil? && lockfile.nil?
+        lockfile = 'Jarfile.lock'
+      end
+      
+      Runtime.instance.list( lockfile, scopes, opts, &blk )
   end
     
-  # Load jars for an array of scopes in a lockfile
+  # Load jars for an array of scopes in a lockfile. Defaults lockfile to Jarfile.lock
   #
-  # Accepts a path to the lockfile, array scopes, and hash of optiosn to configure LockJar
-  def self.load( lockfile = 'Jarfile.lock', scopes = ['compile', 'runtime'], opts = {}, &blk )
-      Runtime.new( opts ).load( lockfile, scopes, &blk )
+  # Accepts a path to the lockfile, array scopes, and hash of options to configure LockJar. A
+  # block of LockJar::Dsl can be set.
+  def self.load( *args, &blk )
+      lockfile = nil
+      opts = {}
+      scopes = ['compile', 'runtime']
+        
+      args.each do |arg|
+        if arg.is_a?(Hash)
+          opts.merge!( arg )
+        elsif arg.is_a?( String )
+          lockfile = arg
+        elsif arg.is_a?( Array )
+          scopes = arg
+        end
+      end
+      
+      # default to Jarfile.lock
+      if blk.nil? && lockfile.nil?
+        lockfile = 'Jarfile.lock'
+      end
+      
+      Runtime.instance.load( lockfile, scopes, opts, &blk )
   end
  
 end

data/lock_jar.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "lock_jar"
-  s.version = "0.0.3"
+  s.version = "0.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Michael Guymon"]
-  s.date = "2012-04-16"
+  s.date = "2012-04-19"
   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"
   s.email = "michael.guymon@gmail.com"
   s.extra_rdoc_files = [
@@ -24,17 +24,23 @@ Gem::Specification.new do |s|
     "VERSION",
     "lib/lock_jar.rb",
     "lib/lock_jar/buildr.rb",
+    "lib/lock_jar/bundler.rb",
     "lib/lock_jar/dsl.rb",
     "lib/lock_jar/maven.rb",
     "lib/lock_jar/resolver.rb",
     "lib/lock_jar/runtime.rb",
     "lock_jar.gemspec",
+    "spec/BundlerJarfile.lock",
     "spec/Jarfile",
+    "spec/helper/bundler_helper.rb",
+    "spec/lock_jar/bundler_spec.rb",
     "spec/lock_jar/dsl_spec.rb",
     "spec/lock_jar/maven_spec.rb",
     "spec/lock_jar/resolver_spec.rb",
+    "spec/lock_jar/runtime_spec.rb",
     "spec/lock_jar_spec.rb",
-    "spec/pom.xml"
+    "spec/pom.xml",
+    "spec/spec_helper.rb"
   ]
   s.homepage = "http://github.com/mguymon/lock_jar"
   s.licenses = ["Apache"]
@@ -47,18 +53,18 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<naether>, ["~> 0.6.0"])
-      s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.9.0"])
       s.add_development_dependency(%q<bundler>, ["> 1.0.0"])
       s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
     else
       s.add_dependency(%q<naether>, ["~> 0.6.0"])
-      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<rspec>, ["~> 2.9.0"])
       s.add_dependency(%q<bundler>, ["> 1.0.0"])
       s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
     end
   else
     s.add_dependency(%q<naether>, ["~> 0.6.0"])
-    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<rspec>, ["~> 2.9.0"])
     s.add_dependency(%q<bundler>, ["> 1.0.0"])
     s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
   end

data/spec/BundlerJarfile.lock

@@ -0,0 +1,22 @@
+--- 
+scopes: 
+  compile: 
+    dependencies: 
+      - /home/zinger/devel/projects/swx/lock_jar/spec/pom.xml
+    resolved_dependencies: 
+      - com.slackworks:modelcitizen:jar:0.2.2
+      - commons-lang:commons-lang:jar:2.6
+      - commons-beanutils:commons-beanutils:jar:1.8.3
+      - commons-logging:commons-logging:jar:1.1.1
+      - ch.qos.logback:logback-classic:jar:0.9.24
+      - ch.qos.logback:logback-core:jar:0.9.24
+      - org.slf4j:slf4j-api:jar:1.6.1
+      - com.metapossum:metapossum-scanner:jar:1.0
+      - commons-io:commons-io:jar:1.4
+      - junit:junit:jar:4.7
+  test: 
+    dependencies: 
+      - junit:junit:jar:4.10
+    resolved_dependencies: 
+      - junit:junit:jar:4.10
+      - org.hamcrest:hamcrest-core:jar:1.1

data/spec/Jarfile

@@ -1,3 +1,4 @@
+local '~/.m2'
 repository 'http://repository.jboss.org/nexus/content/groups/public-jboss'
 
 jar "org.apache.mina:mina-core:2.0.4"

data/spec/helper/bundler_helper.rb

@@ -0,0 +1,156 @@
+# Require the correct version of popen for the current platform
+if RbConfig::CONFIG['host_os'] =~ /mingw|mswin/
+  begin
+    require 'win32/open3'
+  rescue LoadError
+    abort "Run `gem install win32-open3` to be able to run specs"
+  end
+else
+  require 'open3'
+end
+
+
+module BundlerHelper
+  
+  # Taken from Bundler spec supprt
+  # https://github.com/carlhuda/bundler/tree/master/spec/support
+  
+  attr_reader :out, :err, :exitstatus
+  
+  def gemfile(*args)
+    path = bundled_app("Gemfile")
+    path = args.shift if Pathname === args.first
+    str  = args.shift || ""
+    path.dirname.mkpath
+    File.open(path.to_s, 'w') do |f|
+      f.puts str
+    end
+  end
+
+  def lockfile(*args)
+    path = bundled_app("Gemfile.lock")
+    path = args.shift if Pathname === args.first
+    str  = args.shift || ""
+
+    # Trim the leading spaces
+    spaces = str[/\A\s+/, 0] || ""
+    str.gsub!(/^#{spaces}/, '')
+
+    File.open(path.to_s, 'w') do |f|
+      f.puts str
+    end
+  end
+  
+  def install_gemfile(*args)
+    gemfile(*args)
+    opts = args.last.is_a?(Hash) ? args.last : {}
+    bundle :install, opts
+  end
+  
+  def bundle(cmd, options = {})
+      expect_err  = options.delete(:expect_err)
+      exitstatus = options.delete(:exitstatus)
+      options["no-color"] = true unless options.key?("no-color") || %w(exec conf).include?(cmd.to_s[0..3])
+
+      #bundle_bin = File.expand_path('../../../bin/bundle', __FILE__)
+      bundle_bin = `which bundle`.strip
+        
+      requires = options.delete(:requires) || []
+      requires << File.expand_path('../fakeweb/'+options.delete(:fakeweb)+'.rb', __FILE__) if options.key?(:fakeweb)
+      requires << File.expand_path('../artifice/'+options.delete(:artifice)+'.rb', __FILE__) if options.key?(:artifice)
+      requires_str = requires.map{|r| "-r#{r}"}.join(" ")
+
+      env = (options.delete(:env) || {}).map{|k,v| "#{k}='#{v}' "}.join
+      args = options.map do |k,v|
+        v == true ? " --#{k}" : " --#{k} #{v}" if v
+      end.join
+
+      cmd = "#{env}#{Gem.ruby} -I#{lib} #{requires_str} #{bundle_bin} #{cmd}#{args}"
+
+      #puts cmd
+      
+      if exitstatus
+        sys_status(cmd)
+      else
+        sys_exec(cmd, expect_err){|i| yield i if block_given? }
+      end
+    end
+  
+  def root
+    @root ||= Pathname.new(File.expand_path("../../..", __FILE__))
+  end
+  
+  def bundled_app(*path)
+    root = tmp.join("bundled_app")
+    FileUtils.mkdir_p(root)
+    root.join(*path)
+  end
+  
+  def tmp(*path)
+    root.join("tmp", *path)
+  end
+  
+  def in_app_root(&blk)
+      Dir.chdir(bundled_app, &blk)
+  end
+  
+  def lib
+      File.expand_path('../../../lib', __FILE__)
+  end
+  
+  def sys_exec(cmd, expect_err = false)
+    Open3.popen3(cmd.to_s) do |stdin, stdout, stderr|
+      @in_p, @out_p, @err_p = stdin, stdout, stderr
+
+      yield @in_p if block_given?
+      @in_p.close
+
+      @out = @out_p.read_available_bytes.strip
+      @err = @err_p.read_available_bytes.strip
+    end
+
+    #puts @out
+    puts @err unless expect_err || @err.empty? || !$show_err
+    @out
+  end
+  
+  def ruby(ruby, options = {})
+    expect_err = options.delete(:expect_err)
+    env = (options.delete(:env) || {}).map{|k,v| "#{k}='#{v}' "}.join
+    ruby.gsub!(/["`\$]/) {|m| "\\#{m}" }
+    lib_option = options[:no_lib] ? "" : " -I#{lib}"
+     
+    #puts %{#{env}#{Gem.ruby}#{lib_option} -e "#{ruby}"} 
+      
+    sys_exec(%{#{env}#{Gem.ruby}#{lib_option} -e "#{ruby}"}, expect_err)
+  end
+  
+  RSpec::Matchers.define :have_dep do |*args|
+    dep = Bundler::Dependency.new(*args)
+
+    match do |actual|
+      actual.length == 1 && actual.all? { |d| d == dep }
+    end
+  end
+end
+
+class IO
+  def read_available_bytes(chunk_size = 16384, select_timeout = 0.02)
+    buffer = []
+
+    return "" if closed? || eof?
+    # IO.select cannot be used here due to the fact that it
+    # just does not work on windows
+    while true
+      begin
+        IO.select([self], nil, nil, select_timeout)
+        break if eof? # stop raising :-(
+        buffer << self.readpartial(chunk_size)
+      rescue(EOFError)
+        break
+      end
+    end
+
+    return buffer.join
+  end
+end

data/spec/lock_jar/bundler_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+require 'rubygems'
+require 'bundler'
+require 'lib/lock_jar/bundler'
+require 'helper/bundler_helper'
+
+describe Bundler do
+    include BundlerHelper
+    
+    before(:each) do
+      gemfile <<-G
+        require 'lock_jar/bundler'
+        source "file://#{tmp('bundler')}"
+        gem "naether"
+        
+        lock_jar do
+          scope :test do
+            jar 'junit:junit:jar:4.10'
+          end
+          
+          pom "#{File.join(root, 'spec', 'pom.xml')}", :scope => :development
+        end
+      G
+      in_app_root
+    end
+    
+    after(:each) do
+      Dir.chdir(root)
+    end
+  
+  it "provides a list of the env dependencies" do
+    Bundler.load.dependencies.should have_dep("naether", ">= 0")
+  end
+    
+  it "provides a list of the jar and pom dependencies" do
+    Bundler.load.lock_jar.notations.should eql( {"compile"=>["/home/zinger/devel/projects/swx/lock_jar/spec/pom.xml"], "runtime"=>[], "test"=>["junit:junit:jar:4.10"]} )
+  end
+  
+  it "should create Jarfile.lock with bundle install" do
+    File.delete( bundled_app("Jarfile.lock") ) if File.exists? bundled_app("Jarfile.lock")
+    install_gemfile <<-G
+      require 'lock_jar/bundler'
+      source "file://#{tmp('bundler')}"
+      gem "naether"
+      
+      lock_jar do
+        scope :test do
+          jar 'junit:junit:jar:4.10'
+        end
+        
+        pom "#{File.join(root, 'spec', 'pom.xml')}", :scope => :development
+      end
+      
+    G
+    
+    File.exists?(  bundled_app("Jarfile.lock") ).should be_true
+    
+    IO.read( File.join(root,'spec', 'BundlerJarfile.lock') ).should eql( IO.read( bundled_app("Jarfile.lock") ) )
+  end
+  
+  it "should create Jarfile.lock with bundle update" do
+    File.delete( bundled_app("Jarfile.lock") ) if File.exists? bundled_app("Jarfile.lock")
+    bundle "update"
+    File.exists?(  bundled_app("Jarfile.lock") ).should be_true
+    
+    IO.read( File.join(root,'spec', 'BundlerJarfile.lock') ).should eql( IO.read( bundled_app("Jarfile.lock") ) )
+  end
+  
+  it "should load Jarfile.lock with Bundle.setup" do
+    ruby <<-RUBY
+      require 'rubygems'
+      require 'bundler'
+      require 'lock_jar/bundler'
+      Bundler.setup
+
+      puts com.slackworks.modelcitizen.ModelFactory.to_s
+    RUBY
+    err.should eq("")
+    out.should match("Java::ComSlackworksModelcitizen::ModelFactory")
+  end
+  
+end

data/spec/lock_jar/dsl_spec.rb

@@ -1,17 +1,18 @@
-require 'rubygems'
-require 'lib/lock_jar/dsl'
+require 'spec_helper'
 
 describe LockJar::Dsl do
   context "Instance" do
     it "should load a Jarfile" do
       jarfile = LockJar::Dsl.evaluate( "spec/Jarfile" )
       
+      jarfile.local_repository.should eql '~/.m2'
       jarfile.notations.should eql( {"compile"=>["org.apache.mina:mina-core:2.0.4", "spec/pom.xml"], "runtime"=>["spec/pom.xml", "org.apache.tomcat:servlet-api:jar:6.0.35"], "test"=>["spec/pom.xml", "junit:junit:jar:4.10"]}  )
       jarfile.repositories.should eql( ["http://repository.jboss.org/nexus/content/groups/public-jboss"] )
     end
     
     it "should load a block" do
       block = LockJar::Dsl.evaluate  do
+        local '~/.m2'
         repository 'http://repository.jboss.org/nexus/content/groups/public-jboss'
         
         jar "org.apache.mina:mina-core:2.0.4"
@@ -26,6 +27,7 @@ describe LockJar::Dsl do
         end
       end
       
+      block.local_repository.should eql '~/.m2'
       block.notations.should eql( {"compile"=>["org.apache.mina:mina-core:2.0.4", "spec/pom.xml"], "runtime"=>["spec/pom.xml", "org.apache.tomcat:servlet-api:jar:6.0.35"], "test"=>["spec/pom.xml", "junit:junit:jar:4.10"]}  )
       block.repositories.should eql( ["http://repository.jboss.org/nexus/content/groups/public-jboss"] )
           

data/spec/lock_jar/runtime_spec.rb

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'lib/lock_jar/runtime'
+
+describe LockJar::Runtime do
+  context "Singleton" do
+    it "should set local repo" do
+      LockJar::Runtime.instance.load( nil ) do 
+        jar 'org.modeshape:modeshape-common:2.3.0.Final'
+      end
+      
+      LockJar::Runtime.instance.current_resolver.naether.local_repo_path.should eql File.expand_path('~/.m2/repository')
+      
+      LockJar::Runtime.instance.load( nil, [], :local_repo => 'tmp/param_config' ) do 
+        local 'dsl_config'
+      end
+      
+      LockJar::Runtime.instance.current_resolver.naether.local_repo_path.should eql 'tmp/param_config'
+    
+      LockJar::Runtime.instance.load( nil ) do 
+        local 'tmp/dsl_config'
+      end
+      
+      LockJar::Runtime.instance.current_resolver.naether.local_repo_path.should eql 'tmp/dsl_config'
+    
+    end
+  end
+end

data/spec/lock_jar_spec.rb

@@ -16,22 +16,44 @@ describe LockJar do
       jars = LockJar.list( 'tmp/Jarfile.lock', ['compile', 'runtime', 'bad scope'], :local_repo => 'tmp/test-repo' )
       jars.should eql( ["org.apache.mina:mina-core:jar:2.0.4", "org.slf4j:slf4j-api:jar:1.6.1", "com.slackworks:modelcitizen:jar:0.2.2", "commons-lang:commons-lang:jar:2.6", "commons-beanutils:commons-beanutils:jar:1.8.3", "commons-logging:commons-logging:jar:1.1.1", "ch.qos.logback:logback-classic:jar:0.9.24", "ch.qos.logback:logback-core:jar:0.9.24", "com.metapossum:metapossum-scanner:jar:1.0", "commons-io:commons-io:jar:1.4", "junit:junit:jar:4.7", "org.apache.tomcat:servlet-api:jar:6.0.35"] )
     end
+    
+    context "load" do
+      it "by Jarfile.lock" do
+        if Naether.platform == 'java'
+          lambda { include_class 'org.apache.mina.core.IoUtil' }.should raise_error
+        else
+          lambda { Rjb::import('org.apache.mina.core.IoUtil') }.should raise_error
+        end
+        
+        jars = LockJar.load( 'tmp/Jarfile.lock', ['compile', 'runtime'], :local_repo => 'tmp/test-repo' )
         
-    it "should load jars" do
-      if Naether.platform == 'java'
-        lambda { include_class 'org.apache.mina.core.IoUtil' }.should raise_error
-      else
-        lambda { Rjb::import('org.apache.mina.core.IoUtil') }.should raise_error
+        jars.should eql( [File.expand_path("tmp/test-repo/org/apache/mina/mina-core/2.0.4/mina-core-2.0.4.jar"), File.expand_path("tmp/test-repo/org/slf4j/slf4j-api/1.6.1/slf4j-api-1.6.1.jar"), File.expand_path("tmp/test-repo/com/slackworks/modelcitizen/0.2.2/modelcitizen-0.2.2.jar"), File.expand_path("tmp/test-repo/commons-lang/commons-lang/2.6/commons-lang-2.6.jar"), File.expand_path("tmp/test-repo/commons-beanutils/commons-beanutils/1.8.3/commons-beanutils-1.8.3.jar"), File.expand_path("tmp/test-repo/commons-logging/commons-logging/1.1.1/commons-logging-1.1.1.jar"), File.expand_path("tmp/test-repo/ch/qos/logback/logback-classic/0.9.24/logback-classic-0.9.24.jar"), File.expand_path("tmp/test-repo/ch/qos/logback/logback-core/0.9.24/logback-core-0.9.24.jar"), File.expand_path("tmp/test-repo/com/metapossum/metapossum-scanner/1.0/metapossum-scanner-1.0.jar"), File.expand_path("tmp/test-repo/commons-io/commons-io/1.4/commons-io-1.4.jar"), File.expand_path("tmp/test-repo/junit/junit/4.7/junit-4.7.jar"), File.expand_path("tmp/test-repo/org/apache/tomcat/servlet-api/6.0.35/servlet-api-6.0.35.jar")] )
+          
+        if Naether.platform == 'java'
+          lambda { include_class 'org.apache.mina.core.IoUtil' }.should_not raise_error
+        else
+          lambda { Rjb::import('org.apache.mina.core.IoUtil') }.should_not raise_error
+        end
       end
-      
-      jars = LockJar.load( 'tmp/Jarfile.lock', ['compile', 'runtime'], :local_repo => 'tmp/test-repo' )
-      
-      jars.should eql( [File.expand_path("tmp/test-repo/org/apache/mina/mina-core/2.0.4/mina-core-2.0.4.jar"), File.expand_path("tmp/test-repo/org/slf4j/slf4j-api/1.6.1/slf4j-api-1.6.1.jar"), File.expand_path("tmp/test-repo/com/slackworks/modelcitizen/0.2.2/modelcitizen-0.2.2.jar"), File.expand_path("tmp/test-repo/commons-lang/commons-lang/2.6/commons-lang-2.6.jar"), File.expand_path("tmp/test-repo/commons-beanutils/commons-beanutils/1.8.3/commons-beanutils-1.8.3.jar"), File.expand_path("tmp/test-repo/commons-logging/commons-logging/1.1.1/commons-logging-1.1.1.jar"), File.expand_path("tmp/test-repo/ch/qos/logback/logback-classic/0.9.24/logback-classic-0.9.24.jar"), File.expand_path("tmp/test-repo/ch/qos/logback/logback-core/0.9.24/logback-core-0.9.24.jar"), File.expand_path("tmp/test-repo/com/metapossum/metapossum-scanner/1.0/metapossum-scanner-1.0.jar"), File.expand_path("tmp/test-repo/commons-io/commons-io/1.4/commons-io-1.4.jar"), File.expand_path("tmp/test-repo/junit/junit/4.7/junit-4.7.jar"), File.expand_path("tmp/test-repo/org/apache/tomcat/servlet-api/6.0.35/servlet-api-6.0.35.jar")] )
+       
+      it "by block with resolve option" do
+        if Naether.platform == 'java'
+          lambda { include_class 'org.modeshape.common.math.Duration' }.should raise_error
+        else
+          lambda { Rjb::import('org.modeshape.common.math.Duration') }.should raise_error
+        end
+        
+        jars = LockJar.load( :resolve => true ) do 
+          jar 'org.modeshape:modeshape-common:2.3.0.Final'
+        end
         
-      if Naether.platform == 'java'
-        lambda { include_class 'org.apache.mina.core.IoUtil' }.should_not raise_error
-      else
-        lambda { Rjb::import('org.apache.mina.core.IoUtil') }.should_not raise_error
+        jars.should eql( ["/home/zinger/.m2/repository/org/modeshape/modeshape-common/2.3.0.Final/modeshape-common-2.3.0.Final.jar", "/home/zinger/.m2/repository/org/slf4j/slf4j-api/1.5.11/slf4j-api-1.5.11.jar", "/home/zinger/.m2/repository/net/jcip/jcip-annotations/1.0/jcip-annotations-1.0.jar"] )
+          
+        if Naether.platform == 'java'
+          lambda { include_class 'org.modeshape.common.math.Duration' }.should_not raise_error
+        else
+          lambda { Rjb::import('org.modeshape.common.math.Duration') }.should_not raise_error
+        end
       end
     end
   end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+$:.unshift File.expand_path('..', __FILE__)
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+RSpec.configure do |config|
+  
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: lock_jar
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 27
   prerelease: 
   segments: 
   - 0
+  - 1
   - 0
-  - 3
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors: 
 - Michael Guymon
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-04-16 00:00:00 Z
+date: 2012-04-19 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   prerelease: false
@@ -39,12 +39,14 @@ dependencies:
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        hash: 3
+        hash: 43
         segments: 
+        - 2
+        - 9
         - 0
-        version: "0"
+        version: 2.9.0
   version_requirements: *id002
   name: rspec
 - !ruby/object:Gem::Dependency 
@@ -99,17 +101,23 @@ files:
 - VERSION
 - lib/lock_jar.rb
 - lib/lock_jar/buildr.rb
+- lib/lock_jar/bundler.rb
 - lib/lock_jar/dsl.rb
 - lib/lock_jar/maven.rb
 - lib/lock_jar/resolver.rb
 - lib/lock_jar/runtime.rb
 - lock_jar.gemspec
+- spec/BundlerJarfile.lock
 - spec/Jarfile
+- spec/helper/bundler_helper.rb
+- spec/lock_jar/bundler_spec.rb
 - spec/lock_jar/dsl_spec.rb
 - spec/lock_jar/maven_spec.rb
 - spec/lock_jar/resolver_spec.rb
+- spec/lock_jar/runtime_spec.rb
 - spec/lock_jar_spec.rb
 - spec/pom.xml
+- spec/spec_helper.rb
 homepage: http://github.com/mguymon/lock_jar
 licenses: 
 - Apache