tram-policy 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7c972ade529b23a0221126e7d486259729314c26
-  data.tar.gz: 9f39b73542f528d32fc38db56ddf6122b8abae50
+  metadata.gz: 7ffe8d541eb55eb7ba031f7578515523884d74a9
+  data.tar.gz: b0e194a4dcd4682c79526a024b60f574b32014ba
 SHA512:
-  metadata.gz: 595fdd5c5980a99bcec80b407780c3f12ba0ac6915130a7f371309cd0d49bcd15d0d64d4d31a84a7a5b25808a7ddba3b64af701aa69f78816b34596f1762ef39
-  data.tar.gz: 90b47aff56495a7d15587aff63d673195a4bab761db7d34b12c3e05b3f825d7c7aaf0e3f98d90055a3871a465687a8127b5afd3bd44675ffdcfdf3e3209f3419
+  metadata.gz: 9413e5c3d0bf479d3022ce75bbbcd639fee2ffa6632883859419b724ff7cb9b04c792b4118837f854714611b2db1756ca3294ead1767fc9ab669c8c7e0b8806c
+  data.tar.gz: 4be7c88f9c2e1bdb45c70c45c90367afe2b1a8616837ca121a07a769521c8e1c1e3bb29224678d2425a49473db4b6549f4d71b9d9ca0e3e8f2eb0d3715e19138

data/.travis.yml

@@ -4,7 +4,8 @@ sudo: false
 cache: bundler
 bundler_args: --without benchmarks tools
 script:
-  - bundle exec rake spec
+  - bundle exec rake
+  - bundle exec rubocop
 rvm:
   - 2.3.0
   - 2.4.0

data/CHANGELOG.md

@@ -4,6 +4,32 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
+## [0.4.0] - [2018-02-17]
+
+This is beta-release before the first stable version 1.0.0.
+
+It adds methods `#item` and `#items` to policy errors to support lazy translation.
+
+It also renames some methods, and deprecate others that will be removed from v1.0.0.
+
+### Added
+- `Tram::Policy.root_scope` changes the default root scope ("tram-policy") for I18n (nepalez)
+- `Tram::Policy::Error#item` returns an array of [key, tags] which can be sent to I18n.t later (nepalez)
+- `Tram::Policy::Error#to_a` as an alias for the `#item` (nepalez)
+- `Tram::Policy::Errors#items` returns an array of error items (nepalez)
+- `Tram::Policy::Errors#filter` acts like `by_tag` but returns the filtered collection instead of an array (nepalez)
+- `Tram::Policy#messages` as a shortcut for `errors.messages` (nepalez)
+- `Tram::Policy#items` as a shortcut for `errors.items` (nepalez)
+
+### Changed
+- errors are compared by `#to_a` instead of `#to_h` (nepalez)
+
+### Deprecated
+- `Tram::Policy::Error#full_message` (nepalez)
+- `Tram::Policy::Error#to_h` (nepalez)
+- `Tram::Policy::Errors#full_messages` (nepalez)
+- `Tram::Policy::Errors#by_tags` (nepalez)
+
 ## [0.3.1] - [2018-01-05]
 
 ### Fixed
@@ -114,7 +140,7 @@ The gem is battle-tested for production (in a real commertial project).
 
   Use a multiline version instead of `validate :foo, :bar`:
 
