jar-dependencies 0.6.0.pre3-java

data/lib/jars/gemspec_artifacts.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module Jars
+  module MavenVersion
+    class << self
+      def resolve(*args)
+        return nil if args.empty? || (args.size == 1 && args[0].nil?)
+
+        low, high = convert(args[0])
+        low, high = convert(args[1], low, high) if /[=~><]/.match?(args[1])
+        (low == high) ? low : "#{low || '[0'},#{high || ')'}"
+      end
+
+      private
+
+      def convert(arg, low = nil, high = nil)
+        if arg.include?('~>')
+          val = arg.sub(/~>\s*/, '')
+          last = val.include?('.') ? val.sub(/\.[0-9]*[a-z]+.*$/, '').sub(/\.[^.]+$/, '.99999') : '99999'
+          ["[#{snapshot_version(val)}", "#{snapshot_version(last)}]"]
+        elsif arg.include?('>=')
+          val = arg.sub(/>=\s*/, '')
+          ["[#{snapshot_version(val)}", high]
+        elsif arg.include?('<=')
+          val = arg.sub(/<=\s*/, '')
+          [low, "#{snapshot_version(val)}]"]
+        # treat '!' the same way as '>' since maven cannot describe such range
+        elsif /[!>]/.match?(arg)
+          val = arg.sub(/[!>]\s*/, '')
+          ["(#{snapshot_version(val)}", high]
+        elsif arg.include?('<')
+          val = arg.sub(/<\s*/, '')
+          [low, "#{snapshot_version(val)})"]
+        elsif arg.include?('=')
+          val = arg.sub(/=\s*/, '')
+          # for prereleased version pick the maven version (no version range)
+          if /[a-z]|[A-Z]/.match?(val)
+            [val, val]
+          else
+            ["[#{val}", "#{val}.0.0.0.0.1)"]
+          end
+        else
+          # no conversion here, i.e. assume maven version
+          [arg, arg]
+        end
+      end
+
+      def snapshot_version(val)
+        if val.match(/[a-z]|[A-Z]/) && !val.match(/-SNAPSHOT|[${}]/)
+          "#{val}-SNAPSHOT"
+        else
+          val
+        end
+      end
+    end
+  end
+
+  class GemspecArtifacts
+    class Exclusion
+      attr_reader :group_id, :artifact_id
+
+      def initialize(line)
+        @group_id, @artifact_id = line.gsub(/['"]/, '').strip.split(':')
+        @artifact_id.strip!
+      end
+
+      def to_s
+        "#{@group_id}:#{@artifact_id}"
+      end
+    end
+
+    class Exclusions < Array
+      def to_s
+        "[#{join(', ')}]"
+      end
+
+      def initialize(line)
+        super()
+        line.gsub(/'"|^\s*\[|\]\s*$/, '').split(/,\s*/).each do |exclusion|
+          self << Exclusion.new(exclusion)
+        end
+        freeze
+      end
+    end
+
+    class Artifact
+      attr_reader :type, :group_id, :artifact_id, :classifier, :version, :scope, :exclusions
+
+      ALLOWED_TYPES = %w[jar pom].freeze
+
+      def initialize(type, group_id, artifact_id, classifier, version, exclusions, **options)
+        @type = type
+        @group_id = group_id
+        @artifact_id = artifact_id
+        @classifier = classifier
+        @version = version
+        @exclusions = exclusions
+        options.each do |k, v|
+          instance_variable_set(:"@#{k}", v)
+        end
+      end
+
+      def self.parse(line)
+        line = line.strip
+        index = line.index(/\s/)
+        return nil if index.nil?
+
+        type = line[0..index].strip
+        return nil unless ALLOWED_TYPES.member?(type)
+
+        line = line[index..]
+        line.gsub!(/['"]/, '')
+        line.strip!
+
+        options = {}
+        line.sub!(/,\s*:exclusions\s*(:|=>)\s*(\[[^\]]+\])/) do
+          options[:exclusions] = Exclusions.new(Regexp.last_match(2).strip)
+          ''
+        end
+        line.sub!(/,\s*:([a-z]+)\s*(:|=>)\s*(:?[a-zA-Z0-9_]+)/) do
+          options[Regexp.last_match(1).to_sym] = Regexp.last_match(3).sub(/^:/, '')
+          ''
+        end
+        exclusions = nil
+        line.sub!(/[,:]\s*\[(.+:.+,?\s*)+\]$/) do |a|
+          exclusions = Exclusions.new(a[1..].strip)
+          ''
+        end
+
+        line.strip!
+        line.gsub!(/,\s*/, ':')
+
+        if /[\[()\]]/.match?(line)
+          index = line.index(/[\[(].+$/)
+          version = line[index..].sub(':', ', ')
+          line = line[0..(index - 1)].strip.sub(/:$/, '')
+        else
+          index = line.index(/:[^:]+$/)
+          version = line[(index + 1)..]
+          line = line[0..(index - 1)].strip
+        end
+
+        case line.count(':')
+        when 2
+          group_id, artifact_id, classifier = line.split(':')
+        when 1
+          group_id, artifact_id = line.split(':')
+          classifier = nil
+        else
+          warn line
+          return nil
+        end
+        new(type, group_id, artifact_id, classifier, version, exclusions, **options)
+      end
+
+      def to_s
+        args = [@group_id, @artifact_id]
+        args << @classifier if @classifier
+        args << @version
+        args << @exclusions.to_s if @exclusions
+        "#{@type} #{group_id}:#{args[1..].join(', ')}"
+      end
+
+      def to_gacv
+        args = [@group_id, @artifact_id]
+        args << @classifier if @classifier
+        args << @version
+        args.join(':')
+      end
+
+      def to_coord(classifier: true)
+        args = [@group_id, @artifact_id]
+        args << @classifier if classifier && @classifier
+        args << @type
+        args << MavenVersion.resolve(@version)
+        args.join(':')
+      end
+
+      def key
+        args = [@group_id, @artifact_id]
+        args << @classifier if @classifier
+        args.join(':')
+      end
+    end
+
+    attr_reader :artifacts
+
+    def initialize(spec)
+      @artifacts = []
+      spec.requirements.each do |req|
+        req.split("\n").each do |line|
+          artifact = Artifact.parse(line)
+          @artifacts << artifact if artifact
+        end
+      end
+      @artifacts.freeze
+    end
+
+    def [](index)
+      @artifacts[index]
+    end
+
+    def each(&block)
+      @artifacts.each(&block)
+    end
+
+    def size
+      @artifacts.size
+    end
+  end
+end

data/lib/jars/installer.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require 'jar_dependencies'
+require 'jars/maven_exec'
+
+module Jars
+  class Installer
+    class Dependency
+      EMPTY = ""
+      # the trailing ":<file>" of a dependency line; the file may itself contain
+      # a ':' on Windows (C:\...), hence the optional drive-letter prefix
+      TRAILING_FILE = /:(?<file>(?:[A-Z]:\\)?[^:]+)\z/.freeze
+
+      # A dependency:list line has the form
+      #   groupId:artifactId:type[:classifier]:version:scope:/path/to/file
+      def self.parse(line)
+        return unless /:jar:|:pom:/.match?(line)
+
+        line = line.dup
+        # remove ANSI escape sequences and module section (https://issues.apache.org/jira/browse/MDEP-974)
+        line.gsub!(/\e\[\d*m/, EMPTY)
+        line.gsub!(/ -- module.*/, EMPTY)
+        line.strip!
+
+        # Peel off the trailing file path first: since it may contain a ':' it
+        # cannot take part in the split below. What is left (pre_match) is
+        # colon-clean, so every field is addressed by position -- never by
+        # matching a keyword, which breaks when an artifact id is itself a scope
+        # or type keyword (e.g. "com.dylibso.chicory:runtime:jar:1.7.5").
+        tail = line.match(TRAILING_FILE)
+        file = tail[:file]
+
+        # classifier is the only optional field, so there are exactly 5 or 6
+        components = tail.pre_match.split(':')
+        if components.size == 6
+          group_id, artifact_id, type, classifier, version, scope_name = components
+        else
+          group_id, artifact_id, type, version, scope_name = components
+        end
+
+        coord = [group_id, artifact_id, type, classifier, version].compact.join(':')
+        gav = [group_id, artifact_id, classifier, version].compact.join(':')
+        path = File.join(*group_id.split('.'), artifact_id, version, file[%r{[^\\/]+\z}])
+
+        scope =
+          case scope_name
+          when 'provided'
+            :provided
+          when 'test'
+            :test
+          else
+            :runtime
+          end
+
+        new(type.to_sym, scope, coord, gav, file, path, scope_name == 'system')
+      end
+
+      attr_reader :path, :file, :gav, :scope, :type, :coord
+
+      def initialize(type, scope, coord, gav, file, path, system)
+        @type = type
+        @scope = scope
+        @coord = coord
+        @gav = gav
+        @file = file
+        @path = path
+        @system = system
+      end
+
+      def system?
+        @system
+      end
+    end
+
+    def self.install_jars(write_require_file: false)
+      new.install_jars(write_require_file: write_require_file)
+    end
+
+    def self.load_from_maven(file)
+      result = []
+      File.read(file).each_line do |line|
+        dep = Dependency.parse(line)
+        result << dep if dep && dep.scope == :runtime
+      end
+      result
+    end
+
+    def self.vendor_file(dir, dep)
+      return unless !dep.system? && dep.type == :jar && dep.scope == :runtime
+
+      vendored = File.join(dir, dep.path)
+      FileUtils.mkdir_p(File.dirname(vendored))
+      FileUtils.cp(dep.file, vendored)
+    end
+
+    def self.print_require_jar(file, dep, fallback: false)
+      return if dep.type != :jar || dep.scope != :runtime
+
+      if dep.system?
+        file&.puts("require '#{dep.file}'")
+      elsif dep.scope == :runtime
+        if fallback
+          file&.puts("  require '#{dep.path}'")
+        else
+          file&.puts("  require_jar '#{dep.gav.gsub(':', "', '")}'")
+        end
+      end
+    end
+
+    COMMENT = '# this is a generated file, to avoid over-writing it just delete this comment'
+
+    def self.write_require_jars(deps, require_filename)
+      return if !require_filename || (
+        File.exist?(require_filename) && !File.read(require_filename).index(COMMENT)
+      )
+
+      FileUtils.mkdir_p(File.dirname(require_filename))
+      File.open(require_filename, 'w') do |f|
+        f.puts COMMENT
+        f.puts 'begin'
+        f.puts "  require 'jar_dependencies'"
+        f.puts 'rescue LoadError'
+        deps.each do |dep|
+          # do not use require_jar method
+          print_require_jar(f, dep, fallback: true)
+        end
+        f.puts 'end'
+        f.puts
+        f.puts 'if defined? Jars'
+        deps.each do |dep|
+          print_require_jar(f, dep)
+        end
+        f.puts 'end'
+      end
+    end
+
+    def self.vendor_jars(deps, dir)
+      deps.each do |dep|
+        vendor_file(dir, dep)
+      end
+    end
+
+    def initialize(spec = nil)
+      @mvn = MavenExec.new(spec)
+    end
+
+    def spec
+      @mvn.spec
+    end
+
+    def vendor_jars(vendor_dir = nil, write_require_file: true)
+      return unless jars?
+
+      if Jars.to_prop(Jars::VENDOR) == 'false'
+        vendor_dir = nil
+      else
+        vendor_dir ||= spec.require_path
+      end
+      do_install(vendor_dir, write_require_file)
+    end
+
+    def self.vendor_jars!(vendor_dir = nil)
+      new.vendor_jars!(vendor_dir)
+    end
+
+    def vendor_jars!(vendor_dir = nil, write_require_file: true)
+      vendor_dir ||= spec.require_path
+      do_install(vendor_dir, write_require_file)
+    end
+
+    def install_jars(write_require_file: true)
+      return unless jars?
+
+      do_install(nil, write_require_file)
+    end
+
+    def ruby_maven_install_options=(options)
+      # no-op: kept for backward compatibility with post_install_hook
+    end
+
+    def jars?
+      spec = self.spec
+      return if spec.nil? # rubocop:disable Style/ReturnNilInPredicateMethodDefinition
+      return false unless spec.requirements&.any?
+      return false unless spec.runtime_dependencies.find { |s| s.name == 'jar-dependencies' }
+
+      return true if spec.platform.to_s == 'java'
+
+      Jars.warn "jar-dependencies found on non-java platform gem; skipping jar installation"
+      nil # rubocop:disable Style/ReturnNilInPredicateMethodDefinition
+    end
+
+    private
+
+    def do_install(vendor_dir, write_require_file)
+      require_paths = spec.require_paths
+      if vendor_dir && !require_paths.include?(vendor_dir)
+        raise "vendor dir #{vendor_dir} not in require_paths of gemspec #{require_paths}"
+      end
+
+      target_dir = File.join(@mvn.basedir, vendor_dir || spec.require_path)
+      jars_file = File.join(target_dir, "#{spec.name}_jars.rb")
+
+      # write out new jars_file if write_require_file is true or check timestamps:
+      # do not generate file if specfile is older than the generated file
+      if !write_require_file && File.exist?(jars_file) && File.mtime(@mvn.specfile) < File.mtime(jars_file)
+        jars_file = nil # leave jars_file as is
+      end
+      deps = install_dependencies
+      self.class.write_require_jars(deps, jars_file)
+      self.class.vendor_jars(deps, target_dir) if vendor_dir
+    end
+
+    def install_dependencies
+      deps = File.join(@mvn.basedir, 'deps.lst')
+
+      Jars.info("jar dependencies for #{spec.spec_name} ", newline: false)
+      @mvn.resolve_dependencies_list(deps)
+      Jars.info("") # newline after progress dots
+
+      self.class.load_from_maven(deps)
+    ensure
+      FileUtils.rm_f(deps) if deps
+    end
+  end
+end

data/lib/jars/lock.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'jars/maven_exec'
+
+module Jars
+  class JarDetails < Array
+    def scope
+      self[-2].to_sym
+    end
+
+    def file
+      file = self[-1].strip
+      file.empty? ? path : file
+    end
+
+    def group_id
+      self[0]
+    end
+
+    def artifact_id
+      self[1]
+    end
+
+    def version
+      self[-3]
+    end
+
+    def classifier
+      return nil if size == 5
+
+      self[2]
+    end
+
+    def gacv
+      classifier ? self[0..3] : self[0..2]
+    end
+
+    def path
+      if scope == :system
+        # replace maven like system properties embedded into the string
+        self[-1].gsub(/\$\{[a-zA-Z.]+\}/) do |a|
+          ENV_JAVA[a[2..-2]] || a
+        end
+      else
+        File.join(Jars.home, group_id.gsub(/[.]/, '/'), artifact_id, version, "#{gacv[1..].join('-')}.jar")
+      end
+    end
+  end
+
+  class Lock
+    def initialize(file)
+      @file = file
+    end
+
+    def process(scope)
+      scope ||= :runtime
+      File.read(@file).each_line do |line|
+        next unless /:.+:/.match?(line)
+
+        jar = JarDetails.new(line.strip.sub(':jar:', ':').sub(/:$/, ': ').split(':'))
+        case scope
+        when :all, :test
+          yield jar
+        when :compile
+          # jar.scope is maven scope
+          yield jar if jar.scope != :test
+        when :provided
+          # jar.scope is maven scope
+          yield jar if jar.scope == :provided
+        when :runtime
+          # jar.scope is maven scope
+          yield jar if (jar.scope != :test) && (jar.scope != :provided)
+        end
+      end
+    end
+  end
+end

data/lib/jars/lock_down.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'jar_dependencies'
+require 'jars/version'
+require 'jars/gemspec_artifacts'
+
+module Jars
+  class LockDown
+    def basedir
+      File.expand_path('.')
+    end
+
+    def collect_artifacts
+      artifacts = []
+      done = []
+
+      attach_jar_coordinates_from_bundler_dependencies(artifacts, done)
+
+      # Also collect from local gemspec if present
+      specs = Dir['*.gemspec']
+      if specs.size == 1
+        spec = eval(File.read(specs.first), TOPLEVEL_BINDING, specs.first) # rubocop:disable Security/Eval
+        ga = GemspecArtifacts.new(spec)
+        ga.artifacts.each do |a|
+          unless done.include?(a.key)
+            artifacts << a
+            done << a.key
+          end
+        end
+      end
+
+      artifacts
+    end
+    private :collect_artifacts
+
+    def attach_jar_coordinates_from_bundler_dependencies(artifacts, done)
+      load_path = $LOAD_PATH.dup
+      require 'bundler'
+      # TODO: make this group a commandline option
+      Bundler.setup('default')
+      cwd = File.expand_path('.')
+      Gem.loaded_specs.each_value do |spec|
+        all = cwd == spec.full_gem_path # if gemspec is local then include all dependencies
+        ga = GemspecArtifacts.new(spec)
+        ga.artifacts.each do |a|
+          next if done.include?(a.key)
+          next unless all || (a.scope != 'provided' && a.scope != 'test')
+
+          artifacts << a
+          done << a.key
+        end
+      end
+    rescue LoadError => e
+      Jars.warn "bundler unavailable (#{e.message}); skipping dependency discovery" if Jars.verbose?
+    rescue Bundler::GemfileNotFound
+      # bundler is available, but there is no Gemfile to inspect
+    rescue Bundler::GemNotFound
+      Jars.warn "cannot set up bundler with #{Bundler.default_lockfile}"
+      raise
+    ensure
+      $LOAD_PATH.replace(load_path)
+    end
+
+    def lock_down(vendor_dir = nil, force: false, update: false, tree: nil) # rubocop:disable Lint/UnusedMethodArgument
+      lock_file = File.expand_path(Jars.lock)
+
+      if !force && File.exist?(lock_file)
+        puts 'Jars.lock already exists, use --force to overwrite'
+        return
+      end
+
+      artifacts = collect_artifacts
+
+      if artifacts.empty?
+        puts 'no jar dependencies found'
+        return
+      end
+
+      puts
+      puts '-- jar root dependencies --'
+      puts
+      artifacts.each do |a|
+        puts "      #{a.to_gacv}:#{a.scope || 'compile'}"
+        puts "          exclusions: #{a.exclusions}" if a.exclusions && !a.exclusions.empty?
+      end
+
+      context = Jars::Mima.create_context
+      begin
+        resolved = Jars::Mima.resolve_with_context(context, artifacts, all_dependencies: true)
+      ensure
+        context.close
+      end
+
+      # Write Jars.lock
+      File.open(lock_file, 'w') do |f|
+        resolved.each do |dep|
+          next unless dep.type == 'jar'
+
+          f.puts dep.to_lock_entry
+        end
+      end
+
+      # Optionally vendor jars
+      if vendor_dir
+        require 'fileutils'
+        vendor_path = File.expand_path(vendor_dir)
+        resolved.each do |dep|
+          next unless dep.type == 'jar' && dep.runtime? && !dep.system?
+
+          target = File.join(vendor_path, dep.jar_path)
+          FileUtils.mkdir_p(File.dirname(target))
+          FileUtils.cp(dep.file, target)
+        end
+      end
+
+      if tree
+        puts
+        puts '-- jar dependency tree --'
+        puts
+        resolved.each do |dep|
+          prefix = dep.classifier ? "#{dep.classifier}:" : ''
+          puts "   #{dep.group_id}:#{dep.artifact_id}:#{prefix}#{dep.version}:#{dep.scope}"
+        end
+        puts
+      end
+
+      puts
+      puts File.read(lock_file)
+      puts
+    end
+  end
+end