ducalis 0.1.0

data/lib/ducalis/cops/protected_scope_cop.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module Ducalis
+  class ProtectedScopeCop < RuboCop::Cop::Cop
+    OFFENSE = %{
+Seems like you are using `find` on non-protected scope. Potentially it could
+lead to unauthorized access. It's better to call `find` on authorized resources
+scopes. Example:
+
+```ruby
+current_group.employees.find(params[:id])
+# better then
+Employee.find(params[:id])
+```
+    }.strip
+
+    def on_send(node)
+      _, method_name, = *node
+      return unless method_name == :find
+      return unless children(node).any? { |subnode| subnode.type == :const }
+      add_offense(node, :expression, OFFENSE)
+    end
+
+    private
+
+    def children(node)
+      current_nodes = [node]
+      while current_nodes.any? { |subnode| subnode.child_nodes.count != 0 }
+        current_nodes = current_nodes.flat_map do |subnode|
+          subnode.child_nodes.count.zero? ? subnode : subnode.child_nodes
+        end
+      end
+      current_nodes
+    end
+  end
+end

data/lib/ducalis/cops/raise_withour_error_class.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module Ducalis
+  class RaiseWithourErrorClass < RuboCop::Cop::Cop
+    include RuboCop::Cop::DefNode
+    OFFENSE = %(
+It's better to add exception class as raise argument. It will make easier to \
+catch and process it later.
+    ).strip
+
+    def on_send(node)
+      _who, what, *args = *node
+      return if what != :raise
+      return if args.first.type != :str
+      add_offense(node, :expression, OFFENSE)
+    end
+  end
+end

data/lib/ducalis/cops/regex_cop.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+require 'regexp-examples'
+
+module Ducalis
+  class RegexCop < RuboCop::Cop::Cop
+    OFFENSE = %(
+It's better to move regex to constants with example instead of direct using it.
+It will allow you to reuse this regex and provide instructions for others.
+
+```ruby
+CONST_NAME = %<constant>s # "%<example>s"
+%<fixed_string>s
+```
+    ).strip
+    SELF_DESCRIPTIVE = %w(
+      /[[:alnum:]]/
+      /[[:alpha:]]/
+      /[[:blank:]]/
+      /[[:cntrl:]]/
+      /[[:digit:]]/
+      /[[:graph:]]/
+      /[[:lower:]]/
+      /[[:print:]]/
+      /[[:punct:]]/
+      /[[:space:]]/
+      /[[:upper:]]/
+      /[[:xdigit:]]/
+      /[[:word:]]/
+      /[[:ascii:]]/
+    ).freeze
+
+    def on_regexp(node)
+      return if node.parent.type == :casgn
+      return if SELF_DESCRIPTIVE.include?(node.source)
+      return if node.child_nodes.any? { |child_node| child_node.type == :begin }
+      add_offense(node, :expression, format(OFFENSE, present_node(node)))
+    end
+
+    private
+
+    def present_node(node)
+      {
+        constant: node.source,
+        fixed_string: node.source_range.source_line
+                          .sub(node.source, 'CONST_NAME').lstrip,
+        example: Regexp.new(node.to_a.first.to_a.first).examples.sample
+      }
+    end
+  end
+end

data/lib/ducalis/cops/rest_only_cop.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module Ducalis
+  class RestOnlyCop < RuboCop::Cop::Cop
+    include RuboCop::Cop::DefNode
+    WHITELIST = %i[index show new edit create update destroy].freeze
+    OFFENSE = %(
+It's better for controllers to stay adherent to REST:
+http://jeromedalbert.com/how-dhh-organizes-his-rails-controllers/
+    ).strip
+
+    def on_class(node)
+      _classdef_node, superclass, _body = *node
+      return if superclass.nil?
+      @triggered = superclass.loc.expression.source =~ /Controller/
+    end
+
+    def on_def(node)
+      return unless triggered
+      return if non_public?(node)
+      method_name, = *node
+      return if WHITELIST.include?(method_name)
+      add_offense(node, :expression, OFFENSE)
+    end
+    alias on_defs on_def
+
+    private
+
+    attr_reader :triggered
+  end
+end

