avm-tools 0.113.1 → 0.113.5

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/simple_cache'
+
+class CacheableObject
+  include ::EacRubyUtils::SimpleCache
+
+  def my_method_uncached
+    @counter ||= 0
+    @counter += 1
+  end
+
+  def method_with_question_uncached?
+    'question'
+  end
+
+  def method_with_exclamation_uncached!
+    'exclamation'
+  end
+
+  def method_with_args_uncached(arg1)
+    @counter2 ||= 0
+    @counter2 += 1
+    "#{arg1}/#{@counter2}"
+  end
+
+  def method_with_reset_uncached
+    reset_cache
+    'result'
+  end
+
+  private
+
+  def private_method_uncached
+    @counter3 ||= 0
+    @counter3 += 1
+  end
+end
+
+RSpec.describe ::EacRubyUtils::SimpleCache do
+  let(:instance) { CacheableObject.new }
+
+  describe 'cached value' do
+    it 'uncached method return value should update at each call' do
+      expect(instance.my_method_uncached).not_to eq(instance.my_method_uncached)
+    end
+
+    it 'cached method should return same values at each call' do
+      expect(instance.my_method).to eq(instance.my_method)
+    end
+
+    it 'is able to call private uncached as cached' do
+      expect(instance.private_method).to eq(instance.private_method)
+    end
+
+    it 'return value even if reset cache' do
+      expect(instance.method_with_reset).to eq('result')
+    end
+  end
+
+  describe 'cache value with args' do
+    it do
+      expect(instance.method_with_args_uncached('123'))
+        .not_to eq(instance.method_with_args_uncached('123'))
+    end
+
+    it do
+      expect(instance.method_with_args_uncached('456'))
+        .not_to eq(instance.method_with_args_uncached('456'))
+    end
+
+    it do
+      expect(instance.method_with_args('123')).to eq(instance.method_with_args('123'))
+    end
+
+    it do
+      expect(instance.method_with_args('456')).to eq(instance.method_with_args('456'))
+    end
+
+    it do
+      expect(instance.method_with_args('456')).not_to eq(instance.method_with_args('123'))
+    end
+  end
+
+  describe 'method with marks' do
+    it 'found uncached method with exclamation mark' do
+      expect(instance.method_with_exclamation!).to eq('exclamation')
+    end
+
+    it 'found uncached method with question mark' do
+      expect(instance.method_with_question?).to eq('question')
+    end
+  end
+
+  describe '#respond_to?' do
+    it 'responds to cached method without args' do
+      expect(instance.respond_to?(:my_method)).to be(true)
+    end
+
+    it 'responds to cached method with args' do
+      expect(instance.respond_to?(:method_with_args)).to be(true)
+    end
+
+    it 'responds to cached method of uncached private method' do
+      expect(instance.respond_to?(:private_method)).to be(true)
+    end
+
+    it 'not respond to not existent method' do
+      expect(instance.respond_to?(:not_exist)).to be(false)
+    end
+  end
+
+  describe '#reset_cache' do
+    let(:instance) { CacheableObject.new }
+    let(:cached_value) { instance.my_method }
+
+    it 'cached method return should return cached value' do
+      expect(instance.my_method).to eq(cached_value)
+    end
+
+    context 'when reset_cache method is called' do
+      it 'cached method return should return new cached value' do
+        cached_value
+        instance.reset_cache
+        expect(instance.my_method).not_to eq(cached_value)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/struct'
+
+RSpec.describe ::EacRubyUtils::Struct do
+  let(:instance) { described_class.new('a' => 1, b: '') }
+  let(:other) { described_class.new('a' => 'm1', c: 'm2') }
+
+  describe '#[]' do
+    it { expect(instance[:a]).to eq(1) }
+    it { expect(instance['a']).to eq(1) }
+    it { expect(instance[:a?]).to eq(true) }
+    it { expect(instance['a?']).to eq(true) }
+    it { expect(instance[:b]).to eq('') }
+    it { expect(instance['b']).to eq('') }
+    it { expect(instance[:b?]).to eq(false) }
+    it { expect(instance['b?']).to eq(false) }
+    it { expect(instance[:c]).to eq(nil) }
+    it { expect(instance['c']).to eq(nil) }
+    it { expect(instance[:c?]).to eq(false) }
+    it { expect(instance['c?']).to eq(false) }
+  end
+
+  describe '#fetch' do
+    it { expect(instance.fetch(:a)).to eq(1) }
+    it { expect(instance.fetch('a')).to eq(1) }
+    it { expect(instance.fetch(:a?)).to eq(true) }
+    it { expect(instance.fetch('a?')).to eq(true) }
+    it { expect(instance.fetch(:b)).to eq('') }
+    it { expect(instance.fetch('b')).to eq('') }
+    it { expect(instance.fetch(:b?)).to eq(false) }
+    it { expect(instance.fetch('b?')).to eq(false) }
+    it { expect { instance.fetch(:c) }.to raise_error(::KeyError) }
+    it { expect { instance.fetch('c') }.to raise_error(::KeyError) }
+    it { expect { instance.fetch(:c?) }.to raise_error(::KeyError) }
+    it { expect { instance.fetch('c?') }.to raise_error(::KeyError) }
+  end
+
+  describe '#merge' do
+    let(:merged) { instance.merge(other) }
+
+    it { expect(merged.to_h).to eq(a: 'm1', b: '', c: 'm2') }
+  end
+
+  describe '#property_method' do
+    it { expect(instance.a).to eq(1) }
+    it { expect(instance.a?).to eq(true) }
+    it { expect(instance.b).to eq('') }
+    it { expect(instance.b?).to eq(false) }
+    it { expect { instance.c }.to raise_error(::NoMethodError) }
+    it { expect { instance.c? }.to raise_error(::NoMethodError) }
+  end
+
+  describe '#to_h' do
+    it { expect(instance.to_h).to eq(a: 1, b: '') }
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'active_support/hash_with_indifferent_access'
+require 'eac_ruby_utils/yaml'
+
+RSpec.describe ::EacRubyUtils::Yaml do
+  let(:unpermitted_class) do
+    Class.new do
+      def initialize(value)
+        @value = value
+      end
+
+      def to_s
+        @value.to_s
+      end
+    end
+  end
+
+  let(:arrayliable_class) do
+    Class.new do
+      def initialize(value)
+        @value = value
+      end
+
+      def to_a
+        [@value]
+      end
+    end
+  end
+
+  let(:source) do
+    {
+      a: 'a', b: :b, c: false, d: true, e: nil,
+      f: [
+        'f',
+        {
+          g: 'g',
+          h: ::ActiveSupport::HashWithIndifferentAccess.new(
+            'i' => ['i', unpermitted_class.new('j')],
+            k: arrayliable_class.new('k')
+          )
+        }
+      ]
+    }
+  end
+
+  let(:target) do
+    {
+      a: 'a', b: :b, c: false, d: true, e: nil,
+      f: ['f', { g: 'g', h: { i: %w[i j], k: ['k'] } }]
+    }
+  end
+
+  describe '#dump' do
+    it { expect(described_class.load(described_class.dump(source))).to eq(target) }
+  end
+
+  describe '#sanitize' do
+    it { expect(described_class.sanitize(target)).to eq(target) }
+  end
+
+  describe '#yaml' do
+    {
+      ['text'] => false,
+      'text' => false,
+      "--- Text\n\n" => true,
+      "---\n" + ":index: 0\n" + ":codec_name: h264\n" + ":codec_type: video\n" => true,
+      '--- - \n bla bla bla' => false
+    }.each do |source, result|
+      it "return #{result} to source \"#{source}\"" do
+        expect(described_class.yaml?(source)).to eq(result)
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/spec/locales/pt-BR.yml

