File fast.rb has 489 lines of code (exceeds 250 allowed). Consider refactoring.

Open

require 'fileutils'
require 'astrolabe/builder'
require_relative 'fast/rewriter'

# suppress output to avoid parser gem warnings'

Method run! has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.

Open

    def run!
      raise 'pry and parallel options are incompatible :(' if @parallel && @pry

      if @help || @files.empty? && @pattern.nil?
        puts option_parser.help

• Read up
  Read up

Method option_parser has 52 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def option_parser # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
      @option_parser ||= OptionParser.new do |opts| # rubocop:disable Metrics/BlockLength
        opts.banner = 'Usage: fast expression <files> [options]'
        opts.on('-d', '--debug', 'Debug fast engine') do
          @debug = true

Method experiment has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

def experiment(file, name, search, replacement)
  ast = Fast.ast_from_file(file)

  results = Fast.search(ast, search)
  unless results.empty?

• Read up
  Read up

Method search has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

    def search(pattern, node, *args)
      if (match = match?(pattern, node, *args))
        yield node, match if block_given?
        match != true ? [node, match] : [node]
      else

• Read up
  Read up

Method partial_replace has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

    def partial_replace(*indices)
      replacement = experiment.replacement
      new_content = Fast.replace_file experiment.expression, @file do |node, *captures|
        if indices.nil? || indices.empty? || indices.include?(match_index)
          if replacement.parameters.length == 1

• Read up
  Read up

Method parse has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

    def parse
      case (token = next_token)
      when '(' then parse_until_peek(')')
      when '{' then Any.new(parse_until_peek('}'))
      when '[' then All.new(parse_until_peek(']'))

• Read up
  Read up

Method report has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

  def report(result, show_link: false, show_permalink: false, show_sexp: false, file: nil, headless: false, bodyless: false, colorize: true) # rubocop:disable Metrics/ParameterLists
    if file
      line = result.loc.expression.line if result.is_a?(Parser::AST::Node)
      if show_link
        puts(result.link)

• Read up
  Read up

Method highlight has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

  def highlight(node, show_sexp: false, colorize: true, sql: false)
    output =
      if node.respond_to?(:loc) && !show_sexp
        wrap_source_range(node).source
      else

• Read up
  Read up

Method sql_tree_to_ast has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

    def sql_tree_to_ast(obj, source_buffer: nil, source_map: nil)
      recursive = -> (e) { sql_tree_to_ast(e, source_buffer: source_buffer, source_map: source_map.dup) }
      case obj
      when Array
        obj.map(&recursive).flatten.compact

• Read up
  Read up

Method clean_structure has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

    def clean_structure(stmt)
      res_hash = stmt.map do |key, value|
        value = clean_structure(value) if value.is_a?(Hash)
        value = value.map(&Fast::SQL.method(:clean_structure)) if value.is_a?(Array)
        value = nil if [{}, [], "", :SETOP_NONE, :LIMIT_OPTION_DEFAULT, false].include?(value)

• Read up
  Read up

Method parse has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def parse(statement, buffer_name: "(sql)")
      return [] if statement.nil?
      source_buffer = SQL::SourceBuffer.new(buffer_name, source: statement)
      tree = PgQuery.parse(statement).tree
      first, *, last = source_buffer.tokens

• Read up
  Read up

Method run has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def run
      while (combinations = build_combinations).any?
        if combinations.size > 1000
          puts "Ignoring #{@file} because it has #{combinations.size} possible combinations"
          break

• Read up
  Read up

Method capture has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def capture(pattern, node)
      if (match = match?(pattern, node))
        match == true ? node : match
      else
        node.each_child_node

• Read up
  Read up

Method match_recursive has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def match_recursive(expression, node)
      case expression
      when Proc then expression.call(node)
      when Find then expression.match?(node)
      when Symbol then compare_symbol_or_head(expression, node)

• Read up
  Read up