jbundler 0.0.1 → 0.2.0

data/Build.md

@@ -0,0 +1,32 @@
+# build jbundler #
+
+the build uses ruby-maven. **note** ruby-maven uses maven and maven is highly modular, i.e. it comes only with the core and the moment you need a plugin he first time its starts downloading it. with that in mind the first usage of (ruby-)maven involves a lot of downloading - so be prepared :)
+
+first get all the development gems in place:
+
+```jruby -S bundle install```
+
+to build the (extension) jar for the lib directory (prepare the jar before packaging the gem)
+
+```rmvn prepare-package```
+
+this also runs all the test over a couple of jruy version each in 1.8 and 1.9 mode. so these tests take some time. in skip the tests when building the gem use:
+
+```rmvn prepare-package --Dmaven.test.skip```
+
+to build the gem in **target/jbundler-0.0.1.gem**
+
+```rmvn package```
+
+or once the jar file is in place then
+
+```gem build jbundler.gemspec```
+
+will do as well.
+
+## proper maven and IDEs ##
+
+once ```rmvn``` generated the **Gemfile.pom** you can use proper maven3 by setting a sybolic link from **pom.xml** to **Gemfile.pom**. in the end rmvn is just ruby wrapper around maven3. the **Gemfile.pom** is generated from the *jbundler.gemspec*, *Gemfile*, *Gemfile.lock* and *Mavenfile*.
+
+your IDE might be able to use the pom.xml to manage the project and its java sources.
+

data/Gemfile

@@ -0,0 +1,10 @@
+source :rubygems
+gemspec
+
+# needed for local setup
+#gem 'maven-tools', :path => '../jruby-maven-plugins/ruby-tools/src/main/gem/maven-tools'
+
+group :test do
+  gem 'minitest', '~> 2.10.0'
+  gem 'cucumber', '~> 1.1.9'
+end

data/Gemfile.lock