-  ```
+  ```ruby
   validate :foo
   validate :bar
   ```
@@ -143,3 +169,4 @@ This is a first public release (@nepalez, @charlie-wasp, @JewelSam, @sergey-chec
 [0.2.5]: https://github.com/tram-rb/tram-policy/compare/v0.2.4...v0.2.5
 [0.3.0]: https://github.com/tram-rb/tram-policy/compare/v0.2.5...v0.3.0
 [0.3.1]: https://github.com/tram-rb/tram-policy/compare/v0.3.0...v0.3.1
+[0.4.0]: https://github.com/tram-rb/tram-policy/compare/v0.3.1...v0.4.0

data/README.md

@@ -14,12 +14,12 @@ Policy Object Pattern
 
 Policy objects are responsible for context-related validation of objects, or mixes of objects. Here **context-related** means a validation doesn't check whether an object is valid by itself, but whether it is valid for some purpose (context). For example, we could ask if some article is ready (valid) to be published, etc.
 
-There are several well-known interfaces exist for validation like [ActiveModel::Validations][active-model-validation], or its [ActiveRecord][active-record-validation] extension in Rails, or PORO [Dry::Validation][dry-validation]. All of them focus on providing rich DSL-s for **validation rules**.
+There are several well-known interfaces exist for validation like [ActiveModel::Validations][active-model-validation], or its [ActiveRecord][active-record-validation] extension for Rails, or PORO [Dry::Validation][dry-validation]. All of them focus on providing rich DSL-s for **validation rules**.
 
 **Tram::Policy** follows another approach -- it uses simple Ruby methods for validation, but focuses on building both *customizable* and *composable* results of validation, namely their errors.
 
-- By **customizable** we mean adding any number of *tags* to validation error -- to allow filtering and sorting validation results.
-- By **composable** we mean a possibility to merge errors provided by one policy/validator to another, for building nested sets of well-focused policies.
+- By **customizable** we mean adding any number of *tags* to errors -- to allow filtering and sorting validation results.
+- By **composable** we mean a possibility to merge errors provided by one policy into another, and build nested sets of well-focused policies.
 
 Keeping this reasons in mind, let's go to some examples.
 
@@ -51,22 +51,24 @@ class Article::ReadinessPolicy < Tram::Policy
 
   def title_presence
     return unless title.empty?
-    # Adds an error with a message and a set of additional tags
+    # Adds an error with a unique key and a set of additional tags
     # You can use any tags, not only an attribute/field like in ActiveModel
-    errors.add "Title is empty", field: "title", level: "error"
+    errors.add :blank_title, field: "title", level: "error"
   end
 
   def subtitle_presence
     return unless subtitle.empty?
     # Notice that we can set another level
-    errors.add "Subtitle is empty", field: "subtitle", level: "warning"
+    errors.add :blank_subtitle, field: "subtitle", level: "warning"
   end
 end
 ```
 
-Because validation is the only responsibility of a policy, we don't need to call it explicitly. Policy initializer will perform all the checks immediately, memoizing the results into `errors` array. The methods `#valid?`, `#invalid?` and `#validate!` just check those `#errors`.
+Because validation is the only responsibility of a policy, we don't need to call it explicitly.
 
-You can treat an instance of policy object as immutable.
+Policy initializer will perform all the checks immediately, memoizing the results into `errors` array. The methods `#valid?`, `#invalid?` and `#validate!` just check those `#errors`.
+
+You should treat an instance immutable.
 
 ```ruby
 article = Article.new title: "A wonderful article", subtitle: "", text: ""
@@ -78,35 +80,117 @@ policy.valid?      # => false
 policy.invalid?    # => true
 policy.validate!   # raises Tram::Policy::ValidationError
 
-# Look at errors closer
+# And errors
 policy.errors.count # => 2 (no subtitle, no text)
 policy.errors.filter { |error| error.tags[:level] == "error" }.count # => 1
 policy.errors.filter { |error| error.level == "error" }.count # => 1
+```
+
+## Validation Results
+
+Let look at those errors closer. We define 3 representation of errors:
+
+- error objects (`policy.errors`)
+- error items (`policy.items`, `policy.errors.items`, `policy.errors.map(&:item)`)
+- error messages (`policy.messages`, `policy.errors.messages`, `policy.errors.map(&:message)`)
+
+Errors by themselves are used for composition (see the next chapter), while `items` and `messages` represent errors for translation.
+
+The difference is the following.
+
+- The `messages` are translated immediately using the current locale.
+
+- The `items` postpone translation for later (for example, you can store them in a database and translate them to the locale of UI by demand).
+
+### Items
 
-# Error messages are already added under special key :message
-policy.errors.map(&:message) # => ["Subtitle is empty", "Error translation for missed text"]
+Error items contain arrays that could be send to I18n.t for translation. We add the default scope from the name of policy, preceeded by the `["tram-policy"]` root namespace.
 
-# A shortcut
-policy.messages # => ["Subtitle is empty", "Error translation for missed text"]
+```ruby
+policy.items # or policy.errors.items, or policy.errors.map(&:item)
+# => [
+#      [
+#        :blank_title,
+#        {
+#          scope: ["tram-policy", "article/readiness_policy"]],
+#          field: "title",
+#          level: "error"
+#        }
+#      ],
+#      ...
+#    ]
+
+I18n.t(*policy.items.first)
+# => "translation missing: en.tram-policy.article/readiness_policy.blank_title"
+```
+
+You can change the root scope if you will (this could be useful in libraries):
+
+```ruby
+class MyGemPolicy < Tram::Policy
+  scope "mygem", "policies" # inherited by subclasses
+end
+
+class Article::ReadinessPolicy < MyGemPolicy
+  # ...
+end
+
+# ...
+I18n.t(*policy.items.first)
+# => "translation missing: en.mygem.policies.article/readiness_policy.blank_title"
+```
+
+### Messages
+
+Error messages contain translation of `policy.items` in the current locale:
+
+```ruby
+policy.messages # or policy.errors.messages, or policy.errors.map(&:message)
+# => [
+#      "translation missing: en.tram-policy.article/readiness_policy.blank_title",
+#      "translation missing: en.tram-policy.article/readiness_policy.blank_subtitle"
+#    ]
+```
+
+The messages are translated if the keys are symbolic. Strings are treated as already translated:
+
+```ruby
+class Article::ReadinessPolicy < Tram::Policy
+  # ...
+  def title_presence
+    return unless title.empty?
+    errors.add "Title is absent", field: "title", level: "error"
+  end
+end
 
-# More verbose strings
-policy.full_messages
+# ...
+policy.messages
 # => [
-#      'Subtitle is empty: {"field":"subtitle", "level":"warning"}'
-#      'Error translation for missed text: {"field":"text", "level":"error"}'
+#      "Title is absent",
+#      "translation missing: en.tram-policy.article/readiness_policy.blank_subtitle"
 #    ]
+```
+
+## Partial Validation
 
