standard 0.1.0 → 1.51.1

data/lib/standard/cop/semantic_blocks.rb

@@ -1,162 +0,0 @@
-module RuboCop::Cop
-  module Standard
-    class SemanticBlocks < RuboCop::Cop::Cop
-      include RuboCop::Cop::IgnoredMethods
-
-      def on_send(node)
-        return unless node.arguments?
-        return if node.parenthesized? || node.operator_method?
-
-        node.arguments.each do |arg|
-          get_blocks(arg) do |block|
-            # 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
-        end
-      end
-
-      def on_block(node)
-        return if ignored_node?(node) || proper_block_style?(node)
-
-        add_offense(node, location: :begin)
-      end
-
-      def autocorrect(node)
-        return if correction_would_break_code?(node)
-
-        if node.single_line?
-          replace_do_end_with_braces(node.loc)
-        elsif node.braces?
-          replace_braces_with_do_end(node.loc)
-        else
-          replace_do_end_with_braces(node.loc)
-        end
-      end
-
-      private
-
-      def message(node)
-        if node.single_line?
-          "Prefer `{...}` over `do...end` for single-line blocks."
-        elsif node.loc.begin.source == "{"
-          "Prefer `do...end` over `{...}` for procedural blocks."
-        else
-          "Prefer `{...}` over `do...end` for functional blocks."
-        end
-      end
-
-      def replace_braces_with_do_end(loc)
-        b = loc.begin
-        e = loc.end
-
-        lambda do |corrector|
-          corrector.insert_before(b, " ") unless whitespace_before?(b)
-          corrector.insert_before(e, " ") unless whitespace_before?(e)
-          corrector.insert_after(b, " ") unless whitespace_after?(b)
-          corrector.replace(b, "do")
-          corrector.replace(e, "end")
-        end
-      end
-
-      def replace_do_end_with_braces(loc)
-        b = loc.begin
-        e = loc.end
-
-        lambda do |corrector|
-          corrector.insert_after(b, " ") unless whitespace_after?(b, 2)
-
-          corrector.replace(b, "{")
-          corrector.replace(e, "}")
-        end
-      end
-
-      def whitespace_before?(range)
-        range.source_buffer.source[range.begin_pos - 1, 1] =~ /\s/
-      end
-
-      def whitespace_after?(range, length = 1)
-        range.source_buffer.source[range.begin_pos + length, 1] =~ /\s/
-      end
-
-      def get_blocks(node, &block)
-        case node.type
-        when :block
-          yield node
-        when :send
-          get_blocks(node.receiver, &block) if node.receiver
-        when :hash
-          # A hash which is passed as method argument may have no braces
-          # In that case, one of the K/V pairs could contain a block node
-          # which could change in meaning if do...end replaced {...}
-          return if node.braces?
-
-          node.each_child_node { |child| get_blocks(child, &block) }
-        when :pair
-          node.each_child_node { |child| get_blocks(child, &block) }
-        end
-      end
-
-      def proper_block_style?(node)
-        method_name = node.method_name
-
-        if ignored_method?(method_name)
-          true
-        elsif node.single_line?
-          node.braces?
-        elsif node.braces?
-          !procedural_method?(method_name) &&
-            (functional_method?(method_name) || functional_block?(node))
-        else
-          procedural_method?(method_name) || !return_value_used?(node)
-        end
-      end
-
-      def correction_would_break_code?(node)
-        return unless node.keywords?
-
-        node.send_node.arguments? && !node.send_node.parenthesized?
-      end
-
-      def functional_method?(method_name)
-        cop_config["FunctionalMethods"].map(&:to_sym).include?(method_name)
-      end
-
-      def functional_block?(node)
-        return_value_used?(node) || return_value_of_scope?(node)
-      end
-
-      def procedural_method?(method_name)
-        cop_config["ProceduralMethods"].map(&:to_sym).include?(method_name)
-      end
-
-      def return_value_used?(node)
-        return unless node.parent
-
-        # If there are parentheses around the block, check if that
-        # is being used.
-        if node.parent.begin_type?
-          return_value_used?(node.parent)
-        else
-          node.parent.assignment? || node.parent.send_type?
-        end
-      end
-
-      def return_value_of_scope?(node)
-        return unless node.parent
-
-        conditional?(node.parent) || array_or_range?(node.parent) ||
-          node.parent.children.last == node
-      end
-
-      def conditional?(node)
-        node.if_type? || node.or_type? || node.and_type?
-      end
-
-      def array_or_range?(node)
-        node.array_type? || node.irange_type? || node.erange_type?
-      end
-    end
-  end
-end

data/lib/standard/detects_fixability.rb

@@ -1,20 +0,0 @@
-module Standard
-  class DetectsFixability
-    def call(offenses)
-      offenses.any? { |offense|
-        cop = cop_instance(offense.cop_name)
-        cop.support_autocorrect? && safe?(cop)
-      }
-    end
-
-    private
-
-    def cop_instance(cop_name)
-      RuboCop::Cop.const_get(cop_name.gsub("/", "::")).new
-    end
-
-    def safe?(cop)
-      cop.cop_config.fetch("SafeAutoCorrect", true)
-    end
-  end
-end