lock_jar 0.15.11-java

data/lib/lock_jar/domain/lockfile.rb

@@ -0,0 +1,113 @@
+# 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 'set'
+require 'lock_jar/version'
+
+module LockJar
+  module Domain
+    # Class representation of the lock file
+    class Lockfile
+      attr_accessor :local_repository, :maps, :excludes, :remote_repositories,
+                    :version, :groups, :gems, :merged
+
+      # rubocop:disable Metrics/PerceivedComplexity
+      def self.read(path)
+        lock_data = fs_or_classpath(path)
+
+        fail "lockfile #{path} not found" if lock_data.nil?
+
+        Lockfile.new.tap do |lockfile|
+          lockfile.version = lock_data['version'] || LockJar::VERSION
+          lockfile.merged = lock_data['merged']
+          lockfile.local_repository = lock_data['local_repository']
+          lockfile.merged = lock_data['merged'] || []
+          lockfile.maps = lock_data['maps'] || []
+          lockfile.excludes = lock_data['excludes'] || []
+          lockfile.groups = lock_data['groups'] || lock_data['scopes'] || {}
+          lockfile.remote_repositories =
+            Set.new(Array(lock_data['remote_repositories'] || lock_data['repositories']))
+          lockfile.gems = lock_data['gems'] || []
+        end
+      end
+      # rubocop:enable Metrics/PerceivedComplexity
+
+      def self.fs_or_classpath(path)
+        if File.exist? path
+          YAML.load_file(path)
+
+        # Lookup of Jarfile.lock in the classpath
+        elsif Naether.platform == 'java' || path.start_with?('classpath:')
+          stream = java.lang.Object.java_class.resource_as_stream("/#{path.gsub('classpath:', '')}")
+          if stream
+            reader = java.io.BufferedReader.new(java.io.InputStreamReader.new(stream))
+            lines = ''
+            while (line = reader.read_line)
+              lines << line << "\n"
+            end
+            reader.close
+
+            YAML.load(lines)
+          end
+        end
+      end
+
+      def initialize
+        @groups = { 'default' => {} }
+        @maps = []
+        @excludes = []
+        @remote_repositories = Set.new
+        @gems = []
+        @merged = []
+
+        @version = LockJar::VERSION # default version
+      end
+
+      def to_hash
+        lock_data = { 'version' => @version }
+
+        lock_data['local_repository'] = local_repository unless local_repository.nil?
+
+        lock_data['merged'] = merged unless merged.empty?
+
+        lock_data['maps'] = maps if maps.size > 0
+
+        lock_data['excludes'] = excludes if excludes.size > 0
+
+        lock_data['gems'] = gems unless gems.empty?
+
+        lock_data['groups'] = groups
+
+        if remote_repositories.size > 0
+          lock_data['remote_repositories'] = remote_repositories.to_a
+        end
+
+        lock_data
+      end
+      alias_method :to_h, :to_hash
+
+      def to_yaml
+        to_hash.to_yaml
+      end
+
+      def write(path)
+        File.open(path, 'w') do |f|
+          f.write(to_yaml)
+        end
+      end
+    end
+  end
+end

data/lib/lock_jar/logging.rb

@@ -0,0 +1,14 @@
+require 'naether/java'
+
+module LockJar
+  #
+  class Logging
+    def self.verbose!
+      Naether::Java.exec_static_method(
+        'com.tobedevoured.naether.LogUtil',
+        'setDefaultLogLevel',
+        ['info']
+      )
+    end
+  end
+end

data/lib/lock_jar/maven.rb