@@ -0,0 +1,55 @@
+pt-BR:
+  eac_ruby_utils:
+    listable:
+      stub:
+        inteiro:
+          a:
+            label: Inteiro A
+            description: Inteiro A Descr.
+          b:
+            label: Inteiro BB
+            description: Inteiro BB Descr.
+          c:
+            label: Inteiro CCC
+            description: Inteiro CCC Descr.
+        cadeia:
+          a:
+            label: Cadeia AAA
+            description: Cadeia AAA Descr.
+          b:
+            label: Cadeia BB
+            description: Cadeia BB Descr.
+          c:
+            label: Cadeia C
+            description: Cadeia C Descr.
+        code:
+          a:
+            label: Código A
+            description: Código A Descr.
+          b:
+            label: Código B
+            description: Código B Descr.
+        type:
+          a:
+            label: Tipo A
+            description: Tipo A Descr.
+          b:
+            label: Tipo B
+            description: Tipo B Descr.
+        simbolo:
+          a:
+            label: Simbolo A
+            description: Simbolo A Descr.
+          b:
+            label: Simbolo B
+            description: Simbolo B Descr.
+          c:
+            label: Simbolo C
+            description: Simbolo C Descr.
+        tipado:
+          a:
+            label: Tipado A
+            description: Tipado A Descr.
+          b:
+            label: Tipado B
+            description: Tipado B Descr.

data/sub/eac_ruby_utils/spec/rubocop_check_spec.rb

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

