lock_jar 0.10.0 → 0.10.2

data/lib/lock_jar/bundler.rb

@@ -1,155 +1,155 @@
-require 'lock_jar'
-require 'lock_jar/registry'
-require 'lock_jar/domain/lockfile'
-require 'lock_jar/domain/dsl'
-require 'lock_jar/domain/gem_dsl'
-require 'lock_jar/domain/jarfile_dsl'
-require 'lock_jar/domain/dsl_helper'
-
-module LockJar
-  
-  class Bundler
-      
-    class << self
-      
-      attr_accessor :skip_lock
-    
-      def load(*groups)
-        if groups && !groups.empty?  && File.exists?( 'Jarfile.lock')
-          
-          lockfile = LockJar::Domain::Lockfile.read( 'Jarfile.lock' )
-          
-          # expand merged paths to include gem base path
-          unless lockfile.merged.empty?
-            lockfile.merged = LockJar::Bundler.expand_gem_paths( lockfile.merged )
-          end
-          
-          LockJar.load( lockfile, groups )
-          
-          if ENV["DEBUG"]
-            puts "[LockJar] Loaded Jars for #{groups.inspect}: #{LockJar::Registry.instance.loaded_jars.inspect}"
-          end
-        end
-      end
-      
-      def expand_gem_paths(merged)
-        
-        merged_gem_paths = []
-        Gem.path.each do |gem_root|
-          merged.each do |merge|
-            # merged gems follow the notation: gem:gemname:path
-            if merge.start_with? 'gem:'
-              gem_path = merge.gsub(/^gem:.+:/, '')
-              gem_path = File.join( gem_root, gem_path )
-              if File.exists? gem_path
-                merged_gem_paths << gem_path
-              end
-            end
-          end
-        end
-        
-        merged_gem_paths
-      end
-    end
-  end
-  
-end
-
-module Bundler
-  class << self
-    alias :_lockjar_extended_require :require
-    def require(*groups)
-      LockJar::Bundler.load(*groups)
-
-      LockJar::Bundler.skip_lock = true
-
-      _lockjar_extended_require
-    end
-
-    alias :_lockjar_extended_setup :setup
-    def setup(*groups)
-      LockJar::Bundler.load(*groups)
-
-      LockJar::Bundler.skip_lock = true
-
-      _lockjar_extended_setup
-    end
-  end
-
-  class Runtime
-
-    alias :_lockjar_extended_require :require
-    def require(*groups)
-      LockJar::Bundler.load(*groups)
-
-      LockJar::Bundler.skip_lock = true
-
-      _lockjar_extended_require
-    end
-
-    alias :_lockjar_extended_setup :setup
-    def setup(*groups)
-      LockJar::Bundler.load(*groups)
-
-      LockJar::Bundler.skip_lock = true
-
-      _lockjar_extended_setup
-    end
-  end
-
-  class Definition
-    alias :_lockjar_extended_to_lock :to_lock
-    def to_lock
-      to_lock = _lockjar_extended_to_lock
-
-      if LockJar::Bundler.skip_lock != true
-        definition = Bundler.definition
-        #if !definition.send( :nothing_changed? )
-          gems_with_jars = []
-
-          # load local Jarfile
-          if File.exists?( 'Jarfile' )
-            dsl = LockJar::Domain::JarfileDsl.create( File.expand_path( 'Jarfile' ) )
-            gems_with_jars << 'jarfile:Jarfile'
-          # Create new Dsl
-          else
-            dsl = LockJar::Domain::Dsl.new
-          end
-
-          definition.groups.each do |group|
-            if ENV["DEBUG"]
-              puts "[LockJar] Group #{group}:"
-            end
-
-            definition.specs_for( [group] ).each do |spec|
-              gem_dir = spec.gem_dir
-
-              jarfile = File.join( gem_dir, "Jarfile" )
-
-              if File.exists?( jarfile )
-                gems_with_jars << "gem:#{spec.name}"
-
-                if ENV["DEBUG"]
-                  puts "[LockJar]   #{spec.name} has Jarfile"
-                end
-
-                spec_dsl = LockJar::Domain::GemDsl.create( spec, "Jarfile" )
-
-                dsl = LockJar::Domain::DslHelper.merge( dsl, spec_dsl, group.to_s )
-              end
-            end
-
-          end
-
-          puts "[LockJar] Locking Jars for: #{gems_with_jars.inspect}"
-          LockJar.lock( dsl )
-        #elsif ENV["DEBUG"]
-        #  puts "[LockJar] Locking skiped, Gemfile has not changed"
-        #end
-      end
-
-      to_lock
-    end
-
-  end
+require 'lock_jar'
+require 'lock_jar/registry'
+require 'lock_jar/domain/lockfile'
+require 'lock_jar/domain/dsl'
+require 'lock_jar/domain/gem_dsl'
+require 'lock_jar/domain/jarfile_dsl'
+require 'lock_jar/domain/dsl_helper'
+
+module LockJar
+  
+  class Bundler
+      
+    class << self
+      
+      attr_accessor :skip_lock
+    
+      def load(*groups)
+        if groups && !groups.empty?  && File.exists?( 'Jarfile.lock')
+          
+          lockfile = LockJar::Domain::Lockfile.read( 'Jarfile.lock' )
+          
+          # expand merged paths to include gem base path
+          unless lockfile.merged.empty?
+            lockfile.merged = LockJar::Bundler.expand_gem_paths( lockfile.merged )
+          end
+          
+          LockJar.load( lockfile, groups )
+          
+          if ENV["DEBUG"]
+            puts "[LockJar] Loaded Jars for #{groups.inspect}: #{LockJar::Registry.instance.loaded_jars.inspect}"
+          end
+        end
+      end
+      
+      def expand_gem_paths(merged)
+        
+        merged_gem_paths = []
+        Gem.path.each do |gem_root|
+          merged.each do |merge|
+            # merged gems follow the notation: gem:gemname:path
+            if merge.start_with? 'gem:'
+              gem_path = merge.gsub(/^gem:.+:/, '')
+              gem_path = File.join( gem_root, gem_path )
+              if File.exists? gem_path
+                merged_gem_paths << gem_path
+              end
+            end
+          end
+        end
+        
+        merged_gem_paths
+      end
+    end
+  end
+  
+end
+
+module Bundler
+  class << self
+    alias :_lockjar_extended_require :require
+    def require(*groups)
+      LockJar::Bundler.load(*groups)
+
+      LockJar::Bundler.skip_lock = true
+
+      _lockjar_extended_require
+    end
+
+    alias :_lockjar_extended_setup :setup
+    def setup(*groups)
+      LockJar::Bundler.load(*groups)
+
+      LockJar::Bundler.skip_lock = true
+
+      _lockjar_extended_setup
+    end
+  end
+
+  class Runtime
+
+    alias :_lockjar_extended_require :require
+    def require(*groups)
+      LockJar::Bundler.load(*groups)
+
+      LockJar::Bundler.skip_lock = true
+
+      _lockjar_extended_require
+    end
+
+    alias :_lockjar_extended_setup :setup
+    def setup(*groups)
+      LockJar::Bundler.load(*groups)
+
+      LockJar::Bundler.skip_lock = true
+
+      _lockjar_extended_setup
+    end
+  end
+
+  class Definition
+    alias :_lockjar_extended_to_lock :to_lock
+    def to_lock
+      to_lock = _lockjar_extended_to_lock
+
+      if LockJar::Bundler.skip_lock != true
+        definition = Bundler.definition
+        #if !definition.send( :nothing_changed? )
+          gems_with_jars = []
+
+          # load local Jarfile
+          if File.exists?( 'Jarfile' )
+            dsl = LockJar::Domain::JarfileDsl.create( File.expand_path( 'Jarfile' ) )
+            gems_with_jars << 'jarfile:Jarfile'
+          # Create new Dsl
+          else
+            dsl = LockJar::Domain::Dsl.new
+          end
+
+          definition.groups.each do |group|
+            if ENV["DEBUG"]
+              puts "[LockJar] Group #{group}:"
+            end
+
+            definition.specs_for( [group] ).each do |spec|
+              gem_dir = spec.gem_dir
+
+              jarfile = File.join( gem_dir, "Jarfile" )
+
+              if File.exists?( jarfile )
+                gems_with_jars << "gem:#{spec.name}"
+
+                if ENV["DEBUG"]
+                  puts "[LockJar]   #{spec.name} has Jarfile"
+                end
+
+                spec_dsl = LockJar::Domain::GemDsl.create( spec, "Jarfile" )
+
+                dsl = LockJar::Domain::DslHelper.merge( dsl, spec_dsl, group.to_s )
+              end
+            end
+
+          end
+
+          puts "[LockJar] Locking Jars for: #{gems_with_jars.inspect}"
+          LockJar.lock( dsl )
+        #elsif ENV["DEBUG"]
+        #  puts "[LockJar] Locking skiped, Gemfile has not changed"
+        #end
+      end
+
+      to_lock
+    end
+
+  end
 end

