rubyjobbuilderdsl 0.0.2 → 0.0.3

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/metrics/perceived_complexity.rb

@@ -1,61 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Metrics
-      # This cop tries to produce a complexity score that's a measure of the
-      # complexity the reader experiences when looking at a method. For that
-      # reason it considers `when` nodes as something that doesn't add as much
-      # complexity as an `if` or a `&&`. Except if it's one of those special
-      # `case`/`when` constructs where there's no expression after `case`. Then
-      # the cop treats it as an `if`/`elsif`/`elsif`... and lets all the `when`
-      # nodes count. In contrast to the CyclomaticComplexity cop, this cop
-      # considers `else` nodes as adding complexity.
-      #
-      # @example
-      #
-      #   def my_method                   # 1
-      #     if cond                       # 1
-      #       case var                    # 2 (0.8 + 4 * 0.2, rounded)
-      #       when 1 then func_one
-      #       when 2 then func_two
-      #       when 3 then func_three
-      #       when 4..10 then func_other
-      #       end
-      #     else                          # 1
-      #       do_something until a && b   # 2
-      #     end                           # ===
-      #   end                             # 7 complexity points
-      class PerceivedComplexity < Cop
-        include MethodComplexity
-        include IfNode
-
-        MSG = 'Perceived complexity for %s is too high. [%d/%d]'
-        COUNTED_NODES = [:if, :case, :while, :until, :for, :rescue, :and, :or]
-
-        private
-
-        def complexity_score_for(node)
-          case node.type
-          when :case
-            expression, *whens, _else = *node
-            # If cond is nil, that means each when has an expression that
-            # evaluates to true or false. It's just an alternative to
-            # if/elsif/elsif... so the when nodes count.
-            if expression.nil?
-              whens.length
-            else
-              # Otherwise, the case node gets 0.8 complexity points and each
-              # when gets 0.2.
-              (0.8 + 0.2 * whens.length).round
-            end
-          when :if
-            if_else?(node) && !elsif?(node) ? 2 : 1
-          else
-            1
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/mixin/access_modifier_node.rb

@@ -1,22 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    # Common functionality for checking modifier nodes.
-    module AccessModifierNode
-      extend AST::Sexp
-
-      PRIVATE_NODE = s(:send, nil, :private)
-      PROTECTED_NODE = s(:send, nil, :protected)
-      PUBLIC_NODE = s(:send, nil, :public)
-      MODUDULE_FUNCTION_NODE = s(:send, nil, :module_function)
-
-      def modifier_node?(node)
-        [PRIVATE_NODE,
-         PROTECTED_NODE,
-         PUBLIC_NODE,
-         MODUDULE_FUNCTION_NODE].include?(node)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/mixin/annotation_comment.rb