data/sub/eac_ruby_utils/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('../lib', __dir__)
+require 'tmpdir'
+
+require 'i18n'
+::I18n.load_path << ::File.join(__dir__, 'locales/pt-BR.yml')
+::I18n.locale = 'pt-BR'
+
+RSpec.configure do |config|
+  config.example_status_persistence_file_path = ::File.join(::Dir.tmpdir, 'eac_ruby_utils_rspec')
+
+  require 'eac_ruby_utils/rspec/default_setup'
+  ::EacRubyUtils::Rspec.default_setup_create(::File.expand_path('..', __dir__), config)
+end

data/sub/eac_templates/Gemfile

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

data/sub/eac_templates/eac_templates.gemspec

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+
+require 'eac_templates/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'eac_templates'
+  s.version     = EacTemplates::VERSION
+  s.authors     = ['Put here the authors']
+  s.summary     = 'Put here de description.'
+
+  s.files = Dir['{lib}/**/*']
+
+  s.add_dependency 'eac_config', '~> 0.5'
+  s.add_dependency 'eac_ruby_utils', '~> 0.64'
+
+  s.add_development_dependency 'eac_ruby_gem_support', '~> 0.2'
+end

data/sub/eac_templates/lib/eac_templates/core_ext.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'eac_templates/patches'
+require 'eac_templates/from_all_gems'

