dirwatch 0.0.1 → 0.0.2

data/vendor/bundle/ruby/2.3.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.3.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

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/rails/output.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for the use of output calls like puts and print
+      class Output < Cop
+        MSG = 'Do not write to stdout. ' \
+              "Use Rails's logger if you want to log.".freeze
+
+        def_node_matcher :output?, <<-PATTERN
+          (send nil {:ap :p :pp :pretty_print :print :puts} $...)
+        PATTERN
+
+        def on_send(node)
+          output?(node) do |args|
+            return if args.empty?
+
+            add_offense(node, :selector)
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/rails/output_safety.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for the use of output safety calls like html_safe and
+      # raw.
+      #
+      # @example
+      #   # bad
+      #   "<p>#{text}</p>".html_safe
+      #
+      #   # good
+      #   content_tag(:p, text)
+      #
+      #   # bad
+      #   out = ""
+      #   out << content_tag(:li, "one")
+      #   out << content_tag(:li, "two")
+      #   out.html_safe
+      #
+      #   # good
+      #   out = []
+      #   out << content_tag(:li, "one")
+      #   out << content_tag(:li, "two")
+      #   safe_join(out)
+      #
+      class OutputSafety < Cop
+        MSG = 'Tagging a string as html safe may be a security risk, ' \
+              'prefer `safe_join` or other Rails tag helpers instead.'.freeze
+
+        def on_send(node)
+          _receiver, method_name, *_args = *node
+          ignore_node(node) if method_name == :safe_join
+          return unless !part_of_ignored_node?(node) &&
+                        (looks_like_rails_html_safe?(node) ||
+                        looks_like_rails_raw?(node))
+
+          add_offense(node, :selector)
+        end
+
+        private
+
+        def looks_like_rails_html_safe?(node)
+          receiver, method_name, *args = *node
+
+          receiver && method_name == :html_safe && args.empty?
+        end
+
+        def looks_like_rails_raw?(node)
+          receiver, method_name, *args = *node
+
+          receiver.nil? && method_name == :raw && args.one?
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/rails/pluralization_grammar.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for correct grammar when using ActiveSupport's
+      # core extensions to the numeric classes.
+      #
+      # @example
+      #   # bad
+      #   3.day.ago
+      #   1.months.ago
+      #
+      #   # good
+      #   3.days.ago
+      #   1.month.ago
+      class PluralizationGrammar < Cop
+        SINGULAR_DURATION_METHODS = { second: :seconds,
+                                      minute: :minutes,
+                                      hour: :hours,
+                                      day: :days,
+                                      week: :weeks,
+                                      fortnight: :fortnights,
+                                      month: :months,
+                                      year: :years }.freeze
+
+        PLURAL_DURATION_METHODS = SINGULAR_DURATION_METHODS.invert.freeze
+
+        MSG = 'Prefer `%s.%s`.'.freeze
+
+        def on_send(node)
+          receiver, method_name, *_args = *node
+          return unless duration_method?(method_name)
+          return unless literal_number?(receiver)
+
+          number, = *receiver
+          if expect_singular_method?(number, method_name)
+            add_offense(node,
+                        :expression,
+                        format(MSG, number, singularize(method_name)))
+          elsif expect_plural_method?(number, method_name)
+            add_offense(node,
+                        :expression,
+                        format(MSG, number, pluralize(method_name)))
+          end
+        end
+
+        private
+
+        def autocorrect(node)
+          lambda do |corrector|
+            method_name = node.loc.selector.source
+            replacement = if plural_method?(method_name)
+                            singularize(method_name)
+                          else
+                            pluralize(method_name)
+                          end
+            corrector.replace(node.loc.selector, replacement)
+          end
+        end
+
+        def expect_singular_method?(number, method_name)
+          singular_receiver?(number) && plural_method?(method_name)
+        end
+
+        def expect_plural_method?(number, method_name)
+          plural_receiver?(number) && singular_method?(method_name)
+        end
+
+        def plural_method?(method_name)
+          method_name.to_s.end_with?('s')
+        end
+
+        def singular_method?(method_name)
+          !plural_method?(method_name)
+        end
+
+        def singular_receiver?(number)
+          number == 1
+        end
+
+        def plural_receiver?(number)
+          !singular_receiver?(number)
+        end
+
+        def literal_number?(node)
+          node && (node.int_type? || node.float_type?)
+        end
+
+        def pluralize(method_name)
+          SINGULAR_DURATION_METHODS.fetch(method_name.to_sym).to_s
+        end
+
+        def singularize(method_name)
+          PLURAL_DURATION_METHODS.fetch(method_name.to_sym).to_s
+        end
+
+        def duration_method?(method_name)
+          SINGULAR_DURATION_METHODS.key?(method_name) ||
+            PLURAL_DURATION_METHODS.key?(method_name)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/rails/read_write_attribute.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for the use of the read_attribute or
+      # write_attribute methods.
+      #
+      # @example
+      #
+      #   # bad
+      #   x = read_attribute(:attr)
+      #   write_attribute(:attr, val)
+      #
+      #   # good
+      #   x = self[:attr]
+      #   self[:attr] = val
+      class ReadWriteAttribute < Cop
+        MSG = 'Prefer `%s` over `%s`.'.freeze
+
+        def_node_matcher :read_write_attribute?, <<-PATTERN
+          {
+            (send nil :read_attribute _)
+            (send nil :write_attribute _ _)
+          }
+        PATTERN
+
+        def on_send(node)
+          read_write_attribute?(node) do
+            add_offense(node, :selector)
+          end
+        end
+
+        def message(node)
+          _receiver, method_name, *_args = *node
+
+          if method_name == :read_attribute
+            format(MSG, 'self[:attr]', 'read_attribute(:attr)')
+          else
+            format(MSG, 'self[:attr] = val', 'write_attribute(:attr, val)')
+          end
+        end
+
+        def autocorrect(node)
+          _receiver, method_name, _body = *node
+
+          case method_name
+          when :read_attribute
+            replacement = read_attribute_replacement(node)
+          when :write_attribute
+            replacement = write_attribute_replacement(node)
+          end
+
+          ->(corrector) { corrector.replace(node.source_range, replacement) }
+        end
+
+        private
+
+        def read_attribute_replacement(node)
+          _receiver, _method_name, body = *node
+
+          "self[#{body.source}]"
+        end
+
+        def write_attribute_replacement(node)
+          _receiver, _method_name, *args = *node
+          name, value = *args
+
+          "self[#{name.source}] = #{value.source}"
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/rails/request_referer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for consistent uses of request.referrer or
+      # request.referrer, depending on configuration.
+      class RequestReferer < Cop
+        include ConfigurableEnforcedStyle
+
+        def_node_matcher :referer?, <<-PATTERN
+          (send (send nil :request) ${:referer :referrer})
+        PATTERN
+
+        def on_send(node)
+          referer?(node) do |method_name|
+            return unless method_name == wrong_method_name
+            add_offense(node.source_range, node.source_range, message)
+          end
+        end
+
+        def autocorrect(node)
+          ->(corrector) { corrector.replace(node, "request.#{style}") }
+        end
+
+        private
+
+        def message
+          "Use `request.#{style}` instead of `request.#{wrong_method_name}`."
+        end
+
+        def wrong_method_name
+          style == :referer ? :referrer : :referer
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/rails/safe_navigation.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop converts usages of `try!` to `&.`. It can also be configured
+      # to convert `try`. It will convert code to use safe navigation if the
+      # target Ruby version is set to 2.3+
+      #
+      # @example
+      #   # ConvertTry: false
+      #     # bad
+      #     foo.try!(:bar)
+      #     foo.try!(:bar, baz)
+      #     foo.try!(:bar) { |e| e.baz }
+      #
+      #     foo.try!(:[], 0)
+      #
+      #     # good
+      #     foo.try(:bar)
+      #     foo.try(:bar, baz)
+      #     foo.try(:bar) { |e| e.baz }
+      #
+      #     foo&.bar
+      #     foo&.bar(baz)
+      #     foo&.bar { |e| e.baz }
+      #
+      #
+      #   # ConvertTry: true
+      #     # bad
+      #     foo.try!(:bar)
+      #     foo.try!(:bar, baz)
+      #     foo.try!(:bar) { |e| e.baz }
+      #     foo.try(:bar)
+      #     foo.try(:bar, baz)
+      #     foo.try(:bar) { |e| e.baz }
+      #
+      #     # good
+      #     foo&.bar
+      #     foo&.bar(baz)
+      #     foo&.bar { |e| e.baz }
+      class SafeNavigation < Cop
+        MSG = 'Use safe navigation (`&.`) instead of `%s`.'.freeze
+
+        def_node_matcher :try_call, <<-PATTERN
+          (send !nil ${:try :try!} $_ ...)
+        PATTERN
+
+        def on_send(node)
+          return if target_ruby_version < 2.3
+
+          try_call(node) do |try_method, method_to_try|
+            return if try_method == :try && !cop_config['ConvertTry']
+            return unless method_to_try.sym_type?
+            method, = *method_to_try
+            return unless method =~ /\w+[=!?]?/
+            add_offense(node, :expression, format(MSG, try_method))
+          end
+        end
+
+        private
+
+        def autocorrect(node)
+          _receiver, _try, method_node, *params = *node
+          method = method_node.source[1..-1]
+          range = range_between(node.loc.dot.begin_pos,
+                                node.loc.expression.end_pos)
+
+          lambda do |corrector|
+            corrector.replace(range, replacement(method, params))
+          end
+        end
+
+        def replacement(method, params)
+          new_params = params.map(&:source).join(', ')
+
+          if method.end_with?('=')
+            "&.#{method[0...-1]} = #{new_params}"
+          elsif params.empty?
+            "&.#{method}"
+          else
+            "&.#{method}(#{new_params})"
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/rails/save_bang.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop identifies possible cases where Active Record save! or related
+      # should be used instead of save because the model might have failed to
+      # save and an exception is better than unhandled failure.
+      #
+      # This will ignore calls that return a boolean for success if the result
+      # is assigned to a variable or used as the condition in an if/unless
+      # statement.  It will also ignore calls that return a model assigned to a
+      # variable that has a call to `persisted?`. Finally, it will ignore any
+      # call with more than 2 arguments as that is likely not an Active Record
+      # call or a Model.update(id, attributes) call.
+      #
+      # @example
+      #
+      #   # bad
+      #   user.save
+      #   user.update(name: 'Joe')
+      #   user.find_or_create_by(name: 'Joe')
+      #   user.destroy
+      #
+      #   # good
+      #   unless user.save
+      #      . . .
+      #   end
+      #   user.save!
+      #   user.update!(name: 'Joe')
+      #   user.find_or_create_by!(name: 'Joe')
+      #   user.destroy!
+      #
+      #   user = User.find_or_create_by(name: 'Joe')
+      #   unless user.persisted?
+      #      . . .
+      #   end
+      class SaveBang < Cop
+        MSG = 'Use `%s` instead of `%s` if the return value is not checked.'
+              .freeze
+        CREATE_MSG = (MSG +
+                      ' Or check `persisted?` on model returned from `%s`.')
+                     .freeze
+        CREATE_CONDITIONAL_MSG = '`%s` returns a model which is always truthy.'
+                                 .freeze
+
+        CREATE_PERSIST_METHODS = [:create,
+                                  :first_or_create, :find_or_create_by].freeze
+        MODIFY_PERSIST_METHODS = [:save, :update, :destroy].freeze
+        PERSIST_METHODS = (CREATE_PERSIST_METHODS +
+                           MODIFY_PERSIST_METHODS).freeze
+
+        def join_force?(force_class)
+          force_class == VariableForce
+        end
+
+        def after_leaving_scope(scope, _variable_table)
+          scope.variables.each do |_name, variable|
+            variable.assignments.each do |assignment|
+              check_assignment(assignment)
+            end
+          end
+        end
+
+        def check_assignment(assignment)
+          node = right_assignment_node(assignment)
+          return unless node
+          return unless CREATE_PERSIST_METHODS.include?(node.method_name)
+          return unless expected_signature?(node)
+          return if persisted_referenced?(assignment)
+
+          add_offense(node, node.loc.selector,
+                      format(CREATE_MSG,
+                             "#{node.method_name}!",
+                             node.method_name.to_s,
+                             node.method_name.to_s))
+        end
+
+        def on_send(node)
+          return unless PERSIST_METHODS.include?(node.method_name)
+          return unless expected_signature?(node)
+          return if return_value_assigned?(node)
+          return if check_used_in_conditional(node)
+          return if last_call_of_method?(node)
+
+          add_offense(node, node.loc.selector,
+                      format(MSG,
+                             "#{node.method_name}!",
+                             node.method_name.to_s))
+        end
+
+        def autocorrect(node)
+          save_loc = node.loc.selector
+          new_method = "#{node.method_name}!"
+
+          ->(corrector) { corrector.replace(save_loc, new_method) }
+        end
+
+        private
+
+        def right_assignment_node(assignment)
+          node = assignment.node.child_nodes.first
+          return node unless node && node.block_type?
+          node.child_nodes.first
+        end
+
+        def persisted_referenced?(assignment)
+          return unless assignment.referenced?
+          assignment.variable.references.any? do |reference|
+            reference.node.parent.method_name == :persisted?
+          end
+        end
+
+        def check_used_in_conditional(node)
+          return false unless conditional?(node)
+
+          unless MODIFY_PERSIST_METHODS.include?(node.method_name)
+            add_offense(node, node.loc.selector,
+                        format(CREATE_CONDITIONAL_MSG,
+                               node.method_name.to_s))
+          end
+
+          true
+        end
+
+        def conditional?(node)
+          node.parent && (node.parent.if_type? && node.sibling_index.zero? ||
+            conditional?(node.parent))
+        end
+
+        def last_call_of_method?(node)
+          !node.parent.nil? &&
+            node.parent.children.count == node.sibling_index + 1
+        end
+
+        # Ignore simple assignment or if condition
+        def return_value_assigned?(node)
+          return false unless node.parent
+          node.parent.lvasgn_type? ||
+            (node.parent.block_type? && node.parent.parent &&
+              node.parent.parent.lvasgn_type?)
+        end
+
+        # Check argument signature as no arguments or one hash
+        def expected_signature?(node)
+          node.method_args.empty? ||
+            (node.method_args.length == 1 &&
+              node.method_name != :destroy &&
+              (node.method_args.first.hash_type? ||
+              !node.method_args.first.literal?))
+        end
+      end
+    end
+  end
+end