lev 10.1.0 → 11.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb4ccab91175edafaeff83e3bab8ab84e5a650ebc88b5000bf848ff1ad171d49
-  data.tar.gz: ce48c8cc00ed7edfa6076b5ba91ddbf11933f0a4b9f02e65dd6548ab69fc5b6c
+  metadata.gz: 6a420c65f32a06c875e0e5069340f8cf1cc38505d9862a9ecbe20aede96059a2
+  data.tar.gz: 51f9c9746e69f4fc818f8e0d0c33e22a0c62d1a4f87c14b37d3b5645118a40ca
 SHA512:
-  metadata.gz: 9dc7506db7fe12a5122596ea9f6cdf6682bc2f601f6b89d6dc26c49c1733e53a3d74ff0679430877deaf94c1009ab22a2bde64432cd8c946a5790237177c9f25
-  data.tar.gz: 53125d7cb41f17b27539b45802d4ec1dff132434c4d4dcdddc0294128c8a973a02f2bea2df8a852d986b5ecb4e46462af3d552198846a8c2f8caf10ab255d400
+  metadata.gz: dd09071d958ae2590c604f2e6708b0942b06ecc97ff50be00d6a37863945543e56393a58f3a15b4664463104ba1064216cd66937bee00c1a3acdadf41596bfa3
+  data.tar.gz: 668e9e10ea0285ad953b3080484360017d487484f8771e7af1eb235ccdb1e1244ec7f563c1ed59df8148926a5284d2e89b7016c5376b702335ad2de9b88aea4a

data/lib/lev.rb

@@ -9,7 +9,6 @@ require "lev/version"
 require "lev/object"
 require "lev/utilities"
 require "lev/exceptions"
-require "lev/better_active_model_errors"
 require "lev/term_mapper"
 require "lev/outputs"
 require "lev/routine"

data/lib/lev/error_transferer.rb

@@ -5,16 +5,16 @@ module Lev
     def self.transfer(source, target_routine, input_mapper, fail_if_errors=false)
       case source
       when ActiveRecord::Base, Lev::Paramifier
-        source.errors.each_with_type_and_message do |attribute, type, message|
+        source.errors.each do |error|
           target_routine.nonfatal_error(
-            code: type,
+            code: error.type,
             data: {
               model: source,
-              attribute: attribute
+              attribute: error.attribute
             },
             kind: :activerecord,
-            message: message,
-            offending_inputs: input_mapper.map(attribute)
+            message: error.message,
+            offending_inputs: input_mapper.map(error.attribute)
           )
         end
       when Lev::Errors

data/lib/lev/error_translator.rb

@@ -5,15 +5,14 @@ module Lev
     def self.translate(error)
       case error.kind
       when :activerecord
-        model = error.data[:model]
         attribute = error.data[:attribute]
-        # TODO error.message might always be populated now -- really need the other call after ||?
-        message = error.message || Lev::BetterActiveModelErrors.generate_message(model, attribute, error.code)
-        Lev::BetterActiveModelErrors.full_message(model, attribute, message)
+        message = error.message
+        model = error.data[:model]
+        ActiveModel::Error.full_message(attribute, message, model)
       else
         message = error.message.to_s
         message.empty? ? error.code.to_s : message
-      end      
+      end
     end
 
   end

data/lib/lev/version.rb

@@ -1,3 +1,3 @@
 module Lev
-  VERSION = '10.1.0'
+  VERSION = '11.0.0'
 end

