lock_jar 0.15.11-java

data/lib/lock_jar/class_loader.rb

@@ -0,0 +1,67 @@
+# 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 'lock_jar'
+require 'naether'
+
+module LockJar
+  #
+  # Create a ClassLoader populated by a lockfile
+  #
+  # @author Michael Guymon
+  #
+  class ClassLoader
+    # Create new instance, populating ClassLoader with lockfile
+    #
+    # @param [String] lockfile path
+    def initialize(lockfile)
+      # XXX: ensure Naether has been loaded, this should be handled less
+      #     clumsily
+      LockJar::Runtime.instance.resolver(nil)
+      @class_loader = com.tobedevoured.naether.PathClassLoader.new(
+        java.lang.Thread.currentThread.getContextClassLoader())
+
+      jars = LockJar.list(lockfile, local_paths: true)
+      jars.each do |jar|
+        add_path(jar)
+      end
+    end
+
+    # Execute block
+    #
+    # @param [Block] blk
+    def isolate(&blk)
+      instance_eval(&blk)
+    end
+
+    # Add path to the ClassLoader
+    #
+    # @param [String] path of Jar or directory to add to ClassLoader
+    # @return [Boolean] if added
+    def add_path(path)
+      @class_loader.addPath(path)
+    end
+
+    #
+    # Create new instance of a Java class using the populated ClassLoader
+    #
+    # @param [String] clazz fully qualified Java class
+    # @param [Array] args arguments for constructing the Java class
+    # @return [Object]
+    def new_instance(clazz, *args)
+      @class_loader.newInstance(clazz, *args)
+    end
+  end
+end

data/lib/lock_jar/cli.rb

@@ -0,0 +1,92 @@
+require 'rubygems'
+require 'thor'
+require 'lock_jar'
+require 'lock_jar/logging'
+
+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
+
+      def verbose_option
+        method_option(
+          :verbose,
+          aliases: '-v',
+          type: :boolean,
+          desc: 'Verbose output'
+        )
+      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
+    verbose_option
+    def install
+      handle_verbose(options[:verbose])
+      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
+    verbose_option
+    def list
+      handle_verbose(options[:verbose])
+      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
+    verbose_option
+    def lock
+      handle_verbose(options[:verbose])
+      puts "Locking #{options[:jarfile]} to #{options[:lockfile]}"
+      LockJar.lock(options[:jarfile], lockfile: options[:lockfile])
+    end
+
+    private
+
+    def handle_verbose(verbose)
+      LockJar::Logging.verbose! if verbose
+      nil
+    end
+  end
+end

data/lib/lock_jar/config.rb

@@ -0,0 +1,41 @@
+require 'yaml'
+
+module LockJar
+  # Global configuration for LockJar
+  class Config
+    CONFIG_ENV = 'LOCKJAR_CONFIG'.freeze
+    DEFAULT_FILENAME = '.lockjar'.freeze
+
+    attr_reader :repositories
+
+    class << self
+      # Load .lockjar YAML config file from ENV['LOCKJAR_CONFIG'], current_dir, or
+      # home dir.
+      def load_config_file
+        local_config_paths =
+          [Dir.pwd, Dir.home]
+          .map { |path| File.join(path, DEFAULT_FILENAME) }
+
+        config_path =
+          ([ENV[CONFIG_ENV]] + local_config_paths)
+          .compact
+          .find { |path| File.exist? path }
+
+        new(YAML.load_file(config_path)) if config_path
+      end
+    end
+
+    #
+    # {
+    #   'repositories' => {
+    #     ':url' => {
+    #       'username' => ''
+    #       'password' => ''
+    #     }
+    #   }
+    # }
+    def initialize(config)
+      @repositories = config['repositories'] || {}
+    end
+  end
+end

data/lib/lock_jar/domain/artifact.rb

