rubyjobbuilderdsl 0.0.2 → 0.0.3

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/style/blocks.rb

@@ -1,80 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Style
-      # Check for uses of braces or do/end around single line or
-      # multi-line blocks.
-      class Blocks < Cop
-        include AutocorrectUnlessChangingAST
-
-        MULTI_LINE_MSG = 'Avoid using {...} for multi-line blocks.'
-        SINGLE_LINE_MSG = 'Prefer {...} over do...end for single-line blocks.'
-
-        def on_send(node)
-          _receiver, method_name, *args = *node
-          return unless args.any?
-
-          block = get_block(args.last)
-          return unless block && !parentheses?(node) && !operator?(method_name)
-
-          # If there are no parentheses around the arguments, then braces and
-          # do-end have different meaning due to how they bind, so we allow
-          # either.
-          ignore_node(block)
-        end
-
-        def on_block(node)
-          return if ignored_node?(node)
-
-          block_length = Util.block_length(node)
-          block_begin = node.loc.begin.source
-
-          if block_length > 0 && block_begin == '{'
-            add_offense(node, :begin, MULTI_LINE_MSG)
-          elsif block_length == 0 && block_begin != '{'
-            add_offense(node, :begin, SINGLE_LINE_MSG)
-          end
-        end
-
-        private
-
-        def correction(node)
-          lambda do |corrector|
-            b, e = node.loc.begin, node.loc.end
-            if b.is?('{')
-              # If the left brace is immediately preceded by a word character,
-              # then we need a space before `do` to get valid Ruby code.
-              if b.source_buffer.source[b.begin_pos - 1, 1] =~ /\w/
-                corrector.insert_before(b, ' ')
-              end
-              corrector.replace(b, 'do')
-              corrector.replace(e, 'end')
-            else
-              corrector.replace(b, '{')
-              corrector.replace(e, '}')
-            end
-          end
-        end
-
-        def get_block(node)
-          case node.type
-          when :block
-            node
-          when :send
-            receiver, _method_name, *_args = *node
-            get_block(receiver) if receiver
-          end
-        end
-
-        def parentheses?(send_node)
-          send_node.loc.begin
-        end
-
-        def operator?(method_name)
-          method_name =~ /^\W/
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/style/braces_around_hash_parameters.rb

@@ -1,94 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for braces in method calls with hash parameters.
-      class BracesAroundHashParameters < Cop
-        include ConfigurableEnforcedStyle
-
-        def on_send(node)
-          _receiver, method_name, *args = *node
-
-          # Discard attr writer methods.
-          return if method_name.to_s.end_with?('=')
-          # Discard operator methods.
-          return if operator?(method_name)
-
-          # We care only for the last argument.
-          arg = args.last
-
-          check(arg, args) if non_empty_hash?(arg)
-        end
-
-        private
-
-        def check(arg, args)
-          if style == :no_braces
-            if !braces?(arg) || all_hashes?(args)
-              correct_style_detected
-            else
-              add_offense(arg, :expression,
-                          'Redundant curly braces around a hash parameter.') do
-                opposite_style_detected
-              end
-            end
-          elsif braces?(arg)
-            correct_style_detected
-          else
-            add_offense(arg, :expression,
-                        'Missing curly braces around a hash parameter.') do
-              opposite_style_detected
-            end
-          end
-        end
-
-        def autocorrect(node)
-          @corrections << lambda do |corrector|
-            if style == :no_braces
-              corrector.remove(node.loc.begin)
-              corrector.remove(node.loc.end)
-              remove_leading_whitespace(node, corrector)
-              remove_trailing_comma_and_whitespace(node, corrector)
-            elsif style == :braces
-              corrector.insert_before(node.loc.expression, '{')
-              corrector.insert_after(node.loc.expression, '}')
-            end
-          end
-        end
-
-        def remove_leading_whitespace(node, corrector)
-          corrector.remove(
-            Parser::Source::Range.new(
-              node.loc.expression.source_buffer,
-              node.loc.begin.end_pos,
-              node.children.first.loc.expression.begin_pos
-            )
-          )
-        end
-
-        def remove_trailing_comma_and_whitespace(node, corrector)
-          corrector.remove(
-            Parser::Source::Range.new(
-              node.loc.expression.source_buffer,
-              node.children.last.loc.expression.end_pos,
-              node.loc.end.begin_pos
-            )
-          )
-        end
-
-        def non_empty_hash?(arg)
-          arg && arg.type == :hash && arg.children.any?
-        end
-
-        def braces?(arg)
-          arg.loc.begin
-        end
-
-        def all_hashes?(args)
-          args.length > 1 && args.all? { |a| a.type == :hash }
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/style/case_equality.rb

