adequate_errors 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6292086a3e4cbd867447484ac68fbc5a68802a63
+  data.tar.gz: 862ebfd497a58618225482f232b05b08b31c09aa
+SHA512:
+  metadata.gz: 5193cc15cf703b06b4fbe3e72b894ab25eb757b6defc60411cd5dd67f7518f2cd5aecb2ea3348505ce049d07d9413f1184b95cbfe4ba02c620099bf03081f3bf
+  data.tar.gz: 037de8bbfd563dfa981e5ab22ea581d51d8ba693717223674cb91bed5eec95d23812f75a3e671f57931c5ce2736eb6fb4c1528ab3977e30bc198f9054486179d

data/.gitignore

@@ -0,0 +1,9 @@
+/.ruby-version
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.yardopts

@@ -0,0 +1 @@
+--no-private

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in adequate_errors.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,37 @@
+PATH
+  remote: .
+  specs:
+    adequate_errors (0.1.0)
+      activemodel
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (5.1.4)
+      activesupport (= 5.1.4)
+    activesupport (5.1.4)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    builder (3.2.3)
+    concurrent-ruby (1.0.5)
+    i18n (0.9.1)
+      concurrent-ruby (~> 1.0)
+    minitest (5.10.3)
+    rake (10.5.0)
+    thread_safe (0.3.6)
+    tzinfo (1.2.4)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  adequate_errors!
+  builder (~> 3.2.3)
+  bundler (~> 1.16.a)
+  rake (~> 10.0)
+
+BUNDLED WITH
+   1.16.0.pre.3

data/README.md