@@ -0,0 +1,114 @@
+# 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 <=>(other)
+        return to_urn <=> other.to_urn if other.is_a? Artifact
+
+        to_urn <=> other.to_s
+      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(pom_path, pom_scopes = %w(compile runtime))
+        @type = 'pom'
+        @path = pom_path
+        @scopes = pom_scopes
+      end
+
+      def to_urn
+        "pom:#{path}"
+      end
+
+      def to_dep
+        { path => scopes }
+      end
+
+      def notations
+        LockJar::Maven.dependencies(path, scopes)
+      end
+
+      def ==(other)
+        self.<=>(other) == 0
+      end
+
+      def <=>(other)
+        if other.is_a? Pom
+          return Set.new(scopes) <=> Set.new(other.scopes) if to_urn == other.to_urn
+
+          to_urn <=> other.to_urn
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/lock_jar/domain/dsl.rb

@@ -0,0 +1,165 @@
+# 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 'lock_jar/maven'
+require 'lock_jar/domain/dsl_merger'
+require 'lock_jar/domain/artifact'
+
+module LockJar
+  module Domain
+    #
+    class Dsl
+      DEFAULT_GROUP = ['default'].freeze
+
+      attr_accessor :artifacts, :remote_repositories, :local_repository, :groups,
+                    :maps, :excludes, :merged, :clear_repositories
+
+      attr_reader :file_path
+
+      class << self
+        def create(jarfile = nil, &blk)
+          builder = new
+          evaluate(builder, jarfile, &blk)
+        end
+
+        def evaluate(builder, jarfile = nil, &blk)
+          fail 'jarfile or block must be set' if jarfile.nil? && blk.nil?
+
+          builder.instance_eval(IO.read(jarfile.to_s), jarfile.to_s, 1) if jarfile
+
+          builder.instance_eval(&blk) if blk
+
+          builder
+        end
+      end
+
+      def initialize
+        @remote_repositories = []
+        @artifacts = { 'default' => [] }
+        @group_changed = false
+        @present_group = 'default'
+        @local_repository = nil
+        @maps = {}
+        @excludes = []
+        @merged = []
+        @clear_repositories = false
+      end
+
+      def exclude(*notations)
+        @excludes += notations
+      end
+
+      def jar(notation, *args)
+        opts = {}
+
+        opts.merge!(args.last) if args.last.is_a? Hash
+
+        artifact = Jar.new(notation)
+
+        assign_groups(artifact, opts[:group])
+      end
+
+      def local(*args)
+        return if args.empty?
+
+        if File.directory?(File.expand_path(args.first))
+          warn(
+            '[DEPRECATED] `local` to set local_repository is deprecated. '\
+            'Please use `local_repo` instead'
+          )
+          local_repo(args.first)
+        else
+          path = args.shift
+
+          opts = {}
+
+          opts.merge!(args.last) if args.last.is_a? Hash
+
+          artifact = Local.new(path)
+
+          assign_groups(artifact, opts[:group])
+        end
+      end
+
+      def local_repo(path)
+        @local_repository = path
+      end
+
+      alias_method :name, :local_repository
+
+      # Map a dependency to another dependency or local directory.
+      def map(notation, *args)
+        @maps[notation] = args
+      end
+
+      #
+      def pom(path, *args)
+        fail "#{path} is an invalid pom path" unless path =~ /\.xml$/i
+
+        opts = { scopes: %w(runtime compile) }
+
+        opts.merge!(args.last) if args.last.is_a? Hash
+
+        assign_groups(Pom.new(path, opts[:scopes]), opts[:groups])
+      end
+
+      def remote_repo(url, _opts = {})
+        @remote_repositories << url
+      end
+      alias_method :remote_repository, :remote_repo
+      alias_method :repository, :remote_repo
+
+      def group(*groups, &_blk)
+        @group_changed = true
+        groups.each do |group|
+          @present_group = group.to_s
+          yield
+        end
+        @group_changed = false
+        @present_group = 'default'
+      end
+
+      # @deprecated Please use {#group} instead
+      def scope(*scopes, &blk)
+        warn '[DEPRECATED] `scope` is deprecated.  Please use `group` instead.'
+        group(*scopes, &blk)
+      end
+
+      def without_default_maven_repo
+        @clear_repositories = true
+      end
+
+      private
+
+      def assign_groups(artifact, groups = nil)
+        if groups
+          groups = Array(groups)
+
+          # include present group if within a group block
+          groups << @present_group if @group_changed
+
+        else
+          groups = [@present_group]
+        end
+
+        groups.uniq.each do |group|
+          group_key = group.to_s
+          @artifacts[group_key] = [] unless @artifacts[group_key]
+          @artifacts[group_key] << artifact
+        end if artifact
+      end
+    end
+  end
+end