-# You can use tags in checkers -- to add condition for errors to ignore
+You can use tags in checkers -- to add condition for errors to ignore
+
+```ruby
 policy.valid? { |error| !%w(warning error).include? error.level } # => false
 policy.valid? { |error| error.level != "disaster" }               # => true
+```
 
-# Notice the `invalid` takes a block with definitions for errors to count (not ignore)
+Notice the `invalid?` method takes a block with definitions for errors to count (not ignore)
+
+```ruby
 policy.invalid? { |error| %w(warning error).include? error.level } # => true
 policy.invalid? { |error| error.level == "disaster" }              # => false
 
 policy.validate! { |error| error.level != "disaster" } # => nil (seems ok)
 ```
 
+## Composition of Policies
+
 You can use errors in composition of policies:
 
 ```ruby
@@ -121,7 +205,7 @@ class Article::PublicationPolicy < Tram::Policy
 
   def article_readiness
     # Collects errors tagged by level: "error" from "nested" policy
-    readiness_errors = Article::ReadinessPolicy[article].errors.by_tags(level: "error")
+    readiness_errors = Article::ReadinessPolicy[article].errors.filter(level: "error")
 
     # Merges collected errors to the current ones.
     # New errors are also tagged by source: "readiness".
@@ -134,32 +218,9 @@ class Article::PublicationPolicy < Tram::Policy
 end
 ```
 
-As mentioned above, sending a symbolic key to the `errors#add` means the key should be translated by [I18n][i18n]. The only magic under the hood concerns a scope for the translation. By default it is taken from the full name of current class prepended with `"tram-policy"`.
-
-> You can redefine the scope by reloading private method `.scope` of the policy.
-
-All tags are available as options:
+## Exceptions
 
-```ruby
-class Article::PublicationPolicy < Tram::Policy
-  # ...
-  errors.add :empty, field: "text", level: "error"
-  # ...
-end
-```
-
-```yaml
-# /config/locales/en.yml
----
-en:
-  tram-policy:
-    article/publication_policy:
-      empty: "Validation %{level}: %{field} is empty"
-```
-
-This will provide error message "Validation error: text is empty".
-
-The last thing to say is about exceptions. When you use `validate!` it raises `Tram::Policy::ValidationError` (subclass of `RuntimeError`). Its message is built from selected errors (taking into account a `validation!` filter).
+When you use `validate!` it raises `Tram::Policy::ValidationError` (subclass of `RuntimeError`). Its message is built from selected errors (taking into account a `validation!` filter).
 
 The exception also carries a backreference to the `policy` that raised it. You can use it to extract either errors, or arguments of the policy during a debugging:
 
