rubanok 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e340829681d2cdd077e745b2bf858ae9174eb0782c93a5665b86970b40652a67
-  data.tar.gz: 7e07185d8f569c23e67f48a9905725b3cd1ba2401933bb68c9bdc1f25ba927e0
+  metadata.gz: c22d92e478499cec879d532e120f57d6a07f2655c3f0ba112b613e5e4123c97e
+  data.tar.gz: 2010c2271258c7a39cace169a0a6eaf7b90c1c2029392a1d5ec4e9dce49c91be
 SHA512:
-  metadata.gz: 2fb0ef7961c6f9954d59e31f94ab9dfc034a15fe8edb4a611ffd016ee4a81159fb2272a249e6d8693ce45156e38890dc84069def6113cfc90660b5d2e481bbbb
-  data.tar.gz: d07c80bdb6904f1767f69d2f933b5138edef0c11611f29bf0b75dfef1b8aae8383ccc3b2a8e42edccac45842773553a2efe535b3ae95eb60a3163f35f5cf7d3f
+  metadata.gz: 1ae97af6ca1cb1e7ab77f0ac84011a6dcb31882415d96ed6cf89f55d74c47898187d653285b130d7e80b8e97e23d8c23e106954efb455f89189346fad05e3b84
+  data.tar.gz: 35296df1a1434889966c90bd3c309ac25c5a6719035b8088b4964d5071fc8ad9e509833b4a8851bd576bde727a344c5c43610e423247d639953192bc9f1b068d

data/.rubocop.yml

@@ -0,0 +1,63 @@
+require:
+  - standard/cop/semantic_blocks
+  - rubocop-rspec
+
+inherit_gem:
+  standard: config/base.yml
+
+AllCops:
+  Exclude:
+    - 'bin/*'
+    - 'tmp/**/*'
+    - 'Gemfile'
+    - 'vendor/**/*'
+    - 'gemfiles/**/*'
+  DisplayCopNames: true
+
+Standard/SemanticBlocks:
+  Enabled: false
+
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: no_comma
+
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: no_comma
+
+Style/FrozenStringLiteralComment:
+  Enabled: true
+
+RSpec/Focus:
+  Enabled: true
+
+RSpec/EmptyExampleGroup:
+  Enabled: true
+
+RSpec/EmptyLineAfterExampleGroup:
+  Enabled: true
+
+RSpec/EmptyLineAfterFinalLet:
+  Enabled: true
+
+RSpec/EmptyLineAfterHook:
+  Enabled: true
+
+RSpec/EmptyLineAfterSubject:
+  Enabled: true
+
+RSpec/HooksBeforeExamples:
+  Enabled: true
+
+RSpec/ImplicitExpect:
+  Enabled: true
+
+RSpec/IteratedExpectation:
+  Enabled: true
+
+RSpec/LetBeforeExamples:
+  Enabled: true
+
+RSpec/MissingExampleGroupArgument:
+  Enabled: true
+
+RSpec/ReceiveCounts:
+  Enabled: true

data/.travis.yml

@@ -1,5 +1,20 @@
 sudo: false
 language: ruby
 rvm:
-  - 2.5.1
-before_install: gem install bundler -v 1.16.2
+  - 2.6.0
+
+notifications:
+  email: false
+
+matrix:
+  fast_finish: true
+  include:
+    - rvm: ruby-head
+      gemfile: gemfiles/railsmaster.gemfile
+    - rvm: 2.6.0
+      gemfile: gemfiles/rails52.gemfile
+    - rvm: 2.5.1
+      gemfile: gemfiles/rails42.gemfile
+  allow_failures:
+    - rvm: ruby-head
+      gemfile: gemfiles/railsmaster.gemfile

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Change log
+
+## master
+
+## 0.1.0 (2019-01-04)
+
+Initial implementation.
+
+## 0.0.1 (2018-12-07)
+
+Proposal added.

data/Gemfile

@@ -1,6 +1,13 @@
 source "https://rubygems.org"
 
-git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
-
 # Specify your gem's dependencies in rubanok.gemspec
 gemspec
+
+gem "pry-byebug", platform: :mri
+gem "simplecov"
+
+local_gemfile = 'Gemfile.local'
+
+if File.exist?(local_gemfile)
+  eval(File.read(local_gemfile)) # rubocop:disable Security/Eval
+end