@@ -1,18 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for uses of the case equality operator(===).
-      class CaseEquality < Cop
-        MSG = 'Avoid the use of the case equality operator `===`.'
-
-        def on_send(node)
-          _receiver, method_name, *_args = *node
-
-          add_offense(node, :selector) if method_name == :===
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/style/case_indentation.rb

@@ -1,62 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks how the *when*s of a *case* expression
-      # are indented in relation to its *case* or *end* keyword.
-      #
-      # It will register a separate offense for each misaligned *when*.
-      class CaseIndentation < Cop
-        include ConfigurableEnforcedStyle
-
-        def on_case(case_node)
-          _condition, *whens, _else = *case_node
-
-          base = style
-          indent = cop_config['IndentOneStep']
-          base_column = base_column(case_node, base)
-
-          whens.each do |when_node|
-            check_when(when_node, case_node, base, indent, base_column)
-          end
-        end
-
-        private
-
-        def check_when(when_node, case_node, base, indent, base_column)
-          pos = when_node.loc.keyword
-          expected_column = base_column +
-            (indent ? IndentationWidth::CORRECT_INDENTATION : 0)
-          if pos.column == expected_column
-            correct_style_detected
-          else
-            msg = 'Indent `when` ' + if indent
-                                       "one step more than `#{base}`."
-                                     else
-                                       "as deep as `#{base}`."
-                                     end
-            add_offense(when_node, pos, msg) do
-              if pos.column == base_column(case_node, alternative_style)
-                opposite_style_detected
-              else
-                unrecognized_style_detected
-              end
-            end
-          end
-        end
-
-        def parameter_name
-          'IndentWhenRelativeTo'
-        end
-
-        def base_column(case_node, base)
-          case base
-          when :case then case_node.location.keyword.column
-          when :end  then case_node.location.end.column
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/style/character_literal.rb

@@ -1,42 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks for uses of the character literal ?x.
-      class CharacterLiteral < Cop
-        include StringHelp
-
-        MSG = 'Do not use the character literal - use string literal instead.'
-
-        def offense?(node)
-          # we don't register an offense for things like ?\C-\M-d
-          node.loc.begin.is?('?') &&
-            node.loc.expression.source.size.between?(2, 3)
-        end
-
-        def autocorrect(node)
-          @corrections << lambda do |corrector|
-            string = node.loc.expression.source[1..-1]
-
-            if string.length == 1 # normal character
-              corrector.replace(node.loc.expression, "'#{string}'")
-            elsif string.length == 2 # special character like \n
-              corrector.replace(node.loc.expression, %("#{string}"))
-            end
-          end
-        end
-
-        # Dummy implementation of method in ConfigurableEnforcedStyle that is
-        # called from StringHelp.
-        def opposite_style_detected
-        end
-
-        # Dummy implementation of method in ConfigurableEnforcedStyle that is
-        # called from StringHelp.
-        def correct_style_detected
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/style/class_and_module_camel_case.rb

@@ -1,29 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Style
-      # This cops checks for class and module names with
-      # an underscore in them.
-      class ClassAndModuleCamelCase < Cop
-        MSG = 'Use CamelCase for classes and modules.'
-
-        def on_class(node)
-          check_name(node)
-        end
-
-        def on_module(node)
-          check_name(node)
-        end
-
-        private
-
-        def check_name(node)
-          name = node.loc.name.source
-
-          add_offense(node, :name) if name =~ /_/
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/style/class_and_module_children.rb