@@ -238,7 +299,7 @@ RSpec.describe User::ReadinessPolicy do
 end
 ```
 
-**Notice** that you have to wrap policy into block `{ policy }`. This is because the matcher checks not only presence of an error, but also ensures its message is translated to all available locales (`I18n.available_locales`). The block containing a policy will be executed separately for every such language.
+**Notice** that you have to wrap policy into block `{ policy }`. This is because the matcher checks not only the presence of an error, but also ensures its message is translated to all available locales (`I18n.available_locales`). The block containing a policy will be executed separately for every such language.
 
 ## Generators
 
@@ -342,43 +403,6 @@ When called without tags, it checks that the policy is valid as a whole.
 
 Both matchers provide a full description for the essence of the failure.
 
-## To Recap
-
-The `Tram::Policy` DSL provides the following methods:
-
-* `.param` and `.option` - class-level methods for policy constructor arguments
-* `.validate` - class-level method to add validators (they will be invoked in the same order as defined)
-* `.[]` - a syntax sugar for `.new`
-
-* `#errors` - returns an enumerable collection of validation errors
-* `#valid?` - checks whether no errors exist
-* `#invalid?` - checks whether some error exists
-* `#validate!` - raises if some error exist
-
-Enumerable collection of unique policy `errors` (`Tram::Policy::Errors`) responds to methods:
-
-* `add` - adds an error to the collection
-* `each` - iterates by the set of errors (support other methods of enumerables)
-* `empty?` - checks whether a collection is emtpy (in addition to enumerable interface)
-* `by_tags` - filters errors that have given tags
-* `messages` - returns an array of messages
-* `full_messages` - returns an array of messages with tags info added (used in exception)
-* `merge` - merges a collection to another one
-
-Every instance of `Tram::Policy::Error` supports:
-
-* `#tags` - hash of assigned tags
-* `#message` - the translated message
-* `#full_message` - the message with tags info added
-* `#to_h` - hash of tags and a message
-* `#==` - checks whether an error is equal to another one
-* undefined methods treated as tags
-
-The instance of `Tram::Policy::ValidationError` responds to:
-
-* `policy` - returns a policy object that raised an exception
-* other methods defined by the `RuntimeError` class
-
 ## Installation
 
 Add this line to your application's Gemfile:

data/lib/tram/policy.rb

@@ -15,6 +15,15 @@ module Tram
     extend Dry::Initializer
     extend DSL
 
+    # The scope used for translating error messages
+    #
+    # @return [Array<String>]
+    #
+    def scope
+      Array self.class.scope
+    end
+
+    # @!method t(message, options)
     # Translates a message in the scope of current policy
     #
     # @param  [#to_s] message
@@ -23,10 +32,10 @@ module Tram
     #
     def t(message, **options)
       return message.to_s unless message.is_a? Symbol
-      I18n.t message, scope: self.class.send(:scope), **options
+      I18n.t message, scope: scope, **options
     end
 
-    # Collection of validation errors
+    # The collection of validation errors
     #
     # @return [Tram::Policy::Errors]
     #
@@ -34,6 +43,22 @@ module Tram
       @errors ||= Errors.new(self)
     end
 
+    # The array of error items for lazy translation
+    #
+    # @return [Array<Array>]
+    #
+    def items
+      errors.items
+    end
+
+    # The array of error messages translated for the current locale
+    #
+    # @return [Array<String>]
+    #
+    def messages
+      errors.messages
+    end
+
     # Checks whether the policy is valid
     #
     # @param  [Proc, nil] filter Block describing **errors to be skipped**

data/lib/tram/policy/dsl.rb

@@ -22,12 +22,21 @@ class Tram::Policy
       new(*args)
     end
 
+    # Sets the root scope of the policy and its subclasses
+    #
+    # @param  [String, Array<String>] value
+    # @return [self]
+    #
+    def root_scope(*value)
+      tap { @root_scope = value.flatten.map(&:to_s).reject(&:empty?) }
+    end
+
     # Translation scope for a policy
     #
     # @return [Array<String>]
     #
     def scope
-      @scope ||= ["tram-policy", *Inflector.underscore(name)]
+      @scope ||= Array(@root_scope) + [Inflector.underscore(name)]
     end
 
     # List of validators defined by a policy per se
@@ -46,5 +55,17 @@ class Tram::Policy
       parent_validators = self == Tram::Policy ? [] : superclass.validators
       (parent_validators + local_validators).uniq
     end
+
+    private
+
+    def inherited(klass)
+      super
+      klass.send :instance_variable_set, :@root_scope, @root_scope
+    end
+
+    def self.extended(klass)
+      super
+      klass.send :instance_variable_set, :@root_scope, %w[tram-policy]
+    end
   end
 end

data/lib/tram/policy/error.rb

@@ -6,7 +6,7 @@ class Tram::Policy
   #         from one collection of [Tram::Policy::Errors] to another.
   #
   class Error
-    # @!method self.new(value, opts)
+    # @!method self.new(value, opts = {})
     # Builds an error
     #
     # If another error is send to the constructor, the error returned unchanged
@@ -16,65 +16,108 @@ class Tram::Policy
     # @return [Tram::Policy::Error]
     #
     def self.new(value, **opts)
-      return value if value.is_a? self
-      super
+      value.instance_of?(self) ? value : super
     end
 
-    # @!attribute [r] message
+    # @!attribute [r] key
+    # @return [Symbol, String] error key
+    attr_reader :key
+
+    # @!attribute [r] tags
+    # @return [Hash<Symbol, Object>] error tags
+    attr_reader :tags
+
+    # The list of arguments for [I18n.t]
     #
-    # @return [String] The error message text
+    # @return [Array]
     #
-    attr_reader :message
+    def item
+      [key, tags]
+    end
+    alias to_a item
 
