dirwatch 0.0.1 → 0.0.2

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for the correct use of Date methods,
+      # such as Date.today, Date.current etc.
+      #
+      # Using Date.today is dangerous, because it doesn't know anything about
+      # Rails time zone. You must use Time.zone.today instead.
+      #
+      # The cop also reports warnings when you are using 'to_time' method,
+      # because it doesn't know about Rails time zone either.
+      #
+      # Two styles are supported for this cop. When EnforcedStyle is 'strict'
+      # then the Date methods (today, current, yesterday, tomorrow)
+      # are prohibited and the usage of both 'to_time'
+      # and 'to_time_in_current_zone' is reported as warning.
+      #
+      # When EnforcedStyle is 'flexible' then only 'Date.today' is prohibited
+      # and only 'to_time' is reported as warning.
+      #
+      # @example
+      #   # no offense
+      #   Time.zone.today
+      #   Time.zone.today - 1.day
+      #
+      #   # acceptable
+      #   Date.current
+      #   Date.yesterday
+      #
+      #   # always reports offense
+      #   Date.today
+      #   date.to_time
+      #
+      #   # reports offense only when style is 'strict'
+      #   date.to_time_in_current_zone
+      class Date < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Do not use `%s` without zone. Use `%s` instead.'.freeze
+
+        MSG_SEND = 'Do not use `%s` on Date objects, because they ' \
+                   'know nothing about the time zone in use.'.freeze
+
+        BAD_DAYS = [:today, :current, :yesterday, :tomorrow].freeze
+
+        def on_const(node)
+          mod, klass = *node.children
+          # we should only check core Date class (`Date` or `::Date`)
+          return unless (mod.nil? || mod.cbase_type?) && method_send?(node)
+
+          check_date_node(node.parent) if klass == :Date
+        end
+
+        def on_send(node)
+          receiver, method_name, *args = *node
+          return unless receiver && bad_methods.include?(method_name)
+
+          chain = extract_method_chain(node)
+          return if safe_chain?(chain)
+
+          return if method_name == :to_time && args.length == 1
+
+          add_offense(node, :selector,
+                      format(MSG_SEND,
+                             method_name))
+        end
+
+        private
+
+        def check_date_node(node)
+          chain = extract_method_chain(node)
+          return if (chain & bad_days).empty?
+
+          method_name = (chain & bad_days).join('.')
+
+          add_offense(node, :selector,
+                      format(MSG,
+                             "Date.#{method_name}",
+                             "Time.zone.#{method_name}"))
+        end
+
+        def extract_method_chain(node)
+          chain = []
+          while !node.nil? && node.send_type?
+            chain << extract_method(node)
+            node = node.parent
+          end
+          chain
+        end
+
+        def extract_method(node)
+          _receiver, method_name, *_args = *node
+          method_name
+        end
+
+        # checks that parent node of send_type
+        # and receiver is the given node
+        def method_send?(node)
+          return false unless node.parent && node.parent.send_type?
+
+          receiver, _method_name, *_args = *node.parent
+
+          receiver == node
+        end
+
+        def safe_chain?(chain)
+          (chain & bad_methods).empty? || !(chain & good_methods).empty?
+        end
+
+        def good_days
+          style == :strict ? [] : [:current, :yesterday, :tomorrow]
+        end
+
+        def bad_days
+          BAD_DAYS - good_days
+        end
+
+        def bad_methods
+          style == :strict ? [:to_time, :to_time_in_current_zone] : [:to_time]
+        end
+
+        def good_methods
+          style == :strict ? [] : TimeZone::ACCEPTED_METHODS
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop looks for delegations, that could have been created
+      # automatically with delegate method.
+      #
+      # @example
+      #   # bad
+      #   def bar
+      #     foo.bar
+      #   end
+      #
+      #   # good
+      #   delegate :bar, to: :foo
+      #
+      #   # bad
+      #   def foo_bar
+      #     foo.bar
+      #   end
+      #
+      #   # good
+      #   delegate :bar, to: :foo, prefix: true
+      #
+      #   # good
+      #   private
+      #   def bar
+      #     foo.bar
+      #   end
+      class Delegate < Cop
+        MSG = 'Use `delegate` to define delegations.'.freeze
+
+        def on_def(node)
+          method_name, args, body = *node
+          return unless trivial_delegate?(method_name, args, body)
+          return if private_or_protected_delegation(node)
+          add_offense(node, :keyword, MSG)
+        end
+
+        private
+
+        def autocorrect(node)
+          method_name, _args, body = *node
+          delegation = ["delegate :#{body.children[1]}",
+                        "to: :#{body.children[0].children[1]}"]
+          if method_name == prefixed_method_name(body)
+            delegation << ['prefix: true']
+          end
+
+          lambda do |corrector|
+            corrector.replace(node.source_range, delegation.join(', '))
+          end
+        end
+
+        def trivial_delegate?(method_name, args, body)
+          body && delegate?(body) &&
+            method_name_matches?(method_name, body) &&
+            arguments_match?(args, body)
+        end
+
+        def delegate?(body)
+          receiver, = *body
+          return false unless receiver.is_a?(Node) && receiver.send_type?
+          receiver.child_nodes.empty?
+        end
+
+        def arguments_match?(args, body)
+          _receiver, _method_name, *arguments = *body
+          arg_array = Array(args)
+          argument_array = Array(arguments)
+          arg_array.size == argument_array.size && (
+            arg_array == argument_array ||
+            arg_array.map(&:children) == argument_array.map(&:children)
+          )
+        end
+
+        def method_name_matches?(method_name, body)
+          _receiver, property_name, *_args = *body
+          method_name == property_name ||
+            method_name == prefixed_method_name(body)
+        end
+
+        def prefixed_method_name(body)
+          receiver, property_name, *_args = *body
+          _receiver, target, *_args = *receiver
+          [target, property_name].join('_').to_sym
+        end
+
+        def private_or_protected_delegation(node)
+          line = node.loc.line
+          private_or_protected_before(line) ||
+            private_or_protected_inline(line)
+        end
+
+        def private_or_protected_before(line)
+          (processed_source[0..line].map(&:strip) & %w(private protected)).any?
+        end
+
+        def private_or_protected_inline(line)
+          processed_source[line - 1].strip =~ /\A(private )|(protected )/
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop looks for delegations that pass :allow_blank as an option
+      # instead of :allow_nil. :allow_blank is not a valid option to pass
+      # to ActiveSupport#delegate.
+      #
+      # @example
+      #   # bad
+      #   delegate :foo, to: :bar, allow_blank: true
+      #
+      #   # good
+      #   delegate :foo, to: :bar, allow_nil: true
+      class DelegateAllowBlank < Cop
+        MSG = '`allow_blank` is not a valid option, use `allow_nil`.'.freeze
+
+        def_node_matcher :delegate, <<-PATTERN
+          (send _ :delegate _ $hash)
+        PATTERN
+
+        def_node_matcher :delegate_options, <<-PATTERN
+          (hash $...)
+        PATTERN
+
+        def_node_matcher :allow_blank?, <<-PATTERN
+          (pair $(sym :allow_blank) true)
+        PATTERN
+
+        def on_send(node)
+          offending_node = allow_blank_option(node)
+          return unless offending_node
+
+          allow_blank = offending_node.children.first
+          add_offense(node, allow_blank.source_range, MSG)
+        end
+
+        def autocorrect(node)
+          offending_node = allow_blank_option(node)
+          return unless offending_node
+
+          allow_blank = offending_node.children.first
+          lambda do |corrector|
+            corrector.replace(allow_blank.source_range, 'allow_nil')
+          end
+        end
+
+        private
+
+        def allow_blank_option(node)
+          options_hash = delegate(node)
+          return unless options_hash
+          options = delegate_options(options_hash)
+          return unless options
+
+          options.detect { |opt| allow_blank?(opt) }
+        end
+      end
+    end
+  end
+end

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