dirwatch 0.0.7 → 0.0.8

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.46.0/lib/rubocop/cop/rails/dynamic_find_by.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks dynamic `find_by_*` methods.
+      # Use `find_by` instead of dynamic method.
+      # See. https://github.com/bbatsov/rails-style-guide#find_by
+      #
+      # @example
+      #   # bad
+      #   User.find_by_name(name)
+      #
+      #   # bad
+      #   User.find_by_name_and_email(name)
+      #
+      #   # bad
+      #   User.find_by_email!(name)
+      #
+      #   # good
+      #   User.find_by(name: name)
+      #
+      #   # good
+      #   User.find_by(name: name, email: email)
+      #
+      #   # good
+      #   User.find_by!(email: email)
+      class DynamicFindBy < Cop
+        MSG = 'Use `%s` instead of dynamic `%s`.'.freeze
+        METHOD_PATTERN = /^find_by_(.+?)(!)?$/
+
+        def on_send(node)
+          _receiver, method, _args = *node
+          method_name = method.to_s
+          return if whitelist.include?(method_name)
+          static_name = static_method_name(method_name)
+          return unless static_name
+
+          add_offense(node, :expression, format(MSG, static_name, method))
+        end
+
+        def autocorrect(node)
+          _receiver, method, *args = *node
+          static_name = static_method_name(method.to_s)
+          keywords = column_keywords(method)
+          return if keywords.size != args.size
+
+          lambda do |corrector|
+            corrector.replace(node.loc.selector, static_name)
+            keywords.each.with_index do |keyword, idx|
+              corrector.insert_before(args[idx].loc.expression, keyword)
+            end
+          end
+        end
+
+        private
+
+        def whitelist
+          cop_config['Whitelist']
+        end
+
+        def column_keywords(method)
+          keyword_string = method.to_s[METHOD_PATTERN, 1]
+          keyword_string.split('_and_').map { |keyword| "#{keyword}: " }
+        end
+
+        # Returns static method name.
+        # If code isn't wrong, returns nil
+        def static_method_name(method_name)
+          match = METHOD_PATTERN.match(method_name)
+          return nil unless match
+          match[2] ? 'find_by!' : 'find_by'
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.46.0/lib/rubocop/cop/rails/enum_uniqueness.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop looks for duplicate values in enum declarations.
+      #
+      # @example
+      #   # bad
+      #   enum status: { active: 0, archived: 0 }
+      #
+      #   # good
+      #   enum status: { active: 0, archived: 1 }
+      #
+      #   # bad
+      #   enum status: [:active, :archived, :active]
+      #
+      #   # good
+      #   enum status: [:active, :archived]
+      class EnumUniqueness < Cop
+        MSG = 'Duplicate value `%s` found in `%s` enum declaration.'.freeze
+
+        def on_send(node)
+          _receiver, method_name, *args = *node
+
+          return unless method_name == :enum
+
+          enum_name, enum_args = parse_args(args)
+
+          dupes = arr_dupes(enum_values(enum_args))
+          return if dupes.empty?
+
+          add_offense(node, :selector, format(MSG, dupes.join(','), enum_name))
+        end
+
+        private
+
+        def enum_values(enum_args)
+          if enum_args.type == :array
+            enum_array_keys(enum_args)
+          else
+            enum_hash_values(enum_args)
+          end
+        end
+
+        def enum_array_keys(array_node)
+          array_node.each_child_node.map(&:source)
+        end
+
+        def enum_hash_values(hash_node)
+          hash_node.each_child_node.map do |child_node|
+            child_node.child_nodes.last.source
+          end
+        end
+
+        def arr_dupes(array)
+          array.select { |element| array.count(element) > 1 }.uniq
+        end
+
+        def parse_args(args)
+          enum_config = args.first.each_child_node.first.child_nodes
+
+          enum_name = enum_config.first.source
+          enum_opts = enum_config.last
+
+          [enum_name, enum_opts]
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.46.0/lib/rubocop/cop/rails/exit.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop enforces that 'exit' calls are not used within a rails app.
+      # Valid options are instead to raise an error, break, return or some
+      # other form of stopping execution of current request.
+      #
+      # There are two obvious cases where 'exit' is particularly harmful:
+      #
+      # - Usage in library code for your application. Even though rails will
+      # rescue from a SystemExit and continue on, unit testing that library
+      # code will result in specs exiting (potentially silently if exit(0)
+      # is used.)
+      # - Usage in application code outside of the web process could result in
+      # the program exiting, which could result in the code failing to run and
+      # do its job.
+      class Exit < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Do not use `exit` in Rails applications.'.freeze
+        TARGET_METHODS = [:exit, :exit!].freeze
+        EXPLICIT_RECEIVERS = [:Kernel, :Process].freeze
+
+        def on_send(node)
+          add_offense(node, :selector) if offending_node?(node)
+        end
+
+        private
+
+        def offending_node?(node)
+          receiver_node, method_name, *arg_nodes = *node
+
+          right_method_name?(method_name) &&
+            right_argument_count?(arg_nodes) &&
+            right_receiver?(receiver_node)
+        end
+
+        def right_method_name?(method_name)
+          TARGET_METHODS.include?(method_name)
+        end
+
+        # More than 1 argument likely means it is a different
+        # `exit` implementation than the one we are preventing.
+        def right_argument_count?(arg_nodes)
+          arg_nodes.length <= 1
+        end
+
+        # Only register if exit is being called explicitly on
+        # Kernel or Process or if receiver node is nil for plain
+        # `exit` calls.
+        def right_receiver?(receiver_node)
+          return true if receiver_node.nil?
+          _a, receiver_node_class, _c = *receiver_node
+          EXPLICIT_RECEIVERS.include?(receiver_node_class)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.46.0/lib/rubocop/cop/rails/find_by.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop is used to identify usages of `where.first` and
+      # change them to use `find_by` instead.
+      #
+      # @example
+      #   # bad
+      #   User.where(name: 'Bruce').first
+      #   User.where(name: 'Bruce').take
+      #
+      #   # good
+      #   User.find_by(name: 'Bruce')
+      class FindBy < Cop
+        MSG = 'Use `find_by` instead of `where.%s`.'.freeze
+        TARGET_SELECTORS = [:first, :take].freeze
+
+        def_node_matcher :where_first, <<-PATTERN
+          (send $(send _ :where ...) ${:first :take})
+        PATTERN
+
+        def on_send(node)
+          return unless (recv_and_method = where_first(node))
+          receiver, second_method = *recv_and_method
+
+          range = range_between(receiver.loc.selector.begin_pos,
+                                node.loc.selector.end_pos)
+
+          add_offense(node, range, format(MSG, second_method))
+        end
+
+        def autocorrect(node)
+          receiver, second_method = where_first(node)
+          # Don't autocorrect where(...).first, because it can return different
+          # results from find_by. (They order records differently, so the
+          # 'first' record can be different.)
+          return if second_method == :first
+
+          where_loc = receiver.loc.selector
+          first_loc = range_between(node.loc.dot.begin_pos,
+                                    node.loc.selector.end_pos)
+
+          lambda do |corrector|
+            corrector.replace(where_loc, 'find_by')
+            corrector.replace(first_loc, '')
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.46.0/lib/rubocop/cop/rails/find_each.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop is used to identify usages of `all.each` and
+      # change them to use `all.find_each` instead.
+      #
+      # @example
+      #   # bad
+      #   User.all.each
+      #
+      #   # good
+      #   User.all.find_each
+      class FindEach < Cop
+        MSG = 'Use `find_each` instead of `each`.'.freeze
+
+        SCOPE_METHODS = [:all, :where, :not].freeze
+
+        def on_send(node)
+          receiver, second_method, _selector = *node
+          return unless second_method == :each
+          return if receiver.nil?
+
+          _model, first_method = *receiver
+          return unless SCOPE_METHODS.include?(first_method)
+          return if method_chain(node).any? { |m| ignored_by_find_each?(m) }
+
+          add_offense(node, node.loc.selector, MSG)
+        end
+
+        def autocorrect(node)
+          each_loc = node.loc.selector
+
+          ->(corrector) { corrector.replace(each_loc, 'find_each') }
+        end
+
+        private
+
+        def method_chain(node)
+          if (node.send_type? || node.block_type?) && !node.receiver.nil?
+            if node.parent
+              method_chain(node.parent) << node.method_name
+            else
+              [node.method_name]
+            end
+          else
+            []
+          end
+        end
+
+        def ignored_by_find_each?(relation_method)
+          # Active Record's #find_each ignores various extra parameters
+          [:order, :limit, :select].include?(relation_method)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.46.0/lib/rubocop/cop/rails/has_and_belongs_to_many.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for the use of the has_and_belongs_to_many macro.
+      class HasAndBelongsToMany < Cop
+        MSG = 'Prefer `has_many :through` to `has_and_belongs_to_many`.'.freeze
+
+        def on_send(node)
+          return unless node.command?(:has_and_belongs_to_many)
+          add_offense(node, :selector)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.46.0/lib/rubocop/cop/rails/http_positional_arguments.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop is used to identify usages of http methods
+      # like `get`, `post`, `put`, `path` without the usage of keyword arguments
+      # in your tests and change them to use keyword arguments.
+      #
+      # @example
+      #   # bad
+      #   get :new, { user_id: 1}
+      #
+      #   # good
+      #   get :new, params: { user_id: 1 }
+      class HttpPositionalArguments < Cop
+        MSG = 'Use keyword arguments instead of ' \
+              'positional arguments for http call: `%s`.'.freeze
+        KEYWORD_ARGS = [
+          :headers, :env, :params, :body, :flash, :as,
+          :xhr, :session, :method, :format
+        ].freeze
+        HTTP_METHODS = [:get, :post, :put, :patch, :delete, :head].freeze
+
+        def on_send(node)
+          receiver, http_method, http_path, data = *node
+          # if the first word on the line is not an http method, then skip
+          return unless HTTP_METHODS.include?(http_method)
+          # if the data is nil then we don't need to add keyword arguments
+          # because there is no data to put in params or headers, so skip
+          return if data.nil?
+          return unless needs_conversion?(data)
+          # ensures this is the first method on the line
+          # there is an edge case here where sometimes the http method is
+          # wrapped into another method, but its just safer to skip those
+          # cases and process manually
+          return unless receiver.nil?
+          # a http_method without a path?, must be something else
+          return if http_path.nil?
+          add_offense(node, node.loc.selector, format(MSG, node.method_name))
+        end
+
+        # @return [Boolean] true if the line needs to be converted
+        def needs_conversion?(data)
+          # if the line has already been converted to use keyword args
+          # then skip
+          # ie. get :new, params: { user_id: 1 }  (looking for keyword arg)
+          value = data.descendants.find do |d|
+            KEYWORD_ARGS.include?(d.children.first) if d.type == :sym
+          end
+          value.nil?
+        end
+
+        def convert_hash_data(data, type)
+          # empty hash or no hash return empty string
+          return '' if data.nil? || data.children.count < 1
+          hash_data = if data.hash_type?
+                        format('{ %s }', data.children.map(&:source).join(', '))
+                      else
+                        # user supplies an object,
+                        # no need to surround with braces
+                        data.source
+                      end
+          format(', %s: %s', type, hash_data)
+        end
+
+        # given a pre Rails 5 method: get :new, user_id: @user.id, {}
+        #
+        # @return lambda of auto correct procedure
+        # the result should look like:
+        #     get :new, params: { user_id: @user.id }, headers: {}
+        # the http_method is the method use to call the controller
+        # the controller node can be a symbol, method, object or string
+        # that represents the path/action on the Rails controller
+        # the data is the http parameters and environment sent in
+        # the Rails 5 http call
+        def autocorrect(node)
+          _receiver, http_method, http_path, *data = *node
+          controller_action = http_path.source
+          params = convert_hash_data(data.first, 'params')
+          headers = convert_hash_data(data.last, 'headers') if data.count > 1
+          # the range of the text to replace, which is the whole line
+          code_to_replace = node.loc.expression
+          # what to replace with
+          new_code = format('%s %s%s%s', http_method, controller_action,
+                            params, headers)
+          ->(corrector) { corrector.replace(code_to_replace, new_code) }
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.46.0/lib/rubocop/cop/rails/not_null_column.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for add_column call with NOT NULL constraint
+      # in migration file.
+      #
+      # @example
+      #   # bad
+      #   add_column :users, :name, :string, null: false
+      #
+      #   # good
+      #   add_column :users, :name, :string, null: true
+      #   add_column :users, :name, :string, null: false, default: ''
+      class NotNullColumn < Cop
+        MSG = 'Do not add a NOT NULL column without a default value.'.freeze
+
+        def_node_matcher :add_not_null_column?, <<-PATTERN
+          (send nil :add_column _ _ _ (hash $...))
+        PATTERN
+
+        def_node_matcher :null_false?, <<-PATTERN
+          (pair (sym :null) (false))
+        PATTERN
+
+        def_node_matcher :has_default?, <<-PATTERN
+          (pair (sym :default) !(:nil))
+        PATTERN
+
+        def on_send(node)
+          pairs = add_not_null_column?(node)
+          return unless pairs
+          return if pairs.any? { |pair| has_default?(pair) }
+
+          null_false = pairs.find { |pair| null_false?(pair) }
+          return unless null_false
+
+          add_offense(null_false, :expression)
+        end
+      end
+    end
+  end
+end