ducalis 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c78c0b5ad28cbd122b68f755abbbb3f1aa052700
-  data.tar.gz: 63c7074a2d5f41fe414939710ba902e4bcb116ea
+  metadata.gz: c6fa5fd04439b5d750ef52ab27f19c4fe233dc6c
+  data.tar.gz: a700248bc70906a88c759217a76c60873df249c8
 SHA512:
-  metadata.gz: a091ccfd11f2fbbb626014065a2d95f9e0a79b930763d1ec9c3919b4c695ea4cd8cbb1ae301e43be979a895ce72801668a75cc49be4aa63f5d1743e3a5969ec0
-  data.tar.gz: 5e080337b542b2c56b8207ce8dff250be08e6a7cd20606553422d2ee39709d1f84d9cc9c9f6908d235c5c74b528bd3839050753b7874c857595fdee64ec3eee2
+  metadata.gz: e297975d9b71e10ea881e99eebe64af49a756dbf1e5d6167da25431893408697794ee6125f61b60da2981d4dbe0e91a58377b92750a7433b08872e1f00ec64f1
+  data.tar.gz: 5c29c471688d345b4433cf60fe7b488a39ce5499d847a3474edccadab255f4a115dd3bee52fcabd76a50b32f93f8227e7d74312edca74fcdacf148d4bacee33d

data/.codeclimate.yml

@@ -0,0 +1,6 @@
+engines:
+  rubocop:
+    enabled: true
+    channel: rubocop-0-50
+    config:
+      file: .rubocop.yml

data/.rubocop.yml

@@ -1,6 +1,9 @@
 AllCops:
   TargetRubyVersion: 2.4
   UseCache: false
+  Exclude:
+    - 'client/vendor/bundle/**/*'
+    - 'vendor/bundle/**/*'
 
 Metrics/BlockLength:
   Exclude:

data/DOCUMENTATION.md

@@ -1,7 +1,8 @@
 ## Ducalis::CallbacksActiverecord
 
 Please, avoid using of callbacks for models. It's better to keep models small ("dumb") and instead use "builder" classes/services: to construct new objects. You can read more [here](https://medium.com/planet-arkency/a61fd75ab2d3).
