avm-tools 0.114.0 → 0.115.0

data/sub/eac_rest/lib/eac_rest/request.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'curb'
+require 'eac_rest/response'
+require 'eac_ruby_utils/core_ext'
+require 'ostruct'
+
+module EacRest
+  class Request
+    COMMON_MODIFIERS = %w[auth body_data verb].freeze
+    HASH_MODIFIERS = %w[header].freeze
+    MODIFIERS = COMMON_MODIFIERS + HASH_MODIFIERS.map(&:pluralize)
+
+    enable_immutable
+    immutable_accessor(*COMMON_MODIFIERS, type: :common)
+    immutable_accessor(*HASH_MODIFIERS, type: :hash)
+
+    enable_listable
+    lists.add_symbol :verb, :get, :delete, :options, :post, :put
+
+    common_constructor :url, :body_data_proc, default: [nil]
+
+    def autenticate(username, password)
+      auth(::OpenStruct.new(username: username, password: password))
+    end
+
+    def immutable_constructor_args
+      [url, body_data_proc]
+    end
+
+    def response
+      ::EacRest::Response.new(build_curl, body_data_proc)
+    end
+
+    private
+
+    def build_curl
+      r = ::Curl::Easy.new(url)
+      MODIFIERS.each { |suffix| send("build_curl_#{suffix}", r) }
+      r
+    end
+
+    def build_curl_auth(curl)
+      auth.if_present do |a|
+        curl.http_auth_types = :basic
+        curl.username = a.username
+        curl.password = a.password
+      end
+    end
+
+    def build_curl_body_data(curl)
+      www_form_body_data_encoded.if_present { |v| curl.post_body = v }
+    end
+
+    def build_curl_headers(curl)
+      curl.headers.merge!(headers)
+    end
+
+    def build_curl_verb(curl)
+      curl.set(
+        :customrequest,
+        verb.if_present(VERB_GET) { |v| self.class.lists.verb.value_validate!(v) }.to_s.upcase
+      )
+    end
+
+    def www_form_body_data_encoded
+      body_data.if_present do |v|
+        v = v.map { |k, vv| [k, vv] } if v.is_a?(::Hash)
+        v = URI.encode_www_form(v) if v.is_a?(::Array)
+        v.to_s
+      end
+    end
+  end
+end

data/sub/eac_rest/lib/eac_rest/response.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/hash/conversions'
+require 'eac_ruby_utils/core_ext'
+require 'json'
+
+module EacRest
+  class Response < ::StandardError
+    common_constructor :curl, :body_data_proc
+
+    def body_data
+      r = performed_curl.headers['Accept'].if_present(body_str) do |v|
+        method_name = "body_data_from_#{v.parameterize.underscore}"
+        respond_to?(method_name) ? send(method_name) : body_str
+      end
+      r = body_data_proc.call(r) if body_data_proc.present?
+      r
+    end
+
+    def body_data_or_raise
+      raise_unless_200
+
+      body_data
+    end
+
+    delegate :body_str, :headers, to: :performed_curl
+
+    def body_str_or_raise
+      raise_unless_200
+
+      body_str
+    end
+
+    def raise_unless_200
+      return nil if status == 200
+
+      raise self
+    end
+
+    def status
+      performed_curl.status.to_i
+    end
+
+    delegate :url, to: :curl
+
+    def to_s
+      "URL: #{url}\nStatus: #{status}\nBody:\n\n#{body_str}"
+    end
+
+    private
+
+    def body_data_from_application_json
+      ::JSON.parse(body_str)
+    end
+
+    def body_data_from_application_xml
+      Hash.from_xml(body_str)
+    end
+
+    def perform
+      @perform ||= begin
+        curl.perform || raise("CURL perform failed for #{url}")
+        true
+      end
+    end
+
+    def performed_curl
+      perform
+      curl
+    end
+  end
+end

data/sub/eac_rest/lib/eac_rest/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module EacRest
+  VERSION = '0.4.0'
+end

data/sub/eac_rest/lib/eac_rest.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacRest
+  require_sub __FILE__
+end

data/sub/eac_rest/spec/rubocop_spec.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+::EacRubyUtils::Rspec.default_setup.describe_rubocop

data/sub/eac_rest/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/rspec/default_setup'
+::EacRubyUtils::Rspec.default_setup_create(::File.expand_path('..', __dir__))

