ducalis 0.1.0

data/lib/ducalis/adapters/circle_ci.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Ducalis
+  module Adapters
+    class CircleCi < Base
+      def repo
+        @repo ||= ENV.fetch('CIRCLE_REPOSITORY_URL')
+                     .sub('https://github.com/', '')
+      end
+
+      def id
+        @id ||= ENV.fetch('CI_PULL_REQUEST')
+                   .sub("#{ENV.fetch('CIRCLE_REPOSITORY_URL')}/pull/", '')
+      end
+
+      def sha
+        @sha ||= ENV.fetch('CIRCLE_SHA1')
+      end
+    end
+  end
+end

data/lib/ducalis/adapters/custom.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Ducalis
+  module Adapters
+    class Custom < Base
+      def repo
+        @repo ||= options.fetch(:repo)
+      end
+
+      def id
+        @id ||= options.fetch(:id)
+      end
+
+      def sha
+        @sha ||= options.fetch(:sha) do
+          Utils.octokit.pull_request(repo, id).head.sha
+        end
+      end
+    end
+  end
+end

data/lib/ducalis/adapters/pull_request.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Ducalis
+  module Adapters
+    class PullRequest < Base
+      def repo
+        @repo ||= attributes[:repo]
+      end
+
+      def id
+        @id ||= attributes[:number]
+      end
+
+      def sha
+        @sha ||= attributes[:head_sha]
+      end
+
+      private
+
+      def attributes
+        @attributes ||= Policial::PullRequestEvent.new(options)
+                                                  .pull_request_attributes
+      end
+    end
+  end
+end

data/lib/ducalis/cli.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'thor'
+
+module Ducalis
+  class CLI < Thor
+    ADAPTERS = {
+      circle: Adapters::CircleCi,
+      custom: Adapters::Custom
+    }.freeze
+    DEFAULT_ADAPTER = ADAPTERS.keys.last
+    default_task :start
+
+    desc '--ci', ''
+    option :adapter, required: true, default: DEFAULT_ADAPTER,
+                     desc: 'Describes how Ducalis will receive PR information'
+    option :id,   type: :numeric, desc: 'PR id, ex: 2347'
+    option :repo, type: :string,  desc: 'PR repository, ex: author/repo'
+    option :sha,  type: :string,  desc: 'Starting commit, can be skipped'
+    option :dry,  type: :boolean, default: false,
+                  desc: 'Allows user run dry mode, default: false'
+    def start
+      adapter = ADAPTERS.fetch(options[:adapter].to_sym) do
+        raise "Unsupported adapter #{options[:adapter]}"
+      end
+      Runner.new(adapter.new(options)).call
+    end
+
+    desc '--ci help', 'Describe available commands'
+    def help(command = nil, subcommand = false)
+      command ||= :start
+      super
+    end
+  end
+end

data/lib/ducalis/commentators/console.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Ducalis
+  module Commentators
+    class Console
+      DOCUMENTATION_PATH = 'https://github.com/ignat-zakrevsky/ducalis/blob/master/DOCUMENTATION.md'
+
+      def initialize(config)
+        @config = config
+      end
+
+      def call(violations)
+        violations.each do |violation|
+          logger.info(generate_message(violation))
+        end
+      end
+
+      private
+
+      def generate_message(violation)
+        [
+          [cyan(violation.filename), violation.line.patch_position].join(':'),
+          brown(violation.linter),
+          bold(ancor(violation))
+        ].join(' ')
+      end
+
+      def logger
+        @logger ||= Logger.new(STDOUT).tap do |logger|
+          logger.formatter = proc do |_severity, _datetime, _progname, msg|
+            "#{msg}\n"
+          end
+        end
+      end
+
+      def ancor(violation)
+        [
+          DOCUMENTATION_PATH,
+          '#',
+          violation.linter.downcase.gsub(/[^[:alpha:]]/, '')
+        ].join
+      end
+
+      def bold(text)
+        "\e[1m#{text}\e[22m"
+      end
+
+      def brown(text)
+        "\e[33m#{text}\e[0m"
+      end
+
+      def cyan(text)
+        "\e[36m#{text}\e[0m"
+      end
+    end
+  end
+end