-    # The full message (message and tags info)
+    # The text of error message translated to the current locale
     #
     # @return [String]
     #
-    def full_message
-      [message, @tags].reject(&:empty?).join(" ")
+    def message
+      key.is_a?(Symbol) ? I18n.t(*item) : key.to_s
     end
 
-    # Converts the error to a simple hash with message and tags
+    # @deprecated
+    # Converts the error to a hash of message and tags
     #
     # @return [Hash<Symbol, Object>]
     #
     def to_h
-      @tags.merge(message: message)
+      warn "[DEPRECATED] The method Tram::Policy::Error#to_h" \
+           " will be removed in the v1.0.0.."
+
+      tags.reject { |k| k == :scope }.merge(message: message)
+    end
+
+    # @deprecated
+    # The full message (message and tags info)
+    #
+    # @return [String]
+    #
+    def full_message
+      warn "[DEPRECATED] The method Tram::Policy::Error#full_message" \
+           " will be removed in the v1.0.0."
+
+      [message, tags].reject(&:empty?).join(" ")
     end
 
-    # Fetches either message or a tag
+    # Fetches an option
     #
     # @param [#to_sym] tag
     # @return [Object]
     #
     def [](tag)
-      to_h[tag.to_sym]
+      tags[tag.to_sym]
     end
 
-    # Fetches either message or a tag
+    # Fetches the tag
     #
     # @param [#to_sym] tag
     # @param [Object] default
     # @param [Proc] block
     # @return [Object]
     #
-    def fetch(tag, default, &block)
-      to_h.fetch(tag.to_sym, default, &block)
+    def fetch(tag, default = Dry::Initializer::UNDEFINED, &block)
+      if default == Dry::Initializer::UNDEFINED
+        tags.fetch(tag.to_sym, &block)
+      else
+        tags.fetch(tag.to_sym, default, &block)
+      end
     end
 
-    # Compares an error to another object using method [#to_h]
+    # Compares an error to another object using method [#item]
     #
     # @param  [Object] other Other object to compare to
     # @return [Boolean]
     #
     def ==(other)
-      other.respond_to?(:to_h) && other.to_h == to_h
+      other.respond_to?(:to_a) && other.to_a == item
+    end
+
+    # @!method contain?(some_key = nil, some_tags = {})
+    # Checks whether the error contain given key and tags
+    #
+    # @param [Object] some_key Expected key of the error
+    # @param [Hash<Symbol, Object>] some_tags Expected tags of the error
+    # @return [Boolean]
+    #
+    def contain?(some_key = nil, **some_tags)
+      return false if some_key&.!= key
+      some_tags.each { |k, v| return false unless tags[k] == v }
+      true
     end
 
     private
 
-    def initialize(message, **tags)
-      @message = message.to_s
+    def initialize(key, **tags)
+      @key  = key
       @tags = tags
     end
 
@@ -83,7 +126,7 @@ class Tram::Policy
     end
 
     def method_missing(name, *args, &block)
-      args.any? || block ? super : @tags[name]
+      args.any? || block ? super : tags[name]
     end
   end
 end

data/lib/tram/policy/errors.rb

@@ -21,12 +21,10 @@ class Tram::Policy
     # @param [Hash<Symbol, Object>] tags Tags to be attached to the message
     # @return [self] the collection
     #
-    def add(message = nil, **tags)
-      message ||= tags.delete(:message)
+    def add(message, **tags)
+      tags = tags.merge(scope: policy.scope) unless tags.key?(:scope)
       raise ArgumentError.new("Error message should be defined") unless message
-
-      @set << Tram::Policy::Error.new(@policy.t(message, tags), **tags)
-      self
+      tap { @set << Tram::Policy::Error.new(message, **tags) }
     end
 
     # Iterates by collected errors
@@ -38,15 +36,32 @@ class Tram::Policy
       @set.each { |error| yield(error) }
     end
 
-    # @!method by_tags(filter)
-    # Selects errors filtered by tags
+    # @!method filter(key = nil, tags)
+    # Filter errors by optional key and tags
     #
-    # @param  [Hash<Symbol, Object>] filter List of options to filter by
-    # @return [Hash<Symbol, Object>]
+    # @param  [#to_s] key The key to filter errors by
+    # @param  [Hash<Symbol, Object>] tags The list of tags to filter errors by
+    # @return [Tram::Policy::Errors]
     #
