eac_rails_utils 0.8.0 → 0.11.0

data/lib/eac/parsers/files_test.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-require 'yaml'
-
-module Eac
-  module Parsers
-    module FilesTest
-      def test_data
-        if ENV['EAC_PARSERS_FILES_TEST_WRITE'].present?
-          write_results
-        else
-          test_results
-        end
-      end
-
-      protected
-
-      def source_data(source_file)
-        parser_class.new(source_file).data
-      end
-
-      def test_results
-        sts = source_target_fixtures.source_target_files
-        assert_not_equal 0, sts.count, 'Source/target files count cannot be zero'
-        sts.each do |st|
-          assert_source_target_complete(st)
-          sd = source_data(st.source)
-          td = YAML.load_file(st.target)
-          assert_equal sort_results(td), sort_results(sd)
-        end
-      end
-
-      def write_results
-        source_target_fixtures.source_files.each do |source_file|
-          sd = sort_results(source_data(source_file))
-          basename = ::Eac::SourceTargetFixtures.source_target_basename(source_file)
-          target_file = File.expand_path("../#{basename}.target.yaml", source_file)
-          File.write(target_file, sd.to_yaml)
-        end
-      end
-
-      def sort_results(r)
-        r
-      end
-
-      private
-
-      def assert_source_target_complete(st)
-        assert st.source, "Source not found (Target: #{st.target})"
-        assert st.target, "Target not found (Source: #{st.source})"
-      end
-
-      def source_target_fixtures
-        @source_target_fixtures ||= ::Eac::SourceTargetFixtures.new(
-          File.expand_path("../#{self.class.name.demodulize.underscore}_files", test_file)
-        )
-      end
-
-      def parser_class
-        self.class.name.gsub(/Test\z/, '').constantize
-      end
-    end
-  end
-end

data/lib/eac/source_target_fixtures.rb

@@ -1,66 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-require 'yaml'
-
-module Eac
-  # Lists pairs of source/target files in a directory. See {Eac::Parsers::FilesTest} to see
-  # a use of this class.
-  class SourceTargetFixtures
-    class << self
-      def source_target_basename(file)
-        m = /^(.+)\.(?:source|target)(?:\..+)?$/.match(File.basename(file))
-        m ? m[1] : nil
-      end
-    end
-
-    attr_reader :fixtures_directory
-
-    def initialize(fixtures_directory)
-      @fixtures_directory = fixtures_directory
-    end
-
-    def source_target_files
-      sources_targets_basenames.map do |basename|
-        OpenStruct.new(source: source_file(basename), target: target_file(basename))
-      end
-    end
-
-    def source_files
-      r = []
-      source_target_files.each do |st|
-        r << st.source if st.source
-      end
-      r
-    end
-
-    private
-
-    def target_file(basename)
-      fixture_file(basename, 'target')
-    end
-
-    def source_file(basename)
-      fixture_file(basename, 'source')
-    end
-
-    def fixture_file(basename, suffix)
-      prefix = "#{basename}.#{suffix}"
-      Dir.foreach(fixtures_directory) do |item|
-        next if item == '.' || item == '..'
-        return File.expand_path(item, fixtures_directory) if item.starts_with?(prefix)
-      end
-      nil
-    end
-
-    def sources_targets_basenames
-      basenames = Set.new
-      Dir.foreach(fixtures_directory) do |item|
-        next if item == '.' || item == '..'
-        b = self.class.source_target_basename(item)
-        basenames << b if b.present?
-      end
-      basenames
-    end
-  end
-end

