rubanok 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76b1edc5c67f7a783dc3db022fee6aba015af2745a877d0b05089ce2c2ca2df7
-  data.tar.gz: d3e055c5453c793e17d0c6efea3b0bd6bcb3c8b16ada1461544b28431058a3a1
+  metadata.gz: 657a457fbefb6bf0f596ec5d0933dce51cbf74ca2a6cfed72f9c439d02e3d727
+  data.tar.gz: a820673bee22722ad9291332e2cbcef9aa0088a07c0077cc24d99777eca73f3b
 SHA512:
-  metadata.gz: ab19e7909a899d1831f246164888e76c29c1dfd6f9d3864a801b69fd3caba8cc754402a3e3e11ae6a0185bb87cec76711dadcfd8762e32eb4923cf24d3e16bae
-  data.tar.gz: 91c17c4695b0ccc7ff6ab0b75cace311c61b9ca3edf29a43bbd2c747dbb5995bc6f2af45ca6966117dc45304c8cf1ca2f58401bd7329d966a180d8c2942b24dc
+  metadata.gz: af7d742f04ba7399d40e92e66a5e26dda0dfa487254f347ee450020fe308e9f1aab906a69c1ba04468825619f3e49acb3ecca61ce22615ce1aab07c150dbe4ee
+  data.tar.gz: 75fb744a42d0248cc6b4b83da6758fca149fc1212fa4fc434a02ece81ce4bd046653192de7209ef0660f4c3302fb24301b07c418c82f1b6e6d0457000e820428

data/.rubocop.yml

@@ -23,6 +23,9 @@ Style/TrailingCommaInArrayLiteral:
 Style/TrailingCommaInHashLiteral:
   EnforcedStyleForMultiline: no_comma
 
+Style/SignalException:
+  Enabled: true
+
 Style/FrozenStringLiteralComment:
   Enabled: true
 

data/.travis.yml

@@ -8,8 +8,8 @@ notifications:
   email: false
 
 before_install:
-  - gem update --system
-  - gem install bundler
+  - gem uninstall -v '>= 2' -i $(rvm gemdir)@global -ax bundler || true
+  - gem install bundler -v '< 2'
 
 matrix:
   fast_finish: true

data/CHANGELOG.md

@@ -2,6 +2,37 @@
 
 ## master
 