-    def by_tags(**filter)
-      filter = filter.to_a
-      reject { |error| (filter - error.to_h.to_a).any? }
+    def filter(key = nil, **tags)
+      list = each_with_object(Set.new) do |error, obj|
+        obj << error if error.contain?(key, tags)
+      end
+      self.class.new(policy, list)
+    end
+
+    # @deprecated
+    # @!method by_tags(tags)
+    # Selects errors filtered by key and tags
+    #
+    # @param  [Hash<Symbol, Object>] tags List of options to filter by
+    # @return [Array<Tram::Policy::Error>]
+    #
+    def by_tags(**tags)
+      warn "[DEPRECATED] The method Tram::Policy::Errors#by_tags" \
+           " will be removed in the v1.0.0. Use method #filter instead."
+
+      filter(tags).to_a
     end
 
     # @!method empty?
@@ -58,6 +73,14 @@ class Tram::Policy
       block ? !any?(&block) : !any?
     end
 
+    # The array of error items for translation
+    #
+    # @return [Array<Array>]
+    #
+    def items
+      @set.map(&:item)
+    end
+
     # The array of ordered error messages
     #
     # @return [Array<String>]
@@ -66,12 +89,16 @@ class Tram::Policy
       @set.map(&:message).sort
     end
 
-    # The array of ordered error messages with error tags info
+    # @deprecated
+    # List of error descriptions
     #
     # @return [Array<String>]
     #
     def full_messages
-      @set.map(&:full_message).sort
+      warn "[DEPRECATED] The method Tram::Policy::Errors#full_messages" \
+           " will be removed in the v1.0.0."
+
+      map(&:full_message)
     end
 
     # @!method merge(other, options)
@@ -90,8 +117,9 @@ class Tram::Policy
       return self unless other.is_a?(self.class)
 
       other.each do |err|
-        new_err = block_given? ? yield(err.to_h) : err.to_h
-        add new_err.merge(options)
+        key, opts = err.item
+        opts = yield(opts) if block_given?
+        add key, opts.merge(options)
       end
 
       self
@@ -99,9 +127,9 @@ class Tram::Policy
 
     private
 
-    def initialize(policy, errors = Set.new)
+    def initialize(policy, errors = [])
       @policy = policy
-      @set    = errors
+      @set    = Set.new(errors)
     end
   end
 end

data/lib/tram/policy/rspec.rb

@@ -34,7 +34,9 @@ RSpec::Matchers.define :be_invalid_at do |**tags|
     I18n.locale    = locale
     local_policy   = policy_block.call
     self.policy    = local_policy.inspect
-    errors[locale] = local_policy&.errors&.by_tags(tags)
+    errors[locale] = local_policy&.errors&.filter(tags)&.map do |error|
+      { message: error.message, tags: error.options } # translate immediately
+    end
   end
 
   def prepare_results(policy_block, tags)
@@ -62,7 +64,7 @@ RSpec::Matchers.define :be_invalid_at do |**tags|
 
   # Checks if all collected errors are translated
   def translated?
-    texts = errors.values.flatten.map(&:message)
+    texts = errors.values.flatten.map { |err| err[:message] }
     texts.select { |text| text.start_with?("translation missing") }.empty?
   end
 
@@ -70,7 +72,7 @@ RSpec::Matchers.define :be_invalid_at do |**tags|
     text = "Actual errors:\n"
     errors.each do |locale, local_errors|
       text << "  #{locale}:\n"
-      local_errors&.each { |error| text << "  - #{error.full_message}\n" }
+      local_errors&.each { |err| text << "  - #{err.values.join(" ")}\n" }
     end
     text
   end

data/lib/tram/policy/validation_error.rb

@@ -11,7 +11,7 @@ class Tram::Policy
 
     def initialize(policy, filter)
       @policy  = policy
-      messages = policy.errors.reject(&filter).map(&:full_message)
+      messages = policy.errors.to_a.reject(&filter).map(&:message)
       super (["Validation failed with errors:"] + messages).join("\n- ")
     end
   end

data/spec/fixtures/en.yml

@@ -1,6 +1,8 @@
 ---
 en:
+  bad: Something bad has happened
   tram-policy:
+    bad: Something bad has happened
     test/customer_policy:
       name_presence: Name is absent
     test/user_policy:

data/spec/spec_helper.rb

@@ -15,7 +15,11 @@ RSpec.configure do |config|
   config.filter_run focus: true
   config.run_all_when_everything_filtered = true
 
-  # Prepare the Test namespace for constants defined in specs
-  config.before(:each) { Test = Class.new(Module) }
-  config.after(:each)  { Object.send :remove_const, :Test }
+  config.before(:each) do
+    Test = Class.new(Module)
+    I18n.available_locales = %w[en]
+    I18n.backend.store_translations :en, yaml_fixture_file("en.yml")["en"]
+  end
+
+  config.after(:each) { Object.send :remove_const, :Test }
 end

data/spec/tram/policy/error_spec.rb