data/lib/eac/test_utils.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-module Eac
-  module TestUtils
-    # Add more helper methods to be used by all tests here...
-    def valid_invalid_column_values_test(record, column, valid_values, invalid_values)
-      valid_values.each do |v|
-        record.send("#{column}=", v)
-        assert record.valid?, "#{record.errors.messages}, #{column} = #{v.inspect} should be valid"
-      end
-      invalid_values.each do |v|
-        record.send("#{column}=", v)
-        assert_not record.valid?, "#{column} = #{v.inspect} should be invalid"
-      end
-    end
-
-    # Verifica falhas em campos específicos de um record
-    def assert_record_errors(record, fields_without_error, fields_with_error)
-      fields_without_error.each do |c|
-        assert record.errors[c].empty?, "Column: #{c} should not have errors (#{record.errors[c]})"
-      end
-      fields_with_error. each do |c|
-        assert_not record.errors[c].empty?, "Column: #{c} should have errors"
-      end
-    end
-
-    # Verifica, campo por campo, se invalida o registro.
-    def assert_column_changes(ppp, expected_valid_result, changes)
-      changes.each do |k, v|
-        ppp.send("#{k}=", v)
-        assert_equal expected_valid_result, ppp.valid?, "\"#{k}\" change should be " +
-                                                        (expected_valid_result ? 'valid' : 'invalid')
-        assert_not ppp.errors[k].empty? unless expected_valid_result
-        ppp.restore_attributes
-      end
-    end
-
-    # Ex.: attrs = {a: 1, b: 2} resulta em
-    # [{a: nil, b: nil}, {a: 1, b: nil}, {a: nil, b: 2}, {a: 1, b: 2}].
-    def all_combinations(attrs)
-      combs = [{}]
-      attrs.each do |attr_name, value|
-        new_comb = []
-        assert_not value.nil?, "#{attr_name}=#{value}"
-        [nil, value].each do |vv|
-          combs.each do |c|
-            cc = c.dup
-            cc[attr_name] = vv
-            new_comb << cc
-          end
-        end
-        combs = new_comb
-      end
-      combs
-    end
-  end
-end

data/lib/eac_rails_utils/patches/model_attribute_required.rb

@@ -1,31 +0,0 @@
-require 'active_record'
-
-module EacRailsUtils
-  module Patches
-    module ModelAttributeRequired
-      def self.included(base)
-        base.extend ClassMethods
-        base.include InstanceMethods
-      end
-
-      module ClassMethods
-        def column_required?(column)
-          m = new
-          m.validate
-          m.errors.key?(column.to_sym)
-        end
-      end
-
-      module InstanceMethods
-        def attribute_required?(column)
-          self.class.column_required?(column)
-        end
-      end
-    end
-  end
-end
-
-[::ActiveRecord::Base, ::ActiveModel::Model].each do |c|
-  next if c.included_modules.include? ::EacRailsUtils::Patches::ModelAttributeRequired
-  c.include ::EacRailsUtils::Patches::ModelAttributeRequired
-end

data/lib/eac_rails_utils/patches/ofx_parser.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-require 'ofx-parser'
-
-module EacRailsUtils
-  module Patches
-    module OfxParser
-      module OfxParser
-        def self.included(base)
-          base.class_eval do
-            class << self
-              prepend ClassMethods
-            end
-          end
-        end
-
-        module ClassMethods
-          def build_transaction(t)
-            r = super
-            r.currate = (t / 'CURRENCY/CURRATE').inner_text
-            r
-          end
-        end
-      end
-
-      module Transaction
-        attr_accessor :currate, :cursym
-      end
-    end
-  end
-end
-
-unless ::OfxParser::OfxParser.included_modules.include?(
-  ::EacRailsUtils::Patches::OfxParser::OfxParser
-)
-  ::OfxParser::OfxParser.send(:include, ::EacRailsUtils::Patches::OfxParser::OfxParser)
-end
-
-unless ::OfxParser::Transaction.included_modules.include?(
-  ::EacRailsUtils::Patches::OfxParser::Transaction
-)
-  ::OfxParser::Transaction.send(:include, ::EacRailsUtils::Patches::OfxParser::Transaction)
-end