data/sub/eac_templates/lib/eac_templates/directory.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'eac_templates/file'
+
+module EacTemplates
+  class Directory
+    TEMPLATE_EXTNAME = '.template'
+
+    attr_reader :path
+
+    def initialize(path)
+      @path = path.is_a?(::Pathname) ? path : ::Pathname.new(path.to_s)
+    end
+
+    def apply(variables_source, directory)
+      TemplateNode.new(self, '.', directory, variables_source).apply
+    end
+
+    def child(subpath)
+      child_path = ::File.join(path, subpath)
+      return ::EacTemplates::File.new(child_path) if ::File.file?(child_path)
+      return ::EacTemplates::Directory.new(child_path) if ::File.directory?(child_path)
+
+      raise "Child \"#{subpath}\" from \"#{path}\" not found"
+    end
+
+    def children
+      path.children.map do |path_child|
+        child(path_child.basename.to_path)
+      end
+    end
+
+    private
+
+    def apply_fs_object(source_relative, target)
+      if ::File.directory?(source_absolute(source_relative))
+        apply_directory(source_relative, target)
+      elsif ::File.file?(source_absolute(source_relative))
+      end
+    end
+
+    def source_absolute(source_relative)
+      ::File.expand_path(source_relative, path)
+    end
+
+    class TemplateNode
+      attr_reader :source_directory, :source_relative, :target_root_directory, :variables_source
+
+      def initialize(source_directory, source_relative, target_root_directory, variables_source)
+        @source_directory = source_directory
+        @source_relative = source_relative
+        @target_root_directory = target_root_directory
+        @variables_source = variables_source
+      end
+
+      def apply
+        if file?
+          apply_file
+        elsif directory?
+          apply_directory
+        else
+          raise "Unknown filesystem type: #{source_absolute}"
+        end
+      end
+
+      private
+
+      def apply_directory
+        ::FileUtils.mkdir_p(target_absolute)
+        Dir.entries(source_absolute).each do |entry|
+          child(entry).apply unless %w[. ..].include?(entry)
+        end
+      end
+
+      def apply_file
+        if ::File.extname(source_absolute) == TEMPLATE_EXTNAME
+          ::EacTemplates::File.new(source_absolute).apply_to_file(
+            variables_source, target_absolute
+          )
+        else
+          ::FileUtils.cp(source_absolute, target_absolute)
+        end
+      end
+
+      def child(entry)
+        TemplateNode.new(source_directory, ::File.join(source_relative, entry),
+                         target_root_directory, variables_source)
+      end
+
+      def file?
+        ::File.file?(source_absolute)
+      end
+
+      def directory?
+        ::File.directory?(source_absolute)
+      end
+
+      def source_absolute
+        ::File.expand_path(source_relative, source_directory.path)
+      end
+
+      def target_absolute
+        ::File.expand_path(source_relative, target_root_directory)
+              .gsub(/#{::Regexp.quote(TEMPLATE_EXTNAME)}\z/, '')
+      end
+    end
+  end
+end

data/sub/eac_templates/lib/eac_templates/file.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_templates/variable_providers'
+
+module EacTemplates
+  class File
+    VARIABLE_DELIMITER = ::Regexp.quote('%%')
+    VARIABLE_PATTERN = /#{VARIABLE_DELIMITER}([a-z0-9\._]*)#{VARIABLE_DELIMITER}/i.freeze
+
+    enable_simple_cache
+    common_constructor :path do
+      self.path = path.to_pathname
+    end
+
+    # +variables_provider+ A [Hash] or object which responds to +read_entry(entry_name)+.
+    def apply(variables_source)
+      variables_provider = ::EacTemplates::VariableProviders.build(variables_source)
+      variables.inject(content) do |a, e|
+        a.gsub(variable_pattern(e), variables_provider.variable_value(e).to_s)
+      end
+    end
+
+    def apply_to_file(variables_source, output_file_path)
+      output_file_path.to_pathname.write(apply(variables_source))
+    end
+
+    private
+
+    def variables_uncached
+      content.scan(VARIABLE_PATTERN).map(&:first).map do |name|
+        sanitize_variable_name(name)
+      end.to_set
+    end
+
+    def content_uncached
+      path.read
+    end
+
+    def sanitize_variable_name(variable_name)
+      variable_name.to_s.downcase
+    end
+
+    def variable_pattern(name)
+      /#{VARIABLE_DELIMITER}#{::Regexp.quote(name)}#{VARIABLE_DELIMITER}/i
+    end
+  end
+end

data/sub/eac_templates/lib/eac_templates/from_all_gems.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'eac_templates/from_gem'
+::EacTemplates::FromGem.include_all

data/sub/eac_templates/lib/eac_templates/from_gem.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'eac_templates/searcher'
+
+module EacTemplates
+  class FromGem
+    class << self
+      def include_all(searcher = nil)
+        ::Gem::Specification.each { |gemspec| new(gemspec, searcher).include }
+      end
+    end
+
+    TEMPLATES_DIR_SUBPATH = 'template'
+
+    common_constructor :gemspec, :searcher, default: [nil] do
+      self.searcher ||= ::EacTemplates::Searcher.default
+    end
+
+    # @return [Boolean]
+    delegate :exist?, to: :path
+
+    # @return [Pathname]
+    def include
+      return nil unless exist?
+
+      searcher.included_paths << path
+      path
+    end
+
+    # @return [Pathname]
+    def path
+      gemspec.gem_dir.to_pathname.join(TEMPLATES_DIR_SUBPATH)
+    end
+  end
+end

data/sub/eac_templates/lib/eac_templates/patches/module/erb_template.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'erb'
+
+class Module
+  def erb_template(subpath, binding_obj)
+    ::ERB.new(template.child(subpath).path.read).result(binding_obj)
+  end
+end

data/sub/eac_templates/lib/eac_templates/patches/module/template.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string/inflections'
+require 'eac_templates/searcher'
+
+class Module
+  def template
+    @template ||= ::EacTemplates::Searcher.default.template(name.underscore)
+  end
+end

data/sub/eac_templates/lib/eac_templates/patches/module.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/require_sub'
+::EacRubyUtils.require_sub __FILE__

data/sub/eac_templates/lib/eac_templates/patches/object/erb_template.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_templates/patches/module/erb_template'
+
+class Object
+  def erb_template(subpath, binding_obj = nil)
+    self.class.erb_template(subpath, binding_obj || binding)
+  end
+end

data/sub/eac_templates/lib/eac_templates/patches/object/template.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_templates/patches/module/template'
+
+class Object
+  def template
+    self.class.template
+  end
+end

data/sub/eac_templates/lib/eac_templates/patches/object.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/require_sub'
+::EacRubyUtils.require_sub __FILE__

data/sub/eac_templates/lib/eac_templates/patches.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/require_sub'
+::EacRubyUtils.require_sub __FILE__

data/sub/eac_templates/lib/eac_templates/searcher.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+require 'eac_templates/directory'
+require 'eac_templates/file'
+
+module EacTemplates
+  class Searcher
+    class << self
+      def default
+        @default ||= new
+      end
+    end
+
+    def template(subpath, required = true)
+      path = template_path(subpath)
+      if path.blank?
+        return nil unless required
+
+        raise_template_not_found(subpath)
+      end
+      return ::EacTemplates::File.new(path) if ::File.file?(path)
+      return ::EacTemplates::Directory.new(path) if ::File.directory?(path)
+
+      raise 'Invalid branching'
+    end
+
+    # @return The absolute path of template if found, +nil+ otherwise.
+    def template_path(subpath)
+      included_paths.each do |included_path|
+        r = search_template_in_included_path(included_path, subpath)
+        return r if r
+      end
+      nil
+    end
+
+    def included_paths
+      @included_paths ||= ::Set.new
+    end
+
+    private
+
+    def raise_template_not_found(subpath)
+      raise "Template not found for subpath \"#{subpath}\"" \
+        " (Included paths: #{included_paths.to_a.join(::File::PATH_SEPARATOR)})"
+    end
+
+    def search_template_in_included_path(included_path, subpath)
+      path = ::File.join(included_path, subpath)
+      ::File.exist?(path) ? path : nil
+    end
+  end
+end

data/sub/eac_templates/lib/eac_templates/variable_not_found_error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module EacTemplates
+  class VariableNotFoundError < StandardError; end
+end