data/lib/ducalis/commentators/github.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Ducalis
+  module Commentators
+    class Github
+      STATUS = 'COMMENT'
+
+      def initialize(config)
+        @config = config
+      end
+
+      def call(violations)
+        comments = violations.map do |violation|
+          next if commented?(violation)
+          generate_comment(violation)
+        end.compact
+        Utils.octokit
+             .create_pull_request_review(@config.repo, @config.id,
+                                         event: STATUS, comments: comments)
+      end
+
+      private
+
+      def commented?(violation)
+        commented_violations.find do |commented_violation|
+          [
+            violation.filename == commented_violation[:path],
+            violation.line.patch_position == commented_violation[:position],
+            Utils.similarity(
+              violation.message, commented_violation[:body]
+            ) > 0.9
+          ].all?
+        end
+      end
+
+      def commented_violations
+        @commented_violations ||=
+          Utils.octokit.pull_request_comments(@config.repo, @config.id)
+      end
+
+      def generate_comment(violation)
+        {
+          body: violation.message,
+          path: violation.filename,
+          position: violation.line.patch_position
+        }
+      end
+    end
+  end
+end

data/lib/ducalis/cops/callbacks_activerecord.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module Ducalis
+  class CallbacksActiverecord < RuboCop::Cop::Cop
+    OFFENSE = "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).'
+    MODELS_CLASS_NAMES = ['ApplicationRecord', 'ActiveRecord::Base'].freeze
+    METHODS_BLACK_LIST = %i[
+      after_commit
+      after_create
+      after_destroy
+      after_rollback
+      after_save
+      after_update
+      after_validation
+      around_create
+      around_destroy
+      around_save
+      around_update
+      before_create
+      before_destroy
+      before_save
+      before_update
+      before_validation
+    ].freeze
+
+    def on_class(node)
+      _classdef_node, superclass, _body = *node
+      @triggered = superclass &&
+                   MODELS_CLASS_NAMES.include?(superclass.loc.expression.source)
+    end
+
+    def on_send(node)
+      return unless @triggered
+      return unless METHODS_BLACK_LIST.include?(node.method_name)
+      add_offense(node, :selector, OFFENSE)
+    end
+
+    private
+
+    attr_reader :triggered
+  end
+end

data/lib/ducalis/cops/controllers_except.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module Ducalis
+  class ControllersExcept < ::RuboCop::Cop::Cop
+    include RuboCop::Cop::DefNode
+    FILTERS = %i[before_filter after_filter around_filter
+                 before_action after_action around_action].freeze
+    OFFENSE = %(
+Prefer to use `:only` over `:except` in controllers because it's more explicit \
+and will be easier to maintain for new developers.
+    ).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, :except)
+      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/cops/keyword_defaults.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module Ducalis
+  class KeywordDefaults < RuboCop::Cop::Cop
+    include RuboCop::Cop::DefNode
+    OFFENSE = %(
+Prefer to use keyword arguments for defaults. \
+It increases readability and reduces ambiguities.
+    ).strip
+
+    def on_def(node)
+      args = node.type == :defs ? node.to_a[2] : node.to_a[1]
+      return unless args
+      args.children.each do |arg_node|
+        next unless arg_node.type == :optarg
+        add_offense(node, :expression, OFFENSE)
+      end
+    end
+    alias on_defs on_def
+  end
+end

