rspec-openhab-scripting 0.0.1-java

data/vendor/gems/jar-dependencies-1.0.0/lib/jars/gemspec_artifacts.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module Jars
+  class MavenVersion < String
+    class << self
+      def new(*args)
+        if args.empty? || (args.size == 1 && args[0].nil?)
+          nil
+        else
+          low, high = convert(args[0])
+          low, high = convert(args[1], low, high) if /[=~><]/.match?(args[1])
+          if low == high
+            low
+          else
+            super "#{low || "[0"},#{high || ")"}"
+          end
+        end
+      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)}", (nil || high)]
+        elsif arg.include?("<=")
+          val = arg.sub(/<=\s*/, "")
+          [(nil || low), "#{snapshot_version(val)}]"]
+        # treat '!' the same way as '>' since maven can not describe such range
+        elsif /[!>]/.match?(arg)
+          val = arg.sub(/[!>]\s*/, "")
+          ["(#{snapshot_version(val)}", (nil || high)]
+        elsif arg.include?("<")
+          val = arg.sub(/<\s*/, "")
+          [(nil || 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(options, *args)
+        @type, @group_id, @artifact_id, @classifier, @version, @exclusions = *args
+        options.each do |k, v|
+          instance_variable_set("@#{k}", v)
+        end
+      end
+
+      def self.new(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
+        super(options, type, group_id, artifact_id, classifier, version, exclusions)
+      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_no_classifier
+        args = [@group_id, @artifact_id]
+        args << @type
+        args << MavenVersion.new(@version)
+        args.join(":")
+      end
+
+      def to_coord
+        args = [@group_id, @artifact_id]
+        args << @classifier if @classifier
+        args << @type
+        args << MavenVersion.new(@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|
+          if (a = Artifact.new(line))
+            @artifacts << a
+          end
+        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/vendor/gems/jar-dependencies-1.0.0/lib/jars/gemspec_pom.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# this file is maven DSL and used by maven via jars/maven_exec.rb
+
+def eval_file(file)
+  file = File.join(__dir__, file)
+  eval(File.read(file), nil, file)  # rubocop:disable Security/Eval
+end
+
+eval_file("attach_jars_pom.rb")
+eval_file("output_jars_pom.rb")

data/vendor/gems/jar-dependencies-1.0.0/lib/jars/installer.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require "jar_dependencies"
+require "jars/maven_exec"
+
+module Jars
+  class Installer
+    class Dependency
+      attr_reader :path, :file, :gav, :scope, :type, :coord
+
+      def self.new(line)
+        super if /:jar:|:pom:/.match?(line)
+      end
+
+      def setup_type(line)
+        if line.index(":pom:")
+          @type = :pom
+        elsif line.index(":jar:")
+          @type = :jar
+        end
+      end
+      private :setup_type
+
+      def setup_scope(line)
+        @scope =
+          case line
+          when /:provided:/
+            :provided
+          when /:test:/
+            :test
+          else
+            :runtime
+          end
+      end
+      private :setup_scope
+
+      REG = /:jar:|:pom:|:test:|:compile:|:runtime:|:provided:|:system:/.freeze
+      EMPTY = ""
+      def initialize(line)
+        setup_type(line)
+
+        line.strip!
+        @coord = line.sub(/:[^:]+:([A-Z]:\\)?[^:]+$/, EMPTY)
+        first, second = @coord.split(/:#{type}:/)
+        group_id, artifact_id = first.split(":")
+        parts = group_id.split(".")
+        parts << artifact_id
+        parts << second.split(":")[-1]
+        @file = line.slice(@coord.length, line.length).sub(REG, EMPTY).strip
+        last = @file.reverse.index(%r{\\|/})
+        parts << line[-last..]
+        @path = File.join(parts).strip
+
+        setup_scope(line)
+
+        @system = !line.index(":system:").nil?
+        @gav = @coord.sub(REG, ":")
+      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.new(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.needs_to_write?(require_filename)
+      require_filename && (!File.exist?(require_filename) || File.read(require_filename).match(COMMENT))
+    end
+
+    def self.write_require_jars(deps, require_filename)
+      return unless needs_to_write?(require_filename)
+
+      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)
+      @mvn.ruby_maven_install_options = options
+    end
+
+    def jars?
+      # first look if there are any requirements in the spec
+      # and then if gem depends on jar-dependencies for runtime.
+      # only then install the jars declared in the requirements
+      result = (spec = self.spec) && !spec.requirements.empty? &&
+               spec.dependencies.detect { |d| d.name == "jar-dependencies" && d.type == :runtime }
+      if result && spec.platform.to_s != "java"
+        Jars.warn "\njar dependencies found on non-java platform gem - do not install jars\n"
+        false
+      else
+        result
+      end
+    end
+
+    private
+
+    def do_install(vendor_dir, write_require_file)
+      if !spec.require_paths.include?(vendor_dir) && vendor_dir
+        raise "vendor dir #{vendor_dir} not in require_paths of gemspec #{spec.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 it write_require_file is true or
+      # check timestamps:
+      # do not generate file if specfile is older then the generated file
+      if !write_require_file &&
+         File.exist?(jars_file) &&
+         File.mtime(@mvn.specfile) < File.mtime(jars_file)
+        # leave jars_file as is
+        jars_file = nil
+      end
+      deps = install_dependencies
+      self.class.write_require_jars(deps, jars_file)
+      self.class.vendor_jars(target_dir, write_require_file: deps) if vendor_dir
+    end
+
+    def install_dependencies
+      deps = File.join(@mvn.basedir, "deps.lst")
+
+      puts "  jar dependencies for #{spec.spec_name} . . ." unless Jars.quiet?
+      @mvn.resolve_dependencies_list(deps)
+
+      self.class.load_from_maven(deps)
+    ensure
+      FileUtils.rm_f(deps) if deps
+    end
+  end
+end

data/vendor/gems/jar-dependencies-1.0.0/lib/jars/lock.rb

@@ -0,0 +1,75 @@
+# 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
+      size == 5 ? nil : 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/vendor/gems/jar-dependencies-1.0.0/lib/jars/lock_down.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "jar_dependencies"
+require "jars/version"
+require "jars/maven_factory"
+require "jars/gemspec_artifacts"
+
+module Jars
+  class LockDown
+    attr_reader :debug, :verbose
+
+    def initialize(debug, verbose)
+      @debug = debug
+      @verbose = verbose
+    end
+
+    def maven_new
+      factory = MavenFactory.new({}, @debug, @verbose)
+      pom = File.expand_path("lock_down_pom.rb", __dir__)
+      m = factory.maven_new(pom)
+      m["jruby.plugins.version"] = Jars::JRUBY_PLUGINS_VERSION
+      m["dependency.plugin.version"] = Jars::DEPENDENCY_PLUGIN_VERSION
+      m["jars.basedir"] = File.expand_path(basedir)
+      jarfile = File.expand_path(Jars.jarfile)
+      m["jars.jarfile"] = jarfile if File.exist?(jarfile)
+      attach_jar_coordinates_from_bundler_dependencies(m)
+      m
+    end
+    private :maven_new
+
+    def maven
+      @maven ||= maven_new
+    end
+
+    def basedir
+      File.expand_path(".")
+    end
+
+    def attach_jar_coordinates_from_bundler_dependencies(maven)
+      load_path = $LOAD_PATH.dup
+      require "bundler"
+      # TODO: make this group a commandline option
+      Bundler.setup("default")
+      maven.property("jars.bundler", true)
+      cwd = File.expand_path(".")
+      maven.attach_repos
+      Gem.loaded_specs.each do |_name, spec|
+        # if gemspec is local then include all dependencies
+        maven.attach_jars(spec, all_dependencies: cwd == spec.full_gem_path)
+      end
+    rescue LoadError => e
+      if Jars.verbose?
+        warn e.message
+        warn "no bundler found - ignore Gemfile if exists"
+      end
+    rescue Bundler::GemfileNotFound
+    # do nothing then as we have bundler but no Gemfile
+    rescue Bundler::GemNotFound
+      warn "can not setup 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)
+      out = File.expand_path(".jars.output")
+      tree_provided = tree
+      tree ||= File.expand_path(".jars.tree")
+      maven.property("jars.outputFile", out)
+      maven.property("maven.repo.local", Jars.local_maven_repo)
+      maven.property("jars.home", File.expand_path(vendor_dir)) if vendor_dir
+      maven.property("jars.lock", File.expand_path(Jars.lock))
+      maven.property("jars.force", force)
+      maven.property("jars.update", update) if update
+      # tell not to use Jars.lock as part of POM when running mvn
+      maven.property("jars.skip.lock", true)
+
+      args = ["gem:jars-lock"]
+      args += ["dependency:tree", "-P -gemfile.lock", "-DoutputFile=#{tree}"] if tree_provided
+
+      puts
+      puts "-- jar root dependencies --"
+      puts
+      status = maven.exec(*args)
+      exit 1 unless status
+      if File.exist?(tree)
+        puts
+        puts "-- jar dependency tree --"
+        puts
+        puts File.read(tree)
+        puts
+      end
+      puts
+      puts File.read(out).gsub("#{File.dirname(out)}/", "")
+      puts
+    ensure
+      FileUtils.rm_f out
+      FileUtils.rm_f tree
+    end
+  end
+end

data/vendor/gems/jar-dependencies-1.0.0/lib/jars/lock_down_pom.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# this file is maven DSL and used by maven via jars/lock_down.rb
+
+basedir(ENV_JAVA["jars.basedir"])
+
+def eval_file(file)
+  file = File.join(__dir__, file)
+  eval(File.read(file), nil, file) # rubocop:disable Security/Eval
+end
+
+eval_file("attach_jars_pom.rb")
+
+jfile = ENV_JAVA["jars.jarfile"]
+jarfile(jfile) if jfile
+
+# need to fix the version of this plugin for gem:jars_lock goal
+jruby_plugin :gem, ENV_JAVA["jruby.plugins.version"]
+
+# if you use bundler we collect all root jar dependencies
+# from each gemspec file. otherwise we need to resolve
+# the gemspec artifact in the maven way
+unless ENV_JAVA["jars.bundler"]
+  begin
+    gemspec
+  rescue
+    nil
+  end
+end
+
+properties("project.build.sourceEncoding" => "utf-8")
+
+plugin :dependency, ENV_JAVA["dependency.plugin.version"]
+
+eval_file("output_jars_pom.rb")