data/lib/ducalis/cops/rubocop_disable.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module Ducalis
+  class RubocopDisable < RuboCop::Cop::Cop
+    OFFENSE = %(
+Please, do not suppress RuboCop metrics, may be you can introduce some \
+refactoring or another concept.
+    )
+    def investigate(processed_source)
+      return unless processed_source.ast
+      processed_source.comments.each do |comment_node|
+        next unless comment_node.loc.expression.source.match?(/rubocop:disable/)
+        add_offense(comment_node, :expression, OFFENSE)
+      end
+    end
+  end
+end

data/lib/ducalis/cops/strings_in_activerecords.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+require_relative './callbacks_activerecord'
+
+module Ducalis
+  class StringsInActiverecords < ::RuboCop::Cop::Cop
+    OFFENSE = %(
+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.
+    ).strip
+    VALIDATEBLE_METHODS =
+      ::Ducalis::CallbacksActiverecord::METHODS_BLACK_LIST + %i[
+        validates
+        validate
+      ]
+
+    def on_send(node)
+      _, method_name, *args = *node
+      return unless VALIDATEBLE_METHODS.include?(method_name)
+      return if args.empty?
+      node.to_a.last.each_child_node do |current_node|
+        next if skip_node?(current_node)
+        add_offense(node, :selector, format(OFFENSE, method_name: method_name))
+      end
+    end
+
+    private
+
+    def skip_node?(current_node)
+      key, value = *current_node
+      return true unless current_node.type == :pair
+      return true unless %w[if unless].include?(key.source)
+      return true unless value.type == :str
+      false
+    end
+  end
+end

data/lib/ducalis/cops/uncommented_gem.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module Ducalis
+  class UncommentedGem < ::RuboCop::Cop::Cop
+    OFFENSE = %(
+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>).
+    ).strip
+
+    def investigate(processed_source)
+      return unless processed_source.ast
+      gem_declarations(processed_source.ast).select do |node|
+        _, _, gemname, args = *node
+        next if args.nil? || args.type == :str
+        next if commented?(processed_source, node)
+        add_offense(node, :selector,
+                    format(OFFENSE, gem: gemname.loc.expression.source))
+      end
+    end
+
+    private
+
+    def_node_search :gem_declarations, '(send nil :gem str ...)'
+
+    def commented?(processed_source, node)
+      processed_source.comments
+                      .map { |subnode| subnode.loc.line }
+                      .include?(node.loc.line)
+    end
+  end
+end

data/lib/ducalis/cops/useless_only.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module Ducalis
+  class UselessOnly < RuboCop::Cop::Cop
+    include RuboCop::Cop::DefNode
+    FILTERS = %i[before_filter after_filter around_filter
+                 before_action after_action around_action].freeze
+    OFFENSE = %(
+Seems like there is no any reason to keep before filter only for one action. \
+Maybe it will be better to inline it?
+
+```ruby
+before_filter :do_something, only: %i[index]
+def index; end
+
+# to
+
+def index
+  do_something
+end
+```
+    ).strip
+
+    def on_class(node)
+      _classdef_node, superclass, _body = *node
+      return if superclass.nil?
+      @triggered = superclass.loc.expression.source =~ /Controller/
+    end
+
+    def on_send(node)
+      _, method_name, *args = *node
+      hash_node = args.find { |subnode| subnode.type == :hash }
+      return unless FILTERS.include?(method_name) && hash_node
+      type, method_names = decomposite_hash(hash_node)
+      return unless type == s(:sym, :only)
+      return unless method_names.children.count == 1
+      add_offense(node, :selector, OFFENSE)
+    end
+
+    private
+
+    def decomposite_hash(args)
+      args.to_a.first.children.to_a
+    end
+
+    attr_reader :triggered
+  end
+end