@@ -1,45 +1,32 @@
 RSpec.describe Tram::Policy::Error do
-  subject(:error) { described_class.new "Something bad happened", tags }
+  subject(:error) { described_class.new :bad, options }
 
-  let(:tags) { { level: "warning" } }
+  let(:options) { { level: "warning", scope: %w[tram-policy] } }
 
-  describe "#message" do
-    subject { error.message }
-    it { is_expected.to eq "Something bad happened" }
-  end
-
-  describe "#full_message" do
-    subject { error.full_message }
-
-    context "with tags:" do
-      it { is_expected.to eq "Something bad happened {:level=>\"warning\"}" }
-    end
-
-    context "without tags:" do
-      let(:tags) { {} }
-      it { is_expected.to eq "Something bad happened" }
-    end
+  describe "#item" do
+    subject { error.item }
+    it { is_expected.to eq [:bad, level: "warning", scope: %w[tram-policy]] }
   end
 
-  describe "#to_h" do
-    subject { error.to_h }
-    it { is_expected.to eq message: "Something bad happened", level: "warning" }
+  describe "#message" do
+    subject { error.message }
+    it { is_expected.to eq "Something bad has happened" }
   end
 
   describe "#==" do
     subject { error == other }
 
-    context "when other object has the same #to_h:" do
-      let(:other) { double to_h: error.to_h }
+    context "when other object has the same #item:" do
+      let(:other) { double to_a: error.item }
       it { is_expected.to eq true }
     end
 
-    context "when other object has different #to_h:" do
-      let(:other) { double to_h: error.to_h.merge(foo: :bar) }
+    context "when other object has different #item:" do
+      let(:other) { double to_a: [:foo] }
       it { is_expected.to eq false }
     end
 
-    context "when other object not respond to #to_h:" do
+    context "when other object not respond to #item:" do
       let(:other) { double }
       it { is_expected.to eq false }
     end

data/spec/tram/policy/errors_spec.rb

@@ -1,5 +1,5 @@
 RSpec.describe Tram::Policy::Errors do
-  let(:policy) { double :policy, t: "OMG!" }
+  let(:policy) { double :policy, scope: %w[tram-policy] }
   let(:errors) { described_class.new(policy) }
 
   describe ".new" do
@@ -12,14 +12,16 @@ RSpec.describe Tram::Policy::Errors do
   end
 
   describe "#add" do
-    subject     { errors.add :omg, level: "info", field: "name" }
+    subject { errors.add :omg, level: "info", field: "name" }
+
     let(:error) { errors.to_a.last }
 
     it "adds an error to the collection:" do
       expect { 2.times { subject } }.to change { errors.count }.by 1
 
       expect(error).to be_kind_of Tram::Policy::Error
-      expect(error).to eq message: "OMG!", level: "info", field: "name"
+      expect(error)
+        .to eq [:omg, level: "info", field: "name", scope: %w[tram-policy]]
     end
   end
 
@@ -35,6 +37,13 @@ RSpec.describe Tram::Policy::Errors do
     end
   end
 
+  describe "#items" do
+    subject { errors.items }
+
+    before { errors.add "OMG!", level: "info", field: "name" }
+    it { is_expected.to eq errors.map(&:item) }
+  end
+
   describe "#merge" do
     let(:other) { described_class.new(policy) }
 
@@ -48,9 +57,9 @@ RSpec.describe Tram::Policy::Errors do
 
       it "merges other collection as is" do
         expect(subject).to be_a Tram::Policy::Errors
