rubyjobbuilderdsl 0.0.0 → 0.0.1

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

@@ -0,0 +1,80 @@
+# 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

@@ -0,0 +1,94 @@
+# 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

@@ -0,0 +1,18 @@
+# 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

@@ -0,0 +1,62 @@
+# 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

@@ -0,0 +1,42 @@
+# 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

@@ -0,0 +1,29 @@
+# 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

@@ -0,0 +1,69 @@
+# 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

@@ -0,0 +1,42 @@
+# 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

@@ -0,0 +1,54 @@
+# 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

@@ -0,0 +1,23 @@
+# 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

@@ -0,0 +1,70 @@
+# 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

@@ -0,0 +1,33 @@
+# 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

@@ -0,0 +1,37 @@
+# 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