data/lib/ducalis/documentation.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'parser/current'
+
+class SpecsProcessor < Parser::AST::Processor
+  attr_reader :cases
+
+  LINE_BEGIN_OPEN_SQUARE_BRACKET = /\A\[/  # "/[/1, 2, 3]\n"
+  CLOSE_SQUARE_BRACKET_END_LINE = /\]\z/   # "[1, 2, 3/]\n/"
+  LINE_BEGIN_QUOTE = /\A[\'|\"]/           # "/'/idddqd',"
+  QUOTE_COMMA_END_LINE = /[\'|\"]\,?\z/    # "'iddqd/',/"
+
+  def initialize(*)
+    super
+    @cases = []
+    @nesting = []
+  end
+
+  def process(node)
+    @nesting.push(node)
+    super
+    @nesting.pop
+  end
+
+  def on_send(node)
+    _, name, _body = *node
+    if name == :inspect_source
+      source_code = remove_array_wrapping(node.to_a.last.loc.expression.source)
+                    .split("\n")
+                    .map { |line| remove_string_wrapping(line) }
+      cases << [current_it, source_code]
+    end
+    super
+  end
+
+  private
+
+  def current_it
+    it_block = @nesting.reverse.find { |node| node.type == :block }
+    it = it_block.to_a.first
+    _, _, message_node = *it
+    message_node.to_a.first
+  end
+
+  def remove_array_wrapping(source)
+    source.sub(LINE_BEGIN_OPEN_SQUARE_BRACKET, '')
+          .sub(CLOSE_SQUARE_BRACKET_END_LINE, '')
+  end
+
+  def remove_string_wrapping(line)
+    line.strip.sub(LINE_BEGIN_QUOTE, '')
+        .sub(QUOTE_COMMA_END_LINE, '')
+  end
+end
+
+class Documentation
+  def call
+    Dir['./lib/ducalis/cops/*.rb'].map do |f|
+      present_cop(klass_const_for(f), spec_cases_for(f))
+    end.flatten.join("\n")
+  end
+
+  private
+
+  def present_cop(klass, specs)
+    [
+      "## #{klass}\n",                                  # header
+      klass.const_get(:OFFENSE)                         # description
+    ] +
+      specs.map do |(it, code)|
+        [
+          "- #{it}",                                      # case description
+          "```ruby\n#{code.join("\n")}\n```"              # code example
+        ]
+      end
+  end
+
+  def spec_cases_for(f)
+    source_code = File.read(
+      f.sub('/lib/ducalis/', '/spec/')
+       .sub(/.rb$/, '_spec.rb')
+    )
+    SpecsProcessor.new.tap do |processor|
+      processor.process(Parser::CurrentRuby.parse(source_code))
+    end.cases
+  end
+
+  def klass_const_for(f)
+    require f
+    Ducalis.const_get(camelize(File.basename(f).sub(/.rb$/, '')))
+  end
+
+  def camelize(snake_case_word)
+    snake_case_word.sub(/^[a-z\d]*/, &:capitalize).tap do |string|
+      string.gsub!(%r{(?:_|(/))([a-z\d]*)}i) do
+        "#{Regexp.last_match(1)}#{Regexp.last_match(2).capitalize}"
+      end
+      string.gsub!('/', '::')
+    end
+  end
+end

data/lib/ducalis/passed_args.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Ducalis
+  module PassedArgs
+    module_function
+
+    def help_command?
+      ARGV.any? { |arg| Thor::HELP_MAPPINGS.include?(arg) }
+    end
+
+    def ci_mode?
+      ARGV.any? { |arg| arg == '--ci' }
+    end
+
+    def process_args!
+      flag = PatchedRubocop::MODES.keys
+                                  .map { |key| key if ARGV.delete("--#{key}") }
+                                  .find { |possible_flag| !possible_flag.nil? }
+      PatchedRubocop.configure!(flag || :all)
+    end
+  end
+end

data/lib/ducalis/patched_rubocop/diffs.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module PatchedRubocop
+  module Diffs
+    class BaseDiff
+      attr_reader :full_path, :diff
+
+      def initialize(full_path, diff)
+        @full_path = full_path
+        @diff = diff
+      end
+    end
+
+    class NilDiff < BaseDiff
+      def changed?(*)
+        true
+      end
+    end
+
+    class GitDiff < BaseDiff
+      def changed?(changed_line)
+        (Policial::Patch.new(diff.patch).changed_lines.detect do |line|
+          line.number == changed_line
+        end || Policial::UnchangedLine.new).changed?
+      end
+    end
+
+    private_constant :BaseDiff, :NilDiff, :GitDiff
+  end
+end