@@ -1,37 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Style
-      # Common functionality related to annotation comments.
-      module AnnotationComment
-        private
-
-        def annotation?(comment)
-          _margin, first_word, colon, space, note = split_comment(comment)
-          keyword_appearance?(first_word, colon, space) &&
-            !just_first_word_of_sentence?(first_word, colon, space, note)
-        end
-
-        def split_comment(comment)
-          match = comment.text.match(/^(# ?)([A-Za-z]+)(\s*:)?(\s+)?(\S+)?/)
-          return false unless match
-          margin, first_word, colon, space, note = *match.captures
-          [margin, first_word, colon, space, note]
-        end
-
-        def keyword_appearance?(first_word, colon, space)
-          first_word && keyword?(first_word.upcase) && (colon || space)
-        end
-
-        def just_first_word_of_sentence?(first_word, colon, space, note)
-          first_word == first_word.capitalize && !colon && space && note
-        end
-
-        def keyword?(word)
-          config.for_cop('Style/CommentAnnotation')['Keywords'].include?(word)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/mixin/array_syntax.rb

@@ -1,24 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    # Common code for ordinary arrays with [] that can be written with %
-    # syntax.
-    module ArraySyntax
-      def array_of?(element_type, node)
-        return false unless square_brackets?(node)
-
-        array_elems = node.children
-
-        # no need to check empty arrays
-        return false unless array_elems && array_elems.size > 1
-
-        array_elems.all? { |e| e.type == element_type }
-      end
-
-      def square_brackets?(node)
-        node.loc.begin && node.loc.begin.is?('[')
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/mixin/autocorrect_alignment.rb

@@ -1,112 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    # This module does auto-correction of nodes that should just be moved to
-    # the left or to the right, amount being determined by the instance
-    # variable @column_delta.
-    module AutocorrectAlignment
-      def check_alignment(items, base_column = nil)
-        base_column ||= items.first.loc.column unless items.empty?
-        prev_line = -1
-        items.each do |current|
-          if current.loc.line > prev_line && start_of_line?(current.loc)
-            @column_delta = base_column - current.loc.column
-            add_offense(current, :expression) if @column_delta != 0
-          end
-          prev_line = current.loc.line
-        end
-      end
-
-      def start_of_line?(loc)
-        loc.expression.source_line[0...loc.column] =~ /^\s*$/
-      end
-
-      def autocorrect(arg)
-        heredoc_ranges = heredoc_ranges(arg)
-        expr = arg.respond_to?(:loc) ? arg.loc.expression : arg
-
-        # We can't use the instance variable inside the lambda. That would
-        # just give each lambda the same reference and they would all get
-        # the last value of @column_delta. A local variable fixes the
-        # problem.
-        column_delta = @column_delta
-
-        fail CorrectionNotPossible if block_comment_within?(expr)
-
-        @corrections << lambda do |corrector|
-          each_line(expr) do |line_begin_pos|
-            range = calculate_range(expr, line_begin_pos, column_delta)
-            # We must not change indentation of heredoc stings.
-            next if heredoc_ranges.any? { |h| within?(range, h) }
-
-            if column_delta > 0
-              unless range.source == "\n"
-                corrector.insert_before(range, ' ' * column_delta)
-              end
-            else
-              remove(range, corrector) if range.source =~ /^[ \t]+$/
-            end
-          end
-        end
-      end
-
-      private
-
-      def heredoc_ranges(arg)
-        return [] unless arg.is_a?(Parser::AST::Node)
-
-        heredoc_ranges = []
-        arg.each_node(:dstr) do |n|
-          if n.loc.respond_to?(:heredoc_body)
-            heredoc_ranges << n.loc.heredoc_body.join(n.loc.heredoc_end)
-          end
-        end
-        heredoc_ranges
-      end
-
-      def block_comment_within?(expr)
-        processed_source.comments.select(&:document?).find do |c|
-          within?(c.loc.expression, expr)
-        end
-      end
-
-      def within?(inner, outer)
-        inner.begin_pos >= outer.begin_pos && inner.end_pos <= outer.end_pos
-      end
-
-      def calculate_range(expr, line_begin_pos, column_delta)
-        starts_with_space = expr.source_buffer.source[line_begin_pos] =~ / /
-        pos_to_remove = if column_delta > 0 || starts_with_space
-                          line_begin_pos
-                        else
-                          line_begin_pos - column_delta.abs
-                        end
-        Parser::Source::Range.new(expr.source_buffer, pos_to_remove,
-                                  pos_to_remove + column_delta.abs)
-      end
-
-      def remove(range, corrector)
-        original_stderr = $stderr
-        $stderr = StringIO.new # Avoid error messages on console
-        corrector.remove(range)
-      rescue RuntimeError
-        range = Parser::Source::Range.new(range.source_buffer,
-                                          range.begin_pos + 1,
-                                          range.end_pos + 1)
-        retry if range.source =~ /^ +$/
-      ensure
-        $stderr = original_stderr
-      end
-
-      def each_line(expr)
-        offset = 0
-        expr.source.each_line do |line|
-          line_begin_pos = expr.begin_pos + offset
-          yield line_begin_pos
-          offset += line.length
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/mixin/autocorrect_unless_changing_ast.rb

@@ -1,36 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    # This module does auto-correction of nodes that could become grammatically
-    # different after the correction. If the code change would alter the
-    # abstract syntax tree, it is not done.
-    module AutocorrectUnlessChangingAST
-      def autocorrect(node)
-        c = correction(node)
-        new_source = rewrite_node(node)
-
-        # Make the correction only if it doesn't change the AST. Regenerate the
-        # AST for `node` so we get it without context. Otherwise the comparison
-        # could be misleading.
-        if ast_for(node.loc.expression.source) != ast_for(new_source)
-          fail CorrectionNotPossible
-        end
-
-        @corrections << c
-      end
-
-      private
-
-      def ast_for(source)
-        ProcessedSource.new(source).ast
-      end
-
-      def rewrite_node(node)
-        processed_source = ProcessedSource.new(node.loc.expression.source)
-        c = correction(processed_source.ast)
-        Corrector.new(processed_source.buffer, [c]).rewrite
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/mixin/check_assignment.rb

@@ -1,37 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    # Common functionality for checking assignment nodes.
-    module CheckAssignment
-      TYPES = Util::ASGN_NODES - [:casgn, :op_asgn]
-      TYPES.each do |type|
-        define_method("on_#{type}") do |node|
-          _lhs, rhs = *node
-          check_assignment(node, rhs)
-        end
-      end
-
-      def on_casgn(node)
-        _scope, _lhs, rhs = *node
-        check_assignment(node, rhs)
-      end
-
-      def on_op_asgn(node)
-        _lhs, _op, rhs = *node
-        check_assignment(node, rhs)
-      end
-
-      def on_send(node)
-        _receiver, method_name, *_, rhs = *node
-
-        # we only want to indent relative to the receiver
-        # when the method called looks like a setter
-        return unless method_name.to_s.end_with?('=')
-
-        # This will match if, case, begin, blocks, etc.
-        check_assignment(node, rhs) if rhs.is_a?(AST::Node)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/mixin/code_length.rb

@@ -1,32 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    # Common functionality for checking length of code segments.
-    module CodeLength
-      include ConfigurableMax
-
-      def max_length
-        cop_config['Max']
-      end
-
-      def count_comments?
-        cop_config['CountComments']
-      end
-
-      def check_code_length(node, *_)
-        length = code_length(node)
-        return unless length > max_length
-
-        add_offense(node, :keyword, message(length, max_length)) do
-          self.max = length
-        end
-      end
-
-      # Returns true for lines that shall not be included in the count.
-      def irrelevant_line(source_line)
-        source_line.blank? || !count_comments? && comment_line?(source_line)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/mixin/configurable_enforced_style.rb

@@ -1,53 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    # Handles `EnforcedStyle` configuration parameters.
-    module ConfigurableEnforcedStyle
-      def opposite_style_detected
-        self.config_to_allow_offenses ||=
-          { parameter_name => alternative_style.to_s }
-        both_styles_detected if config_to_allow_offenses['Enabled']
-      end
-
-      def correct_style_detected
-        # Enabled:true indicates, later when the opposite style is detected,
-        # that the correct style is used somewhere.
-        self.config_to_allow_offenses ||= { 'Enabled' => true }
-        both_styles_detected if config_to_allow_offenses[parameter_name]
-      end
-
-      def both_styles_detected
-        # Both correct and opposite styles exist.
-        self.config_to_allow_offenses = { 'Enabled' => false }
-      end
-
-      def unrecognized_style_detected
-        # All we can do is to disable.
-        self.config_to_allow_offenses = { 'Enabled' => false }
-      end
-
-      def style
-        s = cop_config[parameter_name]
-        if cop_config['SupportedStyles'].include?(s)
-          s.to_sym
-        else
-          fail "Unknown style #{s} selected!"
-        end
-      end
-
-      def alternative_style
-        a = cop_config['SupportedStyles'].map(&:to_sym)
-        if a.size != 2
-          fail 'alternative_style can only be used when there are exactly ' \
-               '2 SupportedStyles'
-        end
-        style == a.first ? a.last : a.first
-      end
-
-      def parameter_name
-        'EnforcedStyle'
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/mixin/configurable_max.rb

@@ -1,19 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    # Handles `Max` configuration parameters, especially setting them to an
-    # appropriate value with --auto-gen-config.
-    module ConfigurableMax
-      def max=(value)
-        cfg = self.config_to_allow_offenses ||= {}
-        value = [cfg[parameter_name], value].max if cfg[parameter_name]
-        cfg[parameter_name] = value
-      end
-
-      def parameter_name
-        'Max'
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/mixin/configurable_naming.rb

@@ -1,31 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    # This module provides functionality for checking if names match the
-    # configured EnforcedStyle.
-    module ConfigurableNaming
-      include ConfigurableEnforcedStyle
-
-      SNAKE_CASE = /^@{0,2}[\da-z_]+[!?=]?$/
-      CAMEL_CASE = /^@{0,2}[a-z][\da-zA-Z]+[!?=]?$/
-
-      def check_name(node, name, name_range)
-        return if operator?(name)
-
-        if valid_name?(name)
-          correct_style_detected
-        else
-          add_offense(node, name_range, message(style)) do
-            opposite_style_detected
-          end
-        end
-      end
-
-      def valid_name?(name)
-        pattern = (style == :snake_case ? SNAKE_CASE : CAMEL_CASE)
-        name.match(pattern)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/mixin/end_keyword_alignment.rb

@@ -1,42 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    # Functions for checking the alignment of the `end` keyword.
-    module EndKeywordAlignment
-      include ConfigurableEnforcedStyle
-
-      MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d'
-
-      private
-
-      def check_offset_of_node(node)
-        check_offset(node, node.loc.keyword.source, 0)
-      end
-
-      def check_offset(node, alignment_base, offset)
-        return if ignored_node?(node)
-
-        end_loc = node.loc.end
-        return unless end_loc # Discard modifier forms of if/while/until.
-
-        kw_loc = node.loc.keyword
-
-        if kw_loc.line != end_loc.line &&
-            kw_loc.column != end_loc.column + offset
-          add_offense(nil, end_loc,
-                      format(MSG, end_loc.line, end_loc.column,
-                             alignment_base, kw_loc.line, kw_loc.column)) do
-            opposite_style_detected
-          end
-        else
-          correct_style_detected
-        end
-      end
-
-      def parameter_name
-        'AlignWith'
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/mixin/if_node.rb

@@ -1,25 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    # Common functionality for checking if nodes.
-    module IfNode
-      def modifier_if?(node)
-        node.loc.respond_to?(:end) && node.loc.end.nil?
-      end
-
-      def ternary_op?(node)
-        node.loc.respond_to?(:question)
-      end
-
-      def elsif?(node)
-        node.loc.respond_to?(:keyword) && node.loc.keyword &&
-          node.loc.keyword.is?('elsif')
-      end
-
-      def if_else?(node)
-        node.loc.respond_to?(:else) && node.loc.else
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/mixin/method_complexity.rb

@@ -1,30 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    # This module handles measurement and reporting of complexity in methods.
-    module MethodComplexity
-      include OnMethod
-      include ConfigurableMax
-
-      private
-
-      def on_method(node, method_name, _args, _body)
-        max = cop_config['Max']
-        complexity = complexity(node)
-        return unless complexity > max
-
-        add_offense(node, :keyword,
-                    format(self.class::MSG, method_name, complexity, max)) do
-          self.max = complexity
-        end
-      end
-
-      def complexity(node)
-        node.each_node(self.class::COUNTED_NODES).reduce(1) do |score, n|
-          score + complexity_score_for(n)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/mixin/negative_conditional.rb

@@ -1,24 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    # Some common code shared between FavorUnlessOverNegatedIf and
-    # FavorUntilOverNegatedWhile.
-    module NegativeConditional
-      def check_negative_conditional(node)
-        condition, _body, _rest = *node
-
-        # Look at last expression of contents if there's a parenthesis
-        # around condition.
-        condition = condition.children.last while condition.type == :begin
-        return unless condition.type == :send
-
-        _object, method = *condition
-        return unless method == :! && !(node.loc.respond_to?(:else) &&
-                                        node.loc.else)
-
-        add_offense(node, :expression)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/mixin/on_method.rb

@@ -1,30 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    # Common functionality for checking instance methods and singeton methods.
-    module OnMethod
-      def on_def(node)
-        method_name, args, body = *node
-        on_method(node, method_name, args, body)
-      end
-
-      def on_defs(node)
-        _scope, method_name, args, body = *node
-        on_method(node, method_name, args, body)
-      end
-
-      private
-
-      # Returns true for constructs such as
-      # private def my_method
-      # which are allowed in Ruby 2.1 and later.
-      def visibility_and_def_on_same_line?(receiver, method_name, args)
-        !receiver &&
-          [:public, :protected, :private,
-           :module_function].include?(method_name) &&
-          args.size == 1 && [:def, :defs].include?(args.first.type)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/mixin/on_normal_if_unless.rb

@@ -1,24 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    # Common functionality for cops checking if and unless statements.
-    module OnNormalIfUnless
-      include IfNode
-
-      def on_if(node)
-        invoke_hook_for_normal_if_unless(node)
-      end
-
-      def on_unless(node)
-        invoke_hook_for_normal_if_unless(node)
-      end
-
-      def invoke_hook_for_normal_if_unless(node)
-        # We won't check modifier or ternary conditionals.
-        return if modifier_if?(node) || ternary_op?(node)
-        on_normal_if_unless(node)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/mixin/parser_diagnostic.rb

@@ -1,34 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    # Common functionality for cops which processes Parser's diagnostics.
-    # This mixin requires its user class to define `#relevant_diagnostic?`.
-    #
-    #     def relevant_diagnostic?(diagnostic)
-    #       diagnostic.reason == :my_interested_diagnostic_type
-    #     end
-    #
-    # If you want to use an alternative offense message rather than the one in
-    # Parser's diagnostic, define `#alternative_message`.
-    #
-    #     def alternative_message(diagnostic)
-    #       'My custom message'
-    #     end
-    module ParserDiagnostic
-      def investigate(processed_source)
-        processed_source.diagnostics.each do |d|
-          next unless relevant_diagnostic?(d)
-
-          message = if respond_to?(:alternative_message, true)
-                      alternative_message(d)
-                    else
-                      d.message.capitalize
-                    end
-
-          add_offense(nil, d.location, message, d.level)
-        end
-      end
-    end
-  end
-end