naether 0.8.6-java → 0.9.0-java

data/lib/naether/java/jruby.rb

@@ -0,0 +1,129 @@
+require "#{File.dirname(__FILE__)}/../configuration"
+
+# :title:Naether::Java::JRuby
+#
+# Singletn that handles Java interactions for JRuby. Providers helpers for 
+# nomalizing accesss.
+
+# = Authors
+# Michael Guymon
+#
+class Naether
+  class Java
+
+    class JRuby
+      include Singleton
+      
+      attr_reader :loaded_paths, :class_loader
+      
+      #
+      # Creates new instance by loading the Naether jar to the global ClassLoader
+      # and creating the internal Naether ClassLoader
+      #
+      def initialize
+        require 'java'
+        
+        naether_jar = Naether::Configuration.naether_jar
+              
+        @loaded_paths = []
+        
+        load_paths(naether_jar)  
+        @class_loader = com.tobedevoured.naether.PathClassLoader.new()
+        internal_load_paths(naether_jar)  
+      end
+      
+      #
+      # Create a Java Object
+      #
+      def create( target_class, *args )
+        @class_loader.newInstance(target_class, *args )
+      end
+      
+      #
+      # Execute a Staic method on a Java class
+      #
+      def exec_static_method( target_class, target_method, params, types = nil ) 
+        unless params.is_a? Array
+          params = [params]
+        end
+        
+        if types
+          unless types.is_a? Array
+             types = [types]
+          end
+        end
+        
+        @class_loader.execStaticMethod( target_class, target_method, params, types )
+      end
+      
+      #
+      # Load a path into the internal Naether ClassLoader
+      #
+      def internal_load_paths(paths)
+        load_paths = []
+        unless paths.is_a? Array
+          paths = [paths]
+        end
+        
+        paths.each do |path|
+          expanded_path = File.expand_path(path)
+          if File.exists?( expanded_path )
+            @class_loader.addPath( expanded_path )
+            
+            load_paths << expanded_path
+          end
+        end
+        
+        load_paths
+      end
+      
+      #
+      # Load a path onto the Global ClassLoader
+      #
+      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 ) && File.exists?( expanded_path )
+            $CLASSPATH << expanded_path
+            load_paths << expanded_path
+            @loaded_paths << expanded_path
+          end
+        end
+        
+        load_paths
+      end
+      
+      #
+      # Convert a Ruby Array to a Java ArrayList
+      #
+      def convert_to_java_list( ruby_array ) 
+        list = java.util.ArrayList.new
+        ruby_array.each do |item|
+          list.add( item )
+        end
+        
+        list
+      end
+      
+      #
+      # Convert a Java List to a Ruby Array
+      #
+      def convert_to_ruby_array( java_array, to_string = false )
+        java_array.to_a
+      end
+      
+      #
+      # Convert a Java Map to a Ruby Hash
+      #
+      def convert_to_ruby_hash( java_hash, to_string = false )
+        java_hash.to_hash
+      end
+    
+    end    
+  end
+end

data/lib/naether/java/ruby.rb

