eac_rails_utils 0.10.1 → 0.11.4

data/lib/eac_rails_utils/models/fetch_errors.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module EacRailsUtils
+  module Models
+    module FetchErrors
+      # 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
+end

data/lib/eac_rails_utils/models/inequality_queries.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module EacRailsUtils
+  module Models
+    # == Example:
+    #
+    # Note: model Product has a attribute "foo" Date, Time or Number:
+    #
+    #   class Product
+    #     include ::EacRailsUtils::Models::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
+end

data/lib/eac_rails_utils/models/tableless.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'eac_rails_utils/patches/active_model_associations'
+require 'virtus'
+
+module EacRailsUtils
+  module Models
+    class Tableless
+      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
+end

data/lib/eac_rails_utils/models/test_utils.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module EacRailsUtils
+  module Models
+    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
+end

data/lib/eac_rails_utils/patches.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/require_sub'
+
+module EacRailsUtils
+  module Patches
+    ::EacRubyUtils.require_sub __FILE__
+  end
+end

data/lib/eac_rails_utils/patches/action_controller_base.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'action_controller/base'
+
 module EacRailsUtils
   module Patches
     module ActionControllerBasePatch

data/lib/eac_rails_utils/patches/active_model_associations.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'active_model/associations/hooks'
+require 'activemodel/associations'
+
+module EacRailsUtils
+  module Patches
+    module ActiveModelAssociations
+      module ScopeExtensionPatch
+        def add_constraints(scope, owner, association_klass, *extra_args)
+          if extra_args.any?
+            refl = extra_args.first
+            if refl.options[:active_model]
+              target_ids = refl.options[:target_ids]
+              return scope.where(id: owner[target_ids])
+            end
+          end
+
+          super
+        end
+      end
+    end
+  end
+end
+
+module ActiveModel
+  module Associations
+    module Hooks
+      def self.init
+        return unless ::Rails.version < '5'
+
+        ActiveSupport.on_load(:active_record) do
+          ActiveRecord::Associations::AssociationScope.prepend(
+            ::EacRailsUtils::Patches::ActiveModelAssociations::ScopeExtensionPatch
+          )
+        end
+      end
+    end
+  end
+end

data/lib/eac_rails_utils/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EacRailsUtils
-  VERSION = '0.10.1'
+  VERSION = '0.11.4'
 end

data/test/dummy/app/assets/config/manifest.js

@@ -0,0 +1,3 @@
+//= link_tree ../images
+//= link_directory ../javascripts .js
+//= link_directory ../stylesheets .css

data/test/dummy/app/models/user.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
+require 'eac_rails_utils/models/attribute_required'
+
 class User < ActiveRecord::Base
+  include ::EacRailsUtils::Models::AttributeRequired
+
   belongs_to :job
 
   validates :job, presence: true

data/test/dummy/config/application.rb

@@ -9,6 +9,6 @@ require 'eac_rails_utils'
 
 module Dummy
   class Application < Rails::Application
-    config.active_record.raise_in_transactional_callbacks = true
+    config.active_record.raise_in_transactional_callbacks = true if ::Rails.version < '5'
   end
 end

data/test/{lib/eac → helpers/eac_rails_utils}/common_form_helper_test.rb

@@ -2,9 +2,9 @@
 
 require 'test_helper'
 
-module Eac
+module EacRailsUtils
   class CommonFormHelperTest < ActionView::TestCase
-    include Eac::CommonFormHelper
+    include ::EacRailsUtils::CommonFormHelper
 
     setup do
       reset_test_database

data/test/{lib/eac → helpers/eac_rails_utils}/data_table_test_helper_test.rb

@@ -2,9 +2,9 @@
 
 require 'test_helper'
 
-module Eac
+module EacRailsUtils
   class DataTableTestHelperTest < ActionView::TestCase
-    include ::Eac::DataTableHelper
+    include ::EacRailsUtils::DataTableHelper
 
     class Person
       attr_reader :name, :age, :job

data/test/lib/eac_rails_utils/{patches/model_attribute_required_test.rb → models/attribute_required_test.rb}

@@ -32,6 +32,7 @@ module EacRailsUtils
 
       class ActiveModelStub
         include ActiveModel::Model
+        include ::EacRailsUtils::Models::AttributeRequired
 
         attr_accessor :name, :age
         validates :name, presence: true

data/test/lib/eac_rails_utils/models/fetch_errors_test.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module EacRailsUtils
+  module Models
+    class FetchErrorsTest < ActiveSupport::TestCase
+      class M1
+        include ActiveModel::Model
+        include EacRailsUtils::Models::FetchErrors
+        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
+end