@@ -0,0 +1,72 @@
+# AdequateErrors
+
+Overcoming limitation of Rails model errors API:
+
+* more expressive `where` query
+* turn off message's attribute prefix.
+* lazy evaluation of messages
+
+## Introduction
+
+Rails errors API is simple to use, but can be inadequate when coping with more complex requirements.
+
+The existing API was originally a collection of message strings without much meta data, making it very restrictive. Though `details` hash was added later for storing meta information, many fundamental issues can not be fixed without altering the API and the architecture.
+
+This gem redesigned the API, placing it in its own object, co-existing with existing Rails API. Thus nothing will break, allowing you to migrate the code one at a time.
+
+## Quick start
+
+To access the AdequateErrors object, call:
+
+    model.errors.adequate
+
+From this object, many convenience methods are provided, for example this would return an array of AdequateErrors::Error objects, which matches the where query.
+
+    model.errors.adequate.where(attribute:'title', :type => :too_short, length: 5)
+
+The following prints out each error's full message one by one:
+
+    model.errors.adequate.each {|error| puts error.message }
+    
+The following returns an array of all message strings:
+
+    model.errors.adequate.messages
+    
+For full documentation, please see http://www.rubydoc.info/github/lulalala/adequate_errors
+
+## Key difference to Rails own errors API
+
+Errors are stored as Ruby objects instead of message strings, this makes more fine-grained query possible.
+
+Error messages are evaluated lazily, which means it can be rendered in a different locale at view rendering time.
+
+The messages in the locale file are looked up in its own `adequate_errors` namespace, for example:
+
+    en:
+      adequate_errors:
+        messages:
+          invalid: "%{attribute} is invalid"
+
+Note that each message by default has the `attribute` prefix. This allow easy removal of attribute prefix by overriding each message in the locale file. You no longer need to attach errors to `:base` for that purpose. This allows prefix to be changed per language.
+
+Calls to Rails' API are synced to AdequateErrors object, but not the reverse.
+
+## Migration Note
+
+Deprecated methods such as `[]=`, `get` and `set` are not supported, therefore calling those methods will not sync to AdequateErrors.
+
+The gem is developed from ActiveModel 5.1, but it should work with earlier versions.
+
+## We want to hear your issues too
+
+If you also have issues with exsting API, share it by filing that issue here.
+
+We collect use cases in issues and analyze the problem in wiki (publicly editable):
+
+[So come to our wiki, see what's going on, and join us!](https://github.com/lulalala/adequate_errors/wiki)
+
+---
+
+This repo was called Rails Error API Redesign Initiative.  
+This is a fan project and is not affiliated to Rails Core team,  
+but my wish is that one day this can be adapted into Rails too.

data/Rakefile

@@ -0,0 +1,25 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+dir = File.dirname(__FILE__)
+
+task default: :test
+
+task :package
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = Dir.glob("#{dir}/test/cases/**/*_test.rb")
+  t.warning = true
+  t.verbose = true
+  t.ruby_opts = ["--dev"] if defined?(JRUBY_VERSION)
+end
+
+namespace :test do
+  task :isolated do
+    Dir.glob("#{dir}/test/**/*_test.rb").all? do |file|
+      sh(Gem.ruby, "-w", "-I#{dir}/lib", "-I#{dir}/test", file)
+    end || raise("Failures")
+  end
+end
+

data/adequate_errors.gemspec

@@ -0,0 +1,27 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "adequate_errors/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "adequate_errors"
+  spec.version       = AdequateErrors::VERSION
+  spec.authors       = ["lulalala"]
+  spec.email         = ["mark@goodlife.tw"]
+
+  spec.summary       = %q{Object-Oriented ActiveModel errors interface}
+  spec.homepage      = "https://github.com/lulalala/adequate_errors/"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activemodel"
+
+  spec.add_development_dependency "bundler", "~> 1.16.a"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "builder", "~> 3.2.3"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "adequate_errors"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/adequate_errors/error.rb

@@ -0,0 +1,129 @@
+module AdequateErrors
+  # Represents one single error
+  # @!attribute [r] base
+  #   @return [ActiveModel::Base] the object which the error belongs to
+  # @!attribute [r] attribute
+  #   @return [Symbol] attribute of the object which the error belongs to
+  # @!attribute [r] type
+  #   @return [Symbol] error's type
+  # @!attribute [r] options
+  #   @return [Hash] additional options
+  class Error
+    def initialize(base, attribute, type, options = {})
+      @base = base
+      @attribute = attribute
+      @type = type
+      @options = options
+    end
+
+    attr_reader :base, :attribute, :type, :options
+
+    # Full message of the error.
+    #
+    # === Key differences to Rails vanilla errors
+    #
+    # ==== 1. Flexible positioning of attribute name interpolation
+    #
+    # In Rails, errors' full messages are always prefixed with attribute name,
+    # and if prefix is not wanted, developer often adds error to the `base' attribute instead.
+    # This can be unreasonable in different languages or special business requirements.
+    #
+    # AdequateErrors leaves the attribute placement to the developer.
+    # For each error message in the locale file, the %{attribute} indicates placement of the attribute.
+    # The same error can have prefix in English, and be prefix-less in Russian.
+    # If no prefix is needed, one should update the locale file accordingly,
+    #
+    # ==== 2. Message evaluated lazily
+    #
+    # In Rails, error message is evaluated during the `add` call.
+    # AdequateErrors evaluates message lazily at `message` call instead,
+    # so one can change message locale after model has been validated.
+    #
+    # === Order of I18n lookup:
+    #
+    # Error messages are first looked up in <tt>activemodel.adequate_errors.models.MODEL.attributes.ATTRIBUTE.MESSAGE</tt>,
+    # if it's not there, it's looked up in <tt>activemodel.adequate_errors.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.adequate_errors.models.admin.attributes.title.blank</tt>
+    # * <tt>activemodel.adequate_errors.models.admin.blank</tt>
+    # * <tt>activemodel.adequate_errors.models.user.attributes.title.blank</tt>
+    # * <tt>activemodel.adequate_errors.models.user.blank</tt>
+    # * any default you provided through the +options+ hash (in the <tt>activemodel.adequate_errors</tt> scope)
+    # * <tt>activemodel.adequate_errors.messages.blank</tt>
+    # * <tt>adequate_errors.attributes.title.blank</tt>
+    # * <tt>adequate_errors.messages.blank</tt>
+    def message
+      if @options[:message].is_a?(Symbol)
+        type = @options.delete(:message)
+      else
+        type = @type
+      end
+
+      if @base.class.respond_to?(:i18n_scope)
+        i18n_scope = @base.class.i18n_scope.to_s
+        defaults = @base.class.lookup_ancestors.flat_map do |klass|
+          [ :"#{i18n_scope}.adequate_errors.models.#{klass.model_name.i18n_key}.attributes.#{attribute}.#{type}",
+            :"#{i18n_scope}.adequate_errors.models.#{klass.model_name.i18n_key}.#{type}" ]
+        end
+        defaults << :"#{i18n_scope}.adequate_errors.messages.#{type}"
+      else
+        defaults = []
+      end
+
+      defaults << :"adequate_errors.attributes.#{attribute}.#{type}"
+      defaults << :"adequate_errors.messages.#{type}"
+
+      key = defaults.shift
+      defaults = @options.delete(:message) if @options[:message]
+      value = (attribute != :base ? @base.send(:read_attribute_for_validation, attribute) : nil)
+
+      i18n_options = {
+        default: defaults,
+        model: @base.model_name.human,
+        attribute: humanized_attribute,
+        value: value,
+        object: @base
+      }.merge!(@options)
+
+      I18n.translate(key, i18n_options)
+    end
+
+    # @param (see Errors#where)
+    # @return [Boolean] whether error matches the params
+    def match?(params)
+      if params.key?(:attribute) && @attribute != params[:attribute]
+        return false
+      end
+
+      if params.key?(:type) && @type != params[:type]
+        return false
+      end
+
+      (params.keys - [:attribute, :type]).each do |key|
+        if @options[key] != params[key]
+          return false
+        end
+      end
+
+      true
+    end
+
+    private
+
+    def humanized_attribute
+      default = @attribute.to_s.tr(".", "_").humanize
+      @base.class.human_attribute_name(@attribute, default: default)
+    end
+
+  end
+end

data/lib/adequate_errors/errors.rb

@@ -0,0 +1,95 @@
+require 'active_model/errors'
+require 'forwardable'
+require 'adequate_errors/error'
+
+module AdequateErrors
+  # Collection of {Error} objects.
+  # Provides convenience methods to access these errors.
+  # It is accessed via +model.errors.adequate+
+  class Errors
+    include Enumerable
+
+    extend Forwardable
+    def_delegators :@errors, :each, :size, :clear, :blank?, :empty?, *Enumerable.instance_methods(false)
+
+    # @param base [ActiveModel::Base]
+    def initialize(base)
+      @base = base
+      @errors = []
+    end
+
+    # Delete errors of attribute
+    def delete(attribute)
+      @errors.delete_if do |error|
+        error.attribute == attribute
+      end
+    end
+
+    # Adds error.
+    # More than one error can be added to the same `attribute`.
+    # If no `type` is supplied, `:invalid` is assumed.
+    #
+    # @param attribute [Symbol] attribute that the error belongs to
+    # @param type [Symbol] error's type, defaults to `:invalid`.
+    #   As convenience, if type is String/Proc/Lambda,
+    #   it will be moved to `options[:message]`,
+    #   and type itself will be changed to the default `:invalid`.
+    # @param options [Hash] extra conditions such as interpolated value
+    def add(attribute, type = :invalid, options = {})
+
+      if !type.is_a? Symbol
+        options[:message] = type
+        type = :invalid
+      end
+
+      @errors.append(::AdequateErrors::Error.new(@base, attribute, type, options))
+    end
+
+    # @return [Array(String)] all error messages
+    def messages
+      @errors.map(&:message)
+    end
+
+    # Convenience method to fetch error messages filtered by where condition.
+    # @param params [Hash] filter condition, see {#where} for details.
+    # @return [Array(String)] error messages
+    def messages_for(params)
+      where(params).map(&:message)
+    end
+
+    # @param params [Hash]
+    #   filter condition
+    #   The most common keys are +:attribute+ and +:type+,
+    #   but other custom keys given during {#add} can also be used.
+    #   If params is empty, all errors are returned.
+    # @option params [Symbol] :attribute Filtering on attribute the error belongs to
+    # @option params [Symbol] :type Filter on type of error
+    #
+    # @return [Array(AdequateErrors::Error)] matching {Error}.
+    def where(params)
+      return @errors.dup if params.blank?
+
+      @errors.select {|error|
+        error.match?(params)
+      }
+    end
+
+    # @return [Boolean] whether the given attribute contains error.
+    def include?(attribute)
+      @errors.any?{|error| error.attribute == attribute }
+    end
+
+    # @return [Hash] attributes with their error messages
+    def to_hash
+      hash = {}
+      @errors.each do |error|
+        if hash.has_key?(error.attribute)
+          hash[error.attribute] << error.message
+        else
+          hash[error.attribute] = [error.message]
+        end
+      end
+      hash
+    end
+  end
+end

data/lib/adequate_errors/interceptor.rb

@@ -0,0 +1,54 @@
+require "active_model/errors"
+require "adequate_errors/errors"
+
+module AdequateErrors
+  # Wraps around Rails' errors object, intercepting its state changes
+  # in order to update AdequateErrors' errors object.
+  module Interceptor
+    def initialize(base)
+      rails_errors = super
+      @adequate_errors = ::AdequateErrors::Errors.new(base)
+      rails_errors
+    end
+
+    def clear
+      super
+      @adequate_errors.clear
+    end
+
+    def delete(key)
+      super
+      @adequate_errors.delete(key)
+    end
+
+    def add(attribute, message = :invalid, options = {})
+      adequate_options = options.dup
+
+      messages = super
+
+      if options.has_key?(:message) && !options[:message].is_a?(Symbol)
+        adequate_options[:message] = full_message(attribute, messages.last)
+      end
+
+      adequate_message = if !message.is_a?(Symbol)
+        full_message(attribute, messages.last)
+      else
+        message
+      end
+
+      @adequate_errors.add(attribute, adequate_message, adequate_options)
+    end
+
+    # Accessor
+    def adequate
+      @adequate_errors
+    end
+  end
+end
+
+# @private
+module ActiveModel
+  class Errors
+    prepend AdequateErrors::Interceptor
+  end
+end

data/lib/adequate_errors/locale/en.yml

@@ -0,0 +1,33 @@
+en:
+  adequate_errors:
+    # The values :model, :attribute and :value are always available for interpolation
+    # The value :count is available when applicable. Can be used for pluralization.
+    messages:
+      model_invalid: "Validation failed: %{errors}"
+      inclusion: "%{attribute} is not included in the list"
+      exclusion: "%{attribute} is reserved"
+      invalid: "%{attribute} is invalid"
+      confirmation: "%{attribute} doesn't match %{attribute}"
+      accepted: "%{attribute} must be accepted"
+      empty: "%{attribute} can't be empty"
+      blank: "%{attribute} can't be blank"
+      present: "%{attribute} must be blank"
+      too_long:
+        one: "%{attribute} is too long (maximum is 1 character)"
+        other: "%{attribute} is too long (maximum is %{count} characters)"
+      too_short:
+        one: "%{attribute} is too short (minimum is 1 character)"
+        other: "%{attribute} is too short (minimum is %{count} characters)"
+      wrong_length:
+        one: "%{attribute} is the wrong length (should be 1 character)"
+        other: "%{attribute} is the wrong length (should be %{count} characters)"
+      not_a_number: "%{attribute} is not a number"
+      not_an_integer: "%{attribute} must be an integer"
+      greater_than: "%{attribute} must be greater than %{count}"
+      greater_than_or_equal_to: "%{attribute} must be greater than or equal to %{count}"
+      equal_to: "%{attribute} must be equal to %{count}"
+      less_than: "%{attribute} must be less than %{count}"
+      less_than_or_equal_to: "%{attribute} must be less than or equal to %{count}"
+      other_than: "%{attribute} must be other than %{count}"
+      odd: "%{attribute} must be odd"
+      even: "%{attribute} must be even"

data/lib/adequate_errors/version.rb

@@ -0,0 +1,3 @@
+module AdequateErrors
+  VERSION = "0.1.0"
+end

data/lib/adequate_errors.rb

@@ -0,0 +1,6 @@
+require "adequate_errors/version"
+require "adequate_errors/interceptor"
+
+ActiveSupport.on_load(:i18n) do
+  I18n.load_path << File.dirname(__FILE__) + "/adequate_errors/locale/en.yml"
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: adequate_errors
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- lulalala
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-11-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.16.a
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.16.a
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: builder
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.3
+description: 
+email:
+- mark@goodlife.tw
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".yardopts"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- adequate_errors.gemspec
+- bin/console
+- bin/setup
+- lib/adequate_errors.rb
+- lib/adequate_errors/error.rb
+- lib/adequate_errors/errors.rb
+- lib/adequate_errors/interceptor.rb
+- lib/adequate_errors/locale/en.yml
+- lib/adequate_errors/version.rb
+homepage: https://github.com/lulalala/adequate_errors/
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: Object-Oriented ActiveModel errors interface
+test_files: []