data/sub/eac_ruby_utils/lib/eac_ruby_utils/bit.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/module/compare_by'
+
+module EacRubyUtils
+  class Bit
+    VALID_VALUES = [0, 1].freeze
+
+    class << self
+      def assert(obj)
+        return obj if obj.is_a?(self)
+
+        new(obj.to_i)
+      end
+
+      def valid_integer?(value)
+        value.is_a?(::Integer) && VALID_VALUES.include?(value)
+      end
+
+      def validate_integer(value)
+        return value if valid_integer?(value)
+
+        raise(::ArgumentError, "Invalid bit value: #{value} (Valid: #{VALID_VALUES})")
+      end
+    end
+
+    attr_reader :value
+    compare_by :value
+    delegate :to_s, :zero?, to: :value
+
+    # @param value [Integer]
+    def initialize(value)
+      @value = self.class.validate_integer(value)
+    end
+
+    # @return [Boolean]
+    def one?
+      !zero?
+    end
+
+    # @return [Integer]
+    def to_i
+      value
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/bit_array.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/bit'
+require 'eac_ruby_utils/byte'
+require 'eac_ruby_utils/byte_array'
+require 'eac_ruby_utils/patches/module/compare_by'
+
+module EacRubyUtils
+  class BitArray
+    class << self
+      def assert(obj)
+        return obj if obj.is_a?(self)
+        return new(obj) if obj.is_a?(::Enumerable)
+
+        raise "Could not convert #{obj} to #{self}"
+      end
+    end
+
+    delegate :each, :each_with_index, :to_a, :size, :count, :length, :[], :fetch, to: :values_array
+    compare_by :values_array
+
+    def initialize(values = [])
+      values.each { |value| push(value) }
+    end
+
+    def <<(value)
+      push(value)
+    end
+
+    # @return [EacRubyUtils::BitArray] +self+.
+    def push_array(other_bit_array)
+      values_array.push(*other_bit_array.to_a)
+
+      self
+    end
+
+    # @param value [EacRubyUtils::Bit]
+    # @return [EacRubyUtils::Bit]
+    def push(value)
+      values_array.push(::EacRubyUtils::Bit.assert(value))
+    end
+
+    # @return [EacRubyUtils::BitArray]
+    def reverse
+      self.class.new(values_array.reverse)
+    end
+
+    # @param big_endian [Boolean]
+    # @return [EacRubyUtils::ByteArray]
+    def to_byte_array(big_endian = false)
+      unless count.modulo(::EacRubyUtils::Byte::BIT_COUNT).zero?
+        raise 'Bits returned is not multile of 8'
+      end
+
+      byte_bits_enumerator.each_with_object(::EacRubyUtils::ByteArray.new) do |e, a|
+        a << ::EacRubyUtils::Byte.from_bit_array(e, big_endian)
+      end
+    end
+
+    # @return [Array<Integer>]
+    def to_int_array
+      values_array.map(&:to_i)
+    end
+
+    private
+
+    def byte_bits_enumerator
+      ::Enumerator.new do |y|
+        offset = 0
+        while offset < values_array.count
+          y.yield(values_array.slice(offset, ::EacRubyUtils::Byte::BIT_COUNT))
+          offset += ::EacRubyUtils::Byte::BIT_COUNT
+        end
+      end
+    end
+
+    def values_array
+      @values_array ||= []
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/byte.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/bit'
+require 'eac_ruby_utils/bit_array'
+require 'eac_ruby_utils/patches/module/compare_by'
+
+module EacRubyUtils
+  class Byte
+    ASSEMBLY_HEXADECIMAL_PREFIX = '$'
+    BIT_COUNT = 8
+    BIT_INDEX_RANGE = (0..7).freeze
+    VALUE_RANGE = (0..255).freeze
+
+    class << self
+      def assert(obj)
+        return obj if obj.is_a?(self)
+
+        new(obj.to_i)
+      end
+
+      def from_bit_array(bit_array, big_endian = false)
+        bit_array = ::EacRubyUtils::BitArray.assert(bit_array)
+        raise ::ArgumentError, "Wrong bit array size: #{bit_array.size}" if
+        bit_array.size != BIT_COUNT
+
+        bit_array = bit_array.reverse if big_endian
+        bit_array.each_with_index.inject(new(0)) do |a, e|
+          a.bit_set(e[1], e[0])
+        end
+      end
+
+      def valid_bit_index?(value)
+        value.is_a?(::Integer) && BIT_INDEX_RANGE.include?(value)
+      end
+
+      def validate_bit_index(value)
+        return value if valid_bit_index?(value)
+
+        raise(::ArgumentError, "Invalid bit index: #{value} (Range: #{BIT_INDEX_RANGE})")
+      end
+
+      def valid_value?(value)
+        value.is_a?(::Integer) && VALUE_RANGE.include?(value)
+      end
+
+      def validate_value(value)
+        return value if valid_value?(value)
+
+        raise(::ArgumentError, "Invalid byte value: #{value} (Range: #{VALUE_RANGE})")
+      end
+    end
+
+    attr_reader :value
+    compare_by :value
+
+    def initialize(value)
+      self.value = value
+    end
+
+    # @param bit_index [Integer]
+    # @return [EacRubyUtils::Bit]
+    def [](bit_index)
+      bit_get(bit_index)
+    end
+
+    # @param bit_index [Integer]
+    # @return [EacRubyUtils::Bit]
+    def bit_get(bit_index)
+      self.class.validate_bit_index(bit_index)
+
+      ::EacRubyUtils::Bit.new((value & (1 << bit_index)) >> bit_index)
+    end
+
+    def bit_set(bit_index, bit_value)
+      self.class.validate_bit_index(bit_index)
+      bit = ::EacRubyUtils::Bit.assert(bit_value)
+      mask = (1 << bit_index)
+      self.class.new(bit.zero? ? value & ~mask : value | mask)
+    end
+
+    # @return [EacRubyUtils::BitArray]
+    def to_bit_array(range = BIT_INDEX_RANGE)
+      ::EacRubyUtils::BitArray.new(range.map { |bit_index| self[bit_index] })
+    end
+
+    # @return [Integer]
+    def to_i
+      value
+    end
+
+    # @return [String]
+    def to_asm_hex
+      ASSEMBLY_HEXADECIMAL_PREFIX + to_hex
+    end
+
+    # @return [String]
+    def to_hex
+      value.to_s(16).upcase.rjust(2, '0')
+    end
+
+    private
+
+    attr_writer :value
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/byte_array.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/byte'
+require 'eac_ruby_utils/patches/module/compare_by'
+
+module EacRubyUtils
+  class ByteArray
+    delegate :to_a, :size, :count, :length, :[], :fetch, :map, to: :values_array
+    compare_by :values_array
+
+    def initialize(values = [])
+      values.each { |value| push(value) }
+    end
+
+    def <<(value)
+      push(value)
+    end
+
+    # @param value [EacRubyUtils::Byte]
+    # @return [EacRubyUtils::Byte]
+    def push(value)
+      values_array.push(::EacRubyUtils::Byte.assert(value))
+    end
+
+    # @return [Array<Integer>]
+    def to_int_array
+      values_array.map(&:to_i)
+    end
+
+    private
+
+    def values_array
+      @values_array ||= []
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/envs/executable.rb

