avm-tools 0.114.1 → 0.116.0

data/sub/avm-eac_ubuntu_base0/lib/avm/eac_ubuntu_base0/instances/base.rb

@@ -10,6 +10,12 @@ module Avm
         def docker_image_class
           ::Avm::EacUbuntuBase0::DockerImage
         end
+
+        def file_sudo_write(path, content)
+          ::EacRubyUtils::Envs.local.command('echo', content).pipe(
+            host_env.command('sudo', 'tee', path)
+          ).execute!
+        end
       end
     end
   end

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

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

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_rest/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec

data/sub/eac_rest/eac_rest.gemspec

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+
+require 'eac_rest/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'eac_rest'
+  s.version     = EacRest::VERSION
+  s.authors     = ['Eduardo H. Bogoni']
+  s.summary     = 'A REST helper for Ruby.'
+
+  s.files = Dir['{lib}/**/*']
+
+  s.add_dependency 'eac_ruby_utils', '~> 0.70'
+
+  s.add_development_dependency 'eac_ruby_gem_support', '~> 0.3'
+end

data/sub/eac_rest/lib/eac_rest/api.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'eac_rest/request'
+require 'eac_ruby_utils/core_ext'
+
+module EacRest
+  # Abstract methods
+  #   * self.issue_get_url_suffix(provider_issue_id)
+  class Api
+    require_sub __FILE__, include_modules: true
+    common_constructor :root_url, :username, :password, default: [nil, nil]
+
+    def request(service_url_suffix, headers = {}, &body_data_proc)
+      r = ::EacRest::Request.new(build_service_url(service_url_suffix),
+                                 body_data_proc)
+      headers.each { |name, value| r = r.header(name, value) }
+      r = r.autenticate(username, password) if username.present?
+      r
+    end
+
+    def request_json(service_url_suffix, headers = {}, &body_data_proc)
+      request(service_url_suffix, headers.merge('Accept' => 'application/json')) do |body_data|
+        r = ::JSON.parse(body_data)
+        r = body_data_proc.call(r) if body_data_proc
+        r
+      end
+    end
+
+    # @return [Addressable::URI]
+    def build_service_url(suffix)
+      s = ::Addressable::URI.parse(suffix)
+      r = ::Addressable::URI.parse(root_url)
+      r.path += s.path
+      r.query_values = r.query_values(::Array).if_present([]) +
+                       s.query_values(::Array).if_present([])
+      r
+    end
+  end
+end

data/sub/eac_rest/lib/eac_rest/entity.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacRest
+  class Entity
+    enable_simple_cache
+    common_constructor :api, :data
+
+    class << self
+      def from_array_data(api, array_data, *args)
+        array_data.map { |item_data| new(api, item_data, *args) }
+      end
+    end
+  end
+end

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