@@ -1,69 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks the style of children definitions at classes and
-      # modules. Basically there are two different styles:
-      #
-      # nested - have each child on its own line
-      #   class Foo
-      #     class Bar
-      #     end
-      #   end
-      #
-      # compact - combine definitions as much as possible
-      #   class Foo::Bar
-      #   end
-      #
-      # The compact style is only forced, for classes / modules with one child.
-      class ClassAndModuleChildren < Cop
-        include ConfigurableEnforcedStyle
-
-        NESTED_MSG = 'Use nested module/class definitions instead of ' \
-                     'compact style.'
-
-        COMPACT_MSG = 'Use compact module/class definition instead of ' \
-                      'nested style.'
-
-        def on_class(node)
-          _name, _superclass, body = *node
-          check_style(node, body)
-        end
-
-        def on_module(node)
-          _name, body = *node
-          check_style(node, body)
-        end
-
-        private
-
-        def check_style(node, body)
-          if style == :nested
-            check_nested_style(node)
-          else
-            check_compact_style(node, body)
-          end
-        end
-
-        def check_nested_style(node)
-          return unless compact_node_name?(node)
-          add_offense(node, :name, NESTED_MSG)
-        end
-
-        def check_compact_style(node, body)
-          return unless one_child?(body) && !compact_node_name?(node)
-          add_offense(node, :name, COMPACT_MSG)
-        end
-
-        def one_child?(body)
-          body && [:module, :class].include?(body.type)
-        end
-
-        def compact_node_name?(node)
-          node.loc.name.source =~ /::/
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/style/class_check.rb

@@ -1,42 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop enforces consistent use of `Object#is_a?` or `Object#kind_of?`.
-      class ClassCheck < Cop
-        include ConfigurableEnforcedStyle
-
-        MSG = 'Prefer `Object#%s` over `Object#%s`.'
-
-        def on_send(node)
-          _receiver, method_name, *_args = *node
-          return unless [:is_a?,
-                         :kind_of?].include?(method_name)
-
-          return if style == method_name
-          add_offense(node, :selector)
-        end
-
-        def message(node)
-          _receiver, method_name, *_args = *node
-
-          if method_name == :is_a?
-            format(MSG, 'kind_of?', 'is_a?')
-          else
-            format(MSG, 'is_a?', 'kind_of?')
-          end
-        end
-
-        def autocorrect(node)
-          _receiver, method_name, *_args = *node
-
-          @corrections << lambda do |corrector|
-            corrector.replace(node.loc.selector,
-                              method_name == :is_a? ? 'kind_of?' : 'is_a?')
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/style/class_methods.rb

@@ -1,54 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for uses of the class/module name instead of
-      # self, when defining class/module methods.
-      class ClassMethods < Cop
-        MSG = 'Use `self.%s` instead of `%s.%s`.'
-
-        def on_class(node)
-          _name, _superclass, body = *node
-          check(body)
-        end
-
-        def on_module(node)
-          _name, body = *node
-          check(body)
-        end
-
-        private
-
-        def check(node)
-          return unless node
-
-          if node.type == :defs
-            check_defs(node)
-          elsif node.type == :begin
-            defs_nodes = node.children.compact.select { |n| n.type == :defs }
-            defs_nodes.each { |n| check_defs(n) }
-          end
-        end
-
-        def check_defs(node)
-          definee, method_name, _args, _body = *node
-          return unless definee.type == :const
-
-          _, class_name = *definee
-          add_offense(definee, :name, message(class_name, method_name))
-        end
-
-        def message(class_name, method_name)
-          format(MSG, method_name, class_name, method_name)
-        end
-
-        def autocorrect(node)
-          @corrections << lambda do |corrector|
-            corrector.replace(node.loc.name, 'self')
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/style/class_vars.rb