@@ -1,18 +1,34 @@
 # frozen_string_literal: true
 
+require 'eac_ruby_utils/listable'
 require 'eac_ruby_utils/simple_cache'
 
 module EacRubyUtils
   module Envs
     class Executable
+      include ::EacRubyUtils::Listable
       include ::EacRubyUtils::SimpleCache
 
-      attr_reader :env, :name, :check_args
+      lists.add_symbol :option, :check_args, :auto_validate
+
+      DEFAULT_AUTO_VALIDATE = true
+
+      attr_reader :env, :name, :options
 
       def initialize(env, name, *check_args)
         @env = env
         @name = name
-        @check_args = check_args
+        self.options = self.class.lists.option.hash_keys_validate!(check_args.extract_options!)
+        options[OPTION_CHECK_ARGS] = check_args unless options.key?(OPTION_CHECK_ARGS)
+        options.freeze
+      end
+
+      def auto_validate?
+        options.key?(OPTION_AUTO_VALIDATE) ? options[OPTION_AUTO_VALIDATE] : DEFAULT_AUTO_VALIDATE
+      end
+
+      def check_args
+        options[OPTION_CHECK_ARGS]
       end
 
       def exist?
@@ -32,7 +48,7 @@ module EacRubyUtils
       end
 
       def command(*command_args)
-        validate!
+        validate! if auto_validate?
         env.command(*executable_args, *command_args)
       end
 
@@ -50,6 +66,8 @@ module EacRubyUtils
 
       private
 
+      attr_writer :options
+
       def exist_uncached
         env.command(*executable_args, *check_args).execute!
         true

data/sub/eac_ruby_utils/lib/eac_ruby_utils/envs/process.rb

@@ -5,15 +5,23 @@ require 'open3'
 module EacRubyUtils
   module Envs
     class Process
+      EXIT_CODE_KEY = :exit_code
+      ERR_KEY = :stderr
+      OUT_KEY = :stdout
+
       def initialize(command)
