eac_rails_utils 0.9.1 → 0.11.2

data/lib/eac/data_table_helper.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require_dependency 'eac/data_table_helper/column'
-require_dependency 'eac/data_table_helper/setup'
-require_dependency 'eac/data_table_helper/data_table'
-
-module Eac
-  module DataTableHelper
-    def data_table(dataset, &block)
-      ::Eac::DataTableHelper::DataTable.new(self, dataset, &block).output
-    end
-  end
-end

data/lib/eac/inequality_queries.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Eac
-  # == Example:
-  #
-  # Note: model Product has a attribute "foo" Date, Time or Number:
-  #
-  #   class Product
-  #     include ::Eac::InequalityQueries
-  #
-  #     add_inequality_queries(:foo)
-  #   end
-  #
-  # This add the following scopes:
-  #
-  #   Product.by_foo_gt(value) # Equivalent to Product.where("foo > ?", value)
-  #   Product.by_foo_gteq(value) # Equivalent to Product.where("foo >= ?", value)
-  #   Product.by_foo_lt(value) # Equivalent to Product.where("foo < ?", value)
-  #   Product.by_foo_lteq(value) # Equivalent to Product.where("foo <= ?", value)
-  module InequalityQueries
-    class << self
-      def included(base)
-        base.extend(ClassMethods)
-      end
-    end
-
-    module ClassMethods
-      def add_inequality_queries(attribute)
-        %w[gt gteq lt lteq].each do |ineq|
-          scope "by_#{attribute}_#{ineq}", lambda { |v|
-            where(arel_table[attribute].send(ineq, v))
-          }
-        end
-      end
-    end
-  end
-end

data/lib/eac/model.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-module Eac
-  module Model
-    # Adiciona as mensagens de erro de record. As mensagens de uma coluna X em record
-    # serão adicionadas na coluna X em self. Se options[:default_column] for especificado
-    # as mensagens da coluna X de record em que X não existe em self serão adicionadas
-    # na coluna options[:default_column].
-    # Um array de colunas pode ser passado em options[:skip] de colunas em record que não
-    # terão suas falhas adicionadas.
-    def fetch_record_errors(record, options = {})
-      record.errors.keys.each do |column|
-        fetch_column_errors(record, column, column, options)
-      end
-    end
-
-    # Similar a fetch_record_errors, mas torna possível especificar, através de mapping,
-    # colunas-alvo em self com nomes diferentes das colunas-fonte em record.
-    # mapping tem o formato { record_column => self_column }.
-    def fetch_record_errors_by_mapping(record, mapping, options = {})
-      mapping.each do |record_column, self_column|
-        fetch_column_errors(record, record_column, self_column, options)
-      end
-    end
-
-    def fetch_column_errors(record, record_column, self_column, options = {})
-      return if options[:skip]&.include?(record_column)
-
-      record.errors[record_column].each do |message|
-        fetch_error_column_message(self_column, message, options[:default_column],
-                                   "#{record.class.human_attribute_name(record_column)}: ")
-      end
-    end
-
-    # Verifica se uma coluna existe.
-    def column?(column)
-      respond_to?(column) && respond_to?("#{column}=")
-    end
-
-    def save_or_raise
-      raise "Falha ao tentar salvar #{self.class.name}: #{errors_to_string}" unless save
-
-      self
-    end
-
-    private
-
-    def fetch_error_column_message(column, message, default_column, default_column_message_prefix)
-      build_self_columns_messages(column, message, default_column,
-                                  default_column_message_prefix).each do |k, v|
-        if column?(k)
-          add_error_message(k, v)
-          break
-        end
-      end
-    end
-
-    # Adiciona uma mensagem de erro a uma coluna somente se a coluna
-    # ainda não a possui
-    def add_error_message(column, message)
-      return if errors[column].include?(message)
-
-      errors.add(column, message)
-    end
-
-    # Produz uma lista de campos-mensagens, em ordem de preferência,
-    # que podem receber uma mensagem de falha.
-    def build_self_columns_messages(column, message, default_column,
-                                    default_column_message_prefix)
-      r = { column => message }
-      m = /^(.+)_id$/.match(column)
-      if m
-        r[m[1]] = message
-      else
-        r["#{column}_id"] = message
-      end
-      r[default_column] = "#{default_column_message_prefix}#{message}" if default_column
-      r
-    end
-
-    def errors_to_string
-      b = ''
-      errors.messages.each do |field, messages|
-        b += ' / ' if b != ''
-        b += field.to_s + ': ' + messages.to_s
-      end
-      b
-    end
-  end
-end

data/lib/eac/test_utils.rb

@@ -1,61 +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|
-        combs = all_combinations_new_combination(attr_name, value, combs)
-      end
-      combs
-    end
-
-    def all_combinations_new_combination(attr_name, value, combs)
-      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
-      new_comb
-    end
-  end
-end

data/lib/eac_rails_utils/patches/model_attribute_required.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-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,43 +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(transaction)
-            r = super
-            r.currate = (transaction / '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.include ::EacRailsUtils::Patches::OfxParser::OfxParser
-end
-
-unless ::OfxParser::Transaction.included_modules.include?(
-  ::EacRailsUtils::Patches::OfxParser::Transaction
-)
-  ::OfxParser::Transaction.include ::EacRailsUtils::Patches::OfxParser::Transaction
-end

data/lib/eac_rails_utils/tableless_model.rb

@@ -1,92 +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)
-        return unless m
-
-        ::OpenStruct.new(key: m[1], index: m[2].to_i - 1, converter: array_value_converter(m[3]))
-      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,78 +0,0 @@
-# frozen_string_literal: true
-
-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