data/lib/lock_jar/cli.rb

@@ -1,64 +1,64 @@
-require 'rubygems'
-require 'thor'
-require 'lock_jar'
-
-module LockJar
-  
-  class CLI < Thor
-    
-    module ClassMethods
-      def generate_lockfile_option
-        method_option :lockfile, 
-          :aliases => "-l", 
-          :default => 'Jarfile.lock', 
-          :desc => "Path to Jarfile.lock"
-      end
-      
-      def generate_scopes_option
-        method_option :scopes, 
-          :aliases => "-s", 
-          :default => ['default'],
-          :desc => "Scopes to install from Jarfile.lock",
-          :type => :array
-      end
-      
-      def generate_jarfile_option
-        method_option :jarfile,
-          :aliases => "-j", 
-          :default => 'Jarfile', 
-          :desc => "Path to Jarfile"
-      end
-    end
-    extend(ClassMethods)
-    
-    desc "version", "LockJar version"
-    def version
-      puts LockJar::VERSION
-    end
-    
-    desc "install", "Install Jars from a Jarfile.lock"
-    generate_lockfile_option
-    generate_scopes_option
-    def install
-        puts "Installing Jars from #{options[:lockfile]} for #{options[:scopes].inspect}"
-        LockJar.install( options[:lockfile], options[:scopes] )      
-    end
-    
-    desc "list", "List Jars from a Jarfile.lock"
-    generate_lockfile_option
-    generate_scopes_option
-    def list
-      puts "Listing Jars from #{options[:lockfile]} for #{options[:scopes].inspect}"
-      puts LockJar.list( options[:lockfile], options[:scopes] ).inspect
-    end
-    
-    desc 'lock', 'Lock Jars in a Jarfile.lock'
-    generate_jarfile_option
-    generate_lockfile_option
-    def lock
-      puts "Locking #{options[:jarfile]} to #{options[:lockfile]}"
-      LockJar.lock( options[:jarfile], { :lockfile => options[:lockfile] } )
-    end
-    
-  end
-end
+require 'rubygems'
+require 'thor'
+require 'lock_jar'
+
+module LockJar
+  
+  class CLI < Thor
+    
+    module ClassMethods
+      def generate_lockfile_option
+        method_option :lockfile, 
+          :aliases => "-l", 
+          :default => 'Jarfile.lock', 
+          :desc => "Path to Jarfile.lock"
+      end
+      
+      def generate_scopes_option
+        method_option :scopes, 
+          :aliases => "-s", 
+          :default => ['default'],
+          :desc => "Scopes to install from Jarfile.lock",
+          :type => :array
+      end
+      
+      def generate_jarfile_option
+        method_option :jarfile,
+          :aliases => "-j", 
+          :default => 'Jarfile', 
+          :desc => "Path to Jarfile"
+      end
+    end
+    extend(ClassMethods)
+    
+    desc "version", "LockJar version"
+    def version
+      puts LockJar::VERSION
+    end
+    
+    desc "install", "Install Jars from a Jarfile.lock"
+    generate_lockfile_option
+    generate_scopes_option
+    def install
+        puts "Installing Jars from #{options[:lockfile]} for #{options[:scopes].inspect}"
+        LockJar.install( options[:lockfile], options[:scopes] )      
+    end
+    
+    desc "list", "List Jars from a Jarfile.lock"
+    generate_lockfile_option
+    generate_scopes_option
+    def list
+      puts "Listing Jars from #{options[:lockfile]} for #{options[:scopes].inspect}"
+      puts LockJar.list( options[:lockfile], options[:scopes] ).inspect
+    end
+    
+    desc 'lock', 'Lock Jars in a Jarfile.lock'
+    generate_jarfile_option
+    generate_lockfile_option
+    def lock
+      puts "Locking #{options[:jarfile]} to #{options[:lockfile]}"
+      LockJar.lock( options[:jarfile], { :lockfile => options[:lockfile] } )
+    end
+    
+  end
+end