@@ -0,0 +1,112 @@
+# 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 'naether/maven'
+
+module LockJar
+  # Helper for providing Maven specific operations
+  #
+  # @author Michael Guymon
+  #
+  class Maven
+    class << self
+      #
+      # Get the version of a POM
+      #
+      # @param [String] pom_path path to the pom
+      #
+      # @return [String] version of POM
+      #
+      def pom_version(pom_path)
+        maven = Naether::Maven.create_from_pom(pom_path)
+        maven.version
+      end
+
+      #
+      # Get dependencies of a Pom
+      #
+      # @param [String] pom_path path to the pom
+      # @param [Array] scopes
+      #
+      # @return [String] version of POM
+      #
+      def dependencies(pom_path, scopes = %w(compile runtime))
+        maven = Naether::Maven.create_from_pom(pom_path)
+        maven.dependencies(scopes)
+      end
+
+      #
+      # Write a POM from list of notations
+      #
+      # @param [String] pom notation
+      # @param [String] file_path path of new pom
+      # @param [Hash] opts
+      # @option opts [Boolean] :include_resolved to add dependencies of resolve
+      #                        dependencies from Jarfile.lock. Default is true.
+      # @option opts [Array] :dependencies Array of of mixed dependencies:
+      #  * [String] Artifact notation, such as groupId:artifactId:version, e.g. 'junit:junit:4.7'
+      #  * [Hash] of a single artifaction notation => scope - { 'junit:junit:4.7' => 'test' }
+      #
+      def write_pom(notation, file_path, opts = {})
+        opts = { include_resolved: true }.merge(opts)
+
+        maven = Naether::Maven.create_from_notataion(notation)
+
+        if opts[:include_resolved]
+          # Passes in nil to the resolver to get the cache
+          maven.load_naether(Runtime.instance.resolver.naether)
+        end
+
+        if opts[:dependencies]
+          opts[:dependencies].each do |dep|
+            if dep.is_a? Array
+              maven.add_dependency(dep[0], dep[1])
+            else
+              maven.add_dependency(dep)
+            end
+          end
+        end
+
+        maven.write_pom(file_path)
+      end
+
+      #
+      # Deploy an artifact to a Maven repository
+      #
+      # @param [String] notation of artifact
+      # @param [String] file_path path to the Jar
+      # @param [String] url Maven repository deploying to
+      # @param [Hash] deploy_opts options for deploying
+      # @param [Hash] lockjar_opts options for initializing LockJar
+      #
+      def deploy_artifact(notation, file_path, url, deploy_opts = {}, lockjar_opts = {})
+        Runtime.instance.resolver(lockjar_opts).naether.deploy_artifact(
+          notation, file_path, url, deploy_opts)
+      end
+
+      #
+      # Install an artifact to a local repository
+      #
+      # @param [String] notation of artifact
+      # @param [String] pom_path path to the pom
+      # @param [String] jar_path path to the jar
+      # @param [Hash] opts options
+      #
+      def install(notation, pom_path, jar_path, opts = {})
+        Runtime.instance.resolver(opts).naether.install(notation, pom_path, jar_path)
+      end
+    end
+  end
+end

data/lib/lock_jar/registry.rb

@@ -0,0 +1,85 @@
+# 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 'singleton'
+
+module LockJar
+  #
+  # Registry of resources loaded by LockJar
+  #
+  # @author Michael Guymon
+  #
+  class Registry
+    include Singleton
+
+    attr_accessor :loaded_gems, :loaded_jars, :loaded_lockfiles
+
+    def initialize
+      @loaded_gems = {}
+      @loaded_jars = []
+      @loaded_lockfiles = []
+    end
+
+    def lockfile_registered?(lockfile)
+      @loaded_lockfiles.include? File.expand_path(lockfile) if lockfile
+    end
+
+    def register_lockfile(lockfile)
+      return if lockfile.nil? || lockfile_registered?(lockfile)
+
+      @loaded_lockfiles << File.expand_path(lockfile)
+    end
+
+    def register_jars(jars)
+      return if jars.nil?
+
+      jars_to_load = jars - @loaded_jars
+
+      @loaded_jars += jars_to_load
+
+      jars_to_load
+    end
+
+    def register_gem(spec)
+      @loaded_gems[spec.name] = spec
+    end
+
+    def gem_registered?(spec)
+      !@loaded_gems[spec.name].nil?
+    end
+
+    def load_gem(spec)
+      return if gem_registered?(spec)
+
+      register_gem(spec)
+      gem_dir = spec.gem_dir
+
+      lockfile = File.join(gem_dir, 'Jarfile.lock')
+
+      return unless File.exist?(lockfile)
+
+      puts "#{spec.name} has Jarfile.lock, loading jars"
+      LockJar.load(lockfile)
+    end
+
+    def load_jars_for_gems
+      specs = Gem.loaded_specs
+      return if specs.nil?
+
+      gems = specs.keys - @loaded_gems.keys
+      gems.each { |key| load_gem(specs[key]) }
+    end
+  end
+end