-        @data = { command: command }
-        @data[:stdout], @data[:stderr], @data[:exit_code] = Open3.capture3(command)
-        @data[:exit_code] = @data[:exit_code].to_i
+        self.data = { command: command }
+        data[OUT_KEY], data[ERR_KEY], data[EXIT_CODE_KEY] = Open3.capture3(command)
+        data[EXIT_CODE_KEY] = data[EXIT_CODE_KEY].to_i
       end
 
       def to_h
-        @data.dup
+        data.dup
       end
+
+      private
+
+      attr_accessor :data
     end
   end
 end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/object/asserts.rb

@@ -11,4 +11,15 @@ class Object
           "Argument \"#{argument_name}\" is not a #{klass}" \
           "(Actual class: #{self.class}, actual value: #{self})"
   end
+
+  # Raises a ArgumentError if +self.count+ is not equal to +count+.
+  #
+  # @return +self+
+  def assert_count(count, argument_name = 'unknown_argument_name')
+    return self if self.count == count
+
+    raise ::ArgumentError,
+          "Argument \"#{argument_name}\" has wrong elements count" \
+          "(Actual: #{self.count}, Required: #{count})"
+  end
 end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/object/to_uri.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+require 'addressable/uri'
+
+class Object
+  # Convert +self+ to String and then to Addressable::URI. Return nil if +self+ is +blank?+.
+  #
+  # @return [Addressable::URI]
+  def to_uri
+    return self if is_a?(::Addressable::URI)
+
+    to_s.blank? ? nil : ::Addressable::URI.parse(to_s)
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/pathname/basename_noext.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/fs/extname'
+require 'pathname'
+
+class Pathname
+  def basename_noext(limit = 1)
+    basename(::EacRubyUtils::Fs.extname(basename.to_path, limit))
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/pathname/reqdir_glob.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+class Pathname
+  # A .glob that raises a ::RuntimeError if +self+ is not a directory.
+  # @return [Pathname]
+  def reqdir_glob(*args)
+    raise ::RuntimeError, "\"#{self}\" is not a directory" unless directory?
+
+    glob(*args)
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EacRubyUtils
-  VERSION = '0.85.0'
+  VERSION = '0.92.1'
 end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/bit_array_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/bit_array'
+
+RSpec.describe ::EacRubyUtils::BitArray do
+  describe '#to_byte_array' do
+    let(:instance) { described_class.new([0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1]) }
+
+    {
+      false => [0xF0, 0xDC],
+      true => [0x0F, 0x3B]
+    }.each do |big_endian, expected_bytes|
+      context "when big-endian is #{big_endian}" do
+        let(:expected_value) { ::EacRubyUtils::ByteArray.new(expected_bytes) }
+
+        it do
+          expect(instance.to_byte_array(big_endian)).to eq(expected_value)
+        end
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/byte_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/byte'
+
+RSpec.describe ::EacRubyUtils::Byte do
+  describe '#[]' do
+    let(:instance) { described_class.new(0xDC) }
+
+    [0, 0, 1, 1, 1, 0, 1, 1].each_with_index do |bit_value, bit_index|
+      context "when bit index is #{bit_index}" do
+        it { expect(instance[bit_index].value).to eq(bit_value) }
+      end
+    end
+  end
+
+  describe '#bit_set' do
+    let(:instance) { described_class.new(0b11011100) }
+
+    {
+      0 => [0b11011100, 0b11011100, 0b11011000, 0b11010100,
+            0b11001100, 0b11011100, 0b10011100, 0b01011100],
+      1 => [0b11011101, 0b11011110, 0b11011100, 0b11011100,
+            0b11011100, 0b11111100, 0b11011100, 0b11011100]
+    }.each do |bit_value, expected_values|
+      expected_values.each_with_index do |expected_value, bit_index|
+        context "when bit index is #{bit_index} and bit value is #{bit_value}" do
+          it do
+            expect(instance.bit_set(bit_index, bit_value))
+              .to eq(described_class.new(expected_value))
+          end
+        end
+      end
+    end
+  end
+
+  describe '#from_bit_array' do
+    let(:bit_array) { [0, 0, 1, 1, 1, 0, 1, 1] }
+
+    { false => 0b11011100, true => 0b00111011 }.each do |big_endian, expected_integer|
+      context "when big-endian is #{big_endian}" do
+        let(:expected_value) { described_class.new(expected_integer) }
+
+        it do
+          expect(described_class.from_bit_array(bit_array, big_endian)).to eq(expected_value)
+        end
+      end
+    end
+
+    it do
+      expect { described_class.from_bit_array([0, 0, 1, 1, 1, 0, 1]) }
+        .to raise_error(::ArgumentError)
+    end
+  end
+end