@@ -0,0 +1,35 @@
+PATH
+  remote: .
+  specs:
+    jbundler (0.2.0)
+      ruby-maven (= 3.0.4.0.29.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    builder (3.0.0)
+    cucumber (1.1.9)
+      builder (>= 2.1.2)
+      diff-lcs (>= 1.1.2)
+      gherkin (~> 2.9.0)
+      json (>= 1.4.6)
+      term-ansicolor (>= 1.0.6)
+    diff-lcs (1.1.3)
+    gherkin (2.9.3-java)
+      json (>= 1.4.6)
+    json (1.7.3-java)
+    maven-tools (0.29.0)
+    minitest (2.10.1)
+    ruby-maven (3.0.4.0.29.0)
+      maven-tools (= 0.29.0)
+      thor (~> 0.14.6)
+    term-ansicolor (1.0.7)
+    thor (0.14.6)
+
+PLATFORMS
+  java
+
+DEPENDENCIES
+  cucumber (~> 1.1.9)
+  jbundler!
+  minitest (~> 2.10.0)

data/Gemfile.lock-

@@ -0,0 +1,33 @@
+PATH
+  remote: .
+  specs:
+    jbundler (0.2.0)
+      ruby-maven (= 3.0.4.0.29.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    builder (3.0.0)
+    cucumber (1.1.9)
+      builder (>= 2.1.2)
+      diff-lcs (>= 1.1.2)
+      gherkin (~> 2.9.0)
+      json (>= 1.4.6)
+      term-ansicolor (>= 1.0.6)
+    diff-lcs (1.1.3)
+    gherkin (2.9.3-java)
+      json (>= 1.4.6)
+    json (1.7.3-java)
+    minitest (2.10.1)
+    ruby-maven (3.0.4.0.29.0)
+      thor (~> 0.14.6)
+    term-ansicolor (1.0.7)
+    thor (0.14.6)
+
+PLATFORMS
+  java
+
+DEPENDENCIES
+  cucumber (~> 1.1.9)
+  jbundler!
+  minitest (~> 2.10.0)

data/Readme.md

@@ -0,0 +1,88 @@
+# jbundler #
+
+* the DSL mimics the one from bundler
+* you can use maven like version declaration or rubygems/bundler like version ranges
+* it locks down the versions like bundler inside "Mvnfile.lock"
+* you can declare jar dependency within a rubygems using the requirements directive of the gem specification. jbundler will include those jar dependencies into its classpath
+* on the first run everything get resolved, any further run just the setup of classpath is done (without any maven involved)
+* it integrates nicely with bundler when Bundler.require is used
+
+## get started
+
+just add it as **first** entry in your *Gemfile* (pending since no gem is released)
+
+```gem 'jbundler'```
+
+such bundler config will trigger the classpath resolution on the first call of ```Bundler.require```, any successive runs will reuse the classpath from *.jbundler/classpath.rb* without any more action with maven.
+
+if you use only **rubygems** or **isolate** then following require will trigger the classpath setup
+
+```require 'jbundler'```
+
+## example ##
+
+**please first build the jar file for the jbundler gem, see [Build.md](Build.md).** 
+
+*example/my_project* has a Gemfile which uses a gem which depends on jar dependency. see *example/gem_with_jar/gem_with_jar.gemspec* how the jar gets declared.
+
+execute *example/my_project/info.rb* to see it in action:
+
+      cd example/my_project
+      jruby -S bundle install
+      jruby -S bundle exec info.rb
+
+## limitations ##
+
+update of single artifacts is not possible.
+
+since the version resolution happens in two steps - first the gems then the jars/poms - it is possible in case of failure of the second one there could be another set of versions for the gems which would then succeed the jars/poms resolution. but there is plenty of possible ways to improve this (maven could resolve the gems as well, etc)
+
+**Mvnfile** is **not** a DSL, i.e. it is not ruby though it could use a ruby DSL to read the data (any contribution welcome).
+
+## jar/pom dependencies ##
+
+a pom dependency is not associated with a jar file but has dependencies to other poms or jars. 
+
+dependencies can be declared either in **Mvnfile**
+
+    jar 'org.slf4j:slf4j-simple', '> 1.6.2', '< 1.7.0'
+    jar 'org.sonatype.aether:aether-api', '1.13'
+
+or inside the gemspec through the requirements (see also the example directory of this project):
+
+    Gem::Specification.new do |s|
+      s.name = 'gem_with_jar'
+      s.version = '0.0.0'
+      s.requirements << "jar 'org.slf4j:slf4j-api', '1.5.10'"
+    end
+    
+### maven like version ###
+
+```jar 'my.group.id:my-artifact-id', '1.2.3'```
+
+this will add the jar dependency for the maven artifact **my.group.id:my-artifact-id** with version **1.2.3**. this version will be treated as **maven version**, i.e. in case of a version conflict the one which is closer to project root will be used (see also: TODO link)
+
+### rubygem like version ###
+
+some example (see also: TODO link)
+
+    jar 'my.group.id:my-artifact-id', '1.2.3'
+    pom 'my.group:my-artifact-id', '=1.2.3'
+    jar 'my.group.id:artifact-id', '>1.2.3'
+    jar 'my.group:artifact-id', '>1.2.3', '=<2.0.1'
+
+the no version will default to **[0,)** (maven version range) which is **>=0** in the rubygems world.
+
+    jar 'group:artifact-id'
+
+the *not* version **!3.4.5** can not be mapped properly to a maven version ranges. **>3.4.5** is used instead in these (rare) cases.
+
+## update ##
+
+update of a single artifact is not possible (yet). but to update the whole set of artifacts just delete the lockfile *Mvnfile.lock*
+
+if jbundler sees that **Gemfile.lock** or **Mvnfile** is newer then the **.jbundler/classpath.rb** file then jbundler tries to gracefully upgrade towards the changes. the is a maven-like behaviour and once there are command line tools for jbundler they can behave like bundler.
+
+## meta-fu ##
+
+bug-reports and pull request are most welcome.

data/lib/jbundler.rb

@@ -1,34 +1,39 @@
-require 'jbundler/mavenfile'
+require 'maven/tools/jarfile'
 require 'jbundler/classpath_file'
 require 'jbundler/gemfile_lock'
 require 'jbundler/aether'
 
 config = JBundler::AetherConfig.new
 
-mavenfile = JBundler::Mavenfile.new(config.mavenfile)
-classpath_file = JBundler::ClasspathFile.new('.jbundler/classpath.rb')
-gemfile_lock = JBundler::GemfileLock.new(mavenfile, config.gemfile + '.lock')
+jarfile = Maven::Tools::Jarfile.new(config.jarfile)
+if config.skip
+  warn "skip jbundler setup"
+else
+  classpath_file = JBundler::ClasspathFile.new('.jbundler/classpath.rb')
+  gemfile_lock = JBundler::GemfileLock.new(jarfile, config.gemfile + '.lock')
 
-if classpath_file.needs_update?(mavenfile, gemfile_lock)
-  aether = JBundler::AetherRuby.new(config)
+  if classpath_file.needs_update?(jarfile, gemfile_lock)
+    aether = JBundler::AetherRuby.new(config)
 
-  mavenfile.populate_unlocked(aether)
-  gemfile_lock.populate_depedencies(aether)
-  mavenfile.populate_locked(aether)
+    jarfile.populate_unlocked(aether)
+    gemfile_lock.populate_dependencies(aether)
+    jarfile.populate_locked(aether)
 
-  aether.resolve
+    aether.resolve
 
-  classpath_file.generate(aether.classpath)
-  mavenfile.generate_lockfile(aether.resolved_coordinates)
-end
+    classpath_file.generate(aether.classpath)
+    jarfile.generate_lockfile(aether.resolved_coordinates)
+  end
 
-if classpath_file.exists?
-  require 'java'
-  classpath_file.require_classpath
-  if config.verbose
-    warn "jbundler classpath:"
-    JBUNDLER_CLASSPATH.each do |path|
-      warn "\t#{path}"
+  if classpath_file.exists?
+    require 'java'
+    classpath_file.require_classpath
+    if config.verbose
+      warn "jbundler classpath:"
+      JBUNDLER_CLASSPATH.each do |path|
+        warn "\t#{path}"
+      end
     end
   end
+
 end

data/lib/jbundler.rb~

@@ -0,0 +1,2 @@
+require 'jbundler/maven_gemify3'
+

data/lib/jbundler/aether.rb

@@ -1,4 +1,3 @@
-require 'java'
 require 'yaml'
 
 module JBundler
@@ -6,34 +5,54 @@ module JBundler
   # allow yaml config in $HOME/.jbundlerrc and $PWD/.jbundlerrc
   class AetherConfig
 
-    attr_accessor :verbose, :local_repository, :mavenfile, :gemfile
+    attr_accessor :verbose, :local_repository, :jarfile, :gemfile, :skip
 
     def initialize
       file = '.jbundlerrc'
       homefile = File.join(ENV['HOME'], file)
-      home = YAML.load_file() if File.exists? homefile
-      pwd = YAML.load_file(file) if File.exists? file
-      @config = (home || {}).merge(pwd || {})
+      home_config = YAML.load_file(homefile) if File.exists?(homefile)
+      pwd_config = YAML.load_file(file) if File.exists?(file)
+      @config = (home_config || {}).merge(pwd_config || {})
+    end
+
+    if defined? JRUBY_VERSION
+      def jbundler_env(key)
+        ENV[key.upcase.gsub(/./, '_')] || java.lang.System.getProperty(key.downcase.gsub(/_/, '.')) || @config[key.downcase.sub(/^j?bundler/, '').sub(/./, '_')]
+      end
+    else
+      def jbundler_env(key)
+        ENV[key.upcase.gsub(/./, '_')] || @config[key.downcase.sub(/^j?bundler/, '').sub(/./, '_')]
+      end
+    end
+    private :jbundler_env
+
+    def skip
+      skip = jbundler_env('JBUNDLE_SKIP')
+      # defaults to false
+      @skip ||= skip && skip != 'false'
     end
 
     def verbose
-      verbose = ENV['JBUNDLE_VERBOSE'] || @config['verbose']
+      verbose = jbundler_env('JBUNDLE_VERBOSE')
       # defaults to false
       @verbose ||= verbose && verbose != 'false'
     end
 
-    def mavenfile
-      @mavenfile ||= ENV['JBUNDLE_MAVENFILE'] || @config['mavenfile'] || 'Mvnfile'
+    def jarfile
+      if File.exists?('Mvnfile')
+        warn "'Mvnfile' name is deprecated, please use 'Jarfile' instead"
+        @jarfile = 'Mvnfile'
+      end
+      @jarfile ||= jbundler_env('JBUNDLE_JARFILE') || 'Jarfile'
     end
 
     def gemfile
-      @gemfile ||= ENV['BUNDLE_GEMFILE'] || 'Gemfile'
+      @gemfile ||= jbundler_env('BUNDLE_GEMFILE') || 'Gemfile'
     end
 
     def local_repository
       # use maven default local repo as default
-      @local_maven_repository ||= (ENV['JBUNDLE_LOCAL_REPOSITORY'] || 
-                                   @config['local_repository']|| 
+      @local_maven_repository ||= (jbundler_env('JBUNDLE_LOCAL_REPOSITORY') ||
                                    File.join( ENV['HOME'], ".m2", "repository"))
     end
   end
@@ -41,6 +60,8 @@ module JBundler
   class AetherRuby
 
     def self.setup_classloader
+      require 'java'
+
       maven_home = File.dirname(File.dirname(Gem.bin_path('ruby-maven', 
                                                            'rmvn')))
       # TODO reduce to the libs which are really needed
@@ -81,11 +102,15 @@ module JBundler
     end
 
     def resolve
-      @aether.resolve
+      @aether.resolve unless artifacts.empty?
     end
 
-    def classpath
-      @aether.classpath
+    def classpath 
+      if artifacts.empty?
+        ''
+      else
+        @aether.classpath
+      end
     end
    
     def repositories
@@ -97,7 +122,11 @@ module JBundler
     end
 
     def resolved_coordinates
-      @aether.resolved_coordinates
+      if artifacts.empty?
+        []
+      else
+        @aether.resolved_coordinates
+      end
     end
 
     def install(coordinate, file)

data/lib/jbundler/aether.rb~

@@ -0,0 +1,68 @@
+require 'java'
+module JBundler
+
+  class AetherRuby
+
+    def self.setup_classloader
+      unless defined? Aether
+        @maven_home = File.dirname(File.dirname(Gem.bin_path('ruby-maven', 
+                                                             'rmvn')))
+        # TODO reduce to the libs which are really needed
+        Dir.glob(File.join(@maven_home, 'lib', "*jar")).each {|path| require path }
+        require 'jbundler.jar'
+        java_import 'jbundler.Aether'
+      end
+    end
+
+    def initialize(local_repo = File.join( ENV['HOME'], 
+                                           ".m2", 
+                                           "repository"), 
+                   verbose = false)
+      self.class.setup_classloader
+      @aether = AetherRuby.new(local_repo, verbose)
+    end
+
+    def add_artifact(coordinate, extension = nil)
+      if extension
+        coord = coordinate.split(/:/)
+        coord.insert(2, extension)
+        @aether.add_artifact(coordinate.join(":"))
+      else
+        @aether.add_artifact(coordinate)
+      end
+    end
+
+    def add_repository(url, name = "repo_#{repos.size}")
+      @aether.add_repository(name, url)
+    end
+
+    def install(coordinate)
+      @aether.install(coordinate)
+    end
+
+    def resolve
+      @aether.resolve
+    end
+
+    def classpath
+      @aether.classpath
+    end
+    
+    def dependency_map
+      @aether.dependency_map
+    end
+    
+    def repositories
+      @aether.repositories
+    end
+
+    def dependency_coordinates
+      @aether.dependency_coordinates
+    end
+
+    def install(coordinate, file)
+      @aether.install(coordinate, file)
+    end
+    
+  end
+end