rubyjobbuilderdsl 0.0.2 → 0.0.3

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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