data/lib/lock_jar/domain/artifact.rb

@@ -1,124 +1,124 @@
-# 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 'set'
-require 'lock_jar/maven'
-require 'naether/notation'
-
-module LockJar
-  module Domain
-    
-    
-    class Artifact
-      include Comparable
-      attr_reader :type
-      
-      def <=>(another_artifact)
-        if another_artifact.is_a? Artifact
-          to_urn <=> another_artifact.to_urn
-        else
-          to_urn <=> another_artifact.to_s
-        end
-      end
-      
-      def resolvable?
-        true
-      end
-    end
-    
-    class Jar < Artifact
-      attr_reader :notation
-      
-      def initialize( notation )
-        @type = 'jar'
-        @notation = Naether::Notation.new( notation ).to_notation
-      end
-      
-      def to_urn
-        "jar:#{notation}"
-      end
-      
-      def to_dep
-        notation
-      end
-    end
-    
-    class Local < Artifact
-      attr_reader :path
-      def initialize( path )
-        @type = 'local'
-        @path = path
-      end
-      
-      def to_urn
-        "local:#{path}"
-      end
-      
-      def to_dep
-        path
-      end
-
-      def resolvable?
-        false
-      end
-    end
-    
-    class Pom < Artifact
-      attr_reader :path, :scopes
-      
-      def initialize( _path, _scopes = ['compile','runtime'] )
-        @type = 'pom'
-        @path = _path
-        @scopes = _scopes
-      end
-      
-      def to_urn
-        "pom:#{path}"
-      end
-      
-      def to_dep
-        { path => scopes }
-      end
-      
-      def notations
-        LockJar::Maven.dependencies( path, scopes )  
-      end
-      
-      def ==(another_artifact)
-        self.<=>(another_artifact) == 0
-      end
-      
-      def <=>(another_artifact)
-        if another_artifact.is_a? Pom
-          if to_urn == another_artifact.to_urn
-            return 0 if Set.new(scopes) == Set.new(another_artifact.scopes)
-            
-            # XXX: this is not a reliable way to compare. 
-            if scopes.size > another_artifact.scopes.size
-              return 1
-            else
-              return -1
-            end
-          else
-            to_urn <=> another_artifact.to_urn
-          end
-        else
-          super
-        end
-      end
-    end
-    
-  end
+# 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 'set'
+require 'lock_jar/maven'
+require 'naether/notation'
+
+module LockJar
+  module Domain
+    
+    
+    class Artifact
+      include Comparable
+      attr_reader :type
+      
+      def <=>(another_artifact)
+        if another_artifact.is_a? Artifact
+          to_urn <=> another_artifact.to_urn
+        else
+          to_urn <=> another_artifact.to_s
+        end
+      end
+      
+      def resolvable?
+        true
+      end
+    end
+    
+    class Jar < Artifact
+      attr_reader :notation
+      
+      def initialize( notation )
+        @type = 'jar'
+        @notation = Naether::Notation.new( notation ).to_notation
+      end
+      
+      def to_urn
+        "jar:#{notation}"
+      end
+      
+      def to_dep
+        notation
+      end
+    end
+    
+    class Local < Artifact
+      attr_reader :path
+      def initialize( path )
+        @type = 'local'
+        @path = path
+      end
+      
+      def to_urn
+        "local:#{path}"
+      end
+      
+      def to_dep
+        path
+      end
+
+      def resolvable?
+        false
+      end
+    end
+    
+    class Pom < Artifact
+      attr_reader :path, :scopes
+      
+      def initialize( _path, _scopes = ['compile','runtime'] )
+        @type = 'pom'
+        @path = _path
+        @scopes = _scopes
+      end
+      
+      def to_urn
+        "pom:#{path}"
+      end
+      
+      def to_dep
+        { path => scopes }
+      end
+      
+      def notations
+        LockJar::Maven.dependencies( path, scopes )  
+      end
+      
+      def ==(another_artifact)
+        self.<=>(another_artifact) == 0
+      end
+      
+      def <=>(another_artifact)
+        if another_artifact.is_a? Pom
+          if to_urn == another_artifact.to_urn
+            return 0 if Set.new(scopes) == Set.new(another_artifact.scopes)
+            
+            # XXX: this is not a reliable way to compare. 
+            if scopes.size > another_artifact.scopes.size
+              return 1
+            else
+              return -1
+            end
+          else
+            to_urn <=> another_artifact.to_urn
+          end
+        else
+          super
+        end
+      end
+    end
+    
+  end
 end