data/lib/lock_jar/resolver.rb

@@ -0,0 +1,100 @@
+# 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 'rubygems'
+require 'naether'
+require 'naether/bootstrap'
+require 'fileutils'
+
+module LockJar
+  #
+  class Resolver
+    attr_reader :config, :opts, :naether
+
+    def initialize(config, opts = {})
+      @config = config || LockJar::Config.new({})
+      @opts = opts
+      local_repo = opts[:local_repo] || Naether::Bootstrap.default_local_repo
+
+      # Bootstrap Naether
+      Naether::Bootstrap.bootstrap_local_repo(local_repo, opts)
+
+      # Bootstrapping naether will create an instance from downloaded jars.
+      @naether = Naether.create
+      @naether.local_repo_path = local_repo if local_repo
+      @naether.clear_remote_repositories if opts[:offline]
+    end
+
+    def remote_repositories
+      @naether.remote_repository_urls
+    end
+
+    def clear_remote_repositories
+      @naether.clear_remote_repositories
+    end
+
+    def add_remote_repository(repo)
+      repo_config = config.repositories[repo] || {}
+      username = repo_config['username']
+      password = repo_config['password']
+      @naether.add_remote_repository(repo, username, password)
+    end
+
+    def resolve(dependencies, download_artifacts = true)
+      @naether.dependencies = dependencies
+      @naether.resolve_dependencies(download_artifacts)
+      @naether.dependencies_notation
+    end
+
+    def dependencies_graph
+      @naether.dependencies_graph
+    end
+
+    def download(dependencies)
+      @naether.download_artifacts(dependencies)
+    end
+
+    def to_local_paths(notations)
+      paths = []
+      notations.each do |notation|
+        if File.exist?(notation)
+          paths << notation
+        else
+          paths += @naether.to_local_paths([notation])
+        end
+      end
+
+      paths
+    end
+
+    def load_to_classpath(artifacts)
+      paths = []
+      notations = []
+
+      artifacts.each do |art|
+        if File.exist?(art)
+          paths << art
+        else
+          notations << art
+        end
+      end
+
+      paths += @naether.to_local_paths(notations)
+      Naether::Java.load_paths(paths)
+
+      paths
+    end
+  end
+end

data/lib/lock_jar/runtime/install.rb

@@ -0,0 +1,28 @@
+module LockJar
+  #
+  class Runtime
+    #
+    module Install
+      def install(jarfile_lock, groups = ['default'], opts = {}, &blk)
+        deps = list(jarfile_lock, groups, { with_locals: false }.merge(opts), &blk)
+
+        lockfile = LockJar::Domain::Lockfile.read(jarfile_lock)
+        if opts[:local_repo].nil? && lockfile.local_repository
+          opts[:local_repo] = lockfile.local_repository
+        end
+
+        # Older Jarfile expected the defaul maven repo, but did not write
+        # it to the lockfile
+        resolver(opts).clear_remote_repositories if lockfile.version.to_f >= 0.11
+
+        lockfile.remote_repositories.each do |repo|
+          resolver(opts).add_remote_repository(repo)
+        end
+
+        files = resolver(opts).download(deps)
+
+        files
+      end
+    end
+  end
+end

data/lib/lock_jar/runtime/list.rb