-        expect(subject.map(&:to_h)).to match_array [
-          { message: "OMG!", level: "disaster" },
-          { message: "OMG!", level: "error" }
+        expect(subject.items).to match_array [
+          ["D'OH!", level: "disaster", scope: %w[tram-policy]],
+          ["OUCH!", level: "error",    scope: %w[tram-policy]]
         ]
       end
     end
@@ -60,9 +69,9 @@ RSpec.describe Tram::Policy::Errors do
 
       it "merges filtered collection as is" do
         expect(subject).to be_a Tram::Policy::Errors
-        expect(subject.map(&:to_h)).to match_array [
-          { message: "OMG!", level: "disaster" },
-          { message: "OMG!", level: "error", source: "Homer" }
+        expect(subject.items).to match_array [
+          ["D'OH!", level: "disaster", scope: %w[tram-policy]],
+          ["OUCH!", level: "error",    scope: %w[tram-policy], source: "Homer"]
         ]
       end
     end
@@ -72,9 +81,9 @@ RSpec.describe Tram::Policy::Errors do
 
       it "merges other collection with given options" do
         expect(subject).to be_a Tram::Policy::Errors
-        expect(subject.map(&:to_h)).to match_array [
-          { message: "OMG!", level: "disaster" },
-          { message: "OMG!", level: "error", source: "Homer" }
+        expect(subject.items).to match_array [
+          ["D'OH!", level: "disaster", scope: %w[tram-policy]],
+          ["OUCH!", level: "error",    scope: %w[tram-policy], source: "Homer"]
         ]
       end
     end
@@ -84,14 +93,14 @@ RSpec.describe Tram::Policy::Errors do
 
       it "merges filtered collection with given options" do
         expect(subject).to be_a Tram::Policy::Errors
-        expect(subject.map(&:to_h)).to match_array [
-          { message: "OMG!", level: "disaster" },
-          { message: "OMG!", level: "error", id: 5, age: 4 }
+        expect(subject.items).to match_array [
+          ["D'OH!", level: "disaster", scope: %w[tram-policy]],
+          ["OUCH!", level: "error",    scope: %w[tram-policy], id: 5, age: 4]
         ]
       end
     end
 
-    context "not errors:" do
+    context "with no errors:" do
       subject { errors.merge 1 }
       it { is_expected.to eql errors }
     end
@@ -100,26 +109,11 @@ RSpec.describe Tram::Policy::Errors do
   describe "#messages" do
     subject { errors.messages }
 
-    it { is_expected.to eq [] }
-
-    context "with errors added:" do
-      before  { errors.add "OMG!", level: "info", field: "name" }
-      it { is_expected.to eq %w[OMG!] }
-    end
-  end
-
-  describe "#full_messages" do
-    subject { errors.full_messages }
-
-    it { is_expected.to eq [] }
-
-    context "with errors added:" do
-      before  { errors.add "OMG!", level: "info", field: "name" }
-      it { is_expected.to eq ["OMG! {:level=>\"info\", :field=>\"name\"}"] }
-    end
+    before { errors.add "OMG!", level: "info", field: "name" }
+    it { is_expected.to eq errors.map(&:message) }
   end
 
-  describe "#by_tags" do
+  describe "#filter" do
     before do
       errors.add :foo, field: "name",  level: "error"
       errors.add :foo, field: "email", level: "info"
@@ -127,21 +121,21 @@ RSpec.describe Tram::Policy::Errors do
     end
 
     context "with filter" do
-      subject { errors.by_tags level: "error" }
+      subject { errors.filter level: "error" }
 
       it "returns selected errors only" do
-        expect(subject.map(&:to_h)).to match_array [
-          { message: "OMG!", field: "name",  level: "error" },
-          { message: "OMG!", field: "email", level: "error" }
+        expect(subject).to match_array [
+          [:foo, field: "name",  level: "error", scope: %w[tram-policy]],
+          [:foo, field: "email", level: "error", scope: %w[tram-policy]]
         ]
       end
     end
 
     context "without a filter" do
-      subject { errors.by_tags }
+      subject { errors.filter }
 
       it "returns selected all errors" do
-        expect(subject.map(&:to_h)).to match_array errors.to_a
+        expect(subject).to match_array errors.to_a
       end
     end
   end

data/spec/tram/policy/rspec_spec.rb

@@ -57,9 +57,6 @@ RSpec.describe "RSpec support:" do
 
   describe "shared examples" do
     it_behaves_like :invalid_policy
-    it_behaves_like :invalid_policy, field: "name" do
-      before { I18n.available_locales = %i[en ru] }
-    end
-    it_behaves_like :valid_policy,   field: "email"
+    it_behaves_like :valid_policy, field: "email"
   end
 end

data/spec/tram/policy/validation_error_spec.rb

@@ -1,8 +1,8 @@
 RSpec.describe Tram::Policy::ValidationError do
   subject(:error) { described_class.new policy, filter }
 
-  let(:one)    { double full_message: "OMG!",  level: "error" }
-  let(:two)    { double full_message: "phew!", level: "warning" }
+  let(:one)    { double message: "OMG!",  level: "error" }
+  let(:two)    { double message: "phew!", level: "warning" }
   let(:policy) { double :policy, errors: [one, two] }
 
   shared_examples :exception_with_messages do |text|

data/tram-policy.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |gem|
   gem.name     = "tram-policy"
-  gem.version  = "0.3.1"
+  gem.version  = "0.4.0"
   gem.author   = ["Viktor Sokolov (gzigzigzeo)", "Andrew Kozin (nepalez)"]
   gem.email    = "andrew.kozin@gmail.com"
   gem.homepage = "https://github.com/tram/tram-policy"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tram-policy
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Viktor Sokolov (gzigzigzeo)
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-05 00:00:00.000000000 Z
+date: 2018-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-initializer