data/Gemfile.local

@@ -0,0 +1,2 @@
+gem "actionpack", "~> 5.2"
+gem "actionview", "~> 5.2"

data/Gemfile.lock

@@ -0,0 +1,136 @@
+PATH
+  remote: .
+  specs:
+    rubanok (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionpack (5.2.2)
+      actionview (= 5.2.2)
+      activesupport (= 5.2.2)
+      rack (~> 2.0)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.0.2)
+    actionview (5.2.2)
+      activesupport (= 5.2.2)
+      builder (~> 3.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.0.3)
+    activesupport (5.2.2)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    ast (2.4.0)
+    builder (3.2.3)
+    byebug (10.0.2)
+    coderay (1.1.2)
+    concurrent-ruby (1.1.4)
+    crass (1.0.4)
+    diff-lcs (1.3)
+    docile (1.3.1)
+    erubi (1.8.0)
+    i18n (1.4.0)
+      concurrent-ruby (~> 1.0)
+    jaro_winkler (1.5.2)
+    json (2.1.0)
+    loofah (2.2.3)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.5.9)
+    method_source (0.9.2)
+    mini_portile2 (2.4.0)
+    minitest (5.11.3)
+    nokogiri (1.10.0)
+      mini_portile2 (~> 2.4.0)
+    parallel (1.12.1)
+    parser (2.5.3.0)
+      ast (~> 2.4.0)
+    powerpack (0.1.2)
+    pry (0.12.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    pry-byebug (3.6.0)
+      byebug (~> 10.0)
+      pry (~> 0.10)
+    rack (2.0.6)
+    rack-test (1.1.0)
+      rack (>= 1.0, < 3)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.0.4)
+      loofah (~> 2.2, >= 2.2.2)
+    railties (5.2.2)
+      actionpack (= 5.2.2)
+      activesupport (= 5.2.2)
+      method_source
+      rake (>= 0.8.7)
+      thor (>= 0.19.0, < 2.0)
+    rainbow (3.0.0)
+    rake (10.5.0)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-rails (3.8.1)
+      actionpack (>= 3.0)
+      activesupport (>= 3.0)
+      railties (>= 3.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+    rubocop (0.62.0)
+      jaro_winkler (~> 1.5.1)
+      parallel (~> 1.10)
+      parser (>= 2.5, != 2.5.1.1)
+      powerpack (~> 0.1)
+      rainbow (>= 2.2.2, < 4.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.4.0)
+    rubocop-rspec (1.31.0)
+      rubocop (>= 0.60.0)
+    ruby-progressbar (1.10.0)
+    simplecov (0.16.1)
+      docile (~> 1.1)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+    standard (0.0.24)
+      rubocop (>= 0.60)
+    thor (0.20.3)
+    thread_safe (0.3.6)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
+    unicode-display_width (1.4.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  actionpack (~> 5.2)
+  actionview (~> 5.2)
+  bundler (~> 1.16)
+  pry-byebug
+  rake (~> 10.0)
+  rspec (~> 3.0)
+  rspec-rails
+  rubanok!
+  rubocop-rspec
+  simplecov
+  standard
+
+BUNDLED WITH
+   1.17.2

data/README.md

@@ -1,38 +1,206 @@
+[![Gem Version](https://badge.fury.io/rb/rubanok.svg)](https://rubygems.org/gems/rubanok) [![Build Status](https://travis-ci.org/palkan/rubanok.svg?branch=master)](https://travis-ci.org/palkan/rubanok)
+
 # Rubanok
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/rubanok`. To experiment with that code, run `bin/console` for an interactive prompt.
+Rubanok provides a DSL to build parameters-based data transformers.
 
-TODO: Delete this and the text above, and describe your gem
+The typical usage is to describe all the possible collection manipulation for REST `index` action, e.g. filtering, sorting, searching, pagination, etc..
 
-## Installation
+So, instead of:
 
-Add this line to your application's Gemfile:
+```ruby
+class CourseSessionController < ApplicationController
+  def index
+    @sessions = CourseSession.
+                  search(params[:q]).
+                  by_course_type(params[:course_type_id]).
+                  by_role(params[:role_id]).
+                  paginate(page_params).
+                  order(ordering_params)
+  end
+end
+```
+
+You have:
 
 ```ruby
-gem 'rubanok'
+class CourseSessionController < ApplicationController
+  def index
+    @sessions = planish(
+      # pass input
+      CourseSession.all,
+      # pass params
+      params,
+      # provide a plane to use
+      with: CourseSessionsPlane
+    )
+  end
+end
 ```
 
-And then execute:
+Or we can try to infer all the configuration for you:
 
-    $ bundle
 
-Or install it yourself as:
+```ruby
+class CourseSessionController < ApplicationController
+  def index
+    @sessions = planish(CourseSession.all)
+  end
+end
+```
 
-    $ gem install rubanok
+Requirements:
+- Ruby ~> 2.5
+- Rails >= 4.2 (only for using with Rails)
+
+<a href="https://evilmartians.com/">
+<img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Sponsored by Evil Martians" width="236" height="54"></a>
+
+## Installation
+
+**This gem hasn't been released (and even built) yet.**
 
 ## Usage
 
-TODO: Write usage instructions here
+The core concept of this library is a _plane_ (or _hand plane_, or "рубанок" in Russian). Plane is responsible for mapping parameters to transformrations.
+
+From the example above:
+
+```ruby
+class CourseSessionsPlane < Rubanok::Plane
+  # You can map keys
+  map :q do |q:|
+    # `raw` is an accessor for input data
+    raw.searh(q)
+  end
+end
+
+# The following code
+CourseSessionsPlane.call(CourseSession.all, q: "xyz")
+
+# is equal to
+CourseSession.all.search("xyz")
+```
+
+You can map multiple keys at once:
+
+```ruby
+class CourseSessionsPlane < Rubanok::Plane
+  DEFAULT_PAGE_SIZE = 25
+
+  map :page, :per_page do |page:, per_page: DEFAULT_PAGE_SIZE|
+    raw.paginate(page: page, per_page: per_page)
+  end
+end
+```
+
+There is also `match` method to handle values:
+
+```ruby
+class CourseSessionsPlane < Rubanok::Plane
+  SORT_ORDERS = %w(asc desc).freeze
+  SORTABLE_FIELDS = %w(id name created_at).freeze
+
+  match :sort_by, :sort do
+    having "course_id", "desc" do
+      raw.joins(:courses).order("courses.id desc nulls last")
+    end
+
+    having "course_id", "asc" do
+      raw.joins(:courses).order("courses.id asc nulls first")
+    end
+
+    # Match any value for the second arg
+    having "type" do |sort: "asc"|
+      # Prevent SQL injections
+      raise "Possible injection: #{sort}" unless SORT_ORDERS.include?(sort)
+      raw.joins(:course_type).order("course_types.name #{sort}")
+    end
+
+    # Match any value
+    default do |sort_by:, sort: "asc"|
+      raise "Possible injection: #{sort}" unless SORT_ORDERS.include?(sort)
+      raise "The field is not sortable: #{sort_by}" unless SORTABLE_FIELDS.include?(sort_by)
+      raw.order(sort_by => sort)
+    end
+  end
+end
+```
+
+**NOTE:** matching only match the exact values; more complex matching could be added in the future.
+
+### 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.
+
+Sometimes you might want to make some fields optional (or event all of them). You can use `activate_on` and `activate_always` options for that:
+
+```ruby
+# Always apply the rule; use default values for keyword args
+map :page, :per_page, activate_always: true do |page: 1, per_page: 2|
+  raw.page(page).per(per_page)
+end
+
+# Only require `sort_by` to be preset to activate sorting rule
+match :sort_by, :sort, activate_on: :sort_by do
+ # ...
+end
+```
+
+By default, Rubanok ignores empty param values (using `#empty?` under the hood) and do not activate the matching rules (i.e. `{ q: "" }` or `{ q: nil }` won't activate the `map :q` rule).
+
+You can change this behaviour by setting: `Rubanok.ignore_empty_values = false`.
+
+### Testing
+
+One of the benefits of having all the modification logic in its own class is the ability to test it in isolation:
+
+```ruby
+# For example, with RSpec
+describe CourseSessionsPlane do
+  let(:input ) { CourseSession.all }
+  let(:params) { {} }
+
+  subject { described_class.call(input, params) }
+
+  specify "searching" do
+    params[:q] = "wood"
+
+    expect(subject).to eq input.search("wood")
+  end
+end
+```
+
+Now in your controller you only have to test that the specific _plane_ is applied:
+
+```ruby
+describe CourseSessionController do
+  subject { get :index }
+
+  specify do
+    expect { subject }.to have_planished(CourseSession.all).
+      with(CourseSessionsPlane)
+  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"`):
+
+```ruby
+require "rubanok/rspec"
+```
 
-## Development
+### Rails vs. non-Rails
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+Rubanok is a Rails-free library but has some useful Rails extensions, such as `planish` helper for controllers (included automatically into `ActionController::Base` and `ActionController::API`).
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+If you use `ActionController::Metal` you must include the `Rubanok::Controller` module yourself.
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/rubanok.
+Bug reports and pull requests are welcome on GitHub at https://github.com/palkan/rubanok.
 
 ## License
 

data/Rakefile

@@ -1,6 +1,10 @@
+# frozen_string_literal: true
+
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
+require "rubocop/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new
 
-task :default => :spec
+task default: [:rubocop, :spec]

data/bin/console

@@ -2,13 +2,7 @@
 
 require "bundler/setup"
 require "rubanok"
+require "pry"
 
-# 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__)
+require "pry"
+Pry.start

data/gemfiles/rails42.gemfile

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

data/gemfiles/rails52.gemfile

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

data/gemfiles/railsmaster.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem "rails", github: "rails/rails"
+
+gemspec path: ".."

data/lib/rubanok.rb

@@ -1,5 +1,36 @@
+# frozen_string_literal: true
+
 require "rubanok/version"
+require "rubanok/plane"
+
+require "rubanok/railtie" if defined?(Rails)
 
+if defined?(RSpec) && (ENV["RACK_ENV"] == "test" || ENV["RAILS_ENV"] == "test")
+  require "rubanok/rspec"
+end
+
+# Rubanok provides a DSL to build parameters-based data transformers.
+#
+# Example:
+#
+#   class CourseSessionPlane < Rubanok::Plane
+#     map :q do |q:|
+#      raw.searh(q)
+#     end
+#   end
+#
+#   class CourseSessionController < ApplicationController
+#     def index
+#       @sessions = planish(CourseSession.all)
+#     end
+#   end
 module Rubanok
-  # Your code goes here...
+  class << self
+    # Define whether to ignore empty values in params or not.
+    # When the value is empty and ignored the corresponding matcher/mapper
+    # is not activated (true by default)
+    attr_accessor :ignore_empty_values
+  end
+
+  self.ignore_empty_values = true
 end

data/lib/rubanok/dsl/mapping.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Rubanok
+  module DSL
+    # Adds `.map` method to Plane to define key-matching rules:
+    #
+    #   map :q do |q:|
+    #    # this rule is activated iff "q" (or :q) param is present
+    #    # the value is passed to the handler
+    #   end
+    module Mapping
+      class Rule < Rubanok::Rule
+        METHOD_PREFIX = "__map"
+
+        private
+
+        # prefix rule method name to avoid collisions
+        def build_method_name
+          "#{METHOD_PREFIX}#{super}"
+        end
+      end
+
+      def map(*fields, **options, &block)
+        rule = Rule.new(fields, options)
+
+        define_method(rule.to_method_name, &block)
+
+        rules << rule
+      end
+    end
+  end
+end

data/lib/rubanok/dsl/matching.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Rubanok
+  module DSL
+    # Adds `.match` method to Plane 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
+    #     # the values are passed to the matcher
+    #     #
+    #     # then we match against values
+    #     having "name" do |sort_by:|
+    #       raw.joins(:user).order("users.name #{sort_by}")
+    #     end
+    #   end
+    module Matching
+      class Rule < Rubanok::Rule
+        METHOD_PREFIX = "__match"
+
+        class Clause < Rubanok::Rule
+          attr_reader :values, :id, :block
+
+          def initialize(id, fields, values = [], **options, &block)
+            super(fields, options)
+            @id = id
+            @block = block
+            @values = Hash[fields.take(values.size).zip(values)].freeze
+            @fields = (fields - @values.keys).freeze
+          end
+
+          def applicable?(params)
+            values.all? { |key, matcher| params.key?(key) && (matcher == params[key]) }
+          end
+
+          alias to_method_name id
+        end
+
+        attr_reader :clauses
+
+        def initialize(*)
+          super
+          @clauses = []
+        end
+
+        def matching_clause(params)
+          clauses.detect do |clause|
+            clause.applicable?(params)
+          end
+        end
+
+        def having(*values, &block)
+          clauses << Clause.new("#{to_method_name}_#{clauses.size}", fields, values, &block)
+        end
+
+        def default(&block)
+          clauses << Clause.new("#{to_method_name}_default", fields, activate_always: true, &block)
+        end
+
+        private
+
+        # prefix rule method name to avoid collisions
+        def build_method_name
+          "#{METHOD_PREFIX}#{super}"
+        end
+      end
+
+      def match(*fields, **options, &block)
+        rule = Rule.new(fields, options)
+
+        rule.instance_eval(&block)
+
+        define_method(rule.to_method_name) do |params|
+          clause = rule.matching_clause(params)
+          next raw unless clause
+
+          apply_rule! clause.to_method_name, clause.project(params)
+        end
+
+        rule.clauses.each do |clause|
+          define_method(clause.to_method_name, &clause.block)
+        end
+
+        rules << rule
+      end
+    end
+  end
+end

data/lib/rubanok/ext/symbolize_keys.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Rubanok
+  module SymbolizeKeys
+    refine Hash do
+      def symbolize_keys
+        each_with_object({}) do |(key, value), acc|
+          acc[key.to_sym] = value
+        end
+      end
+    end
+  end
+end

data/lib/rubanok/plane.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "rubanok/rule"
+
+require "rubanok/dsl/mapping"
+require "rubanok/dsl/matching"
+
+require "rubanok/ext/symbolize_keys"
+using Rubanok::SymbolizeKeys
+
+module Rubanok
+  # Base class for transformers (_planes_)
+  #
+  # Define transformation rules via `map` and `match` methods
+  # and apply them by calling the plane:
+  #
+  #   class MyPlane < Rubanok::Plane
+  #     map :type do
+  #       raw.where(type: type)
+  #     end
+  #   end
+  #
+  #   MyPlane.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.
+  #
+  # You can access the input data via `raw` method.
+  class Plane
+    class << self
+      include DSL::Mapping
+      include DSL::Matching
+
+      def call(input, params)
+        new(input).call(params)
+      end
+
+      def add_rule(rule)
+        rules << rule
+      end
+
+      def rules
+        return @rules if instance_variable_defined?(:@rules)
+
+        @rules =
+          if superclass <= Plane
+            superclass.rules.dup
+          else
+            []
+          end
+      end
+    end
+
+    def initialize(input)
+      @input = input
+    end
+
+    def call(params)
+      params = params.symbolize_keys
+
+      rules.each do |rule|
+        next unless rule.applicable?(params)
+
+        apply_rule! rule.to_method_name, rule.project(params)
+      end
+
+      input
+    end
+
+    private
+
+    attr_accessor :input
+
+    alias raw input
+
+    def apply_rule!(method_name, data)
+      self.input =
+        if data.empty?
+          send(method_name)
+        else
+          send(method_name, **data)
+        end
+    end
+
+    def rules
+      self.class.rules
+    end
+  end
+end

data/lib/rubanok/rails/controller.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Rubanok
+  # Controller concern.
+  # Adds `planish` method.
+  module Controller
+    extend ActiveSupport::Concern
+
+    # Planish passed data (e.g. ActiveRecord relation) using
+    # the corrsponding Plane class.
+    #
+    # Plane is inferred from controller name, e.g.
+    # "PostsController -> PostPlane".
+    #
+    # You can specify the Plane class explicitly via `with` option.
+    #
+    # By default, `params` object is passed as paraters, but you
+    # can specify the params via `params` option.
+    def planish(data, plane_params = nil, with: implicit_plane_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"
+      end
+
+      plane_params ||= params
+
+      plane_params = plane_params.to_unsafe_h if plane_params.is_a?(ActionController::Parameters)
+      with.call(data, plane_params)
+    end
+
+    # Tries to infer the plane class from controller path
+    def implicit_plane_class
+      "#{controller_path.classify.pluralize}Plane".safe_constantize
+    end
+  end
+end

data/lib/rubanok/railtie.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Rubanok # :nodoc:
+  class Railtie < ::Rails::Railtie # :nodoc:
+    config.to_prepare do |_app|
+      ActiveSupport.on_load(:action_controller) do
+        require "rubanok/rails/controller"
+
+        ActionController::Base.include Rubanok::Controller
+      end
+    end
+  end
+end

data/lib/rubanok/rspec.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "rspec/mocks"
+
+module Rubanok
+  class HavePlanished < RSpec::Matchers::BuiltIn::BaseMatcher
+    include RSpec::Mocks::ExampleMethods
+
+    attr_reader :data_class, :plane, :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)
+    end
+
+    def with(plane)
+      @plane = plane
+      self
+    end
+
+    def supports_block_expectations?
+      true
+    end
+
+    def matches?(proc)
+      raise ArgumentError, "have_planished only supports block expectations" unless Proc === proc
+
+      raise ArgumentError, "Plane class is required. Please, specify it using `.with` modifier" if plane.nil?
+
+      allow(plane).to receive(:call)
+      proc.call
+
+      matcher.with(an_instance_of(data_class), anything) if data_class
+
+      matcher.matches?(plane)
+    end
+
+    def failure_message
+      "expected to use #{plane.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"
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include(Module.new do
+    def have_planished(*args)
+      Rubanok::HavePlanished.new(*args)
+    end
+  end)
+end

data/lib/rubanok/rule.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Rubanok
+  class Rule # :nodoc:
+    UNDEFINED = :__undef__
+
+    attr_reader :fields, :activate_on, :activate_always
+
+    def initialize(fields, activate_on: fields, activate_always: false)
+      @fields = fields.freeze
+      @activate_on = Array(activate_on).freeze
+      @activate_always = activate_always
+    end
+
+    def project(params)
+      fields.each_with_object({}) do |field, acc|
+        val = fetch_value params, field
+        next acc if val == UNDEFINED
+
+        acc[field] = val
+        acc
+      end
+    end
+
+    def applicable?(params)
+      return true if activate_always == true
+
+      activate_on.all? { |field| params.key?(field) && !empty?(params[field]) }
+    end
+
+    def to_method_name
+      @method_name ||= build_method_name
+    end
+
+    private
+
+    def build_method_name
+      "__#{fields.join("_")}__"
+    end
+
+    def fetch_value(params, field)
+      return UNDEFINED if !params.key?(field) || empty?(params[field])
+
+      params[field]
+    end
+
+    using(Module.new do
+      refine NilClass do
+        def empty?
+          true
+        end
+      end
+
+      refine Object do
+        def empty?
+          false
+        end
+      end
+    end)
+
+    def empty?(val)
+      return false unless Rubanok.ignore_empty_values
+
+      val.empty?
+    end
+  end
+end

data/lib/rubanok/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rubanok
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/rubanok.gemspec

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
@@ -13,16 +14,22 @@ Gem::Specification.new do |spec|
   spec.description   = "Parameters-based transformation DSL"
   spec.homepage      = "https://github.com/palkan/rubanok"
   spec.license       = "MIT"
+  spec.required_ruby_version = ">= 2.5.0"
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+  spec.files = Dir.chdir(File.expand_path("..", __FILE__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
 
   spec.require_paths = ["lib"]
 
+  spec.add_development_dependency "actionpack", ">= 4.2"
+  spec.add_development_dependency "actionview", ">= 4.2"
   spec.add_development_dependency "bundler", "~> 1.16"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rspec-rails"
+  spec.add_development_dependency "rubocop-rspec"
+  spec.add_development_dependency "standard"
 end

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: rubanok
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Vladimir Dementyev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-07 00:00:00.000000000 Z
+date: 2019-01-05 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: actionview
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +80,48 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Parameters-based transformation DSL
 email:
 - dementiev.vm@gmail.com
@@ -61,14 +131,29 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
+- Gemfile.local
+- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
 - bin/console
 - bin/setup
+- gemfiles/rails42.gemfile
+- gemfiles/rails52.gemfile
+- gemfiles/railsmaster.gemfile
 - lib/rubanok.rb
+- lib/rubanok/dsl/mapping.rb
+- lib/rubanok/dsl/matching.rb
+- lib/rubanok/ext/symbolize_keys.rb
+- lib/rubanok/plane.rb
+- lib/rubanok/rails/controller.rb
+- lib/rubanok/railtie.rb
+- lib/rubanok/rspec.rb
+- lib/rubanok/rule.rb
 - lib/rubanok/version.rb
 - rubanok.gemspec
 homepage: https://github.com/palkan/rubanok
@@ -83,15 +168,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: Parameters-based transformation DSL