naether 0.8.6 → 0.9.0

data/lib/naether/bootstrap.rb

@@ -1,4 +1,5 @@
 require "#{File.dirname(__FILE__)}/java"
+require "#{File.dirname(__FILE__)}/configuration"
 require 'yaml'
 require 'open-uri'
 require 'fileutils'
@@ -21,19 +22,13 @@ class Naether
         ENV['M2_REPO'] || File.expand_path('~/.m2/repository')
       end
       
-      # Find naether jar relative to the gem install
-      def naether_jar
-        Dir.glob(File.expand_path("#{File.dirname(__FILE__)}/../../naether*.jar")).first
-      end
-      
       # write bootstrap dependencies to yaml file
-      def write_dependencies( jar_path = nil, dest = 'jar_dependencies.yml' )
-        Naether::Java.load_jars_dir( jar_path || Naether::JAR_LIB )
+      def write_dependencies( dest = 'jar_dependencies.yml' )
         deps = {};
-        if Naether.platform == 'java'
-          deps[:dependencies] = com.slackworks.naether.Bootstrap.dependencies.to_a
+        if Naether::Configuration.platform == 'java'
+          deps[:dependencies] = com.tobedevoured.naether.Bootstrap.dependencies.to_a
         else
-          bootstrap = Rjb::import('com.slackworks.naether.Bootstrap')
+          bootstrap = Rjb::import('com.tobedevoured.naether.Bootstrap')
           deps[:dependencies] = bootstrap.dependencies.toArray().map{ |dep| dep.toString() }
         end  
         
@@ -50,13 +45,36 @@ class Naether
         end
         
         if dep_file.nil?
-          dep_file = "#{File.dirname( __FILE__ )}/../../jar_dependencies.yml"
+          dep_file = Naether::Configuration.dependencies_yml
         end
         
         dep = YAML.load_file( dep_file )  
         @@dependencies = dep[:dependencies]
       end
       
+
+      def bootstrap_local_repo(local_repo = nil, opts = {} )
+        local_repo = local_repo || default_local_repo
+        
+        opts[:local_repo] = local_repo
+        
+        temp_naether_dir = File.join( local_repo, ".naether" )
+        
+        
+        deps = download_dependencies( temp_naether_dir, opts )
+        
+        jars = (deps[:exists] + deps[:downloaded]).map {|jar| jar.values.first }
+          
+        jars = Naether::Java.internal_load_paths( jars )
+        
+        if ( deps[:downloaded].size > 0)
+          install_dependencies_to_local_repo( deps[:downloaded], jars, opts )
+        end
+        
+        #raise Naether::Java.instance.java.class_loader.getLoadedPaths().map { |x| x.toString() }.sort.inspect
+        
+      end
+      
       def download_dependencies( dest, opts = {} )
          
         if !File.exists? dest
@@ -68,13 +86,12 @@ class Naether
         if opts[:deps]
           deps[:missing] = opts[:deps] 
         else
-          deps = check_local_repo_for_deps( opts[:local_repo] )
+          deps = check_local_repo_for_deps( opts[:local_repo], opts )
         end
         
         deps[:downloaded] = []
           
         if deps[:missing].size > 0
-          puts "Downloading jars for Naether"  
             
           deps[:missing].each do |dep|
             notation = dep.split(":")
@@ -96,7 +113,7 @@ class Naether
               
               deps[:downloaded] << { dep => maven_path }
             else
-              deps[:exists] << { dep => maven_path }
+              deps[:downloaded] << { dep => maven_path }
             end
           end
         end
@@ -104,16 +121,16 @@ class Naether
         deps
       end
       
-      def check_local_repo_for_deps(local_repo = nil)
+      def check_local_repo_for_deps(local_repo = nil, opts = {} )
         
         local_repo = local_repo || default_local_repo
         local_repo = File.expand_path(local_repo)
         
         #puts "Checking #{local_repo} for jars to bootstrap Naether"
         
-        deps = {:exists => [], :missing => [] }
+        deps = {:exists => [], :missing => [], :downloaded => [] }
         
-        dependencies.each do |dep|
+        dependencies( opts[:dep_yaml] ).each do |dep|
           notation = dep.split(":")
           group = notation[0].gsub("\.", File::SEPARATOR)
           artifact = notation[1].gsub("\.", File::SEPARATOR)
@@ -131,41 +148,22 @@ class Naether
           end
           
         end  
-          
         deps
       end
       
-      def install_dependencies_to_local_repo( jars_or_dir, opts = {}  )
+      def install_dependencies_to_local_repo( install_jars, naether_jars, opts = {}  )
           