@@ -0,0 +1,77 @@
+module LockJar
+  #
+  class Runtime
+    #
+    module List
+      # rubocop:disable Metrics/PerceivedComplexity, MethodLength
+      def list(lockfile_or_path, groups = ['default'], opts = {}, &blk)
+        dependencies = []
+        maps = []
+        with_locals = { with_locals: true }.merge(opts).delete(:with_locals)
+
+        if lockfile_or_path
+          lockfile = build_lockfile(lockfile_or_path)
+          dependencies = dependencies_from_lockfile(lockfile, groups, with_locals, opts)
+          maps = lockfile.maps
+        end
+
+        # Support limited DSL from block
+        unless blk.nil?
+          dsl = LockJar::Domain::Dsl.create(&blk)
+          dependencies += dsl_dependencies(dsl, groups, with_locals).map(&:to_dep)
+          maps = dsl.maps
+        end
+
+        if maps && maps.size > 0
+          maps.each do |notation, replacements|
+            dependencies = dependencies.flat_map do |dep|
+              if dep =~ /#{notation}/
+                replacements
+              else
+                dep
+              end
+            end
+          end
+        end
+
+        dependencies = resolver(opts).resolve(dependencies) if opts[:resolve]
+
+        # local_paths and !resolve are mutualally exclusive
+        if opts[:local_paths] && opts[:resolve] != false
+          # remove local_paths opt so resolver is not reset
+          resolver(opts.reject { |k| k == :local_paths }).to_local_paths(dependencies)
+
+        else
+          dependencies
+        end
+      end
+      # rubocop:enable Metrics/PerceivedComplexity, MethodLength
+
+      def build_lockfile(lockfile_or_path)
+        if lockfile_or_path.is_a? LockJar::Domain::Lockfile
+          lockfile_or_path
+        elsif lockfile_or_path
+          LockJar::Domain::Lockfile.read(lockfile_or_path)
+        end
+      end
+
+      def dependencies_from_lockfile(lockfile, groups, with_locals, opts)
+        # Only list root dependencies
+        if opts[:resolve] == false
+          lockfile_dependencies(lockfile, groups, with_locals) do |group|
+            group['artifacts'].flat_map(&:keys).map do |notation|
+              # remove the prefix from artifacts, such as jar: or pom:
+              notation.gsub(/^.+?:/, '')
+            end
+          end
+
+        # List all dependencies
+        else
+          lockfile_dependencies(lockfile, groups, with_locals) do |group|
+            group['dependencies']
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lock_jar/runtime/load.rb

@@ -0,0 +1,53 @@
+module LockJar
+  #
+  class Runtime
+    #
+    module Load
+      # Load paths from a lockfile or block. Paths are loaded once per lockfile.
+      #
+      # @param [String] lockfile_path the lockfile
+      # @param [Array] groups to load into classpath
+      # @param [Hash] opts
+      # @param [Block] blk
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def load(lockfile_or_path, groups = ['default'], opts = {}, &blk)
+        # lockfile is only loaded once
+        unless lockfile_or_path.nil?
+          # loaded a Lockfile instance
+          if lockfile_or_path.is_a? LockJar::Domain::Lockfile
+            lockfile = lockfile_or_path
+
+          else
+            # check if lockfile path is already loaded
+            return if LockJar::Registry.instance.lockfile_registered?(lockfile_or_path)
+
+            # convert lockfile path to a Lockfile instance
+            lockfile = LockJar::Domain::Lockfile.read(lockfile_or_path)
+          end
+
+          if opts[:local_repo].nil? && lockfile.local_repository
+            opts[:local_repo] = lockfile.local_repository
+          end
+        end
+
+        # set local_repo if passed in the block
+        unless blk.nil?
+          dsl = LockJar::Domain::Dsl.create(&blk)
+
+          # set local_repo from block
+          opts[:local_repo] = dsl.local_repository if opts[:local_repo].nil? && dsl.local_repository
+        end
+
+        # registered merged lockfiles for lockfile
+        if lockfile && !lockfile.merged.empty?
+          lockfile.merged.each { |path| LockJar::Registry.instance.register_lockfile(path) }
+        end
+
+        dependencies = LockJar::Registry.instance.register_jars(list(lockfile, groups, opts, &blk))
+
+        resolver(opts).load_to_classpath(dependencies)
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    end
+  end
+end