@@ -0,0 +1,153 @@
+require "#{File.dirname(__FILE__)}/../configuration"
+
+# :title:Naether::Java::Ruby
+#
+# Sngleton that handles Java interactions for Ruby using RJB. Providers helpers for
+# nomalizing accesss.
+#
+# = Authors
+# Michael Guymon
+#
+class Naether
+  class Java
+
+    class Ruby
+      include Singleton
+      
+      attr_reader :loaded_paths, :class_loader
+      
+      def initialize
+        require 'rjb' 
+        
+        naether_jar = Naether::Configuration.naether_jar
+              
+        # 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_paths = []
+        load_paths( naether_jar )
+        
+        class_loader_class = Rjb::import( "com.tobedevoured.naether.PathClassLoader" )
+        @class_loader = class_loader_class.new()
+          
+        internal_load_paths( naether_jar )
+        
+      end
+      
+      def create( target_class, *args )
+        #@class_loader.newInstance(target_class, *args )
+        if args.size > 0
+          @class_loader._invoke('newInstance', 'Ljava.lang.String;[Ljava.lang.Object;', target_class, args )
+        else
+          @class_loader._invoke('newInstance', 'Ljava.lang.String;', target_class )
+        end
+      end
+      
+      def exec_static_method( target_class, target_method, params, types = nil ) 
+        unless params.is_a? Array
+          params = [params]
+        end
+        
+        if types
+          unless types.is_a? Array
+             types = [types]
+          end
+        end
+        result = nil
+        if params.nil?
+          result = @class_loader._invoke('execStaticMethod','Ljava.lang.String;Ljava.lang.String;', target_class, target_method )
+        elsif types.nil?
+          result = @class_loader._invoke('execStaticMethod','Ljava.lang.String;Ljava.lang.String;Ljava.util.List;', target_class, target_method, convert_to_java_list(params) )
+        else
+          result = @class_loader._invoke('execStaticMethod','Ljava.lang.String;Ljava.lang.String;Ljava.util.List;Ljava.util.List;', target_class, target_method, convert_to_java_list(params), convert_to_java_list(types) )
+        end
+        
+        unless result.nil?
+          # Force toString on java.lang.String otherwise the result will be a Rjb::Proxy
+          if result.getClass().getName() == 'java.lang.String'
+            result.toString()
+          else
+            result
+          end
+        end
+      end
+      
+      def internal_load_paths(paths)
+        loadable_paths = []
+        unless paths.is_a? Array
+          paths = [paths]
+        end
+        
+        paths.each do |path|
+          expanded_path = File.expand_path(path)
+          if File.exists?( expanded_path )
+            @class_loader.addPath( path )
+            loadable_paths << expanded_path
+          end
+        end
+        
+        loadable_paths
+      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) && File.exists?( expanded_path )
+            @loaded_paths << expanded_path
+            Rjb::add_jar( expanded_path )
+            loadable_paths << expanded_path
+          end
+        end
+        
+        loadable_paths
+      end
+      
+      def convert_to_java_list( ruby_array ) 
+        list = Rjb::import("java.util.ArrayList").new
+        ruby_array.each do |item|
+          list.add( item )
+        end
+        
+        list
+      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

data/lib/naether/maven.rb

