rubyjobbuilderdsl 0.0.0 → 0.0.1

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

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+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.
+      class EmptyLiteral < Cop
+        ARR_MSG = 'Use array literal [] instead of Array.new.'
+        HASH_MSG = 'Use hash literal {} instead of Hash.new.'
+        STR_MSG = "Use string literal '' instead of String.new."
+
+        # Empty array node
+        #
+        # (send
+        #   (const nil :Array) :new)
+        ARRAY_NODE = s(:send, s(:const, nil, :Array), :new)
+
+        # Empty hash node
+        #
+        # (send
+        #   (const nil :Hash) :new)
+        HASH_NODE = s(:send, s(:const, nil, :Hash), :new)
+
+        # Empty string node
+        #
+        # (send
+        #   (const nil :String) :new)
+        STR_NODE = s(:send, s(:const, nil, :String), :new)
+
+        def on_send(node)
+          return if part_of_ignored_node?(node)
+
+          case node
+          when ARRAY_NODE
+            add_offense(node, :expression, ARR_MSG)
+          when HASH_NODE
+            add_offense(node, :expression, HASH_MSG)
+          when STR_NODE
+            add_offense(node, :expression, STR_MSG)
+          end
+        end
+
+        # TODO: Check block contents as well.
+        alias_method :on_block, :ignore_node
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            name = case node
+                   when ARRAY_NODE then '[]'
+                   when HASH_NODE then '{}'
+                   when STR_NODE then "''"
+                   end
+            corrector.replace(node.loc.expression, name)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks whether the source file has a utf-8 encoding
+      # comment or not. This check makes sense only for code that
+      # should support Ruby 1.9, since in 2.0+ utf-8 is the default
+      # source file encoding. There are two style:
+      #
+      # when_needed - only enforce an encoding comment if there are non ASCII
+      #               characters, otherwise report an offense
+      # always - enforce encoding comment in all files
+      class Encoding < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG_MISSING = 'Missing utf-8 encoding comment.'
+        MSG_UNNECESSARY = 'Unnecessary utf-8 encoding comment.'
+
+        def investigate(processed_source)
+          return if processed_source.buffer.source.empty?
+
+          line_number = encoding_line_number(processed_source)
+          message = offense(processed_source, line_number)
+
+          return unless message
+
+          range = source_range(processed_source.buffer, line_number + 1, 0)
+          add_offense(nil, range, message)
+        end
+
+        private
+
+        def offense(processed_source, line_number)
+          line = processed_source[line_number]
+          encoding_present = line =~ /#.*coding\s?[:=]\s?(UTF|utf)-8/
+          ascii_only = processed_source.buffer.source.ascii_only?
+          always_encode = style == :always
+
+          if !encoding_present && (always_encode || !ascii_only)
+            MSG_MISSING
+          elsif !always_encode && ascii_only && encoding_present
+            MSG_UNNECESSARY
+          end
+        end
+
+        def encoding_line_number(processed_source)
+          line_number = 0
+          line_number += 1 if processed_source[line_number] =~ /^#!/
+          line_number
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for END blocks.
+      class EndBlock < Cop
+        MSG = 'Avoid the use of `END` blocks. Use `Kernel#at_exit` instead.'
+
+        def on_postexe(node)
+          add_offense(node, :keyword)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for Windows-style line endings in the source code.
+      class EndOfLine < Cop
+        MSG = 'Carriage return character detected.'
+
+        def investigate(processed_source)
+          processed_source.raw_source.each_line.with_index do |line, index|
+            next unless line =~ /\r$/
+
+            range =
+              source_range(processed_source.buffer, index + 1, 0, line.length)
+            add_offense(nil, range, MSG)
+            # Usually there will be carriage return characters on all or none
+            # of the lines in a file, so we report only one offense.
+            break
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where Fixnum#even? or Fixnum#odd?
+      # should have been used.
+      #
+      # @example
+      #
+      #   # bad
+      #   if x % 2 == 0
+      #
+      #   # good
+      #   if x.even?
+      class EvenOdd < Cop
+        MSG_EVEN = 'Replace with `Fixnum#even?`.'
+        MSG_ODD = 'Replace with `Fixnum#odd?`.'
+
+        ZERO = s(:int, 0)
+        ONE = s(:int, 1)
+        TWO = s(:int, 2)
+
+        def on_send(node)
+          receiver, method, args = *node
+
+          return unless [:==, :!=].include?(method)
+          return unless div_by_2?(receiver)
+
+          if args == ZERO
+            add_offense(node,
+                        :expression,
+                        method == :== ? MSG_EVEN : MSG_ODD)
+          elsif args == ONE
+            add_offense(node,
+                        :expression,
+                        method == :== ? MSG_ODD : MSG_EVEN)
+          end
+        end
+
+        private
+
+        def div_by_2?(node)
+          return unless node
+
+          # check for scenarios like (x % 2) == 0
+          if node.type == :begin && node.children.size == 1
+            node = node.children.first
+          end
+
+          return unless node.type == :send
+
+          _receiver, method, args = *node
+
+          method == :% && args == TWO
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop makes sure that Ruby source files have snake_case names.
+      class FileName < Cop
+        MSG = 'Use snake_case for source file names.'
+
+        SNAKE_CASE = /^[\da-z_]+$/
+
+        def investigate(processed_source)
+          file_path = processed_source.buffer.name
+          return if config.file_to_include?(file_path)
+
+          basename = File.basename(file_path).sub(/\.[^\.]+$/, '')
+          return if snake_case?(basename)
+
+          range = source_range(processed_source.buffer, 1, 0)
+          add_offense(nil, range)
+        end
+
+        private
+
+        def snake_case?(basename)
+          basename.split('.').all? { |fragment| fragment =~ SNAKE_CASE }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop looks for uses of flip flop operator
+      class FlipFlop < Cop
+        MSG = 'Avoid the use of flip flop operators.'
+
+        def on_iflipflop(node)
+          add_offense(node, :expression)
+        end
+
+        def on_eflipflop(node)
+          add_offense(node, :expression)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop looks for uses of the *for* keyword, or *each* method. The
+      # preferred alternative is set in the EnforcedStyle configuration
+      # parameter. An *each* call with a block on a single line is always
+      # allowed, however.
+      class For < Cop
+        include ConfigurableEnforcedStyle
+
+        def on_for(node)
+          if style == :each
+            add_offense(node, :keyword, 'Prefer `each` over `for`.') do
+              opposite_style_detected
+            end
+          else
+            correct_style_detected
+          end
+        end
+
+        def on_block(node)
+          return if block_length(node) == 0
+
+          method, _args, _body = *node
+          return unless method.type == :send
+
+          _receiver, method_name, *args = *method
+          return unless method_name == :each && args.empty?
+
+          if style == :for
+            end_pos = method.loc.expression.end_pos
+            range = Parser::Source::Range.new(processed_source.buffer,
+                                              end_pos - 'each'.length,
+                                              end_pos)
+            add_offense(range, range, 'Prefer `for` over `each`.') do
+              opposite_style_detected
+            end
+          else
+            correct_style_detected
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces the use of a single string formatting utility.
+      # Valid options include Kernel#format, Kernel#sprintf and String#%.
+      #
+      # The detection of String#% cannot be implemented in a reliable
+      # manner for all cases, so only two scenarios are considered -
+      # if the first argument is a string literal and if the second
+      # argument is an array literal.
+      class FormatString < Cop
+        include ConfigurableEnforcedStyle
+
+        def on_send(node)
+          add_offense(node, :selector) if offending_node?(node)
+        end
+
+        private
+
+        def offending_node?(node)
+          case style
+          when :format
+            sprintf?(node) || percent?(node)
+          when :sprintf
+            format?(node) || percent?(node)
+          when :percent
+            format?(node) || sprintf?(node)
+          end
+        end
+
+        def format_method?(name, node)
+          receiver, method_name, args = *node
+
+          # we do an argument count check to reduce false positives
+          return false if args && args.children.size < 2
+
+          # commands have no explicit receiver
+          !receiver && method_name == name
+        end
+
+        def format?(node)
+          format_method?(:format, node)
+        end
+
+        def sprintf?(node)
+          format_method?(:sprintf, node)
+        end
+
+        def percent?(node)
+          receiver_node, method_name, *arg_nodes = *node
+
+          method_name == :% &&
+            ([:str, :dstr].include?(receiver_node.type) ||
+             arg_nodes[0].type == :array)
+        end
+
+        def message(node)
+          _receiver_node, method_name, *_arg_nodes = *node
+
+          preferred =
+            if style == :percent
+              'String#%'
+            else
+              style
+            end
+
+          method_name = 'String#%' if method_name == :%
+
+          "Favor `#{preferred}` over `#{method_name}`."
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cops looks for uses of global variables.
+      # It does not report offenses for built-in global variables.
+      # Built-in global variables are allowed by default. Additionally
+      # users can allow additional variables via the AllowedVariables option.
+      #
+      # Note that backreferences like $1, $2, etc are not global variables.
+      class GlobalVars < Cop
+        MSG = 'Do not introduce global variables.'
+
+        # predefined global variables their English aliases
+        # http://www.zenspider.com/Languages/Ruby/QuickRef.html
+        BUILT_IN_VARS = %w(
+          $: $LOAD_PATH
+          $" $LOADED_FEATURES
+          $0 $PROGRAM_NAME
+          $! $ERROR_INFO
+          $@ $ERROR_POSITION
+          $; $FS $FIELD_SEPARATOR
+          $, $OFS $OUTPUT_FIELD_SEPARATOR
+          $/ $RS $INPUT_RECORD_SEPARATOR
+          $\\ $ORS $OUTPUT_RECORD_SEPARATOR
+          $. $NR $INPUT_LINE_NUMBER
+          $_ $LAST_READ_LINE
+          $> $DEFAULT_OUTPUT
+          $< $DEFAULT_INPUT
+          $$ $PID $PROCESS_ID
+          $? $CHILD_STATUS
+          $~ $LAST_MATCH_INFO
+          $= $IGNORECASE
+          $* $ARGV
+          $& $MATCH
+          $` $PREMATCH
+          $' $POSTMATCH
+          $+ $LAST_PAREN_MATCH
+          $stdin $stdout $stderr
+          $DEBUG $FILENAME $VERBOSE $SAFE
+          $-0 $-a $-d $-F $-i $-I $-l $-p $-v $-w
+          $CLASSPATH $JRUBY_VERSION $JRUBY_REVISION $ENV_JAVA
+        ).map(&:to_sym)
+
+        def user_vars
+          if cop_config['AllowedVariables']
+            cop_config['AllowedVariables'].map(&:to_sym)
+          else
+            []
+          end
+        end
+
+        def allowed_var?(global_var)
+          BUILT_IN_VARS.include?(global_var) || user_vars.include?(global_var)
+        end
+
+        def on_gvar(node)
+          check(node)
+        end
+
+        def on_gvasgn(node)
+          check(node)
+        end
+
+        def check(node)
+          global_var, = *node
+
+          add_offense(node, :name) unless allowed_var?(global_var)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # Use a guard clause instead of wrapping the code inside a conditional
+      # expression
+      #
+      # @example
+      #   # bad
+      #   def test
+      #     if something
+      #       work
+      #     end
+      #   end
+      #
+      #   # good
+      #   def test
+      #     return unless something
+      #     work
+      #   end
+      #
+      #   # also good
+      #   def test
+      #     work if something
+      #   end
+      class GuardClause < Cop
+        include ConfigurableEnforcedStyle
+        include IfNode
+
+        MSG = 'Use a guard clause instead of wrapping the code inside a ' \
+              'conditional expression.'
+
+        def on_def(node)
+          _, _, body = *node
+          return unless body
+
+          if if?(body)
+            check_if_node(body)
+          elsif body.type == :begin
+            expressions = *body
+            last_expr = expressions.last
+
+            check_if_node(last_expr) if if?(last_expr)
+          end
+        end
+
+        private
+
+        def if?(body)
+          body && body.type == :if
+        end
+
+        def check_if_node(node)
+          _cond, body, else_body = *node
+
+          return if body && else_body
+          # discard modifier ifs and ternary_ops
+          return if modifier_if?(node) || ternary_op?(node)
+          # discard short ifs
+          return unless min_body_length?(node)
+
+          add_offense(node, :keyword, MSG)
+        end
+
+        def min_body_length?(node)
+          (node.loc.end.line - node.loc.keyword.line) > min_body_length
+        end
+
+        def min_body_length
+          length = cop_config['MinBodyLength'] || 1
+          return length if length.is_a?(Integer) && length > 0
+
+          fail 'MinBodyLength needs to be a positive integer!'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks hash literal syntax.
+      #
+      # It can enforce either the use of the class hash rocket syntax or
+      # the use of the newer Ruby 1.9 syntax (when applicable).
+      #
+      # A separate offense is registered for each problematic pair.
+      class HashSyntax < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG_19 = 'Use the new Ruby 1.9 hash syntax.'
+        MSG_HASH_ROCKETS = 'Always use hash rockets in hashes.'
+
+        def on_hash(node)
+          style == :ruby19 ? ruby19_check(node) : hash_rockets_check(node)
+        end
+
+        def ruby19_check(node)
+          pairs = *node
+
+          sym_indices = pairs.all? { |p| word_symbol_pair?(p) }
+
+          check(pairs, '=>', MSG_19) if sym_indices
+        end
+
+        def hash_rockets_check(node)
+          pairs = *node
+
+          check(pairs, ':', MSG_HASH_ROCKETS)
+        end
+
+        def autocorrect(node)
+          key = node.children.first.loc.expression
+          op = node.loc.operator
+
+          @corrections << lambda do |corrector|
+            if style == :ruby19
+              range = Parser::Source::Range.new(key.source_buffer,
+                                                key.begin_pos, op.end_pos)
+              range = range_with_surrounding_space(range, :right)
+              corrector.replace(range,
+                                range.source.sub(/^:(.*\S)\s*=>\s*$/, '\1: '))
+            else
+              corrector.insert_after(key, ' => ')
+              corrector.insert_before(key, ':')
+              corrector.remove(range_with_surrounding_space(op))
+            end
+          end
+        end
+
+        private
+
+        def space_before_operator?(op, key)
+          op.begin_pos - key.begin_pos - key.source.length > 0
+        end
+
+        def check(pairs, delim, msg)
+          pairs.each do |pair|
+            if pair.loc.operator && pair.loc.operator.is?(delim)
+              add_offense(pair,
+                          pair.loc.expression.begin.join(pair.loc.operator),
+                          msg) do
+                opposite_style_detected
+              end
+            else
+              correct_style_detected
+            end
+          end
+        end
+
+        def word_symbol_pair?(pair)
+          key, _value = *pair
+
+          if key.type == :sym
+            sym_name = key.to_a[0]
+
+            sym_name =~ /\A[A-Za-z_]\w*\z/
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for if and unless statements that would fit on one line
+      # if written as a modifier if/unless.
+      # The maximum line length is configurable.
+      class IfUnlessModifier < Cop
+        include StatementModifier
+
+        def message(keyword)
+          "Favor modifier `#{keyword}` usage when having a single-line body." \
+          ' Another good alternative is the usage of control flow `&&`/`||`.'
+        end
+
+        def on_if(node)
+          # discard ternary ops, if/else and modifier if/unless nodes
+          return if ternary_op?(node)
+          return if modifier_if?(node)
+          return if elsif?(node)
+          return if if_else?(node)
+          return unless fit_within_line_as_modifier_form?(node)
+          add_offense(node, :keyword, message(node.loc.keyword.source))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of semicolon in if statements.
+      class IfWithSemicolon < Cop
+        include OnNormalIfUnless
+
+        MSG = 'Never use if x; Use the ternary operator instead.'
+
+        def on_normal_if_unless(node)
+          beginning = node.loc.begin
+          return unless beginning && beginning.is?(';')
+          add_offense(node, :expression, MSG)
+        end
+      end
+    end
+  end
+end