lock_jar 0.15.11-java

data/lib/lock_jar/runtime/lock.rb

@@ -0,0 +1,152 @@
+require 'delegate'
+
+module LockJar
+  #
+  class Runtime
+    #
+    class Lock < SimpleDelegator
+      attr_accessor :jarfile, :lockfile, :opts
+
+      def initialize(runtime)
+        super(runtime)
+
+        @lockfile = LockJar::Domain::Lockfile.new
+      end
+
+      def lock(jarfile_or_dsl, opts = {}, &blk)
+        @opts = { download: true }.merge(opts)
+
+        create_dsl!(jarfile_or_dsl, &blk)
+
+        apply_repositories!
+
+        apply_maps!
+
+        apply_excludes!
+
+        apply_merged!
+
+        artifacts = jarfile.artifacts.values.flatten
+        apply_artifacts!(artifacts) unless artifacts.empty?
+
+        lockfile.write(@opts[:lockfile] || 'Jarfile.lock')
+
+        lockfile
+      end
+
+      private
+
+      def create_dsl!(jarfile_or_dsl, &blk)
+        if jarfile_or_dsl
+          @jarfile = if jarfile_or_dsl.is_a? LockJar::Domain::Dsl
+                       jarfile_or_dsl
+                     else
+                       LockJar::Domain::JarfileDsl.create(jarfile_or_dsl)
+                     end
+        end
+
+        return @jarfile if blk.nil?
+
+        if @jarfile
+          @jarfile = LockJar::Domain::DslMerger.new(
+            jarfile, LockJar::Domain::Dsl.create(&blk)).merge
+        else
+          @jarfile = LockJar::Domain::Dsl.create(&blk)
+        end
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def apply_artifacts!(artifacts)
+        # Build the dependencies_graph hash in the resolver
+        resolver(opts).resolve(
+          artifacts.select(&:resolvable?).map(&:to_dep), opts[:download] == true
+        )
+
+        jarfile.artifacts.each do |group_name, group_artifacts|
+          group = { 'locals' => [], 'dependencies' => [], 'artifacts' => [] }
+
+          group_artifacts.each do |artifact|
+            artifact_data = {}
+
+            add_artifact!(group, artifact_data, artifact)
+
+            next unless artifact_data['transitive']
+
+            # flatten the graph of nested hashes
+            group['dependencies'] += dependency_merge(artifact_data['transitive'])
+            # xxX: set required_by ?
+            group['artifacts'] << { artifact.to_urn => artifact_data }
+          end
+
+          lockfile.excludes.each do |exclude|
+            group['dependencies'].delete_if { |dep| dep =~ /#{exclude}/ }
+          end if lockfile.excludes
+
+          group['dependencies'] = group['dependencies'].sort.uniq
+
+          group.delete 'locals' if group['locals'].empty?
+
+          lockfile.groups[group_name] = group
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def apply_excludes!
+        lockfile.excludes = jarfile.excludes if jarfile.excludes.size > 0
+      end
+
+      def apply_maps!
+        lockfile.maps = jarfile.maps if jarfile.maps.size > 0
+      end
+
+      def apply_merged!
+        lockfile.merged = jarfile.merged unless jarfile.merged.empty?
+      end
+
+      def apply_repositories!
+        lockfile.local_repository = opts[:local_repo] ||= jarfile.local_repository
+
+        if jarfile.clear_repositories
+          resolver(opts).clear_remote_repositories
+        else
+          repos = resolver(opts).remote_repositories
+          lockfile.remote_repositories += repos.to_a if repos
+        end
+
+        # Add remote repos to the resolver and the lockfile
+        jarfile.remote_repositories.each do |repo|
+          resolver(opts).add_remote_repository(repo)
+          lockfile.remote_repositories << repo
+        end
+      end
+
+      def add_artifact!(group, artifact_data, artifact)
+        if artifact.is_a? LockJar::Domain::Jar
+          group['dependencies'] << artifact.notation
+          g = resolver(opts).dependencies_graph[artifact.notation]
+          artifact_data['transitive'] = g.to_hash if g
+
+        elsif artifact.is_a? LockJar::Domain::Pom
+          artifact_data['scopes'] = artifact.scopes
+
+          # iterate each dependency in Pom to map transitive dependencies
+          transitive = {}
+          artifact.notations.each do |notation|
+            transitive[notation] = resolver(opts).dependencies_graph[notation]
+          end
+          artifact_data['transitive'] = transitive
+
+        elsif artifact.is_a? LockJar::Domain::Local
+          group['locals'] << artifact.path
+        else
+          fail("Unsupported artifact: #{artifact.inspect}")
+        end
+      end
+
+      def dependency_merge(graph)
+        deps = graph.keys
+        graph.values.flat_map { |next_step| deps += dependency_merge(next_step) }
+      end
+    end
+  end
+end

data/lib/lock_jar/runtime.rb

@@ -0,0 +1,106 @@
+# 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 'yaml'
+require 'singleton'
+require 'lock_jar/config'
+require 'lock_jar/resolver'
+require 'lock_jar/registry'
+require 'lock_jar/domain/dsl'
+require 'lock_jar/domain/jarfile_dsl'
+require 'lock_jar/domain/lockfile'
+require 'lock_jar/runtime/load'
+require 'lock_jar/runtime/lock'
+require 'lock_jar/runtime/list'
+require 'lock_jar/runtime/install'
+
+module LockJar
+  #
+  class Runtime
+    include Singleton
+    include Load
+    include List
+    include Install
+
+    attr_reader :current_resolver, :config
+
+    def initialize
+      @config = Config.load_config_file
+      @current_resolver = nil
+    end
+
+    def lock(jarfile_or_dsl, opts = {}, &blk)
+      Lock.new(self).lock(jarfile_or_dsl, opts, &blk)
+    end
+
+    def opts
+      current_resolver.opts if current_resolver
+    end
+
+    def resolver(opts = {})
+      # XXX: Caches the resolver by the options. Passing in nil opts will replay
+      #      from the cache. This need to change.
+      if !opts.nil?
+        opts[:local_repo] = File.expand_path(opts[:local_repo]) if opts[:local_repo]
+      elsif @current_resolver
+        opts = @current_resolver.opts
+      else
+        opts = {}
+      end
+
+      if @current_resolver.nil? || opts != @current_resolver.opts
+        @current_resolver = LockJar::Resolver.new(config, opts)
+      end
+
+      @current_resolver
+    end
+
+    def reset!
+      @current_resolver = nil
+    end
+
+    private
+
+    def lockfile_dependencies(lockfile, groups, with_locals = true)
+      dependencies = []
+
+      groups.each do |group|
+        next unless lockfile.groups[group.to_s]
+        dependencies += yield lockfile.groups[group.to_s]
+
+        if with_locals
+          locals = lockfile.groups[group.to_s]['locals']
+          dependencies += locals if locals
+        end
+      end
+
+      dependencies
+    end
+
+    def dsl_dependencies(dsl, groups, with_locals = true)
+      dependencies = []
+
+      groups.each do |group|
+        dependencies += dsl.artifacts[group.to_s] if dsl.artifacts[group.to_s]
+      end
+
+      unless with_locals
+        dependencies.select! { |dep| !dep.is_a? LockJar::Domain::Local }
+      end
+
+      dependencies
+    end
+  end
+end

data/lib/lock_jar/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+module LockJar
+  # still the version
+  VERSION = '0.15.11'.freeze
+end

data/lib/lock_jar.rb

@@ -0,0 +1,203 @@
+# 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 'yaml'
+require 'lock_jar/config'
+require 'lock_jar/resolver'
+require 'lock_jar/runtime'
+require 'lock_jar/version'
+require 'lock_jar/domain/lockfile'
+require 'lock_jar/domain/jarfile_dsl'
+require 'lock_jar/domain/gem_dsl'
+require 'lock_jar/domain/dsl'
+
+#
+# LockJar manages Java Jars for Ruby.
+#
+# @author Michael Guymon
+#
+module LockJar
+  class << self
+    #
+    # Override LockJar configuration
+    #
+    def config(opts)
+      Runtime.instance.resolver(opts)
+    end
+
+    def install(*args, &blk)
+      lockfile, groups, opts = extract_args :lockfile, args, &blk
+      Runtime.instance.install(lockfile, groups, opts, &blk)
+    end
+
+    # Lists all dependencies as notations for groups from the Jarfile.lock.
+    # Depending on the type of arg, a different configuration is set.
+    #
+    # * An arg of a String will set the Jarfile.lock, e.g. 'Better.lock'.
+    #   Default lock file is *Jarfile.lock*.
+    # * An arg of an Array will set the groups, e.g. ['development','test'].
+    #   Defaults group is *default*
+    # * An arg of a Hash will set the options, e.g. { :local_repo => 'path' }
+    #   * :local_repo [String] sets the local repo path
+    #   * :local_paths [Boolean] to true converts the notations to paths to jars
+    #                            in the local repo path
+    #   * :resolve [Boolean] to true will make transitive dependences resolve
+    #                        before loading to classpath
+    #
+    # A block can be passed in, overriding values from a Jarfile.lock.
+    #
+    # @return [Array] of jar and mapped path
+    def list(*args, &blk)
+      lockfile, groups, opts = extract_args :lockfile, args, &blk
+      Runtime.instance.list(lockfile, groups, opts, &blk)
+    end
+
+    # LockJar.load(*args): Loads all dependencies to the classpath for groups
+    # from the Jarfile.lock. Depending on the type of arg, a different configuration is set.
+    # * An arg of a String will set the Jarfile.lock, e.g. 'Better.lock'.
+    #   Default lock file is *Jarfile.lock*.
+    # * An arg of an Array will set the groups, e.g. ['development','test'].
+    #   Defaults group is *default*.
+    # * An arg of a Hash will set the options, e.g. { :local_repo => 'path' }
+    #    * :local_repo [String] sets the local repo path
+    #    * :resolve [Boolean] to true will make transitive dependences resolve
+    #                         before loading to classpath
+    #    * :disable [Boolean] to true will disable any additional calls to load and lock
+    #
+    # A block can be passed in, overriding values from a Jarfile.lock.
+    #
+    # @return [Array] of absolute paths of jars and mapped paths loaded into claspath
+    def load(*args, &blk)
+      if Runtime.instance.opts.nil? || !Runtime.instance.opts[:disable]
+        lockfile, groups, opts = extract_args(:lockfile, args, &blk)
+        Runtime.instance.load(lockfile, groups, opts, &blk)
+      else
+        puts 'LockJar#load has been disabled'
+        []
+      end
+    end
+
+    # Lock a Jarfile and generate a Jarfile.lock.
+    #
+    # LockJar.lock accepts an Array for parameters. Depending on the type of
+    # arg, a different configuration is set.
+    #
+    # * An arg of a String will set the Jarfile, e.g. 'Jarfile.different'.
+    #   Default Jarfile is *Jarfile*.
+    # * An arg of a Hash will set the options, e.g. { :local_repo => 'path' }
+    #   * :download_artifacts if true, will download jars to local repo. Defaults to true.
+    #   * :local_repo sets the local repo path
+    #   * :lockfile sets the Jarfile.lock path. Default lockfile is *Jarfile.lock*.
+    #   * :disable [Boolean] to true will disable any additional calls to load and lock
+
+    # A block can be passed in, overriding values from a Jarfile.
+    #
+    # @return [Hash] Lock data
+    def lock(*args, &blk)
+      if Runtime.instance.opts.nil? || !Runtime.instance.opts[:disable]
+        jarfile, _, opts = extract_args(:jarfile, args, &blk)
+        Runtime.instance.lock(jarfile, opts, &blk)
+      else
+        puts 'LockJar#lock has been disabled'
+        []
+      end
+    end
+
+    #
+    # Read a Jafile.lock and convert it to a LockJar::Domain::Lockfile
+    #
+    # @param [String] lockfile path to lockfile
+    # @return [Hash] Lock Data
+    def read(lockfile)
+      LockJar::Domain::Lockfile.read(lockfile)
+    end
+
+    # Add a Jarfile to be included when LockJar.lock_registered_jarfiles is called.
+    #
+    # @param [String] jarfile path to register
+    # @param [GemSpec] gem spec if the Jarfile is from a gem
+    # @return [Array] All registered jarfiles
+    def register_jarfile(jarfile, gem_spec = nil)
+      fail "Jarfile not found: #{jarfile}" unless File.exist? jarfile
+      registered_jarfiles[jarfile] = gem_spec
+    end
+
+    # Clear all registered jarfiles
+    def reset_registered_jarfiles
+      @registered_jarfiles = {}
+    end
+
+    # Hash of registered jarfiles
+    def registered_jarfiles
+      @registered_jarfiles ||= {}
+    end
+
+    # Lock the registered Jarfiles and generate a Jarfile.lock.
+    #
+    # Options and groups are passed through to the LockJar.lock method, but
+    # if a Jarfile is specified, it will be ignored. Use LockJar.register_jarfile
+    # to add dependencies.
+    #
+    # A block can be passed in, overriding values from the Jarfiles.
+    #
+    # @return [Hash] Lock data
+    def lock_registered_jarfiles(*args, &blk)
+      jarfiles = registered_jarfiles
+      return if jarfiles.empty?
+      instances = jarfiles.map do |jarfile, spec|
+        if spec
+          LockJar::Domain::GemDsl.create spec, jarfile
+        else
+          LockJar::Domain::JarfileDsl.create jarfile
+        end
+      end
+      combined = instances.reduce do |result, inst|
+        LockJar::Domain::DslMerger.new(result, inst).merge
+      end
+      args = args.reject { |arg| arg.is_a? String }
+      lock(combined, *args, &blk)
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def extract_args(type, args, &blk)
+      lockfile_or_path = nil
+      opts = {}
+      groups = ['default']
+      args.each do |arg|
+        case arg
+        when Hash
+          opts.merge!(arg)
+        when String
+          lockfile_or_path = arg
+        when LockJar::Domain::Lockfile
+          lockfile_or_path = arg if type == :lockfile
+        when LockJar::Domain::Dsl
+          lockfile_or_path = arg if type == :jarfile
+        when Array
+          groups = arg
+        end
+      end
+      if blk.nil? && lockfile_or_path.nil?
+        if type == :lockfile
+          lockfile_or_path = opts.fetch(:lockfile, 'Jarfile.lock')
+        elsif type == :jarfile
+          lockfile_or_path = 'Jarfile'
+        end
+      end
+      [lockfile_or_path, groups, opts]
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+  end
+end

data/lock_jar.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'lock_jar/version'
+
+unless RUBY_PLATFORM == 'java'
+  raise "lock_jar requires JRuby. Current platform: #{RUBY_PLATFORM}. Please install and use JRuby to run this gem."
+end
+
+Gem::Specification.new do |s|
+  s.name = 'lock_jar'
+  s.version = LockJar::VERSION
+  s.authors = ['Michael Guymon']
+  s.date = '2014-03-06'
+  s.description = 'Manage Jar files for Ruby. In the spirit of Bundler, a 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'
+  s.email = 'michael@tobedevoured.com'
+  s.files         = `git ls-files -z`.split("\x0")
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.extra_rdoc_files = %w(LICENSE README.md)
+  s.homepage = 'http://github.com/mguymon/lock_jar'
+  s.licenses = %w(Apache)
+  s.require_paths = %w(lib)
+  s.summary = 'Manage Jar files for Ruby'
+  s.platform = 'java'
+
+  s.add_dependency('naether', ['~> 0.15.11'])
+  s.add_dependency('thor', ['>= 0.18.1'])
+  s.add_development_dependency('rspec', '~> 3.0')
+  s.add_development_dependency('rubocop', '~> 0.35.0')
+  s.add_development_dependency('rake')
+end

data/spec/fixtures/Jarfile

@@ -0,0 +1,14 @@
+local_repo '~/.m2/repository'
+repository 'http://mirrors.ibiblio.org/pub/mirrors/maven2'
+
+jar "org.apache.mina:mina-core:2.0.4"
+local "spec/fixtures/naether-0.13.0.jar"
+pom 'spec/pom.xml'
+
+group 'development' do
+    jar 'com.typesafe:config:jar:0.5.0'
+end
+
+group 'test' do
+    jar 'org.testng:testng:jar:6.9.10'
+end

data/spec/fixtures/Jarfile2

@@ -0,0 +1 @@
+jar "org.eclipse.jetty:jetty-servlet:8.1.3.v20120416"

data/spec/fixtures/jarfile_gem/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in jarfile_gem.gemspec
+gemspec

data/spec/fixtures/jarfile_gem/Jarfile

@@ -0,0 +1 @@
+jar 'commons-lang:commons-lang:jar:2.4'

data/spec/fixtures/jarfile_gem/jarfile_gem.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jarfile_gem/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "jarfile_gem"
+  spec.version       = JarfileGem::VERSION
+  spec.authors       = ["Michael Guymon"]
+  spec.email         = ["michael@tobedevoured.com"]
+  spec.summary       = %q{a short summary.}
+  spec.description   = %q{a longer description.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/spec/fixtures/jarfile_gem/lib/jarfile_gem/version.rb

@@ -0,0 +1,3 @@
+module JarfileGem
+  VERSION = "0.0.1"
+end

data/spec/fixtures/jarfile_gem/lib/jarfile_gem.rb

@@ -0,0 +1,5 @@
+require "jarfile_gem/version"
+
+module JarfileGem
+  # Your code goes here...
+end

data/spec/fixtures/lock_jar_config.yml

@@ -0,0 +1,4 @@
+repositories:
+  'https://some.fancy.doman/maven':
+    username: 'user1'
+    password: 'the_pass'

data/spec/lock_jar/bundler_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'lock_jar/bundler'
+require 'bundler/cli'
+require 'bundler/cli/install'
+
+describe LockJar::Bundler do
+  include Spec::Helpers
+
+  describe '.lock!' do
+    let(:bundler) do
+      Class.new { attr_accessor :setup }.new
+    end
+
+    before do
+      remove_file('Jarfile.lock')
+    end
+
+    context 'when Bundler.install has run' do
+      xit 'should create Jarfile.lock' do
+        LockJar::Bundler.lock!('spec/fixtures/Jarfile')
+        expect(File).to exist('Jarfile.lock')
+      end
+    end
+
+    context 'when Bundler.setup has run' do
+      before { bundler.setup = true }
+
+      it 'should not create Jarfile.lock' do
+        LockJar::Bundler.lock!(bundler, 'spec/fixtures/Jarfile')
+        expect(File).to_not exist('Jarfile.lock')
+      end
+    end
+  end
+end

data/spec/lock_jar/class_loader_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require 'lock_jar/class_loader'
+
+describe LockJar::ClassLoader, '#isolate' do
+  if Naether.platform != 'java'
+    pending 'need tests for RJB backed classloader'
+  else
+    it 'should create a SimpleEmail' do
+      # Generate the IsolateJarfile.lock
+      LockJar.lock(lockfile: "#{TEMP_DIR}/IsolateJarfile.lock") do
+        jar 'org.apache.commons:commons-email:1.2'
+      end
+
+      email = LockJar::ClassLoader.new("#{TEMP_DIR}/IsolateJarfile.lock").isolate do
+        email = new_instance('org.apache.commons.mail.SimpleEmail')
+        email.setSubject('test subject')
+
+        email
+      end
+
+      email.getSubject.should eql 'test subject'
+
+      unless $CLASSPATH.nil?
+        $CLASSPATH.to_a.join(' ').should_not =~ /commons-email-1\.2\.jar/
+      end
+
+      expect { org.apache.commons.mail.SimpleEmail.new }.to raise_error
+    end
+
+    it 'should create a JsonFactory and ObjectMapper' do
+      # Generate the IsolateJarfile.lock
+      LockJar.lock(lockfile: "#{TEMP_DIR}/IsolateJarfile.lock") do
+        jar 'com.fasterxml.jackson.core:jackson-core:2.0.6'
+        jar 'com.fasterxml.jackson.core:jackson-databind:2.0.6'
+      end
+
+      json = '{ "test1": "1test1", "test2": "2test2" }'
+
+      map = LockJar::ClassLoader.new("#{TEMP_DIR}/IsolateJarfile.lock").isolate do
+        factory = new_instance('com.fasterxml.jackson.core.JsonFactory')
+        mapper = new_instance('com.fasterxml.jackson.databind.ObjectMapper', factory)
+        mapper.readValue(json, java.util.Map.java_class)
+      end
+
+      map.get('test1').should eql '1test1'
+      map.get('test2').should eql '2test2'
+
+      unless $CLASSPATH.nil?
+        $CLASSPATH.to_a.join(' ').should_not =~ /jackson-databind-2\.0\.6\.jar/
+      end
+
+      expect { com.fasterxml.jackson.core.JsonFactory.new }.to raise_error
+    end
+  end
+end