avm-tools 0.114.2 → 0.116.1

data/sub/avm-eac_webapp_base0/avm-eac_webapp_base0.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |s|
   s.add_dependency 'avm', '~> 0.1'
   s.add_dependency 'avm-eac_generic_base0', '~> 0.1'
   s.add_dependency 'avm-eac_postgresql_base0', '~> 0.1'
-  s.add_dependency 'avm-eac_ubuntu_base0', '~> 0.2.1'
+  s.add_dependency 'avm-eac_ubuntu_base0', '~> 0.3'
   s.add_dependency 'eac_ruby_utils', '~> 0.68'
 
   s.add_development_dependency 'eac_ruby_gem_support', '~> 0.2'

data/sub/avm-eac_webapp_base0/lib/avm/eac_webapp_base0/instance.rb

@@ -5,12 +5,14 @@ require 'avm/eac_postgresql_base0/instance_with'
 require 'avm/data/instance/files_unit'
 require 'avm/data/instance/package'
 require 'avm/eac_webapp_base0/deploy/file_unit'
+require 'avm/eac_ubuntu_base0/instances/base'
 
 module Avm
   module EacWebappBase0
     class Instance < ::Avm::Instances::Base
       require_sub __FILE__
       include ::Avm::EacPostgresqlBase0::InstanceWith
+      enable_simple_cache
 
       FILES_UNITS = [].freeze
 
@@ -45,6 +47,11 @@ module Avm
 
       private
 
+      # @return [Avm::EacUbuntuBase0::Instances::Base]
+      def platform_instance_uncached
+        ::Avm::EacUbuntuBase0::Instances::Base.by_id(id)
+      end
+
       def files_units
         self.class.const_get('FILES_UNITS').transform_values do |fs_path_subpath|
           ::Avm::Data::Instance::FilesUnit.new(self, fs_path_subpath)

data/sub/avm-eac_webapp_base0/lib/avm/eac_webapp_base0/version.rb

@@ -2,6 +2,6 @@
 
 module Avm
   module EacWebappBase0
-    VERSION = '0.2.1'
+    VERSION = '0.3.0'
   end
 end

data/sub/eac_cli/lib/eac_cli/runner/context.rb

@@ -23,6 +23,10 @@ module EacCli
         raise ::NameError, "No method \"#{method_name}\" found in #{runner} or in its ancestors"
       end
 
+      def respond_to_call?((method_name))
+        parent.respond_to?(:runner_context) && parent.runner_context.respond_to_call?(method_name)
+      end
+
       protected
 
       def parent_call(method_name, *args)

data/sub/eac_cli/lib/eac_cli/runner/instance_methods.rb

@@ -37,6 +37,16 @@ module EacCli
       def program_name
         runner_context.if_present(&:program_name) || $PROGRAM_NAME
       end
+
+      def respond_to_missing?(method, include_all = false)
+        runner_context.respond_to_call?(method) || super
+      end
+
+      def method_missing(method, *args, &block)
+        return super unless runner_context.respond_to_call?(method)
+
+        runner_context.call(method, *args, &block)
+      end
     end
   end
 end

data/sub/eac_cli/lib/eac_cli/runner_with/subcommands.rb

@@ -95,7 +95,7 @@ module EacCli
         raise(::EacCli::Parser::Error.new(
                 self.class.runner_definition, runner_context.argv,
                 "Subcommand \"#{subcommand_name}\" not found " \
-                  "(Available: #{available_subcommands.keys}"
+                  "(Available: #{available_subcommands.keys})"
               ))
       end
 

data/sub/eac_cli/lib/eac_cli/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EacCli
-  VERSION = '0.26.2'
+  VERSION = '0.27.2'
 end

data/sub/eac_fs/lib/eac_fs/patches/object/fs_cache.rb

@@ -10,7 +10,12 @@ class Object
       def fs_#{type}
         oid = fs_object_id_by_type(:'#{type}')
         oid = [oid.to_s] unless oid.is_a?(::Enumerable)
-        oid.inject(self.class.fs_#{type}) { |a, e| a.child(e.to_s) }
+        oid.inject(fs_#{type}_parent) { |a, e| a.child(e.to_s) }
+      end
+
+      # @return [EacFs::StorageTree]
+      def fs_#{type}_parent
+        self.class.fs_#{type}
       end
     CODE
   end

data/sub/eac_fs/lib/eac_fs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EacFs
-  VERSION = '0.11.1'
+  VERSION = '0.12.0'
 end

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/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/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.87.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

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/pathname/basename_noext_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/pathname/basename_noext'
+
+RSpec.describe ::Pathname do
+  describe '#basename_noext' do
+    {
+      'After.Life.S01E01.WEBRip.x264-ION10.mp4' =>
+        %w[After.Life.S01E01.WEBRip.x264-ION10 After.Life.S01E01.WEBRip.x264-ION10.mp4
+           After.Life.S01E01.WEBRip.x264-ION10 After.Life.S01E01.WEBRip.x264-ION10],
+      's01e01.en.srt' => %w[s01e01 s01e01.en.srt s01e01.en s01e01 s01e01],
+      's01e01.srt' => %w[s01e01 s01e01.srt s01e01 s01e01 s01e01],
+      '/path/to/file.tar.gz' => %w[file file.tar.gz file.tar file file]
+    }.each do |source, expected_values|
+      expected_values.each_with_index do |expected_value, index|
+        limit = index - 1
+        context "when source is \"#{source}\" and limit is \"#{limit}\"" do
+          let(:instance) { described_class.new(source) }
+          let(:expected_path) { described_class.new(expected_value) }
+
+          it { expect(instance.basename_noext(limit)).to eq(expected_path) }
+        end
+      end
+    end
+  end
+end