-- rejects ActiveRecord classes which contains callbacks
+
+![](https://placehold.it/15/f03c15/000000?text=+) raises on ActiveRecord classes which contains callbacks
 ```ruby
 
 class A < ActiveRecord::Base
@@ -9,18 +10,116 @@ class A < ActiveRecord::Base
 end
 
 ```
-- ignores non-ActiveRecord classes which contains callbacks
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores non-ActiveRecord classes which contains callbacks
 ```ruby
 
 class A < SomeBasicClass
   before_create :generate_code
 end
 
+```
+## Ducalis::CaseMapping
+
+Try to avoid `case when` statements. You can replace it with a sequence of
+`if... elsif... elsif... else`. For cases where you need to choose from a
+large number of possibilities, you can create a dictionary mapping case values
+to functions to call by `call`. It's nice to have prefix for the method
+names, i.e.: `visit_`.
+
+<details>
+Usually `case when` statements are using for the next reasons:
+
+I. Mapping between different values.
+("A" => 1, "B" => 2, ...)
+
+This case is all about data representing. If you do not need to execute any code
+it's better to use data structure which represents it. This way you are
+separating concepts: code returns corresponding value and you have config-like
+data structure which describes your data.
+
+```ruby
+  %w[A B ...].index("A") + 1
+  # or
+  { "A" => 1, "B" => 2 }.fetch("A")
+```
+
+II. Code execution depending of parameter or type:
+
+  - a. (:attack => attack, :defend => defend)
+  - b. (Feet => value * 0.348, Meters => `value`)
+
+In this case code violates OOP and S[O]LID principle. Code shouldn't know about
+object type and classes should be open for extension, but closed for
+modification (but you can't do it with case-statements).
+This is a signal that you have some problems with architecture.
+
+  a.
+```ruby
+attack: -> { execute_attack }, defend: -> { execute_defend }
+# or
+call(:"execute_#{action}")
+```
+
+  b.
+```ruby
+class Meters; def to_metters; value;         end
+class Feet;   def to_metters; value * 0.348; end
+```
+
+III. Code execution depending on some statement.
+(`a > 0` => 1, `a == 0` => 0, `a < 0` => -1)
+
+This case is combination of I and II -- high code complexity and unit-tests
+complexity. There are variants how to solve it:
+
+  a. Rewrite to simple if statement
+
+```ruby
+return 0 if a == 0
+a > 0 ? 1 : -1
+```
+
+  b. Move statements to lambdas:
+
+```ruby
+ ->(a) { a > 0 }  =>  1,
+ ->(a) { a == 0 } =>  0,
+ ->(a) { a < 0 }  => -1
+```
+
+This way decreases code complexity by delegating it to lambdas and makes it easy
+ to unit-testing because it's easy to test pure lambdas.
+
+Such approach is named
+[table-driven design](<https://www.d.umn.edu/~gshute/softeng/table-driven.html>)
+. Table-driven methods are schemes that allow you to look up information in a
+table rather than using logic statements (i.e. case, if). In simple cases,
+it's quicker and easier to use logic statements, but as the logic chain becomes
+more complex, table-driven code is simpler than complicated logic, easier to
+modify and more efficient.
+</details>
+
+![](https://placehold.it/15/f03c15/000000?text=+) raises on case statements
+```ruby
+
+case grade
+when "A"
+  puts "Well done!"
+when "B"
+  puts "Try harder!"
+when "C"
+  puts "You need help!!!"
+else
+  puts "You just making it up!"
+end
+
 ```
 ## Ducalis::ControllersExcept
 
 Prefer to use `:only` over `:except` in controllers because it's more explicit and will be easier to maintain for new developers.
-- raises for `before_filters` with `except` method as array
+
+![](https://placehold.it/15/f03c15/000000?text=+) raises for `before_filters` with `except` method as array
 ```ruby
 
 class MyController < ApplicationController
@@ -32,7 +131,8 @@ class MyController < ApplicationController
 end
 
 ```
-- raises for filters with many actions and only one `except` method
+
+![](https://placehold.it/15/f03c15/000000?text=+) raises for filters with many actions and only one `except` method
 ```ruby
 
 class MyController < ApplicationController
@@ -45,7 +145,8 @@ class MyController < ApplicationController
 end
 
 ```
-- ignores `before_filters` without arguments
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores `before_filters` without arguments
 ```ruby
 
 class MyController < ApplicationController
@@ -59,30 +160,36 @@ end
 ## Ducalis::KeywordDefaults
 
 Prefer to use keyword arguments for defaults. It increases readability and reduces ambiguities.
-- rejects if method definition contains default values
+
+![](https://placehold.it/15/f03c15/000000?text=+) raises if method definition contains default values
 ```ruby
 def some_method(a, b, c = 3); end
 ```
-- rejects if class method definition contains default values
+
+![](https://placehold.it/15/f03c15/000000?text=+) raises if class method definition contains default values
 ```ruby
 def self.some_method(a, b, c = 3); end
 ```
-- works if method definition contains default values through keywords
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores if method definition contains default values through keywords
 ```ruby
 def some_method(a, b, c: 3); end
 ```
-- works for methods without arguments
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores for methods without arguments
 ```ruby
 def some_method; end
 ```
-- works for class methods without arguments
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores for class methods without arguments
 ```ruby
 def self.some_method; end
 ```
 ## Ducalis::ModuleLikeClass
 
 Seems like it will be better to define initialize and pass %<args>s there instead of each method.
-- raise if class doesn't contain constructor but accept the same args
+
+![](https://placehold.it/15/f03c15/000000?text=+) raises if class doesn't contain constructor but accept the same args
 ```ruby
 
 class MyClass
@@ -107,7 +214,8 @@ class MyClass
 end
 
 ```
-- raise for class with only one public method with args
+
+![](https://placehold.it/15/f03c15/000000?text=+) raises for class with only one public method with args
 ```ruby
 
 class MyClass
@@ -123,7 +231,8 @@ class MyClass
 end
 
 ```
-- ignores classes with custom includes
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores classes with custom includes
 ```ruby
 
 class MyClass
@@ -135,7 +244,8 @@ class MyClass
 end
 
 ```
-- ignores classes with inheritance
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores classes with inheritance
 ```ruby
 
 class MyClass < AnotherClass
@@ -151,7 +261,8 @@ class MyClass < AnotherClass
 end
 
 ```
-- ignores classes with one method and initializer
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores classes with one method and initializer
 ```ruby
 
 class MyClass
@@ -169,7 +280,8 @@ end
 
 It's better to pass already preprocessed params hash to services. Or you can use
 `arcane` gem
-- raise if user pass `params` as argument from controller
+
+![](https://placehold.it/15/f03c15/000000?text=+) raises if user pass `params` as argument from controller
 ```ruby
 
 class MyController < ApplicationController
@@ -179,7 +291,8 @@ class MyController < ApplicationController
 end
 
 ```
-- raise if user pass `params` as any argument from controller
+
+![](https://placehold.it/15/f03c15/000000?text=+) raises if user pass `params` as any argument from controller
 ```ruby
 
 class MyController < ApplicationController
@@ -189,7 +302,8 @@ class MyController < ApplicationController
 end
 
 ```
-- raise if user pass `params` as keyword argument from controller
+
+![](https://placehold.it/15/f03c15/000000?text=+) raises if user pass `params` as keyword argument from controller
 ```ruby
 
 class MyController < ApplicationController
@@ -199,7 +313,8 @@ class MyController < ApplicationController
 end
 
 ```
-- ignores passing only one `params` field
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores passing only one `params` field
 ```ruby
 
 class MyController < ApplicationController
@@ -209,7 +324,8 @@ class MyController < ApplicationController
 end
 
 ```
-- ignores passing processed `params`
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores passing processed `params`
 ```ruby
 
 class MyController < ApplicationController
@@ -219,7 +335,8 @@ class MyController < ApplicationController
 end
 
 ```
-- ignores passing `params` from `arcane` gem
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores passing `params` from `arcane` gem
 ```ruby
 
 class MyController < ApplicationController
@@ -228,11 +345,117 @@ class MyController < ApplicationController
   end
 end
 
+```
+## Ducalis::PossibleTap
+
+Consider of using `.tap`, default ruby [method](<https://apidock.com/ruby/Object/tap>) which allows to replace intermediate variables with block, by this you are limiting scope pollution and make scope more clear. [Related article](<http://seejohncode.com/2012/01/02/ruby-tap-that/>).
+
+![](https://placehold.it/15/f03c15/000000?text=+) raises for methods with scope variable return
+```ruby
+
+def load_group
+  group = channel.groups.find(params[:group_id])
+  authorize group, :edit?
+  group
+end
+
+```
+
+![](https://placehold.it/15/f03c15/000000?text=+) raises for methods with instance variable changes and return
+```ruby
+
+def load_group
+  @group = Group.find(params[:id])
+  authorize @group
+  @group
+end
+
+```
+
+![](https://placehold.it/15/f03c15/000000?text=+) raises for methods with instance variable `||=` assign and return
+```ruby
+
+def define_roles
+  return [] unless employee
+
+  @roles ||= []
+  @roles << "primary"  if employee.primary?
+  @roles << "contract" if employee.contract?
+  @roles
+end
+
+```
+
+![](https://placehold.it/15/f03c15/000000?text=+) raises for methods which return call on scope variable
+```ruby
+
+def load_group
+  elections = @elections.group_by(&:code)
+  result = elections.map do |code, elections|
+    { code => statistic }
+  end
+  result << total_spend(@elections)
+  result.inject(:merge)
+end
+
+```
+
+![](https://placehold.it/15/f03c15/000000?text=+) raises for methods which return instance variable but have scope vars
+```ruby
+
+def generate_file(file_name)
+  @file = Tempfile.new([file_name, ".pdf"])
+  signed_pdf = some_new_stuff
+  @file.write(signed_pdf.to_pdf)
+  @file.close
+  @file
+end
+
+```
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores empty methods
+```ruby
+
+def edit
+end
+
+```
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores methods which body is just call
+```ruby
+
+def total_cost(cost_field)
+  Service.cost_sum(cost_field)
+end
+
+```
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores methods which return some statement
+```ruby
+
+  def stop_terminated_employee
+  if current_user && current_user.terminated?
+    sign_out current_user
+    redirect_to new_user_session_path
+  end
+end
+
+
+```
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores methods which simply returns instance var without changes
+```ruby
+
+def employee
+  @employee
+end
+
 ```
 ## Ducalis::PrivateInstanceAssign
 
 Please, don't assign instance variables in controller's private methods. It's make hard to understand what variables are available in views.
-- raises for assigning instance variables in controllers private methods
+
+![](https://placehold.it/15/f03c15/000000?text=+) raises for assigning instance variables in controllers private methods
 ```ruby
 
 class MyController < ApplicationController
@@ -244,7 +467,8 @@ class MyController < ApplicationController
 end
 
 ```
-- raises for memoization variables in controllers private methods
+
+![](https://placehold.it/15/f03c15/000000?text=+) raises for memoization variables in controllers private methods
 ```ruby
 
 class MyController < ApplicationController
@@ -256,7 +480,8 @@ class MyController < ApplicationController
 end
 
 ```
-- ignores memoization variables in controllers private methods with _
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores memoization variables in controllers private methods with _
 ```ruby
 
 class MyController < ApplicationController
@@ -268,7 +493,8 @@ class MyController < ApplicationController
 end
 
 ```
-- ignores assigning instance variables in controllers public methods
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores assigning instance variables in controllers public methods
 ```ruby
 
 class MyController < ApplicationController
@@ -295,30 +521,50 @@ current_group.employees.find(params[:id])
 # better then
 Employee.find(params[:id])
 ```
-- raise if somewhere AR search was called on not protected scope
+
+![](https://placehold.it/15/f03c15/000000?text=+) raises if somewhere AR search was called on not protected scope
 ```ruby
 Group.find(8)
 ```
-- raise if AR search was called even for chain of calls
+
+![](https://placehold.it/15/f03c15/000000?text=+) raises if AR search was called even for chain of calls
 ```ruby
 Group.includes(:some_relation).find(8)
 ```
-- works ignores where statements and still raises error
+
+![](https://placehold.it/15/f03c15/000000?text=+) ignores where statements and still raises error
 ```ruby
 Group.includes(:some_relation).where(name: "John").find(8)
+```
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores find method with passed block
+```ruby
+MAPPING.find { |x| x == 42 }
+```
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores find method with passed multiline block
+```ruby
+
+MAPPING.find do |x|
+  x == 42
+end
+
 ```
 ## Ducalis::RaiseWithourErrorClass
 
 It's better to add exception class as raise argument. It will make easier to catch and process it later.
-- raise when `raise` called without exception class
+
+![](https://placehold.it/15/f03c15/000000?text=+) raises when `raise` called without exception class
 ```ruby
 raise "Something went wrong"
 ```
-- works when `raise` called with exception class
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores when `raise` called with exception class
 ```ruby
 raise StandardError, "Something went wrong"
 ```
-- works when `raise` called with exception instance
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores when `raise` called with exception instance
 ```ruby
 raise StandardError.new("Something went wrong")
 ```
@@ -331,14 +577,16 @@ It will allow you to reuse this regex and provide instructions for others.
 CONST_NAME = %<constant>s # "%<example>s"
 %<fixed_string>s
 ```
-- raise if somewhere in code used regex which is not moved to const
+
+![](https://placehold.it/15/f03c15/000000?text=+) raises if somewhere in code used regex which is not moved to const
 ```ruby
 
 name = "john"
 puts "hi" if name =~ /john/
 
 ```
-- accepts matching constants
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores matching constants
 ```ruby
 
 REGEX = /john/
@@ -346,14 +594,16 @@ name = "john"
 puts "hi" if name =~ REGEX
 
 ```
-- ignores named ruby constants
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores named ruby constants
 ```ruby
 
 name = "john"
 puts "hi" if name =~ /[[:alpha:]]/
 
 ```
-- ignores dynamic regexs
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores dynamic regexs
 ```ruby
 
 name = "john"
@@ -364,7 +614,8 @@ puts "hi" if name =~ /.{#{name.length}}/
 
 It's better for controllers to stay adherent to REST:
 http://jeromedalbert.com/how-dhh-organizes-his-rails-controllers/
-- raise for controllers with non-REST methods
+
+![](https://placehold.it/15/f03c15/000000?text=+) raises for controllers with non-REST methods
 ```ruby
 
 class MyController < ApplicationController
@@ -373,7 +624,8 @@ class MyController < ApplicationController
 end
 
 ```
-- doesn't raise for controllers with private non-REST methods
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores controllers with private non-REST methods
 ```ruby
 
 class MyController < ApplicationController
@@ -383,7 +635,8 @@ class MyController < ApplicationController
 end
 
 ```
-- doesn't raise for controllers with only REST methods
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores controllers with only REST methods
 ```ruby
 
 class MyController < ApplicationController
@@ -397,7 +650,8 @@ class MyController < ApplicationController
 end
 
 ```
-- doesn't raise for non-controllers with non-REST methods
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores non-controllers with non-REST methods
 ```ruby
 
 class MyClass
@@ -411,14 +665,16 @@ end
 
 Please, do not suppress RuboCop metrics, may be you can introduce some refactoring or another concept.
     
-- raises on RuboCop disable comments
+
+![](https://placehold.it/15/f03c15/000000?text=+) raises on RuboCop disable comments
 ```ruby
 
 # rubocop:disable Metrics/ParameterLists
 def some_method(a, b, c, d, e, f); end
 
 ```
-- doesnt raise on comment without RuboCop disabling
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores comment without RuboCop disabling
 ```ruby
 
 # some meaningful comment
@@ -430,14 +686,16 @@ def some_method(a, b, c, d, e, f); end
 Please, do not use strings as arguments for %<method_name>s argument.
 It's hard to test, grep sources, code highlighting and so on.
 Consider using of symbols or lambdas for complex expressions.
-- raise for string if argument
+
+![](https://placehold.it/15/f03c15/000000?text=+) raises for string if argument
 ```ruby
 
 before_save :set_full_name, 
  if: 'name_changed? || postfix_name_changed?'
 
 ```
-- doesnt raise for lambda if argument
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores lambda if argument
 ```ruby
 validates :file, if: -> { remote_url.blank? }
 ```
@@ -445,7 +703,8 @@ validates :file, if: -> { remote_url.blank? }
 
 Please, add comment why are you including non-realized gem version for %<gem>s.
 It will increase [bus-factor](<https://en.wikipedia.org/wiki/Bus_factor>).
-- raise for gem from github without comment
+
+![](https://placehold.it/15/f03c15/000000?text=+) raises for gem from github without comment
 ```ruby
 
 gem 'a' 
@@ -453,7 +712,8 @@ gem 'b', '~> 1.3.1'
 gem 'c', git: 'https://github.com/c/c'
 
 ```
-- doesn't raise for gem from github with comment
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores for gem from github with comment
 ```ruby
 
 gem 'a' 
@@ -475,7 +735,8 @@ def index
   do_something
 end
 ```
-- raises for `before_filters` with only one method as array
+
+![](https://placehold.it/15/f03c15/000000?text=+) raises for `before_filters` with only one method as array
 ```ruby
 
 class MyController < ApplicationController
@@ -486,7 +747,8 @@ class MyController < ApplicationController
 end
 
 ```
-- raises for `before_filters` with only one method as keyword array
+
+![](https://placehold.it/15/f03c15/000000?text=+) raises for `before_filters` with only one method as keyword array
 ```ruby
 
 class MyController < ApplicationController
@@ -497,7 +759,8 @@ class MyController < ApplicationController
 end
 
 ```
-- raises for `before_filters` with many actions and only one method
+
+![](https://placehold.it/15/f03c15/000000?text=+) raises for `before_filters` with many actions and only one method
 ```ruby
 
 class MyController < ApplicationController
@@ -509,7 +772,8 @@ class MyController < ApplicationController
 end
 
 ```
-- raises for `before_filters` with only one method as argument
+
+![](https://placehold.it/15/f03c15/000000?text=+) raises for `before_filters` with only one method as argument
 ```ruby
 
 class MyController < ApplicationController
@@ -520,7 +784,8 @@ class MyController < ApplicationController
 end
 
 ```
-- ignores `before_filters` without arguments
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores `before_filters` without arguments
 ```ruby
 
 class MyController < ApplicationController
@@ -531,7 +796,8 @@ class MyController < ApplicationController
 end
 
 ```
-- ignores `before_filters` with `only` and many arguments
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores `before_filters` with `only` and many arguments
 ```ruby
 
 class MyController < ApplicationController
@@ -543,7 +809,8 @@ class MyController < ApplicationController
 end
 
 ```
-- ignores `before_filters` with `except` and one argument
+
+![](https://placehold.it/15/2cbe4e/000000?text=+) ignores `before_filters` with `except` and one argument
 ```ruby
 
 class MyController < ApplicationController

data/Gemfile

@@ -4,3 +4,9 @@ source 'https://rubygems.org'
 git_source(:github) { |repo| "https://github.com/#{repo}.git" }
 
 gemspec
+
+# Development dependencies
+gem 'bundler', '~> 1.16.a'
+gem 'pry', '~> 0.10', '>= 0.10.0'
+gem 'rake', '~> 12.1'
+gem 'rspec', '~> 3.0'

data/Gemfile.lock

@@ -1,11 +1,10 @@
 PATH
   remote: .
   specs:
-    ducalis (0.2.0)
+    ducalis (0.3.0)
       git (~> 1.3, >= 1.3.0)
       policial (= 0.0.4)
       regexp-examples (~> 1.3, >= 1.3.2)
-      rubocop (~> 0.50.0)
       thor (~> 0.20.0)
 
 GEM

data/README.md

@@ -2,8 +2,12 @@
 
 [![Gem Version](https://badge.fury.io/rb/ducalis.svg)](https://badge.fury.io/rb/ducalis)
 [![Build Status](https://travis-ci.org/ignat-z/ducalis.svg?branch=master)](https://travis-ci.org/ignat-z/ducalis)
+[![Code Climate](https://codeclimate.com/github/ignat-z/ducalis/badges/gpa.svg)](https://codeclimate.com/github/ignat-z/ducalis)
 
-__Ducalis__ is RuboCop based static code analyzer for enterprise Rails applications.
+__Ducalis__ is RuboCop-based static code analyzer for enterprise Rails applications.
+As __Ducalis__ isn't style checker and could sometimes be false-positive it's not
+necessary to follow all it rules, the main purpose of __Ducalis__ is help to find
+possible weak code parts.
 
 ## Installation
 
@@ -16,3 +20,41 @@ gem 'ducalis'
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Usage
+
+There are a lot of variants how you can use __Ducalis__:
+
+1. As CLI application. In this mode __Ducalis__ will notify you about any
+possible violations in CLI.
+```
+ducalis
+ducalis app/controllers/
+```
+As __Ducalis__ allows to pass build even with violations it's make sense to run
+__Ducalis__ across current branch or index:
+```
+ducalis --branch
+ducalis --index
+```
+
+2. As CLI application in CI mode: In this mode __Ducalis__ will notify you about
+any violations in your PR.
+```
+ducalis --ci --repo="author/repo" --id=3575 --dry
+ducalis --ci --repo="author/repo" --id=3575
+ducalis --ci --adapter=circle # mode for running on CircleCI
+```
+`--dry` option declares that output will be printed in console, if you will run
+without this option __Ducalis__ will notify about violations in your PR.
+_N.B._ You should provide GITHUB_TOKEN Env to allow __Ducalis__ download your PR
+code and write review comments.
+
+3. As stand-alone server mode: In this mode __Ducalis__ will work as server,
+listen webhooks from GitHub, and notify about any violations in PR. There is a
+`Dockerfile` which you could use to run server for this or run it manually like
+rack application. All related files are located in the `client/` directory.
+
+In CLI modes you can provide yours `.ducalis.yml` file based on
+[default](https://github.com/ignat-z/ducalis/blob/master/config/.ducalis.yml) by
+`-c` flag or simply putting it in your project directory.

data/config/.ducalis.yml

@@ -5,9 +5,15 @@ AllCops:
     - 'node_modules/**/*'
     - 'vendor/bundle/**/*'
 
+Ducalis/CaseMapping:
+  Enabled: true
+
 Ducalis/CallbacksActiverecord:
   Enabled: true
 
+Ducalis/PossibleTap:
+  Enabled: true
+
 Ducalis/ProtectedScopeCop:
   Enabled: true
 
@@ -39,6 +45,8 @@ Ducalis/UncommentedGem:
 
 Ducalis/ParamsPassing:
   Enabled: true
+  Exclude:
+    - 'spec/**/*.rb'
 
 Ducalis/ControllersExcept:
   Enabled: true

data/ducalis.gemspec

@@ -29,13 +29,7 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
 
   spec.add_dependency 'policial', '0.0.4'
-  spec.add_dependency 'rubocop', '~> 0.50.0'
   spec.add_dependency 'regexp-examples', '~> 1.3', '>= 1.3.2'
   spec.add_dependency 'thor', '~> 0.20.0'
   spec.add_dependency 'git', '~> 1.3', '>= 1.3.0'
-
-  spec.add_development_dependency 'bundler', '~> 1.16.a'
-  spec.add_development_dependency 'rake', '~> 12.1'
-  spec.add_development_dependency 'rspec', '~> 3.0'
-  spec.add_development_dependency 'pry', '~> 0.10', '>= 0.10.0'
 end

data/lib/ducalis.rb

@@ -32,10 +32,12 @@ require 'ducalis/patched_rubocop/git_turget_finder'
 require 'ducalis/patched_rubocop/rubo_cop'
 
 require 'ducalis/cops/callbacks_activerecord'
+require 'ducalis/cops/case_mapping'
 require 'ducalis/cops/controllers_except'
 require 'ducalis/cops/keyword_defaults'
 require 'ducalis/cops/module_like_class'
 require 'ducalis/cops/params_passing'
+require 'ducalis/cops/possible_tap'
 require 'ducalis/cops/private_instance_assign'
 require 'ducalis/cops/protected_scope_cop'
 require 'ducalis/cops/raise_withour_error_class'

data/lib/ducalis/commentators/github.rb

@@ -4,6 +4,7 @@ module Ducalis
   module Commentators
     class Github
       STATUS = 'COMMENT'
+      SIMILARITY_THRESHOLD = 0.8
 
       def initialize(config)
         @config = config
@@ -26,13 +27,16 @@ module Ducalis
           [
             violation.filename == commented_violation[:path],
             violation.line.patch_position == commented_violation[:position],
-            Utils.similarity(
-              violation.message, commented_violation[:body]
-            ) > 0.9
+            similar_messages?(violation.message, commented_violation[:body])
           ].all?
         end
       end
 
+      def similar_messages?(message, body)
+        body.include?(message) ||
+          Utils.similarity(message, body) > SIMILARITY_THRESHOLD
+      end
+
       def commented_violations
         @commented_violations ||=
           Utils.octokit.pull_request_comments(@config.repo, @config.id)

data/lib/ducalis/cops/case_mapping.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module Ducalis
+  class CaseMapping < RuboCop::Cop::Cop
+    OFFENSE = %(
+Try to avoid `case when` statements. You can replace it with a sequence of
+`if... elsif... elsif... else`. For cases where you need to choose from a
+large number of possibilities, you can create a dictionary mapping case values
+to functions to call by `call`. It's nice to have prefix for the method
+names, i.e.: `visit_`.
+
+<details>
+Usually `case when` statements are using for the next reasons:
+
+I. Mapping between different values.
+("A" => 1, "B" => 2, ...)
+
+This case is all about data representing. If you do not need to execute any code
+it's better to use data structure which represents it. This way you are
+separating concepts: code returns corresponding value and you have config-like
+data structure which describes your data.
+
+```ruby
+  %w[A B ...].index("A") + 1
+  # or
+  { "A" => 1, "B" => 2 }.fetch("A")
+```
+
+II. Code execution depending of parameter or type:
+
+  - a. (:attack => attack, :defend => defend)
+  - b. (Feet => value * 0.348, Meters => `value`)
+
+In this case code violates OOP and S[O]LID principle. Code shouldn't know about
+object type and classes should be open for extension, but closed for
+modification (but you can't do it with case-statements).
+This is a signal that you have some problems with architecture.
+
+  a.
+```ruby
+attack: -> { execute_attack }, defend: -> { execute_defend }
+#{(action = '#{' + 'action' + '}') && '# or'}
+call(:"execute_#{action}")
+```
+
+  b.
+```ruby
+class Meters; def to_metters; value;         end
+class Feet;   def to_metters; value * 0.348; end
+```
+
+III. Code execution depending on some statement.
+(`a > 0` => 1, `a == 0` => 0, `a < 0` => -1)
+
+This case is combination of I and II -- high code complexity and unit-tests
+complexity. There are variants how to solve it:
+
+  a. Rewrite to simple if statement
+
+```ruby
+return 0 if a == 0
+a > 0 ? 1 : -1
+```
+
+  b. Move statements to lambdas:
+
+```ruby
+ ->(a) { a > 0 }  =>  1,
+ ->(a) { a == 0 } =>  0,
+ ->(a) { a < 0 }  => -1
+```
+
+This way decreases code complexity by delegating it to lambdas and makes it easy
+ to unit-testing because it's easy to test pure lambdas.
+
+Such approach is named
+[table-driven design](<https://www.d.umn.edu/~gshute/softeng/table-driven.html>)
+. Table-driven methods are schemes that allow you to look up information in a
+table rather than using logic statements (i.e. case, if). In simple cases,
+it's quicker and easier to use logic statements, but as the logic chain becomes
+more complex, table-driven code is simpler than complicated logic, easier to
+modify and more efficient.
+</details>
+    ).strip
+
+    def on_case(node)
+      add_offense(node, :expression, OFFENSE)
+    end
+  end
+end

data/lib/ducalis/cops/possible_tap.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module Ducalis
+  class PossibleTap < RuboCop::Cop::Cop
+    include RuboCop::Cop::DefNode
+
+    OFFENSE = %(
+Consider of using `.tap`, default ruby \
+[method](<https://apidock.com/ruby/Object/tap>) which allows to replace \
+intermediate variables with block, by this you are limiting scope pollution \
+and make scope more clear. \
+[Related article](<http://seejohncode.com/2012/01/02/ruby-tap-that/>).
+    ).strip
+
+    PAIRS = {
+      lvar: :lvasgn,
+      ivar: :ivasgn
+    }.freeze
+    ASSIGNS = PAIRS.keys
+
+    def on_def(node)
+      _name, _args, body = *node
+      return if body.nil?
+      return unless (possibe_var = return_var?(body) || return_var_call?(body))
+      return unless (assign_node = find_assign(body, possibe_var))
+      add_offense(assign_node, :expression, OFFENSE)
+    end
+
+    private
+
+    def unwrap_asign(node)
+      node.type == :or_asgn ? node.children.first : node
+    end
+
+    def find_assign(body, var_node)
+      subnodes(body).find do |subnode|
+        unwrap_asign(subnode).type == PAIRS[var_node.type] &&
+          unwrap_asign(subnode).to_a.first == var_node.to_a.first
+      end
+    end
+
+    def return_var?(body)
+      return unless body.children.last.respond_to?(:type)
+      return unless ASSIGNS.include?(body.children.last.type)
+      body.children.last
+    end
+
+    def return_var_call?(body)
+      return unless body.children.last.respond_to?(:children)
+      subnodes(body.children.last).find { |node| ASSIGNS.include?(node.type) }
+    end
+
+    def subnodes(node)
+      node.children.select { |child| child.respond_to?(:type) }
+    end
+  end
+end

data/lib/ducalis/cops/protected_scope_cop.rb

@@ -17,8 +17,9 @@ Employee.find(params[:id])
     }.strip
 
     def on_send(node)
-      _, method_name, = *node
+      _, method_name, *args = *node
       return unless method_name == :find
+      return if args.empty?
       return unless children(node).any? { |subnode| subnode.type == :const }
       add_offense(node, :expression, OFFENSE)
     end

data/lib/ducalis/documentation.rb

@@ -69,12 +69,20 @@ class Documentation
     ] +
       specs.map do |(it, code)|
         [
-          "- #{it}",                                      # case description
-          "```ruby\n#{code.join("\n")}\n```"              # code example
+          "\n#{color(it)} #{it}",                       # case description
+          "```ruby\n#{code.join("\n")}\n```"            # code example
         ]
       end
   end
 
+  def color(it)
+    if it.include?('raises')
+      '![](https://placehold.it/15/f03c15/000000?text=+)'
+    else
+      '![](https://placehold.it/15/2cbe4e/000000?text=+)'
+    end
+  end
+
   def spec_cases_for(f)
     source_code = File.read(
       f.sub('/lib/ducalis/', '/spec/')

data/lib/ducalis/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ducalis
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ducalis
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Ignat Zakrevsky
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-07 00:00:00.000000000 Z
+date: 2017-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: policial
@@ -24,20 +24,6 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 0.0.4
-- !ruby/object:Gem::Dependency
-  name: rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.50.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.50.0
 - !ruby/object:Gem::Dependency
   name: regexp-examples
   requirement: !ruby/object:Gem::Requirement
@@ -92,68 +78,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.3.0
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.16.a
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.16.a
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '12.1'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '12.1'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: pry
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.10'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.10.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.10'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.10.0
 description: "    Ducalis is RuboCop based static code analyzer for enterprise Rails
   \    applications.\n"
 email:
@@ -163,6 +87,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".codeclimate.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
@@ -186,10 +111,12 @@ files:
 - lib/ducalis/commentators/console.rb
 - lib/ducalis/commentators/github.rb
 - lib/ducalis/cops/callbacks_activerecord.rb
+- lib/ducalis/cops/case_mapping.rb
 - lib/ducalis/cops/controllers_except.rb
 - lib/ducalis/cops/keyword_defaults.rb
 - lib/ducalis/cops/module_like_class.rb
 - lib/ducalis/cops/params_passing.rb
+- lib/ducalis/cops/possible_tap.rb
 - lib/ducalis/cops/private_instance_assign.rb
 - lib/ducalis/cops/protected_scope_cop.rb
 - lib/ducalis/cops/raise_withour_error_class.rb