data/spec/{better_active_model_errors_spec.rb → active_model_errors_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-RSpec.describe 'BetterActiveModelErrors' do
+RSpec.describe 'ActiveModelErrors' do
   class DummyModel
     def self.human_attribute_name(attr, default='')
       return attr.capitalize
@@ -8,10 +8,11 @@ RSpec.describe 'BetterActiveModelErrors' do
   end
 
   let(:test_model) { DummyModel.new }
-  let(:errors) { Lev::BetterActiveModelErrors.new(test_model) }
+  let(:errors) { ActiveModel::Errors.new(test_model) }
 
   it 'can record errors' do
-    errors[:foo] = 'bar'
+    errors.add(:foo, 'bar')
+    expect(errors[:foo]).to eq ['bar']
     expect(errors.any?).to be(true)
   end
 
@@ -24,13 +25,13 @@ RSpec.describe 'BetterActiveModelErrors' do
   it 'duplicates when copy called' do
     model = OpenStruct.new
 
-    error = Lev::BetterActiveModelErrors.new(model)
-    error.set(:code, 'error')
-    expect(error.get(:code)).to eq 'error'
+    error = ActiveModel::Errors.new(model)
+    error.add(:code, 'error')
+    expect(error[:code]).to eq ['error']
 
-    other = Lev::BetterActiveModelErrors.new(model)
-    other.set(:code, 'warning')
+    other = ActiveModel::Errors.new(model)
+    other.add(:code, 'warning')
     error.copy!(other)
-    expect(error.get(:code)).to eq 'warning'
+    expect(error[:code]).to eq ['warning']
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lev
 version: !ruby/object:Gem::Version
-  version: 10.1.0
+  version: 11.0.0
 platform: ruby
 authors:
 - JP Slavinsky
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-31 00:00:00.000000000 Z
+date: 2021-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '6.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '6.1'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -206,7 +206,6 @@ files:
 - lib/lev/active_job.rb
 - lib/lev/active_job/base.rb
 - lib/lev/active_job/configured_job.rb
-- lib/lev/better_active_model_errors.rb
 - lib/lev/delegate_to_routine.rb
 - lib/lev/error.rb
 - lib/lev/error_transferer.rb
@@ -227,7 +226,7 @@ files:
 - lib/lev/utilities.rb
 - lib/lev/version.rb
 - spec/active_job_routines_spec.rb
-- spec/better_active_model_errors_spec.rb
+- spec/active_model_errors_spec.rb
 - spec/create_sprocket_spec.rb
 - spec/deep_merge_spec.rb
 - spec/delegates_to_spec.rb
@@ -265,28 +264,28 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.2.7
 signing_key: 
 specification_version: 4
 summary: Ride the rails but don't touch them.
 test_files:
-- spec/active_job_routines_spec.rb
-- spec/paramify_handler_spec.rb
-- spec/spec_helper.rb
-- spec/sprocket_spec.rb
 - spec/create_sprocket_spec.rb
+- spec/paramify_handler_spec.rb
 - spec/outputs_spec.rb
-- spec/deep_merge_spec.rb
-- spec/sprocket_handler_spec.rb
-- spec/statused_routines_spec.rb
-- spec/better_active_model_errors_spec.rb
-- spec/routine_spec.rb
-- spec/support/sprocket_handler.rb
-- spec/support/create_sprocket.rb
-- spec/support/delegated_routine.rb
-- spec/support/sprocket.rb
+- spec/transaction_spec.rb
 - spec/support/paramify_handler_a.rb
+- spec/support/delegated_routine.rb
 - spec/support/paramify_handler_b.rb
+- spec/support/create_sprocket.rb
+- spec/support/sprocket_handler.rb
 - spec/support/delegating_routine.rb
-- spec/transaction_spec.rb
+- spec/support/sprocket.rb
+- spec/statused_routines_spec.rb
+- spec/active_model_errors_spec.rb
 - spec/delegates_to_spec.rb
+- spec/active_job_routines_spec.rb
+- spec/deep_merge_spec.rb
+- spec/routine_spec.rb
+- spec/sprocket_handler_spec.rb
+- spec/spec_helper.rb
+- spec/sprocket_spec.rb

data/lib/lev/better_active_model_errors.rb

@@ -1,421 +0,0 @@
-# -*- coding: utf-8 -*-
-
-require 'active_support/core_ext/array/wrap'
-require 'active_support/core_ext/array/conversions'
-require 'active_support/core_ext/string/inflections'
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/hash/reverse_merge'
-require 'active_support/ordered_hash'
-
-module Lev
-  # == Better Errors
-  #
-  # Same as ActiveModel::Errors but also retains error types
-  #
-  # Provides a modified +OrderedHash+ that you can include in your object
-  # for handling error messages and interacting with Action Pack helpers.
-  #
-  # A minimal implementation could be:
-  #
-  #   class Person
-  #
-  #     # Required dependency for ActiveModel::Errors
-  #     extend ActiveModel::Naming
-  #
-  #     def initialize
-  #       @errors = ActiveModel::Errors.new(self)
-  #     end
-  #
-  #     attr_accessor :name
-  #     attr_reader   :errors
-  #
-  #     def validate!
-  #       errors.add(:name, "can not be nil") if name == nil
-  #     end
-  #
-  #     # The following methods are needed to be minimally implemented
-  #
-  #     def read_attribute_for_validation(attr)
-  #       send(attr)
-  #     end
-  #
-  #     def Person.human_attribute_name(attr, options = {})
-  #       attr
-  #     end
-  #
-  #     def Person.lookup_ancestors
-  #       [self]
-  #     end
-  #
-  #   end
-  #
-  # The last three methods are required in your object for Errors to be
-  # able to generate error messages correctly and also handle multiple
-  # languages. Of course, if you extend your object with ActiveModel::Translation
-  # you will not need to implement the last two. Likewise, using
-  # ActiveModel::Validations will handle the validation related methods
-  # for you.
-  #
-  # The above allows you to do:
-  #
-  #   p = Person.new
-  #   p.validate!             # => ["can not be nil"]
-  #   p.errors.full_messages  # => ["name can not be nil"]
-  #   # etc..
-  class BetterActiveModelErrors
-    include Enumerable
-
-    CALLBACKS_OPTIONS = [:if, :unless, :on, :allow_nil, :allow_blank, :strict]
-
-    attr_reader :messages
-    attr_reader :types
-
-    # Pass in the instance of the object that is using the errors object.
-    #
-    #   class Person
-    #     def initialize
-    #       @errors = ActiveModel::Errors.new(self)
-    #     end
-    #   end
-    def initialize(base)
-      @base     = base
-      @types = ActiveSupport::OrderedHash.new
-      @messages = ActiveSupport::OrderedHash.new
-    end
-
-    # copy & details are needed to match `ActiveModel::Errors` interface
-    def copy!(other)
-      initialize_dup(other)
-    end
-    def details
-      {}
-    end
-
-    def initialize_dup(other)
-      @types = other.types.dup
-      @messages = other.messages.dup
-    end
-
-    # Backport dup from 1.9 so that #initialize_dup gets called
-    unless Object.respond_to?(:initialize_dup, true)
-      def dup # :nodoc:
-        copy = super
-        copy.initialize_dup(self)
-        copy
-      end
-    end
-
-    # Clear the messages
-    def clear
-      types.clear
-      messages.clear
-    end
-
-    # Do the error messages include an error with key +error+?
-    def include?(error)
-      (v = messages[error.to_sym]) && v.any?
-    end
-    alias :has_key? :include?
-
-    # Get messages for +key+
-    def get(key)
-      messages[key.to_sym]
-    end
-
-    def get_type(key)
-      types[key.to_sym]
-    end
-
-    # Set messages for +key+ to +value+
-    def set(key, value)
-      types[key.to_sym] = (value == [] ? [] : (value.is_a?(Symbol) ? value : nil))
-      messages[key.to_sym] = value
-    end
-
-    # Delete messages for +key+
-    def delete(key)
-      key = key.to_sym
-      types.delete(key)
-      messages.delete(key)
-    end
-
-    # When passed a symbol or a name of a method, returns an array of errors
-    # for the method.
-    #
-    #   p.errors[:name]   # => ["can not be nil"]
-    #   p.errors['name']  # => ["can not be nil"]
-    def [](attribute)
-      get(attribute.to_sym) || set(attribute.to_sym, [])
-    end
-
-    # Adds to the supplied attribute the supplied error message.
-    #
-    #   p.errors[:name] = "must be set"
-    #   p.errors[:name] # => ['must be set']
-    def []=(attribute, error)
-      self[attribute] << error
-    end
-
-    # Iterates through each error key, value pair in the error messages hash.
-    # Yields the attribute and the error for that attribute. If the attribute
-    # has more than one error message, yields once for each error message.
-    #
-    #   p.errors.add(:name, "can't be blank")
-    #   p.errors.each do |attribute, errors_array|
-    #     # Will yield :name and "can't be blank"
-    #   end
-    #
-    #   p.errors.add(:name, "must be specified")
-    #   p.errors.each do |attribute, errors_array|
-    #     # Will yield :name and "can't be blank"
-    #     # then yield :name and "must be specified"
-    #   end
-    def each
-      messages.each_key do |attribute|
-        self[attribute].each { |error| yield attribute, error }
-      end
-    end
-
-    def each_with_type_and_message
-      types.each_key do |attribute|
-        for ii in 0..self.types[attribute].size-1
-          yield attribute, self.types[attribute][ii], self.messages[attribute][ii]
-        end
-      end
-    end
-
-    # Returns the number of error messages.
-    #
-    #   p.errors.add(:name, "can't be blank")
-    #   p.errors.size # => 1
-    #   p.errors.add(:name, "must be specified")
-    #   p.errors.size # => 2
-    def size
-      values.flatten.size
-    end
-
-    # Returns all message values
-    def values
-      messages.values
-    end
-
-    # Returns all message keys
-    def keys
-      messages.keys
-    end
-
-    # Returns an array of error messages, with the attribute name included
-    #
-    #   p.errors.add(:name, "can't be blank")
-    #   p.errors.add(:name, "must be specified")
-    #   p.errors.to_a # => ["name can't be blank", "name must be specified"]
-    def to_a
-      full_messages
-    end
-
-    # Returns the number of error messages.
-    #   p.errors.add(:name, "can't be blank")
-    #   p.errors.count # => 1
-    #   p.errors.add(:name, "must be specified")
-    #   p.errors.count # => 2
-    def count
-      to_a.size
-    end
-
-    # Returns true if no errors are found, false otherwise.
-    # If the error message is a string it can be empty.
-    def empty?
-      all? { |k, v| v && v.empty? && !v.is_a?(String) }
-    end
-    alias_method :blank?, :empty?
-
-    # Returns an xml formatted representation of the Errors hash.
-    #
-    #   p.errors.add(:name, "can't be blank")
-    #   p.errors.add(:name, "must be specified")
-    #   p.errors.to_xml
-    #   # =>
-    #   #  <?xml version=\"1.0\" encoding=\"UTF-8\"?>
-    #   #  <errors>
-    #   #    <error>name can't be blank</error>
-    #   #    <error>name must be specified</error>
-    #   #  </errors>
-    def to_xml(options={})
-      to_a.to_xml options.reverse_merge(:root => "errors", :skip_types => true)
-    end
-
-    # Returns an ActiveSupport::OrderedHash that can be used as the JSON representation for this object.
-    def as_json(options=nil)
-      to_hash
-    end
-
-    def to_hash
-      messages.dup
-    end
-
-    def to_s
-      inspect
-    end
-
-    # Adds +message+ to the error messages on +attribute+. More than one error can be added to the same
-    # +attribute+.
-    # If no +message+ is supplied, <tt>:invalid</tt> is assumed.
-    #
-    # If +message+ is a symbol, it will be translated using the appropriate scope (see +translate_error+).
-    # If +message+ is a proc, it will be called, allowing for things like <tt>Time.now</tt> to be used within an error.
-    def add(attribute, message = nil, options = {})
-      normalized_message = normalize_message(attribute, message, options)
-      if options[:strict]
-        raise ActiveModel::StrictValidationFailed, full_message(attribute, normalized_message)
-      end
-
-      self[attribute] << normalized_message
-      self.types[attribute.to_sym] << message.try(:to_sym)
-    end
-
-    # Will add an error message to each of the attributes in +attributes+ that is empty.
-    def add_on_empty(attributes, options = {})
-      [attributes].flatten.each do |attribute|
-        value = @base.send(:read_attribute_for_validation, attribute)
-        is_empty = value.respond_to?(:empty?) ? value.empty? : false
-        add(attribute, :empty, options) if value.nil? || is_empty
-      end
-    end
-
-    # Will add an error message to each of the attributes in +attributes+ that is blank (using Object#blank?).
-    def add_on_blank(attributes, options = {})
-      [attributes].flatten.each do |attribute|
-        value = @base.send(:read_attribute_for_validation, attribute)
-        add(attribute, :blank, options) if value.blank?
-      end
-    end
-
-    # Returns true if an error on the attribute with the given message is present, false otherwise.
-    # +message+ is treated the same as for +add+.
-    #   p.errors.add :name, :blank
-    #   p.errors.added? :name, :blank # => true
-    def added?(attribute, message = nil, options = {})
-      message = normalize_message(attribute, message, options)
-      self[attribute].include? message
-    end
-
-    # Returns all the full error messages in an array.
-    #
-    #   class Company
-    #     validates_presence_of :name, :address, :email
-    #     validates_length_of :name, :in => 5..30
-    #   end
-    #
-    #   company = Company.create(:address => '123 First St.')
-    #   company.errors.full_messages # =>
-    #     ["Name is too short (minimum is 5 characters)", "Name can't be blank", "Email can't be blank"]
-    def full_messages
-      map { |attribute, message| full_message(attribute, message) }
-    end
-
-    # Returns a full message for a given attribute.
-    #
-    #   company.errors.full_message(:name, "is invalid")  # =>
-    #     "Name is invalid"
-    def full_message(attribute, message)
-      self.class.full_message(@base, attribute, message)
-    end
-
-    def self.full_message(model, attribute, message)
-      return message if attribute == :base
-      attr_name = attribute.to_s.gsub('.', '_').humanize
-      attr_name = model.class.human_attribute_name(attribute, default: attr_name)
-      I18n.t(:"errors.format", {
-        default:   "%{attribute} %{message}",
-        attribute: attr_name,
-        message:   message
-      })
-    end
-
-    # Translates an error message in its default scope
-    # (<tt>activemodel.errors.messages</tt>).
-    #
-    # Error messages are first looked up in <tt>models.MODEL.attributes.ATTRIBUTE.MESSAGE</tt>,
-    # if it's not there, it's looked up in <tt>models.MODEL.MESSAGE</tt> and if that is not
-    # there also, it returns the translation of the default message
-    # (e.g. <tt>activemodel.errors.messages.MESSAGE</tt>). The translated model name,
-    # translated attribute name and the value are available for interpolation.
-    #
-    # When using inheritance in your models, it will check all the inherited
-    # models too, but only if the model itself hasn't been found. Say you have
-    # <tt>class Admin < User; end</tt> and you wanted the translation for
-    # the <tt>:blank</tt> error message for the <tt>title</tt> attribute,
-    # it looks for these translations:
-    #
-    # * <tt>activemodel.errors.models.admin.attributes.title.blank</tt>
-    # * <tt>activemodel.errors.models.admin.blank</tt>
-    # * <tt>activemodel.errors.models.user.attributes.title.blank</tt>
-    # * <tt>activemodel.errors.models.user.blank</tt>
-    # * any default you provided through the +options+ hash (in the <tt>activemodel.errors</tt> scope)
-    # * <tt>activemodel.errors.messages.blank</tt>
-    # * <tt>errors.attributes.title.blank</tt>
-    # * <tt>errors.messages.blank</tt>
-    #
-    def generate_message(attribute, type = :invalid, options = {})
-      self.class.generate_message(@base, attribute, type, options)
-    end
-
-    # TODO maybe don't need this method split out any more?
-    def self.generate_message(model, attribute, type = :invalid, options = {})
-      type = options.delete(:message) if options[:message].is_a?(Symbol)
-      attribute = attribute.to_sym
-      if model.class.respond_to?(:i18n_scope)
-        defaults = model.class.lookup_ancestors.map do |klass|
-          [ :"#{model.class.i18n_scope}.errors.models.#{klass.model_name.i18n_key}.attributes.#{attribute}.#{type}",
-            :"#{model.class.i18n_scope}.errors.models.#{klass.model_name.i18n_key}.#{type}" ]
-        end
-      else
-        defaults = []
-      end
-
-      defaults << options.delete(:message)
-      defaults << :"#{model.class.i18n_scope}.errors.messages.#{type}" if model.class.respond_to?(:i18n_scope)
-      defaults << :"errors.attributes.#{attribute}.#{type}"
-      defaults << :"errors.messages.#{type}"
-
-      defaults.compact!
-      defaults.flatten!
-
-      key = defaults.shift
-      value = (attribute != :base ? model.send(:read_attribute_for_validation, attribute) : nil)
-
-      options = {
-        :default => defaults,
-        :model => model.class.model_name.human,
-        :attribute => model.class.human_attribute_name(attribute),
-        :value => value
-      }.merge(options)
-
-      I18n.translate(key, options)
-    end
-
-  private
-    def normalize_message(attribute, message, options)
-      message ||= :invalid
-
-      if message.is_a?(Symbol)
-        generate_message(attribute, message, options.except(*CALLBACKS_OPTIONS))
-      elsif message.is_a?(Proc)
-        message.call
-      else
-        message
-      end
-    end
-  end
-
-  class StrictValidationFailed < StandardError
-  end
-end
-
-module ActiveModel
-  module Validations
-    def errors
-      @errors ||= Lev::BetterActiveModelErrors.new(self)
-    end
-  end
-end