+## 0.2.0 (2019-08-23)
+
+- Add `Process.project` and `rubanok_scope` methods to get the Hash of recognized params. ([@palkan][])
+
+```ruby
+class PostsProcessor < Rubanok::Processor
+  map :q { ... }
+  match :page, :per_page, activate_on: :page { ... }
+end
+
+PostsProcessor.project(q: "search_me", filter: "smth", page: 2)
+# => { q: "search_me", page: 2 }
+
+class PostsController < ApplicationController
+  def index
+    @filter_params = rubanok_scope
+    # or
+    @filter_params = rubanok_scope params.require(:filter), with: PostsProcessor
+    # ...
+  end
+end
+```
+
+- Improve naming by using "processor" instead of "plane". ([@palkan][])
+
+See [the discussion](https://github.com/palkan/rubanok/issues/3).
+
+**NOTE**: Older API is still available without deprecation.
+
+- Add `fail_when_no_matches` parameter to `match` method. ([@Earendil95][])
+
 ## 0.1.3 (2019-03-05)
 
 - Fix using `activate_always: true` with `default` matching clause. ([@palkan][])
@@ -19,3 +50,4 @@ Initial implementation.
 Proposal added.
 
 [@palkan]: https://github.com/palkan
+[@Earendil95]: https://github.com/Earendil95

data/README.md

@@ -4,7 +4,7 @@
 
 Rubanok provides a DSL to build parameters-based data transformers.
 
-📖 Read the introduction post: ["Carve your controllers like Papa Carlo"](https://dev.to/evilmartians/carve-your-controllers-like-papa-carlo-32m6)
+📖 Read the introduction post: ["Carve your controllers like Papa Carlo"](https://evilmartians.com/chronicles/rubanok-carve-your-rails-controllers-like-papa-carlo)
 
 The typical usage is to describe all the possible collection manipulation for REST `index` action, e.g. filtering, sorting, searching, pagination, etc..
 
@@ -28,13 +28,13 @@ You have:
 ```ruby
 class CourseSessionController < ApplicationController
   def index
-    @sessions = planish(
+    @sessions = rubanok_process(
       # pass input
       CourseSession.all,
       # pass params
       params,
-      # provide a plane to use
-      with: CourseSessionsPlane
+      # provide a processor to use
+      with: CourseSessionsProcessor
     )
   end
 end
@@ -42,16 +42,16 @@ end
 
 Or we can try to infer all the configuration for you:
 
-
 ```ruby
 class CourseSessionController < ApplicationController
   def index
-    @sessions = planish(CourseSession.all)
+    @sessions = rubanok_process(CourseSession.all)
   end
 end
 ```
 
 Requirements:
+
 - Ruby ~> 2.5
 - Rails >= 4.2 (only for using with Rails)
 
@@ -70,12 +70,12 @@ And run `bundle install`.
 
 ## Usage
 
-The core concept of this library is a _plane_ (or _hand plane_, or "рубанок" in Russian). Plane is responsible for mapping parameters to transformations.
+The core concept of this library is a processor (previously called _plane_ or _hand plane_, or "рубанок" in Russian). Processor is responsible for mapping parameters to transformations.
 
 From the example above:
 
 ```ruby
-class CourseSessionsPlane < Rubanok::Plane
+class CourseSessionsProcessor < Rubanok::Processor
   # You can map keys
   map :q do |q:|
     # `raw` is an accessor for input data
@@ -84,7 +84,7 @@ class CourseSessionsPlane < Rubanok::Plane
 end
 
 # The following code
-CourseSessionsPlane.call(CourseSession.all, q: "xyz")
+CourseSessionsProcessor.call(CourseSession.all, q: "xyz")
 
 # is equal to
 CourseSession.all.search("xyz")
@@ -93,7 +93,7 @@ CourseSession.all.search("xyz")
 You can map multiple keys at once:
 
 ```ruby
-class CourseSessionsPlane < Rubanok::Plane
+class CourseSessionsProcessor < Rubanok::Processor
   DEFAULT_PAGE_SIZE = 25
 
   map :page, :per_page do |page:, per_page: DEFAULT_PAGE_SIZE|
@@ -105,7 +105,7 @@ end
 There is also `match` method to handle values:
 
 ```ruby
-class CourseSessionsPlane < Rubanok::Plane
+class CourseSessionsProcessor < Rubanok::Processor
   SORT_ORDERS = %w(asc desc).freeze
   SORTABLE_FIELDS = %w(id name created_at).freeze
 
@@ -132,11 +132,54 @@ class CourseSessionsPlane < Rubanok::Plane
       raw.order(sort_by => sort)
     end
   end
+
+  # strict matching; if Processor will not match parameter, it will raise Rubanok::UnexpectedInputError
+  # You can handle it in controller, for example, with sending 422 Unprocessable Entity to client
+  match :filter, fail_when_no_matches: true do
+    having "active" do
+      raw.active
+    end
+
+    having "finished" do
+      raw.finished
+    end
+  end
 end
 ```
 
+By default, Rubanok will not fail if no matches found in `match` rule. You can change it by setting: `Rubanok.fail_when_no_matches = true`.
+If in example above you will call `CourseSessionsProcessor.call(CourseSession, filter: 'acitve')`, you will get `Rubanok::UnexpectedInputError: Unexpected input: {:filter=>'acitve'}`.
+
 **NOTE:** Rubanok only matches exact values; more complex matching could be added in the future.
 
+### Getting the matching params
+
+Sometimes it could be useful to get the params that were used to process the data by Rubanok processor (e.g., you can use this data in views to display the actual filters state).
+
+In Rails, you can use the `#rubanok_scope` method for that:
+
+```ruby
+class CourseSessionController < ApplicationController
+  def index
+    @sessions = rubanok_process(CourseSession.all)
+    # Returns the Hash of params recognized by the CourseSessionProcessor.
+    # For example:
+    #
+    #    params == {q: "search", role_id: 2, date: "2019-08-22"}
+    #    @session_filter == {q: "search", role_id: 2}
+    @sessions_filter = rubanok_scope(
+      params.permit(:q, :role_id),
+      with: CourseSessionProcessor
+    )
+
+    # You can omit all the arguments
+    @sessions_filter = rubanok_scope #=> equals to rubanok_scope(params, with: implicit_rubanok_class)
+  end
+end
+```
+
+You can also accesss `rubanok_scope` in views (it's a helper method).
+
 ### Rule activation
 
 Rubanok _activates_ a rule by checking whether the corresponding keys are present in the params object. All the fields must be present to apply the rule.
@@ -165,7 +208,7 @@ One of the benefits of having modification logic contained in its own class is t
 
 ```ruby
 # For example, with RSpec
-describe CourseSessionsPlane do
+RSpec.describe CourseSessionsProcessor do
   let(:input ) { CourseSession.all }
   let(:params) { {} }
 
@@ -182,19 +225,19 @@ end
 Now in your controller you only have to test that the specific _plane_ is applied:
 
 ```ruby
-describe CourseSessionController do
+RSpec.describe CourseSessionController do
   subject { get :index }
 
   specify do
-    expect { subject }.to have_planished(CourseSession.all).
-      with(CourseSessionsPlane)
+    expect { subject }.to have_rubanok_processed(CourseSession.all).
+      with(CourseSessionsProcessor)
   end
 end
 ```
 
 **NOTE**: input matching only checks for the class equality.
 
-To use `have_planished` matcher you must add the following line to your `spec_helper.rb` / `rails_helper.rb` (it's added automatically if RSpec defined and `RAILS_ENV`/`RACK_ENV` is equal to `"test"`):
+To use `have_rubanok_processed` matcher you must add the following line to your `spec_helper.rb` / `rails_helper.rb` (it's added automatically if RSpec defined and `RAILS_ENV`/`RACK_ENV` is equal to `"test"`):
 
 ```ruby
 require "rubanok/rspec"
@@ -202,33 +245,20 @@ require "rubanok/rspec"
 
 ### Rails vs. non-Rails
 
-Rubanok does not require Rails, but it has some useful Rails extensions such as `planish` helper for controllers (included automatically into `ActionController::Base` and `ActionController::API`).
+Rubanok does not require Rails, but it has some useful Rails extensions such as `rubanok_process` helper for controllers (included automatically into `ActionController::Base` and `ActionController::API`).
 
 If you use `ActionController::Metal` you must include the `Rubanok::Controller` module yourself.
 
-## Questions & Answers
-
-- **🧐"Planish"? Is there a word?**
-
-Yes, [it is](https://en.wiktionary.org/wiki/planish).
-
-- **Where to put my _plane_ classes?**
+### Processor class inference in Rails controllers
 
-I put mine under `app/planes` (as `<resources>_plane.rb`) in my Rails app.
-
-- **I don't like the naming ("planes" ✈️?), can I still use the library?**
+By default, `rubanok_process` uses the following algorithm to define a processor class: `"#{controller_path.classify.pluralize}Processor".safe_constantize`.
 
-First, feel free to [propose your variant](https://github.com/palkan/rubanok/issues). We would be glad to discuss it.
-
-Secondly, you can easily avoid it by adding a few lines to your `ApplicationController`:
+You can change this by overriding the `#implicit_rubanok_class` method:
 
 ```ruby
 class ApplicationController < ActionController::Smth
-  # add `planish` alias
-  alias transform_scope planish
-
-  # override the `implicit_plane_class` method
-  def implicit_plane_class
+  # override the `implicit_rubanok_class` method
+  def implicit_rubanok_class
     "#{controller_path.classify.pluralize}Scoper".safe_constantize
   end
 end
@@ -239,13 +269,25 @@ Now you can use it like this:
 ```ruby
 class CourseSessionsController < ApplicationController
   def index
-    @sessions = transform_scope(CourseSession.all, params)
+    @sessions = rubanok_process(CourseSession.all, params)
     # which equals to
     @sessions = CourseSessionsScoper.call(CourseSession.all, params.to_unsafe_h)
   end
 end
 ```
 
+**NOTE:** the `planish` method is still available and it uses `#{controller_path.classify.pluralize}Plane".safe_constantize` under the hood (via the `#implicit_plane_class` method).
+
+## Questions & Answers
+
+- **Where to put my processor/plane classes?**
+
+I put mine under `app/planes` (as `<resources>_plane.rb`) in my Rails app.
+
+- **I don't like the naming ("planes" ✈️?), can I still use the library?**
+
+Good news—the default naming [has been changed](https://github.com/palkan/rubanok/pull/8). "Planes" are still available if you prefer them (just like me 😉).
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/palkan/rubanok.

data/gemfiles/rails42.gemfile

@@ -1,6 +1,5 @@
 source "https://rubygems.org"
 
-gem "actionpack", "~> 4.2"
-gem "actionview", "~> 4.2"
+gem "rails", "~> 4.2"
 
 gemspec path: ".."

data/lib/rubanok.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "rubanok/version"
-require "rubanok/plane"
+require "rubanok/processor"
 
 require "rubanok/railtie" if defined?(Rails)
 
@@ -13,15 +13,15 @@ end
 #
 # Example:
 #
-#   class CourseSessionPlane < Rubanok::Plane
+#   class CourseSessionProcessor < Rubanok::Processor
 #     map :q do |q:|
-#      raw.searh(q)
+#       raw.searh(q)
 #     end
 #   end
 #
 #   class CourseSessionController < ApplicationController
 #     def index
-#       @sessions = planish(CourseSession.all)
+#       @sessions = rubanok_process(CourseSession.all)
 #     end
 #   end
 module Rubanok
@@ -30,7 +30,10 @@ module Rubanok
     # When the value is empty and ignored the corresponding matcher/mapper
     # is not activated (true by default)
     attr_accessor :ignore_empty_values
+    # Define wheter to fail when `match` rule cannot find matching value
+    attr_accessor :fail_when_no_matches
   end
 
   self.ignore_empty_values = true
+  self.fail_when_no_matches = false
 end

data/lib/rubanok/dsl/mapping.rb

@@ -2,7 +2,7 @@
 
 module Rubanok
   module DSL
-    # Adds `.map` method to Plane to define key-matching rules:
+    # Adds `.map` method to Processor to define key-matching rules:
     #
     #   map :q do |q:|
     #    # this rule is activated iff "q" (or :q) param is present
@@ -20,12 +20,18 @@ module Rubanok
         end
       end
 
-      def map(*fields, **options, &block)
-        rule = Rule.new(fields, options)
+      module ClassMethods
+        def map(*fields, **options, &block)
+          rule = Rule.new(fields, options)
 
-        define_method(rule.to_method_name, &block)
+          define_method(rule.to_method_name, &block)
 
-        rules << rule
+          add_rule rule
+        end
+      end
+
+      def self.included(base)
+        base.extend ClassMethods
       end
     end
   end

data/lib/rubanok/dsl/matching.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 module Rubanok
+  class UnexpectedInputError < StandardError; end
+
   module DSL
-    # Adds `.match` method to Plane class to define key-value-matching rules:
+    # Adds `.match` method to Processor class to define key-value-matching rules:
     #
     #   match :sort, :sort_by do |sort:, sort_by:|
     #     # this rule is activated iff both "sort" and "sort_by" params are present
@@ -64,23 +66,40 @@ module Rubanok
         end
       end
 
-      def match(*fields, **options, &block)
-        rule = Rule.new(fields, options)
+      module ClassMethods
+        def match(*fields, **options, &block)
+          rule = Rule.new(fields, options.slice(:activate_on, :activate_always))
 
-        rule.instance_eval(&block)
+          rule.instance_eval(&block)
 
-        define_method(rule.to_method_name) do |params = {}|
-          clause = rule.matching_clause(params)
-          next raw unless clause
+          define_method(rule.to_method_name) do |params = {}|
+            clause = rule.matching_clause(params)
+            next default_match_handler(rule, params, options[:fail_when_no_matches]) unless clause
 
-          apply_rule! clause.to_method_name, clause.project(params)
-        end
+            apply_rule! clause.to_method_name, clause.project(params)
+          end
+
+          rule.clauses.each do |clause|
+            define_method(clause.to_method_name, &clause.block)
+          end
 
-        rule.clauses.each do |clause|
-          define_method(clause.to_method_name, &clause.block)
+          add_rule rule
         end
+      end
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      def default_match_handler(rule, params, fail_when_no_matches)
+        fail_when_no_matches = Rubanok.fail_when_no_matches if fail_when_no_matches.nil?
+        return raw unless fail_when_no_matches
 
-        rules << rule
+        raise ::Rubanok::UnexpectedInputError, <<~MSG
+          Unexpected input: #{params.slice(*rule.fields)}.
+          Available values are:
+            #{rule.clauses.map(&:values).join("\n  ")}
+        MSG
       end
     end
   end

data/lib/rubanok/{plane.rb → processor.rb}

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "set"
+
 require "rubanok/rule"
 
 require "rubanok/dsl/mapping"
@@ -9,36 +11,37 @@ require "rubanok/ext/symbolize_keys"
 using Rubanok::SymbolizeKeys
 
 module Rubanok
-  # Base class for transformers (_planes_)
+  # Base class for processors (_planes_)
   #
   # Define transformation rules via `map` and `match` methods
-  # and apply them by calling the plane:
+  # and apply them by calling the processor:
   #
-  #   class MyPlane < Rubanok::Plane
+  #   class MyTransformer < Rubanok::Processor
   #     map :type do
   #       raw.where(type: type)
   #     end
   #   end
   #
-  #   MyPlane.call(MyModel.all, {type: "public"})
+  #   MyTransformer.call(MyModel.all, {type: "public"})
   #
   # NOTE: the second argument (`params`) MUST be a Hash. Keys could be either Symbols
   # or Strings (we automatically transform strings to symbols while matching rules).
   #
   # All transformation methods are called within the context of the instance of
-  # a plane class.
+  # a processor class.
   #
   # You can access the input data via `raw` method.
-  class Plane
-    class << self
-      include DSL::Mapping
-      include DSL::Matching
+  class Processor
+    include DSL::Matching
+    include DSL::Mapping
 
+    class << self
       def call(input, params)
         new(input).call(params)
       end
 
       def add_rule(rule)
+        fields_set.merge rule.fields
         rules << rule
       end
 
@@ -46,12 +49,30 @@ module Rubanok
         return @rules if instance_variable_defined?(:@rules)
 
         @rules =
-          if superclass <= Plane
+          if superclass <= Processor
             superclass.rules.dup
           else
             []
           end
       end
+
+      def fields_set
+        return @fields_set if instance_variable_defined?(:@fields_set)
+
+        @fields_set =
+          if superclass <= Processor
+            superclass.fields_set.dup
+          else
+            Set.new
+          end
+      end
+
+      # Generates a `params` projection including only the keys used
+      # by the rules
+      def project(params)
+        params = params.symbolize_keys
+        params.slice(*fields_set)
+      end
     end
 
     def initialize(input)
@@ -89,4 +110,6 @@ module Rubanok
       self.class.rules
     end
   end
+
+  Plane = Processor
 end

data/lib/rubanok/rails/controller.rb

@@ -4,33 +4,76 @@ require "active_support/concern"
 
 module Rubanok
   # Controller concern.
-  # Adds `planish` method.
+  # Adds `rubanok_process` method.
   module Controller
     extend ActiveSupport::Concern
 
-    # Planish passed data (e.g. ActiveRecord relation) using
-    # the corrsponding Plane class.
+    included do
+      helper_method :rubanok_scope
+      helper_method :planish_scope
+    end
+
+    # This method process passed data (e.g. ActiveRecord relation) using
+    # the corresponding Processor class.
+    #
+    # Processor is inferred from controller name, e.g.
+    # "PostsController -> PostProcessor".
+    #
+    # You can specify the Processor class explicitly via `with` option.
+    #
+    # By default, `params` object is passed as parameters, but you
+    # can specify the params via `params` option.
+    def rubanok_process(data, params = nil, with: nil)
+      with_inferred_rubanok_params(with, params) do |rubanok_class, rubanok_params|
+        rubanok_class.call(data, rubanok_params)
+      end
+    end
+
+    # This method filters the passed params and returns the Hash (!)
+    # of the params recongnized by the processor.
     #
-    # Plane is inferred from controller name, e.g.
-    # "PostsController -> PostPlane".
+    # Processor is inferred from controller name, e.g.
+    # "PostsController -> PostProcessor".
     #
-    # You can specify the Plane class explicitly via `with` option.
+    # You can specify the Processor class explicitly via `with` option.
     #
-    # By default, `params` object is passed as paraters, but you
+    # By default, `params` object is passed as parameters, but you
     # can specify the params via `params` option.
-    def planish(data, plane_params = nil, with: implicit_plane_class)
+    def rubanok_scope(params = nil, with: nil)
+      with_inferred_rubanok_params(with, params) do |rubanok_class, rubanok_params|
+        rubanok_class.project(rubanok_params)
+      end
+    end
+
+    # Tries to infer the rubanok processor class from controller path
+    def implicit_rubanok_class
+      "#{controller_path.classify.pluralize}Processor".safe_constantize
+    end
+
+    def with_inferred_rubanok_params(with, params)
+      with ||= implicit_rubanok_class
+
       if with.nil?
-        raise ArgumentError, "Failed to find a plane class for #{self.class.name}. " \
-                             "Please, specify the plane class explicitly via `with` option"
+        raise ArgumentError, "Failed to find a processor class for #{self.class.name}. " \
+                             "Please, specify the processor class explicitly via `with` option"
       end
 
-      plane_params ||= params
+      params ||= self.params
+
+      params = params.to_unsafe_h if params.is_a?(ActionController::Parameters)
+
+      yield with, params
+    end
+
+    # Backward compatibility
+    def planish(*args, with: implicit_plane_class)
+      rubanok_process(*args, with: with)
+    end
 
-      plane_params = plane_params.to_unsafe_h if plane_params.is_a?(ActionController::Parameters)
-      with.call(data, plane_params)
+    def planish_scope(*args, with: implicit_plane_class)
+      rubanok_scope(*args, with: with)
     end
 
-    # Tries to infer the plane class from controller path
     def implicit_plane_class
       "#{controller_path.classify.pluralize}Plane".safe_constantize
     end

data/lib/rubanok/rspec.rb

@@ -3,20 +3,26 @@
 require "rspec/mocks"
 
 module Rubanok
-  class HavePlanished < RSpec::Matchers::BuiltIn::BaseMatcher
+  class HaveProcessed < RSpec::Matchers::BuiltIn::BaseMatcher
     include RSpec::Mocks::ExampleMethods
 
-    attr_reader :data_class, :plane, :matcher
+    attr_reader :data_class, :processor, :matcher
 
     def initialize(data_class = nil)
       if data_class
         @data_class = data_class.is_a?(Module) ? data_class : data_class.class
       end
       @matcher = have_received(:call)
+      @name = "have_rubanok_processed"
     end
 
-    def with(plane)
-      @plane = plane
+    def as(alias_name)
+      @name = alias_name
+      self
+    end
+
+    def with(processor)
+      @processor = processor
       self
     end
 
@@ -25,32 +31,40 @@ module Rubanok
     end
 
     def matches?(proc)
-      raise ArgumentError, "have_planished only supports block expectations" unless Proc === proc
+      raise ArgumentError, "#{name} only supports block expectations" unless Proc === proc
 
-      raise ArgumentError, "Plane class is required. Please, specify it using `.with` modifier" if plane.nil?
+      raise ArgumentError, "Processor class is required. Please, specify it using `.with` modifier" if processor.nil?
 
-      allow(plane).to receive(:call).and_call_original
+      allow(processor).to receive(:call).and_call_original
       proc.call
 
       matcher.with(an_instance_of(data_class), anything) if data_class
 
-      matcher.matches?(plane)
+      matcher.matches?(processor)
     end
 
     def failure_message
-      "expected to use #{plane.name}#{data_class ? " for #{data_class.name}" : ""}, but didn't"
+      "expected to use #{processor.name}#{data_class ? " for #{data_class.name}" : ""}, but didn't"
     end
 
     def failure_message_when_negated
-      "expected not to use #{plane.name}#{data_class ? " for #{data_class.name} " : ""}, but have used"
+      "expected not to use #{processor.name}#{data_class ? " for #{data_class.name} " : ""}, but have used"
     end
+
+    private
+
+    attr_reader :name
   end
 end
 
 RSpec.configure do |config|
   config.include(Module.new do
+    def have_rubanok_processed(*args)
+      Rubanok::HaveProcessed.new(*args)
+    end
+
     def have_planished(*args)
-      Rubanok::HavePlanished.new(*args)
+      Rubanok::HaveProcessed.new(*args).as("have_planished")
     end
   end)
 end

data/lib/rubanok/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rubanok
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

data/rubanok.gemspec

@@ -22,6 +22,14 @@ Gem::Specification.new do |spec|
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
 
+  spec.metadata = {
+    "bug_tracker_uri" => "http://github.com/palkan/rubanok/issues",
+    "changelog_uri" => "https://github.com/palkan/rubanok/blob/master/CHANGELOG.md",
+    "documentation_uri" => "http://github.com/palkan/rubanok",
+    "homepage_uri" => "http://github.com/palkan/rubanok",
+    "source_code_uri" => "http://github.com/palkan/rubanok"
+  }
+
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "actionpack", ">= 4.2"
@@ -31,5 +39,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "rspec-rails"
   spec.add_development_dependency "rubocop-rspec"
-  spec.add_development_dependency "standard", "~> 0.0.36"
+  spec.add_development_dependency "standard", "~> 0.0.39"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubanok
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Vladimir Dementyev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-06 00:00:00.000000000 Z
+date: 2019-08-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -114,14 +114,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.36
+        version: 0.0.39
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.36
+        version: 0.0.39
 description: Parameters-based transformation DSL
 email:
 - dementiev.vm@gmail.com
@@ -149,7 +149,7 @@ files:
 - lib/rubanok/dsl/mapping.rb
 - lib/rubanok/dsl/matching.rb
 - lib/rubanok/ext/symbolize_keys.rb
-- lib/rubanok/plane.rb
+- lib/rubanok/processor.rb
 - lib/rubanok/rails/controller.rb
 - lib/rubanok/railtie.rb
 - lib/rubanok/rspec.rb
@@ -159,7 +159,12 @@ files:
 homepage: https://github.com/palkan/rubanok
 licenses:
 - MIT
-metadata: {}
+metadata:
+  bug_tracker_uri: http://github.com/palkan/rubanok/issues
+  changelog_uri: https://github.com/palkan/rubanok/blob/master/CHANGELOG.md
+  documentation_uri: http://github.com/palkan/rubanok
+  homepage_uri: http://github.com/palkan/rubanok
+  source_code_uri: http://github.com/palkan/rubanok
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -175,7 +180,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.2
+rubygems_version: 3.0.4
 signing_key: 
 specification_version: 4
 summary: Parameters-based transformation DSL