data/lib/lock_jar/domain/dsl_merger.rb

@@ -0,0 +1,76 @@
+# 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.
+
+module LockJar
+  module Domain
+    # Merge DSLs
+    class DslMerger
+      attr_reader :into_dsl, :from_dsl, :into_groups
+
+      # @param [LockJar::Domain::Dsl] into_dsl dsl that is merged into
+      # @param [LockJar::Domain::Dsl] from_dsl dsl that is merged from
+      # @param [String] into_group force only runtime and default groups to be
+      #                            loaded into this group
+      def initialize(into_dsl, from_dsl, into_groups = nil)
+        @into_dsl = into_dsl
+        @from_dsl = from_dsl
+        @into_groups = into_groups
+      end
+
+      # Merge LockJar::Domain::Dsl
+      # @return [LockJar::Domain::Dsl]
+      def merge
+        merged_dsl = into_dsl.dup
+
+        merged_dsl.remote_repositories = remote_repositories
+
+        merged_dsl.artifacts = artifact_groups(into_groups)
+
+        from_dsl.maps.each do |artifact, paths|
+          maps = into_dsl.maps[artifact] || []
+          merged_dsl.maps[artifact] = (maps + paths).uniq
+        end
+
+        from_dsl.excludes.each do |exclude|
+          merged_dsl.excludes << exclude unless into_dsl.excludes.include? exclude
+        end
+
+        merged_dsl.merged << from_dsl.file_path if from_dsl.file_path
+
+        merged_dsl
+      end
+
+      private
+
+      def remote_repositories
+        (into_dsl.remote_repositories + from_dsl.remote_repositories).uniq
+      end
+
+      def artifact_groups(restrict = nil)
+        artifacts = Hash.new { |hash, key| hash[key] = [] }
+
+        from_dsl.artifacts.each do |group, group_artifacts|
+          next if restrict && !restrict.include?(group)
+          artifacts[group] += into_dsl.artifacts[group] || []
+          group_artifacts.each do |art|
+            artifacts[group] << art unless artifacts[group].include? art
+          end
+        end
+
+        artifacts
+      end
+    end
+  end
+end

data/lib/lock_jar/domain/gem_dsl.rb

@@ -0,0 +1,43 @@
+# 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 'lock_jar/maven'
+require 'lock_jar/domain/jarfile_dsl'
+require 'lock_jar/domain/dsl_merger'
+
+module LockJar
+  module Domain
+    # Jarfile found in a Gem
+    class GemDsl < JarfileDsl
+      attr_accessor :gem_dir
+
+      class << self
+        def create(spec, jarfile)
+          builder = new
+          builder.gem_dir = spec.gem_dir
+
+          builder.file_path = "gem:#{spec.name}:Jarfile.lock"
+
+          evaluate(builder, jarfile)
+        end
+      end
+
+      alias_method :overriden_pom, :pom
+      def pom(path, *args)
+        overriden_pom(File.join(gem_dir, path), *args)
+      end
+    end
+  end
+end

data/lib/lock_jar/domain/jarfile_dsl.rb

@@ -0,0 +1,35 @@
+# 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 'lock_jar/maven'
+require 'lock_jar/domain/dsl_merger'
+
+module LockJar
+  module Domain
+    # Jarfile DSL
+    class JarfileDsl < Dsl
+      attr_accessor :file_path
+
+      class << self
+        def create(jarfile)
+          builder = new
+          builder.file_path = jarfile
+
+          evaluate(builder, jarfile)
+        end
+      end
+    end
+  end
+end