data/lib/ducalis/cops/module_like_class.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module Ducalis
+  class ModuleLikeClass < RuboCop::Cop::Cop
+    include RuboCop::Cop::DefNode
+
+    OFFENSE = %(
+Seems like it will be better to define initialize and pass %<args>s there \
+instead of each method.
+    ).strip
+
+    def on_class(node)
+      _name, inheritance, body = *node
+      return if !inheritance.nil? || body.nil? || allowed_include?(body)
+      matched = matched_args(body)
+      return if matched.empty?
+      add_offense(node, :expression,
+                  format(OFFENSE, args:
+                      matched.map { |arg| "`#{arg}`" }.join(', ')))
+    end
+
+    private
+
+    def allowed_include?(body)
+      return if cop_config['AllowedIncludes'].to_a.empty?
+      (all_includes(body) & cop_config['AllowedIncludes']).any?
+    end
+
+    def matched_args(body)
+      methods_defintions = children(body).select(&public_method_definition?)
+      return [] if methods_defintions.count == 1 && with_initialize?(body)
+      methods_defintions.map(&method_args).inject(&:&).to_a
+    end
+
+    def children(body)
+      (body.type != :begin ? s(:begin, body) : body).children
+    end
+
+    def all_includes(body)
+      children(body).select(&method(:include_node?))
+                    .map(&:to_a)
+                    .map { |_, _, node| node.loc.expression.source }
+                    .to_a
+    end
+
+    def public_method_definition?
+      ->(node) { node.type == :def && !non_public?(node) && !initialize?(node) }
+    end
+
+    def method_args
+      lambda do |n|
+        _name, args = *n
+        args.children
+            .select { |node| node.type == :arg }
+            .map    { |node| node.loc.expression.source }
+      end
+    end
+
+    def with_initialize?(body)
+      children(body).find(&method(:initialize?))
+    end
+
+    def_node_search :include_node?, '(send _ :include (...))'
+    def_node_search :initialize?, '(def :initialize ...)'
+  end
+end

data/lib/ducalis/cops/params_passing.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module Ducalis
+  class ParamsPassing < RuboCop::Cop::Cop
+    include RuboCop::Cop::DefNode
+    PARAMS_CALL = s(:send, nil, :params)
+    OFFENSE = %(
+It's better to pass already preprocessed params hash to services. Or you can use
+`arcane` gem
+    ).strip
+
+    def on_send(node)
+      _who, _what, *args = *node
+      node = inspect_args(args)
+      add_offense(node, :expression, OFFENSE) if node
+    end
+
+    private
+
+    def inspect_args(args)
+      return if Array(args).empty?
+      args.find { |arg| arg == PARAMS_CALL }.tap do |node|
+        return node if node
+      end
+      inspect_hash(args.find { |arg| arg.type == :hash })
+    end
+
+    def inspect_hash(args)
+      return if args.nil?
+      args.children.find { |arg| arg.to_a[1] == PARAMS_CALL }
+    end
+  end
+end

data/lib/ducalis/cops/private_instance_assign.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module Ducalis
+  class PrivateInstanceAssign < RuboCop::Cop::Cop
+    include RuboCop::Cop::DefNode
+
+    OFFENSE = %(
+Please, don't assign instance variables in controller's private methods. It's \
+make hard to understand what variables are available in views.
+).strip
+    ADD_OFFENSE = %(
+If you want to memoize variable, please, add underscore to the variable name \
+start: `@_name`.
+).strip
+    def on_class(node)
+      _classdef_node, superclass, _body = *node
+      return if superclass.nil?
+      @triggered = superclass.loc.expression.source =~ /Controller/
+    end
+
+    def on_ivasgn(node)
+      return unless triggered
+      return unless non_public?(node)
+      return check_memo(node) if node.parent.type == :or_asgn
+      add_offense(node, :expression, OFFENSE)
+    end
+
+    private
+
+    def check_memo(node)
+      return if node.to_a.first.to_s.start_with?('@_')
+      add_offense(node, :expression, OFFENSE + ADD_OFFENSE)
+    end
+
+    attr_reader :triggered
+  end
+end