@@ -1,23 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for uses of class variables. Offenses
-      # are signaled only on assignment to class variables to
-      # reduced the number of offenses that would be reported.
-      class ClassVars < Cop
-        MSG = 'Replace class var %s with a class instance var.'
-
-        def on_cvasgn(node)
-          add_offense(node, :name)
-        end
-
-        def message(node)
-          class_var, = *node
-          format(MSG, class_var)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/style/collection_methods.rb

@@ -1,70 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for uses of unidiomatic method names
-      # from the Enumerable module.
-      #
-      # The current definition of the check is flawed and should be
-      # enhanced by check for by blocks & procs as arguments of the
-      # methods.
-      class CollectionMethods < Cop
-        MSG = 'Prefer `%s` over `%s`.'
-
-        def on_block(node)
-          method, _args, _body = *node
-
-          check_method_node(method)
-        end
-
-        def on_send(node)
-          _receiver, _method_name, *args = *node
-          return unless args.size == 1 && args.first.type == :block_pass
-
-          check_method_node(node)
-        end
-
-        def autocorrect(node)
-          @corrections << lambda do |corrector|
-            corrector.replace(node.loc.selector,
-                              preferred_method(node.loc.selector.source))
-          end
-        end
-
-        private
-
-        def check_method_node(node)
-          _receiver, method_name, *_args = *node
-
-          return unless preferred_methods[method_name]
-          add_offense(node, :selector,
-                      format(MSG,
-                             preferred_method(method_name),
-                             method_name)
-                     )
-        end
-
-        def preferred_method(method)
-          preferred_methods[method.to_sym]
-        end
-
-        def preferred_methods
-          @preferred_methods ||=
-            begin
-              # Make sure default configuration 'foo' => 'bar' is removed from
-              # the total configuration if there is a 'bar' => 'foo' override.
-              default = default_cop_config['PreferredMethods']
-              merged = cop_config['PreferredMethods']
-              overrides = merged.values - default.values
-              merged.reject { |key, _| overrides.include?(key) }.symbolize_keys
-            end
-        end
-
-        def default_cop_config
-          ConfigLoader.default_configuration[cop_name]
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/style/colon_method_call.rb

@@ -1,33 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for methods invoked via the :: operator instead
-      # of the . operator (like FileUtils::rmdir instead of FileUtils.rmdir).
-      class ColonMethodCall < Cop
-        MSG = 'Do not use `::` for method calls.'
-
-        def on_send(node)
-          receiver, method_name, *_args = *node
-
-          # discard methods with nil receivers and op methods(like [])
-          return unless receiver && node.loc.dot && node.loc.dot.is?('::')
-          return if allowed_name(method_name.to_s)
-
-          add_offense(node, :dot)
-        end
-
-        def allowed_name(method_name)
-          method_name.match(/^[A-Z]/)
-        end
-
-        def autocorrect(node)
-          @corrections << lambda do |corrector|
-            corrector.replace(node.loc.dot, '.')
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/style/comment_annotation.rb

@@ -1,37 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks that comment annotation keywords are written according
-      # to guidelines.
-      class CommentAnnotation < Cop
-        include AnnotationComment
-
-        MSG = 'Annotation keywords should be all upper case, followed by a ' \
-              'colon and a space, then a note describing the problem.'
-
-        def investigate(processed_source)
-          processed_source.comments.each do |comment|
-            margin, first_word, colon, space, note = split_comment(comment)
-            next unless annotation?(comment) &&
-              !correct_annotation?(first_word, colon, space, note)
-
-            start = comment.loc.expression.begin_pos + margin.length
-            length = first_word.length + (colon || '').length
-            range = Parser::Source::Range.new(processed_source.buffer,
-                                              start,
-                                              start + length)
-            add_offense(nil, range)
-          end
-        end
-
-        private
-
-        def correct_annotation?(first_word, colon, space, note)
-          keyword?(first_word) && (colon && space && note || !colon && !note)
-        end
-      end
-    end
-  end
-end