@@ -0,0 +1,142 @@
+# 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 "#{File.dirname(__FILE__)}/java"
+
+class Naether
+  
+  # Helper for interacting with a Maven POM
+  #
+  # @author Michael Guymon
+  #
+  class Maven
+    
+    class << self
+      
+      # Create an instance from a POM
+      #
+      # @params [String] pom_path
+      # @return [Naether::Maven]
+      def create_from_pom( pom_path )
+        maven = Maven.new( pom_path )
+      end
+      
+      # Create an instance based on notation
+      # 
+      # @params [String] notation
+      # @return [Naether::Maven]
+      # @see https://github.com/mguymon/naether/wiki/Notations
+      def create_from_notation( notation )
+        maven = Maven.new
+        maven.notation = notation
+        maven
+      end
+    end
+    
+    #
+    # Create new instance
+    #
+    def initialize(pom_path = nil)
+      if pom_path
+        @project = Naether::Java.create("com.tobedevoured.naether.maven.Project", pom_path )
+      else
+        @project = Naether::Java.create("com.tobedevoured.naether.maven.Project" )
+      end
+      
+    end
+    
+    # Set the Notation for this Project
+    #
+    # @param [String] notation
+    # @see https://github.com/mguymon/naether/wiki/Notations
+    def notation=(notation)
+      @project.setProjectNotation( notation )
+    end
+    
+    # Get dependences for Project as notations
+    # 
+    # @param [Array<String>] scopes valid options are compile,test,runtime
+    def dependencies( scopes = nil)
+      if scopes
+        unless scopes.is_a? Array
+           scopes = [scopes]
+        end
+      end
+          
+      if Naether.platform == 'java'
+        if scopes.nil?
+          deps = @project.getDependenciesNotation()
+        else
+          deps = @project.getDependenciesNotation( scopes )
+        end
+        
+      else
+        list = nil
+        if scopes
+          list = Naether::Java.convert_to_java_list( scopes )
+          
+          deps = @project._invoke('getDependenciesNotation', 'Ljava.util.List;', list)
+        else
+          deps = @project.getDependenciesNotation()
+        end
+        
+      end
+      
+      Naether::Java.convert_to_ruby_array( deps, true )
+    end
+    
+    # Set dependencies
+    #
+    # @param [Array] dependencies
+    def dependencies=(dependencies)
+      @project.setDependencies( dependencies )
+    end
+    
+    # Set repositories
+    #
+    # @param [Array] repositories of urls
+    def repositories=( repositories )
+      @project.setRepositories( repositories )
+    end
+  
+    # Get the version
+    #
+    # return [String] version
+    def version()
+      return @project.getVersion()
+    end
+    
+    # Load dependencies and remote repo from a {Naether} instance
+    def load_naether( naether )
+      self.dependencies= naether.resolver.getDependencies()
+      self.repositories= naether.resolver.getRemoteRepositoryUrls()
+    end
+    
+    # Create the XML for a Maven Pom
+    #
+    # @return [String] pom xml
+    def build_pom()
+      @project.toXml()
+    end
+    
+  
+    # Write Maven Pom
+    #
+    # @param [String] file_path
+    def write_pom( file_path )
+      @project.writePom( file_path )
+    end
+  end
+end

data/naether.gemspec

@@ -0,0 +1,75 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "naether"
+  s.version = "0.9.0"
+  s.platform = "java"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Michael Guymon"]
+  s.date = "2012-09-12"
+  s.description = "Java dependency resolver using Maven's Aether"
+  s.email = "michael@tobedevoured.com"
+  s.extensions = ["Rakefile"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.md"
+  ]
+  s.files = [
+    "LICENSE",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "jar_dependencies.yml",
+    "lib/naether.rb",
+    "lib/naether/bootstrap.rb",
+    "lib/naether/configuration.rb",
+    "lib/naether/java.rb",
+    "lib/naether/java/jruby.rb",
+    "lib/naether/java/ruby.rb",
+    "lib/naether/maven.rb",
+    "naether-0.9.0.jar",
+    "naether.gemspec",
+    "pom.xml"
+  ]
+  s.homepage = "http://github.com/mguymon/naether"
+  s.licenses = ["Apache"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = "naether"
+  s.rubygems_version = "1.8.24"
+  s.summary = "Java dependency resolver using Maven's Aether"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rake>, ["~> 0.9.2"])
+      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.5.2"])
+      s.add_development_dependency(%q<yard>, [">= 0"])
+      s.add_development_dependency(%q<kramdown>, [">= 0"])
+      s.add_development_dependency(%q<jruby-openssl>, [">= 0"])
+    else
+      s.add_dependency(%q<rake>, ["~> 0.9.2"])
+      s.add_dependency(%q<rspec>, ["> 2.9.0"])
+      s.add_dependency(%q<bundler>, ["> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["> 1.5.2"])
+      s.add_dependency(%q<yard>, [">= 0"])
+      s.add_dependency(%q<kramdown>, [">= 0"])
+      s.add_dependency(%q<jruby-openssl>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rake>, ["~> 0.9.2"])
+    s.add_dependency(%q<rspec>, ["> 2.9.0"])
+    s.add_dependency(%q<bundler>, ["> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["> 1.5.2"])
+    s.add_dependency(%q<yard>, [">= 0"])
+    s.add_dependency(%q<kramdown>, [">= 0"])
+    s.add_dependency(%q<jruby-openssl>, [">= 0"])
+  end
+end
+