talon_one 2.0.0

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/empty_lambda_parameter.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for parentheses for empty lambda parameters. Parentheses
+      # for empty lambda parameters do not cause syntax errors, but they are
+      # redundant.
+      #
+      # @example
+      #   # bad
+      #   -> () { do_something }
+      #
+      #   # good
+      #   -> { do_something }
+      #
+      #   # good
+      #   -> (arg) { do_something(arg) }
+      class EmptyLambdaParameter < Cop
+        include EmptyParameter
+        include RangeHelp
+
+        MSG = 'Omit parentheses for the empty lambda parameters.'.freeze
+
+        def on_block(node)
+          send_node = node.send_node
+          return unless send_node.send_type?
+
+          check(node) if node.send_node.lambda_literal?
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            send_node = node.parent.send_node
+            range = range_between(
+              send_node.loc.expression.end_pos,
+              node.loc.expression.end_pos
+            )
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/empty_literal.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for the use of a method, the result of which
+      # would be a literal, like an empty array, hash, or string.
+      #
+      # @example
+      #   # bad
+      #   a = Array.new
+      #   h = Hash.new
+      #   s = String.new
+      #
+      #   # good
+      #   a = []
+      #   h = {}
+      #   s = ''
+      class EmptyLiteral < Cop
+        include FrozenStringLiteral
+        include RangeHelp
+
+        ARR_MSG = 'Use array literal `[]` instead of `Array.new`.'.freeze
+        HASH_MSG = 'Use hash literal `{}` instead of `Hash.new`.'.freeze
+        STR_MSG = 'Use string literal `%<prefer>s` instead of ' \
+                  '`String.new`.'.freeze
+
+        def_node_matcher :array_node, '(send (const nil? :Array) :new)'
+        def_node_matcher :hash_node, '(send (const nil? :Hash) :new)'
+        def_node_matcher :str_node, '(send (const nil? :String) :new)'
+        def_node_matcher :array_with_block,
+                         '(block (send (const nil? :Array) :new) args _)'
+        def_node_matcher :hash_with_block,
+                         '(block (send (const nil? :Hash) :new) args _)'
+
+        def on_send(node)
+          add_offense(node, message: ARR_MSG)  if offense_array_node?(node)
+          add_offense(node, message: HASH_MSG) if offense_hash_node?(node)
+
+          str_node(node) do
+            return if frozen_string_literals_enabled?
+
+            add_offense(node,
+                        message: format(STR_MSG,
+                                        prefer: preferred_string_literal))
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(replacement_range(node), correction(node))
+          end
+        end
+
+        private
+
+        def preferred_string_literal
+          enforce_double_quotes? ? '""' : "''"
+        end
+
+        def enforce_double_quotes?
+          string_literals_config['EnforcedStyle'] == 'double_quotes'
+        end
+
+        def string_literals_config
+          config.for_cop('Style/StringLiterals')
+        end
+
+        def first_argument_unparenthesized?(node)
+          parent = node.parent
+          unless parent && %i[send super zsuper].include?(parent.type)
+            return false
+          end
+
+          node.object_id == parent.arguments.first.object_id &&
+            !parentheses?(node.parent)
+        end
+
+        def replacement_range(node)
+          if hash_node(node) &&
+             first_argument_unparenthesized?(node)
+            # `some_method {}` is not same as `some_method Hash.new`
+            # because the braces are interpreted as a block. We will have
+            # to rewrite the arguments to wrap them in parenthesis.
+            args = node.parent.arguments
+
+            range_between(args[0].loc.expression.begin_pos - 1,
+                          args[-1].loc.expression.end_pos)
+          else
+            node.source_range
+          end
+        end
+
+        def offense_array_node?(node)
+          array_node(node) && !array_with_block(node.parent)
+        end
+
+        def offense_hash_node?(node)
+          # If Hash.new takes a block, it can't be changed to {}.
+          hash_node(node) && !hash_with_block(node.parent)
+        end
+
+        def correction(node)
+          if offense_array_node?(node)
+            '[]'
+          elsif str_node(node)
+            preferred_string_literal
+          elsif offense_hash_node?(node)
+            if first_argument_unparenthesized?(node)
+              # `some_method {}` is not same as `some_method Hash.new`
+              # because the braces are interpreted as a block. We will have
+              # to rewrite the arguments to wrap them in parenthesis.
+              args = node.parent.arguments
+              "(#{args[1..-1].map(&:source).unshift('{}').join(', ')})"
+            else
+              '{}'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/empty_method.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for the formatting of empty method definitions.
+      # By default it enforces empty method definitions to go on a single
+      # line (compact style), but it can be configured to enforce the `end`
+      # to go on its own line (expanded style).
+      #
+      # Note: A method definition is not considered empty if it contains
+      #       comments.
+      #
+      # @example EnforcedStyle: compact (default)
+      #   # bad
+      #   def foo(bar)
+      #   end
+      #
+      #   def self.foo(bar)
+      #   end
+      #
+      #   # good
+      #   def foo(bar); end
+      #
+      #   def foo(bar)
+      #     # baz
+      #   end
+      #
+      #   def self.foo(bar); end
+      #
+      # @example EnforcedStyle: expanded
+      #   # bad
+      #   def foo(bar); end
+      #
+      #   def self.foo(bar); end
+      #
+      #   # good
+      #   def foo(bar)
+      #   end
+      #
+      #   def self.foo(bar)
+      #   end
+      class EmptyMethod < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG_COMPACT = 'Put empty method definitions on a single line.'.freeze
+        MSG_EXPANDED = 'Put the `end` of empty method definitions on the ' \
+                       'next line.'.freeze
+
+        def on_def(node)
+          return if node.body || comment_lines?(node)
+          return if correct_style?(node)
+
+          add_offense(node)
+        end
+        alias on_defs on_def
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.source_range, corrected(node))
+          end
+        end
+
+        private
+
+        def message(_node)
+          compact_style? ? MSG_COMPACT : MSG_EXPANDED
+        end
+
+        def correct_style?(node)
+          compact_style? && compact?(node) ||
+            expanded_style? && expanded?(node)
+        end
+
+        def corrected(node)
+          has_parentheses = parentheses?(node.arguments)
+
+          arguments   = node.arguments? ? node.arguments.source : ''
+          extra_space = node.arguments? && !has_parentheses ? ' ' : ''
+          scope       = node.receiver ? "#{node.receiver.source}." : ''
+
+          signature = [scope, node.method_name, extra_space, arguments].join
+
+          ["def #{signature}", 'end'].join(joint(node))
+        end
+
+        def joint(node)
+          indent = ' ' * node.loc.column
+
+          compact_style? ? '; ' : "\n#{indent}"
+        end
+
+        def comment_lines?(node)
+          processed_source[line_range(node)].any? { |line| comment_line?(line) }
+        end
+
+        def compact?(node)
+          node.single_line?
+        end
+
+        def expanded?(node)
+          node.multiline?
+        end
+
+        def compact_style?
+          style == :compact
+        end
+
+        def expanded_style?
+          style == :expanded
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/encoding.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks ensures source files have no utf-8 encoding comments.
+      # @example
+      #   # bad
+      #   # encoding: UTF-8
+      #   # coding: UTF-8
+      #   # -*- coding: UTF-8 -*-
+      class Encoding < Cop
+        include RangeHelp
+
+        MSG_UNNECESSARY = 'Unnecessary utf-8 encoding comment.'.freeze
+        ENCODING_PATTERN = /#.*coding\s?[:=]\s?(?:UTF|utf)-8/.freeze
+        SHEBANG = '#!'.freeze
+
+        def investigate(processed_source)
+          return if processed_source.buffer.source.empty?
+
+          line_number = encoding_line_number(processed_source)
+          return unless (@message = offense(processed_source, line_number))
+
+          range = processed_source.buffer.line_range(line_number + 1)
+          add_offense(range, location: range, message: @message)
+        end
+
+        def autocorrect(range)
+          lambda do |corrector|
+            corrector.remove(range_with_surrounding_space(range: range,
+                                                          side: :right))
+          end
+        end
+
+        private
+
+        def offense(processed_source, line_number)
+          line = processed_source[line_number]
+
+          MSG_UNNECESSARY if encoding_omitable?(line)
+        end
+
+        def encoding_omitable?(line)
+          line =~ ENCODING_PATTERN
+        end
+
+        def encoding_line_number(processed_source)
+          line_number = 0
+          line_number += 1 if processed_source[line_number].start_with?(SHEBANG)
+          line_number
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/end_block.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for END blocks.
+      #
+      # @example
+      #   # bad
+      #   END { puts 'Goodbye!' }
+      #
+      #   # good
+      #   at_exit { puts 'Goodbye!' }
+      #
+      class EndBlock < Cop
+        MSG = 'Avoid the use of `END` blocks. ' \
+              'Use `Kernel#at_exit` instead.'.freeze
+
+        def on_postexe(node)
+          add_offense(node, location: :keyword)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/eval_with_location.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks `eval` method usage. `eval` can receive source location
+      # metadata, that are filename and line number. The metadata is used by
+      # backtraces. This cop recommends to pass the metadata to `eval` method.
+      #
+      # @example
+      #   # bad
+      #   eval <<-RUBY
+      #     def do_something
+      #     end
+      #   RUBY
+      #
+      #   # bad
+      #   C.class_eval <<-RUBY
+      #     def do_something
+      #     end
+      #   RUBY
+      #
+      #   # good
+      #   eval <<-RUBY, binding, __FILE__, __LINE__ + 1
+      #     def do_something
+      #     end
+      #   RUBY
+      #
+      #   # good
+      #   C.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      #     def do_something
+      #     end
+      #   RUBY
+      class EvalWithLocation < Cop
+        MSG = 'Pass `__FILE__` and `__LINE__` to `eval` method, ' \
+              'as they are used by backtraces.'.freeze
+        MSG_INCORRECT_LINE = 'Use `%<expected>s` instead of `%<actual>s`, ' \
+                             'as they are used by backtraces.'.freeze
+
+        def_node_matcher :eval_without_location?, <<-PATTERN
+          {
+            (send nil? :eval ${str dstr})
+            (send nil? :eval ${str dstr} _)
+            (send nil? :eval ${str dstr} _ #special_file_keyword?)
+            (send nil? :eval ${str dstr} _ #special_file_keyword? _)
+
+            (send _ {:class_eval :module_eval :instance_eval}
+              ${str dstr})
+            (send _ {:class_eval :module_eval :instance_eval}
+              ${str dstr} #special_file_keyword?)
+            (send _ {:class_eval :module_eval :instance_eval}
+              ${str dstr} #special_file_keyword? _)
+          }
+        PATTERN
+
+        def_node_matcher :line_with_offset?, <<-PATTERN
+          {
+            (send #special_line_keyword? %1 (int %2))
+            (send (int %2) %1 #special_line_keyword?)
+          }
+        PATTERN
+
+        def on_send(node)
+          eval_without_location?(node) do |code|
+            if with_lineno?(node)
+              on_with_lineno(node, code)
+            else
+              add_offense(node)
+            end
+          end
+        end
+
+        private
+
+        def special_file_keyword?(node)
+          node.str_type? &&
+            node.source == '__FILE__'
+        end
+
+        def special_line_keyword?(node)
+          node.int_type? &&
+            node.source == '__LINE__'
+        end
+
+        # FIXME: It's a Style/ConditionalAssignment's false positive.
+        # rubocop:disable Style/ConditionalAssignment
+        def with_lineno?(node)
+          if node.method_name == :eval
+            node.arguments.size == 4
+          else
+            node.arguments.size == 3
+          end
+        end
+        # rubocop:enable Style/ConditionalAssignment
+
+        def message_incorrect_line(actual, sign, line_diff)
+          expected =
+            if line_diff.zero?
+              '__LINE__'
+            else
+              "__LINE__ #{sign} #{line_diff}"
+            end
+          format(MSG_INCORRECT_LINE, actual: actual.source, expected: expected)
+        end
+
+        def on_with_lineno(node, code)
+          line_node = node.arguments.last
+          lineno_range = line_node.loc.expression
+          line_diff = string_first_line(code) - lineno_range.first_line
+          if line_diff.zero?
+            add_offense_for_same_line(node, line_node)
+          else
+            add_offense_for_different_line(node, line_node, line_diff)
+          end
+        end
+
+        def string_first_line(str_node)
+          if str_node.heredoc?
+            str_node.loc.heredoc_body.first_line
+          else
+            str_node.loc.expression.first_line
+          end
+        end
+
+        def add_offense_for_same_line(node, line_node)
+          return if special_line_keyword?(line_node)
+
+          add_offense(
+            node,
+            location: line_node.loc.expression,
+            message: message_incorrect_line(line_node, nil, 0)
+          )
+        end
+
+        def add_offense_for_different_line(node, line_node, line_diff)
+          sign = line_diff > 0 ? :+ : :-
+          return if line_with_offset?(line_node, sign, line_diff.abs)
+
+          add_offense(
+            node,
+            location: line_node.loc.expression,
+            message: message_incorrect_line(line_node, sign, line_diff.abs)
+          )
+        end
+      end
+    end
+  end
+end