eac_tools 0.1.2 → 0.2.2

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/bundler/gemfile/add_or_replace_gem_line.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module EacRubyBase1
+    module Bundler
+      class Gemfile
+        class AddOrReplaceGemLine
+          enable_method_class
+          common_constructor :sender, :gem_name, :gem_specs
+          delegate :lines, to: :sender
+
+          def existing_gem_line_index
+            lines.index { |line| line.start_with?(gem_line_prefix) }
+          end
+
+          def result
+            if existing_gem_line_index.present?
+              replace_line
+            else
+              add_line
+            end
+          end
+
+          def add_line
+            lines.insert(add_line_index, new_gem_line)
+          end
+
+          def add_line_index
+            (gems_lines_start_index..(lines.count - 1)).each do |e|
+              return e if new_gem_line < lines[e]
+            end
+            lines.count
+          end
+
+          def gems_lines_start_index
+            lines.index { |line| line.start_with?('gem ') } || lines.count
+          end
+
+          def new_gem_line
+            ([gem_line_prefix] + gem_specs).join(', ')
+          end
+
+          def gem_line_prefix
+            "gem '#{gem_name}'"
+          end
+
+          def replace_line
+            lines[existing_gem_line_index] = new_gem_line
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/bundler/gemfile/dependency.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module EacRubyBase1
+    module Bundler
+      class Gemfile
+        class Dependency
+          common_constructor :gemfile, :gem_name
+
+          def version_specs=(version_specs)
+            gemfile.add_or_replace_gem_line(gem_name, version_specs)
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/bundler/gemfile.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module EacRubyBase1
+    module Bundler
+      class Gemfile
+        require_sub __FILE__, require_dependency: true
+
+        class << self
+          def from_file(path)
+            new(path.read.each_line.map(&:rstrip))
+          end
+        end
+
+        common_constructor :lines
+
+        # @return [Avm::EacRubyBase1::Bundler::Gemfile::Dependency]
+        def dependency(gem_name)
+          ::Avm::EacRubyBase1::Bundler::Gemfile::Dependency.new(self, gem_name)
+        end
+
+        def write(path)
+          path.to_pathname.write(to_text)
+        end
+
+        def to_text
+          lines.map { |line| "#{line}\n" }.join
+        end
+      end
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/bundler/incompatible_parser/depends_on.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'avm/eac_ruby_base1/bundler/incompatible_parser/line_parser_base'
+
+module Avm
+  module EacRubyBase1
+    module Bundler
+      class IncompatibleParser
+        class DependsOn < ::Avm::EacRubyBase1::Bundler::IncompatibleParser::LineParserBase
+          LINE_PARSER = /(.+) was resolved to (.+), which depends on/
+                          .to_parser { |m| new(m[1], m[2]) }
+
+          common_constructor :gem_name, :version do
+            self.version = ::Gem::Version.new(version)
+          end
+
+          def data
+            { gem_name: gem_name, version: version }
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/bundler/incompatible_parser/gem_conflict.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'avm/eac_ruby_base1/bundler/incompatible_parser/line_parser_base'
+
+module Avm
+  module EacRubyBase1
+    module Bundler
+      class IncompatibleParser
+        class GemConflict < ::Avm::EacRubyBase1::Bundler::IncompatibleParser::LineParserBase
+          LINE_PARSER = /Bundler could not find compatible versions for gem "(.+)":/
+                          .to_parser { |m| new(m[1]) }
+
+          enable_simple_cache
+          common_constructor :gem_name
+
+          def add_depends_on(depends_on)
+            depends_on_stack << depends_on
+          end
+
+          def add_version_requirement(version_requirement)
+            version_requirement.stack = depends_on_stack
+            versions_requirements << version_requirement
+            @depends_on_stack = nil
+          end
+
+          def data
+            { gem_name: gem_name, versions_requirements: versions_requirements.map(&:data) }
+          end
+
+          def versions_requirements
+            @versions_requirements ||= []
+          end
+
+          private
+
+          def depends_on_stack
+            @depends_on_stack ||= []
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/bundler/incompatible_parser/in_gemfile.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'avm/eac_ruby_base1/bundler/incompatible_parser/line_parser_base'
+
+module Avm
+  module EacRubyBase1
+    module Bundler
+      class IncompatibleParser
+        class InGemfile < ::Avm::EacRubyBase1::Bundler::IncompatibleParser::LineParserBase
+          LINE_PARSER = /In Gemfile:/
+                          .to_parser { |_m| new }
+        end
+      end
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/bundler/incompatible_parser/line_buffer.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'avm/eac_ruby_base1/bundler/incompatible_parser/gem_conflict'
+require 'avm/eac_ruby_base1/bundler/incompatible_parser/line_factory'
+
+module Avm
+  module EacRubyBase1
+    module Bundler
+      class IncompatibleParser
+        class LineBuffer
+          class << self
+            def from_file(path)
+              new(::File.read(path.to_s))
+            end
+          end
+
+          attr_reader :gems_in_conflict
+
+          def initialize(content)
+            self.gems_in_conflict = []
+            self.parsing_required = false
+            content.each_line { |string_line| add_line(LineFactory.new(string_line)) }
+          end
+
+          private
+
+          attr_accessor :parsing_required
+          attr_writer :gems_in_conflict
+
+          def add_line(line)
+            return if line.blank?
+
+            return if LineFactory::TYPES.any? do |type|
+              next false unless line.result.is_a?(type)
+
+              send("on_#{type.name.demodulize.underscore.variableize}_line", line.result)
+              true
+            end
+
+            return unless parsing_required
+
+            raise(::ArgumentError, "Unparsed line: \"#{line.content}\"")
+          end
+
+          def on_gem_conflict_line(result)
+            self.parsing_required = true
+            gems_in_conflict << result
+          end
+
+          def on_in_gemfile_line(result)
+            # Do nothing
+          end
+
+          def on_depends_on_line(result)
+            current_gem_conflict.add_depends_on(result)
+          end
+
+          def on_version_requirement_line(result)
+            current_gem_conflict.add_version_requirement(result)
+          end
+
+          def current_gem_conflict
+            raise 'No gems in conflict' if gems_in_conflict.none?
+            raise 'Last gem is blank' if gems_in_conflict.last.blank?
+
+            gems_in_conflict.last
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/bundler/incompatible_parser/line_factory.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'avm/eac_ruby_base1/bundler/incompatible_parser/depends_on'
+require 'avm/eac_ruby_base1/bundler/incompatible_parser/gem_conflict'
+require 'avm/eac_ruby_base1/bundler/incompatible_parser/in_gemfile'
+
+module Avm
+  module EacRubyBase1
+    module Bundler
+      class IncompatibleParser
+        class LineFactory
+          TYPES = [GemConflict, InGemfile, DependsOn, VersionRequirement].freeze
+
+          enable_simple_cache
+          common_constructor :content do
+            self.content = content.strip
+          end
+
+          delegate :blank?, to: :content
+
+          private
+
+          def result_uncached
+            TYPES.lazy.map { |type| type.parse(content) }.find(&:present?)
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/bundler/incompatible_parser/line_parser_base.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module EacRubyBase1
+    module Bundler
+      class IncompatibleParser
+        class LineParserBase
+          class << self
+            def parse(line_content)
+              const_get('LINE_PARSER').parse(line_content)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/bundler/incompatible_parser/version_requirement.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'avm/eac_ruby_base1/bundler/incompatible_parser/line_parser_base'
+
+module Avm
+  module EacRubyBase1
+    module Bundler
+      class IncompatibleParser
+        class VersionRequirement < ::Avm::EacRubyBase1::Bundler::IncompatibleParser::LineParserBase
+          LINE_PARSER = /\A([a-z][a-z\-_0-9]*)(?: \((.+)\))?\z/
+                          .to_parser { |m| new(m[1], m[2]) }
+
+          enable_simple_cache
+          attr_accessor :stack
+
+          common_constructor :gem_name, :requirements_source
+
+          def data
+            { requirements_source: requirements_source, stack: stack.map(&:data) }
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/bundler/incompatible_parser.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module EacRubyBase1
+    module Bundler
+      class IncompatibleParser
+        require_sub __FILE__
+
+        enable_simple_cache
+        attr_reader :gems_in_conflict
+
+        def initialize(path)
+          @gems_in_conflict = ::Avm::EacRubyBase1::Bundler::IncompatibleParser::LineBuffer
+                                .from_file(path).gems_in_conflict.freeze
+        end
+
+        def data
+          gems_in_conflict.map(&:data)
+        end
+      end
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/bundler.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module EacRubyBase1
+    module Bundler
+      require_sub __FILE__
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/rubocop/configured.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'avm/sources/configuration'
+
+module Avm
+  module EacRubyBase1
+    class Rubocop
+      module Configured
+        def configured_rubocop_command_uncached
+          configured_rubocop_command_by_command || configured_rubocop_command_by_gemfile
+        end
+
+        def configured_rubocop_command_by_command
+          configuration.if_present(&:rubocop_command)
+        end
+
+        def configured_rubocop_command_by_gemfile
+          configuration.if_present(&:rubocop_gemfile).if_present do |v|
+            rubocop_command_by_gemfile_path(v.parent)
+          end
+        end
+
+        private
+
+        def configuration_uncached
+          ::Avm::Sources::Configuration.find_by_path(base_path)
+        end
+      end
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/rubocop/envvar.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module EacRubyBase1
+    class Rubocop
+      module Envvar
+        RUBOCOP_COMMAND_ENVVAR_NAME = 'RUBOCOP_COMMAND'
+
+        def env_rubocop_command
+          ENV[RUBOCOP_COMMAND_ENVVAR_NAME].present? ? cmd(ENV[RUBOCOP_COMMAND_ENVVAR_NAME]) : nil
+        end
+      end
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/rubocop/gemfile.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'avm/eac_ruby_base1/sources/base'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module EacRubyBase1
+    class Rubocop
+      module Gemfile
+        def gemfile_rubocop_command
+          return nil unless rubocop_gemfile?
+
+          rubocop_command_by_gemfile_path(mygem.path)
+        end
+
+        def rubocop_command_by_gemfile_path(path)
+          ::Avm::EacRubyBase1::Sources::Base.new(path).bundle('exec', 'rubocop').chdir_root
+        end
+
+        def rubocop_gemfile?
+          return false if mygem.blank?
+
+          mygem.bundle('install').execute!
+          mygem.gemfile_lock_gem_version('rubocop').present?
+        end
+
+        private
+
+        def mygem_uncached
+          find_gem(::Pathname.new(base_path).expand_path)
+        end
+
+        def find_gem(path)
+          r = ::Avm::EacRubyBase1::Sources::Base.new(path)
+          return r if r.gemfile_path.exist?
+          return find_gem(path.dirname) unless path.root?
+        end
+      end
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/rubocop.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/ruby/on_clean_environment'
+
+module Avm
+  module EacRubyBase1
+    class Rubocop
+      require_sub __FILE__, include_modules: true
+      enable_speaker
+      enable_simple_cache
+      common_constructor :base_path, :rubocop_args
+      set_callback :initialize, :after do
+        @base_path = ::Pathname.new(base_path.to_s) unless base_path.is_a?(::Pathname)
+      end
+
+      def run
+        start_banner
+        run_rubocop
+      end
+
+      private
+
+      def cmd(*args)
+        ::EacRubyUtils::Envs.local.command(*args)
+      end
+
+      def rubocop_command_uncached
+        %w[env configured gemfile].each do |s|
+          cmd = send("#{s}_rubocop_command")
+          return cmd if cmd.present?
+        end
+        cmd('rubocop')
+      end
+
+      def rubocop_command_with_args
+        rubocop_command.append(rubocop_args)
+      end
+
+      def rubocop_version_uncached
+        ::EacRubyUtils::Ruby.on_clean_environment do
+          rubocop_command.append(['--version']).execute!.strip
+        end
+      end
+
+      def run_rubocop
+        ::EacRubyUtils::Ruby.on_clean_environment { rubocop_command_with_args.system }
+      end
+
+      def start_banner
+        infov 'Rubocop version', rubocop_version
+      end
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/rubygems/version_file.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module EacRubyBase1
+    module Rubygems
+      class VersionFile
+        common_constructor :path
+
+        VERSION_LINE_PATTERN = /\A(\s*)VERSION\s*=\s*[\'\"]([^\'\"]+)[\'\"](\s*)\z/.freeze
+
+        def value
+          path.read.each_line.lazy.map { |line| line_value(line) }.find { |v| v }
+        end
+
+        def value=(new_value)
+          path.write(new_value_content(new_value))
+        end
+
+        private
+
+        # @return Version found in line, nil otherwise.
+        def line_value(line)
+          VERSION_LINE_PATTERN.if_match(line.rstrip, false) { |m| ::Gem::Version.new(m[2]) }
+        end
+
+        def new_value_content(new_value)
+          path.read.each_line
+            .map { |line| new_value_line(line, new_value) }
+            .join
+        end
+
+        def new_value_line(line, new_value)
+          m = VERSION_LINE_PATTERN.match(line)
+          return line unless m
+
+          "#{m[1]}VERSION = '#{new_value}'#{m[3]}"
+        end
+      end
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/rubygems.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module EacRubyBase1
+    module Rubygems
+      require_sub __FILE__
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/sources/base/bundle_command.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'avm/eac_generic_base0/sources/base'
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/ruby/command'
+
+module Avm
+  module EacRubyBase1
+    module Sources
+      class Base < ::Avm::EacGenericBase0::Sources::Base
+        class BundleCommand < ::EacRubyUtils::Ruby::Command
+          GEMFILE_PATH_ENVVAR = 'BUNDLE_GEMFILE'
+
+          attr_reader :source
+
+          def initialize(source, command_args, extra_options = {})
+            @source = source
+            super(command_args, extra_options.merge(host_env: source.env))
+          end
+
+          # Changes current directory to the source's directory.
+          def chdir_root
+            chdir(source.path)
+          end
+
+          def envvar_gemfile
+            envvar(GEMFILE_PATH_ENVVAR, source.gemfile_path.to_path)
+          end
+
+          protected
+
+          def duplicate(command, extra_options)
+            self.class.new(source, command, extra_options)
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/sources/base/bundler.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'avm/eac_generic_base0/sources/base'
+require 'avm/eac_ruby_base1/sources/base/bundle_command'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module EacRubyBase1
+    module Sources
+      class Base < ::Avm::EacGenericBase0::Sources::Base
+        module Bundler
+          CONFIGURED_GEMFILE_PATH_ENTRY_KEY = 'ruby.gemfile_path'
+          DEFAULT_GEMFILE_PATH = 'Gemfile'
+
+          # @return [Avm::EacRubyBase1::Sources::Base::BundleCommand]
+          def bundle(*args)
+            ::Avm::EacRubyBase1::Sources::Base::BundleCommand.new(self, %w[bundle] + args)
+              .envvar_gemfile
+          end
+
+          # @return [String]
+          def configured_gemfile_path
+            configuration.entry(CONFIGURED_GEMFILE_PATH_ENTRY_KEY).value
+          end
+
+          # @return [String]
+          def default_gemfile_path
+            DEFAULT_GEMFILE_PATH
+          end
+
+          # @return [Bundler::LockfileParser]
+          def gemfile_lock_content
+            ::Bundler::LockfileParser.new(::Bundler.read_file(gemfile_lock_path))
+          end
+
+          def gemfile_lock_gem_version(gem_name)
+            gemfile_lock_content.specs.find { |gem| gem.name == gem_name }.if_present(&:version)
+          end
+
+          # @return [Pathname]
+          def gemfile_lock_path
+            gemfile_path.basename_sub { |b| "#{b}.lock" }
+          end
+
+          # @return [Pathname]
+          def gemfile_path
+            path.join(configured_gemfile_path || default_gemfile_path)
+          end
+        end
+      end
+    end
+  end
+end