data/lib/eac_rails_utils/tableless_model.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-module EacRailsUtils
-  class TablelessModel
-    include ActiveModel::Model
-    include Virtus.model
-    include ActiveModel::Associations
-
-    def initialize(values = {})
-      super(build_attributes(values))
-    end
-
-    def attributes=(values)
-      super(build_attributes(values))
-    end
-
-    # need hash like accessor, used internal Rails
-    def [](attr)
-      send(attr)
-    end
-
-    # need hash like accessor, used internal Rails
-    def []=(attr, value)
-      send("#{attr}=", value)
-    end
-
-    def save!
-      save || raise("#{self.class}.save failed: #{errors.messages}")
-    end
-
-    private
-
-    def build_attributes(values)
-      AttributesBuilder.new(self.class, values).to_attributes
-    end
-
-    class AttributesBuilder
-      DATE_TIME_FIELDS = %i(year month day hour min sec).freeze
-
-      def initialize(model_class, values)
-        @model_class = model_class
-        @values = {}
-        values.each { |k, v| add(k, v) }
-      end
-
-      def to_attributes
-        @values
-      end
-
-      private
-
-      def add(key, value)
-        array_attr = parse_array_attr_key(key)
-        if array_attr
-          array_value_set(array_attr, value)
-        else
-          @values[key] = value
-        end
-      end
-
-      def parse_array_attr_key(key)
-        m = /\A(.+)\(([0-9]+)(.)\)\z/.match(key)
-        if m
-          ::OpenStruct.new(key: m[1], index: m[2].to_i - 1, converter: array_value_converter(m[3]))
-        end
-      end
-
-      def array_value_set(array_attr, value)
-        @values[array_attr.key] ||= {}
-        @values[array_attr.key].merge!(
-          DATE_TIME_FIELDS[array_attr.index] => value.send(array_attr.converter)
-        )
-      end
-
-      def array_value_converter(str_type)
-        case str_type
-        when 'i'
-          'to_i'
-        else
-          raise "Unknown array type: \"#{str_type}\""
-        end
-      end
-
-      def date_time_attribute?(key)
-        attr = @model_class.attributes[key]
-        return false unless attr
-        raise attr.to_s
-      end
-    end
-  end
-end

data/test/lib/eac/model_test.rb

@@ -1,76 +0,0 @@
-require 'test_helper'
-
-module Eac
-  class ModelTest < ActiveSupport::TestCase
-    class M1
-      include ActiveModel::Model
-      include Eac::Model
-      attr_accessor :name, :age, :account, :country_id, :other
-    end
-
-    class M2
-      include ActiveModel::Model
-      attr_accessor :name, :myage, :account_id, :country
-
-      validate :my_validate
-
-      def my_validate
-        errors.add(:name, 'NAME_ERROR')
-        errors.add(:myage, 'MYAGE_ERROR')
-        errors.add(:account_id, 'ACCOUNT_ID_ERROR')
-        errors.add(:country, 'COUNTRY_ERROR')
-      end
-    end
-
-    def setup
-      reset_m1
-      reset_m2
-    end
-
-    def test_fetch_column_errors
-      @m1.fetch_column_errors(@m2, :myage, :age)
-      assert_equal @m2.errors[:myage], @m1.errors[:age]
-    end
-
-    def test_fetch_record_errors
-      @m1.fetch_record_errors(@m2)
-      { name: :name, account_id: :account, country: :country_id }.each do |c2, c1|
-        assert_equal @m2.errors[c2], @m1.errors[c1], "c2: #{c2}, c1: #{c1}"
-      end
-      assert @m1.errors[:age].empty?
-    end
-
-    def test_fetch_record_errors_with_default_column
-      @m1.fetch_record_errors(@m2, default_column: :other)
-      assert_equal @m2.errors[:name], @m1.errors[:name]
-      assert @m1.errors[:age].empty?
-      assert_equal ['Myage: MYAGE_ERROR'], @m1.errors[:other]
-    end
-
-    def test_fetch_record_errors_with_skip_option
-      @m1.fetch_record_errors(@m2, skip: [:name])
-      assert @m1.errors[:name].empty?
-      assert @m1.errors[:age].empty?
-    end
-
-    def test_fetch_record_errors_by_mapping
-      @m1.fetch_record_errors_by_mapping(@m2, name: :name, myage: :age)
-      assert_equal @m2.errors[:name], @m1.errors[:name]
-      assert_equal @m2.errors[:myage], @m1.errors[:age]
-    end
-
-    private
-
-    def reset_m1
-      @m1 = M1.new
-      assert @m1.errors.empty?
-    end
-
-    def reset_m2
-      @m2 = M2.new
-      assert_not @m2.valid?
-      assert_not @m2.errors[:name].empty?
-      assert_not @m2.errors[:myage].empty?
-    end
-  end
-end

data/test/lib/eac/parsers/files_test_test.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-require 'test_helper'
-
-module Eac
-  module Parsers
-    class BaseStub
-      def initialize(source)
-        @source = source
-      end
-
-      def data
-        YAML.load(File.read(@source))
-      end
-    end
-
-    class Ok < BaseStub
-    end
-
-    class OkTest < ActiveSupport::TestCase
-      include ::Eac::Parsers::FilesTest
-
-      def test_file
-        __FILE__
-      end
-    end
-  end
-end