-        @naether = nil
-        jars = []  
-        unless jars_or_dir.is_a? Array
-          @naether = Naether.create_from_paths( jars_or_dir, opts[:naether_jar_dir] )
-          jars = Dir.glob( "#{jars_or_dir}#{File::SEPARATOR}*.jar" )
-        else
-          @naether = Naether.create_from_jars( jars_or_dir )
-          jars = jars_or_dir
-        end
+        require "#{File.dirname(__FILE__)}/../naether"
+        
+        @naether = Naether.create_from_jars( naether_jars )
         
         if opts[:local_repo]
           @naether.local_repo_path = opts[:local_repo]
         end
         
-        dependencies.each do |dep|
-          notation = dep.split(":")
-          group = notation[0].gsub("\.", File::SEPARATOR)
-          artifact = notation[1].gsub("\.", File::SEPARATOR)
-          type = notation[2]
-          version = notation[3]
-          
-          name = "#{artifact}-#{version}.#{type}"
-          
-          jar = jars.select { |x| x =~ /#{name}/ }
-          if jar.size > 0
-            jar = jar[0]
-            @naether.install( dep, nil, jar )
-          end
-          
+        install_jars.each do |dep|
+          notation, path = dep.to_a.first
+          @naether.install( notation, nil, path )
         end
         
         @naether

data/lib/naether/configuration.rb

@@ -0,0 +1,61 @@
+
+class Naether
+  class Configurator
+    def initialize(data={})
+      gem_dir = File.expand_path("#{File.dirname(__FILE__)}/../../")
+      
+      version = nil
+      
+      # Load VERSION file from gem to VERSION var
+      if File.exists?( File.expand_path("#{File.dirname(__FILE__)}/../../VERSION") )
+        version = IO.read(File.expand_path("#{File.dirname(__FILE__)}/../../VERSION")).strip
+          
+      # VERSION file not found in gem dir, assume in current path, e.g.running from checkout
+      else
+        version = IO.read(File.expand_path("VERSION")).strip
+      end
+      
+      
+      
+      @data = {
+        :gem_dir =>     gem_dir,
+        :naether_jar => File.join( gem_dir, "naether-#{version}.jar"),
+        :platform =>    ($platform || RUBY_PLATFORM[/java/] || 'ruby'),
+        :version =>     version,
+        :depenencies_yml => File.expand_path("#{File.dirname( __FILE__ )}/../../jar_dependencies.yml")
+      }
+      
+      update!(data)
+    end
+  
+    def update!(data)
+      data.each do |key, value|
+        self[key] = value
+      end
+    end
+  
+    def [](key)
+      @data[key.to_sym]
+    end
+  
+    def []=(key, value)
+      if value.class == Hash
+        @data[key.to_sym] = Config.new(value)
+      else
+        @data[key.to_sym] = value
+      end
+    end
+  
+    def method_missing(sym, *args)
+      if sym.to_s =~ /(.+)=$/
+        self[$1] = args.first
+      else
+        self[sym]
+      end
+    end
+  end
+  
+  unless defined?(Naether::Configuration)
+    Naether::Configuration = Naether::Configurator.new
+  end
+end

data/lib/naether/java.rb

@@ -1,4 +1,5 @@
 require 'singleton'
+require "#{File.dirname(__FILE__)}/configuration"
 
 # :title:Naether::Java
 #
@@ -14,39 +15,22 @@ class Naether
     
     attr_reader :java
     
-    def initialize
-      if Naether.platform == 'java'
+    def initialize()
+      naether_jar = Naether::Configuration.naether_jar
+      
+      unless File.exists? naether_jar
+        raise "Cannot create Naether::Java: #{naether_jar} does not exist"
+      end
+      
+      if Naether::Configuration.platform == 'java'
+        require "#{File.dirname(__FILE__)}/java/jruby"
         @java = Naether::Java::JRuby.instance
       else
+        require "#{File.dirname(__FILE__)}/java/ruby"
         @java = Naether::Java::Ruby.instance
       end
     end
     
-    # Jars loaded
-    def self.loaded_jars
-      instance.java.loaded_jars
-    end
-    
-    # Loads all jars from the array of paths
-    def self.load_jars_dir(paths)
-      unless paths.is_a? Array
-        paths = [paths]
-      end
-      
-      jars = []
-      paths.each do |path|
-        jars = jars + Dir.glob( "#{File.expand_path(path)}/*.jar", File::FNM_CASEFOLD)
-      end
-      
-      Naether::Java.load_jars(jars)
-      
-    end
-    
-    # Load jars for the runtime platform
-    def self.load_jars(jars)
-      instance.java.load_jars(jars)
-    end
-    
     # Paths loaded
     def self.loaded_paths
       instance.java.loaded_paths
@@ -57,12 +41,21 @@ class Naether
       instance.java.load_paths(paths)
     end
     
+    # Load paths for the runtime platform
+    def self.internal_load_paths(paths)
+      instance.java.internal_load_paths(paths)
+    end
+    
     def self.create( target_class, *args )
       instance.java.create( target_class, *args )
     end
     
-    def self.java_class( target_class ) 
-      instance.java.java_class( target_class )
+    def self.exec_static_method( target_class, target_method, *args ) 
+      instance.java.exec_static_method( target_class, target_method, *args )
+    end
+    
+    def self.convert_to_java_list( ruby_array )
+      instance.java.convert_to_java_list( ruby_array )
     end
     
     def self.convert_to_ruby_array( java_array, to_string = false )
@@ -73,174 +66,5 @@ class Naether
       instance.java.convert_to_ruby_hash( java_hash, to_string )
     end
     
-    #
-    # Handle loading jars for JRuby
-    #
-    class JRuby
-      include Singleton
-      
-      attr_reader :loaded_jars, :loaded_paths
-      
-      def initialize
-        require 'java'
-        
-        @loaded_jars = []
-        @loaded_paths = []
-      end
-      
-      def create( target_class, *args )
-        java_class = java_class(target_class)
-        java_class.new( *args )
-      end
-      
-      def java_class( target_class ) 
-        eval(target_class)
-      end
-      
-      def load_paths(paths)
-        load_paths = []
-        unless paths.is_a? Array
-          paths = [paths]
-        end
-        
-        paths.each do |path|
-          expanded_path = File.expand_path(path)
-          if !@loaded_paths.include? expanded_path
-            $CLASSPATH << expanded_path
-            load_paths << expanded_path
-            @loaded_paths << expanded_path
-          end
-        end
-        
-        load_paths
-      end
-      
-      def load_jars(jars)
-        load_jars = []
-        unless jars.is_a? Array
-          jars = [jars]
-        end
-        
-        jars.each do |jar|
-          expanded_jar = File.expand_path(jar)
-          if !@loaded_jars.include? expanded_jar
-            require expanded_jar
-            load_jars << expanded_jar
-            @loaded_jars << expanded_jar
-          end
-        end
-        
-        load_jars
-      end
-      
-      def convert_to_ruby_array( java_array, to_string = false )
-        java_array.to_a
-      end
-      
-      def convert_to_ruby_hash( java_hash, to_string = false )
-        java_hash.to_hash
-      end
-    
-    end
-    
-    #
-    # Handle loading jars for Ruby via Rjb
-    #
-    class Ruby
-      include Singleton
-      
-      attr_reader :loaded_jars, :loaded_paths
-      
-      def initialize()
-        require 'rjb' 
-        
-        # Call Rjb::load with an empty classpath, incase Rjb::load has already been called
-        java_opts = (ENV['JAVA_OPTS'] || ENV['JAVA_OPTIONS']).to_s.split
-        Rjb::load("", java_opts)
-        
-        @loaded_jars = []
-        @loaded_paths = []
-      end
-      
-      def create( target_class, *args )
-        target_class = java_class(target_class) 
-        target_class.new( *args )
-      end
-      
-      def java_class( target_class ) 
-        Rjb::import( target_class )
-      end
-      
-      def load_paths(paths)
-        loadable_paths = []
-        unless paths.is_a? Array
-          paths = [paths]
-        end
-        
-        paths.each do |path|
-          expanded_path = File.expand_path(path)
-          if !@loaded_paths.include? expanded_path
-            @loaded_paths << expanded_path
-            loadable_paths << expanded_path
-          end
-        end
-        
-        Rjb::load(loadable_paths.join(File::PATH_SEPARATOR))
-        
-        loadable_paths
-      end
-      
-      def load_jars(jars)
-        loadable_jars = []
-        unless jars.is_a?( Array )
-          jars = [jars]
-        end
-        
-        jars.each do |jar|
-          expanded_jar = File.expand_path(jar)
-          if !@loaded_jars.include? expanded_jar
-            loadable_jars << expanded_jar
-            @loaded_jars << expanded_jar
-          end
-        end
-        
-        unless loadable_jars.empty?
-          Rjb::add_jar( loadable_jars )
-        end
-        
-        loadable_jars
-      end
-      
-      def convert_to_ruby_array( java_array, to_string = false )
-        ruby_array = java_array.toArray()
-        
-        if to_string
-          ruby_array = ruby_array.map { |x| x.toString()}
-        end
-        
-        ruby_array
-      end
-      
-      def convert_to_ruby_hash( java_hash, to_string = false )
-        
-        hash = {}
-        keys = java_hash.keySet()
-        iterator = keys.iterator()
-        if to_string
-          while iterator.hasNext()
-            key = iterator.next().toString()
-            hash[key] = java_hash.get( key ).toString()
-          end
-        else
-          while iterator.hasNext()
-            key = iterator.next()
-            hash[key] = java_hash.get( key )              
-          end
-        end
-        
-        hash
-        
-      end
-    end
   end
 end