require "sexp_processor"
require "ruby_parser"
require "timeout"

##
# Flog is a SexpProcessor that calculates a ABC (assignments,
# branches, conditionals) complexity metric with some ruby-aware
# enhancements and a compounding penalty for increasing depth.
#
# In essence, this calculates the most tortured code. The higher the
# score, the more pain the code is in and the harder it is to
# thoroughly test.

class Flog < MethodBasedSexpProcessor
  VERSION = "4.8.0" # :nodoc:

  ##
  # Cut off point where the report should stop unless --all given.

  DEFAULT_THRESHOLD = 0.60

  THRESHOLD = DEFAULT_THRESHOLD # :nodoc:

  ##
  # The scoring system hash. Maps node type to score.

  SCORES = Hash.new 1

  ##
  # Names of nodes that branch.

  BRANCHING = [ :and, :case, :else, :if, :or, :rescue, :until, :when, :while ]

  ##
  # Various non-call constructs

  OTHER_SCORES = {
    :alias          => 2,
    :assignment     => 1,
    :block          => 1,
    :block_pass     => 1,
    :block_call     => 1,
    :branch         => 1,
    :magic_number   => 0.25,
    :sclass         => 5,
    :super          => 1,
    :to_proc_icky!  => 10,
    :to_proc_lasgn  => 15,
    :yield          => 1,
  }

  ##
  # Eval forms

  SCORES.merge!(:define_method => 5,
                :eval          => 5,
                :module_eval   => 5,
                :class_eval    => 5,
                :instance_eval => 5)

  ##
  # Various "magic" usually used for "clever code"

  SCORES.merge!(:alias_method               => 2,
                :extend                     => 2,
                :include                    => 2,
                :instance_method            => 2,
                :instance_methods           => 2,
                :method_added               => 2,
                :method_defined?            => 2,
                :method_removed             => 2,
                :method_undefined           => 2,
                :private_class_method       => 2,
                :private_instance_methods   => 2,
                :private_method_defined?    => 2,
                :protected_instance_methods => 2,
                :protected_method_defined?  => 2,
                :public_class_method        => 2,
                :public_instance_methods    => 2,
                :public_method_defined?     => 2,
                :remove_method              => 2,
                :send                       => 3,
                :undef_method               => 2)

  ##
  # Calls that are ALMOST ALWAYS ABUSED!

  SCORES.merge!(:inject => 2)

  # :stopdoc:
  attr_accessor :multiplier
  attr_reader :calls, :option, :mass
  attr_reader :method_scores, :scores
  attr_reader :total_score, :totals
  attr_writer :threshold

  # :startdoc:

  ##
  # Add a score to the tally. Score can be predetermined or looked up
  # automatically. Uses multiplier for additional spankings.
  # Spankings!

  def add_to_score name, score = OTHER_SCORES[name]
    return if option[:methods] and method_stack.empty?
    @calls[signature][name] += score * @multiplier
  end

  ##
  # really?

  def average
    return 0 if calls.size == 0
    total_score / calls.size
  end

  ##
  # Calculates classes and methods scores.

  def calculate
    each_by_score threshold do |class_method, score, call_list|
      klass = class_method.scan(/.+(?=#|::)/).first

      method_scores[klass] << [class_method, score]
      scores[klass] += score
    end
  end

  ##
  # Returns true if the form looks like a "DSL" construct.
  #
  #   task :blah do ... end
  #   => s(:iter, s(:call, nil, :task, s(:lit, :blah)), ...)

  def dsl_name? args
    return false unless args and not args.empty?

    first_arg, = args
    first_arg = first_arg[1] if first_arg.sexp_type == :hash

    type, value, * = first_arg

    value if [:lit, :str].include? type
  end

  ##
  # Iterate over the calls sorted (descending) by score.

  def each_by_score max = nil
    current = 0

    calls.sort_by { |k,v| -totals[k] }.each do |class_method, call_list|
      score = totals[class_method]

      yield class_method, score, call_list

      current += score
      break if max and current >= max
    end
  end

  ##
  # Flog the given files. Deals with "-", and syntax errors.
  #
  # Not as smart as FlogCLI's #flog method as it doesn't traverse
  # dirs. Use PathExpander to expand dirs into files.

  def flog(*files)
    files.each do |file|
      next unless file == "-" or File.readable? file

      ruby = file == "-" ? $stdin.read : File.binread(file)

      flog_ruby ruby, file
    end

    calculate_total_scores
  end

  ##
  # Flog the given ruby source, optionally using file to provide paths
  # for methods. Smart. Handles syntax errors and timeouts so you
  # don't have to.

  def flog_ruby ruby, file="-", timeout = 10
    flog_ruby! ruby, file, timeout
  rescue Timeout::Error
    warn "TIMEOUT parsing #{file}. Skipping."
  rescue RubyParser::SyntaxError, Racc::ParseError => e
    q = option[:quiet]
    if e.inspect =~ /<\%|%\>/ or ruby =~ /<\%|%\>/ then
      return if q
      warn "#{e.inspect} at #{e.backtrace.first(5).join(", ")}"
      warn "\n...stupid lemmings and their bad erb templates... skipping"
    else
      warn "ERROR: parsing ruby file #{file}" unless q
      unless option[:continue] then
        warn "ERROR! Aborting. You may want to run with --continue."
        raise e
      end
      return if q
      warn "%s: %s at:\n  %s" % [e.class, e.message.strip,
                                 e.backtrace.first(5).join("\n  ")]
    end
  end

  ##
  # Flog the given ruby source, optionally using file to provide paths for
  # methods. Does not handle timeouts or syntax errors. See #flog_ruby.

  def flog_ruby! ruby, file="-", timeout = 10
    @parser = (option[:parser] || RubyParser).new

    warn "** flogging #{file}" if option[:verbose]

    ast = @parser.process ruby, file, timeout

    return unless ast

    mass[file] = ast.mass
    process ast
  end

  ##
  # Creates a new Flog instance with +options+.

  def initialize option = {}
    super()
    @option              = option
    @mass                = {}
    @parser              = nil
    @threshold           = option[:threshold] || DEFAULT_THRESHOLD
    self.auto_shift_type = true
    self.reset
  end

  ##
  # Returns the method/score pair of the maximum score.

  def max_method
    totals.max_by { |_, score| score }
  end

  ##
  # Returns the maximum score for a single method. Used for FlogTask.

  def max_score
    max_method.last
  end

  ##
  # For the duration of the block the complexity factor is increased
  # by #bonus This allows the complexity of sub-expressions to be
  # influenced by the expressions in which they are found.  Yields 42
  # to the supplied block.

  def penalize_by bonus
    @multiplier += bonus
    yield
    @multiplier -= bonus
  end

  ##
  # Reset score data

  def reset
    @totals           = @total_score = nil
    @multiplier       = 1.0
    @calls            = Hash.new { |h,k| h[k] = Hash.new 0 }
    @method_scores    = Hash.new { |h,k| h[k] = [] }
    @scores           = Hash.new 0
    method_locations.clear
  end

  ##
  # Compute the distance formula for a given tally

  def score_method(tally)
    a, b, c = 0, 0, 0
    tally.each do |cat, score|
      case cat
      when :assignment then a += score
      when :branch, :block_call then b += score
      else                  c += score
      end
    end
    Math.sqrt(a*a + b*b + c*c)
  end

  ##
  # Final threshold that is used for report

  def threshold
    option[:all] ? nil : total_score * @threshold
  end

  ##
  # Calculates the total score and populates @totals.

  def calculate_total_scores
    return if @totals

    @total_score = 0
    @totals = Hash.new(0)

    calls.each do |meth, tally|
      score = score_method(tally)

      @totals[meth] = score
      @total_score += score
    end
  end

  def no_method # :nodoc:
    @@no_method
  end

  ############################################################
  # Process Methods:

  # :stopdoc:
  def process_alias(exp)
    process exp.shift
    process exp.shift
    add_to_score :alias
    s()
  end

  def process_and(exp)
    add_to_score :branch
    penalize_by 0.1 do
      process exp.shift # lhs
      process exp.shift # rhs
    end
    s()
  end
  alias :process_or :process_and

  def process_attrasgn(exp)
    add_to_score :assignment
    process exp.shift # lhs
    exp.shift # name
    process_until_empty exp # rhs
    s()
  end

  def process_block(exp)
    penalize_by 0.1 do
      process_until_empty exp
    end
    s()
  end

  def process_block_pass(exp)
    arg = exp.shift

    add_to_score :block_pass

    return s() unless arg

    case arg.sexp_type
    when :lvar, :dvar, :ivar, :cvar, :self, :const, :colon2, :nil then # f(&b)
      # do nothing
    when :lit then                                                     # f(&:b)
      # do nothing -- this now costs about the same as a block
    when :call then                                                    # f(&x.b)
      # do nothing -- I don't like the indirection, but that's already scored
    when :lasgn then                                                   # f(&l=b)
      add_to_score :to_proc_lasgn
    when :iter, :dsym, :dstr, :hash, *BRANCHING then                   # below
      # f(&proc { ... })
      # f(&"#{...}")
      # f(&:"#{...}")
      # f(&if ... then ... end") and all other branching forms
      # f(&{ a: 42 })  WHY?!?
      add_to_score :to_proc_icky!
    else
      raise({:block_pass_even_ickier! => arg}.inspect)
    end

    process arg

    s()
  end

  def process_call(exp)
    penalize_by 0.2 do
      process exp.shift # recv
    end

    name = exp.shift

    penalize_by 0.2 do
      process_until_empty exp
    end

    add_to_score name, SCORES[name]

    s()
  end

  def process_safe_call(exp)
    penalize_by 0.3 do
      process exp.shift # recv
    end

    name = exp.shift

    penalize_by 0.2 do
      process_until_empty exp
    end

    add_to_score name, SCORES[name]

    s()
  end

  def process_case(exp)
    add_to_score :branch
    process exp.shift # recv
    penalize_by 0.1 do
      process_until_empty exp
    end
    s()
  end

  def process_class(exp)
    super do
      penalize_by 1.0 do
        process exp.shift # superclass expression
      end
      process_until_empty exp
    end
  end

  def process_dasgn_curr(exp) # FIX: remove
    add_to_score :assignment
    exp.shift # name
    process exp.shift # assigment, if any
    s()
  end
  alias :process_iasgn :process_dasgn_curr
  alias :process_lasgn :process_dasgn_curr

  # TODO:  it's not clear to me whether this can be generated at all.
  def process_else(exp)
    add_to_score :branch
    penalize_by 0.1 do
      process_until_empty exp
    end
    s()
  end
  alias :process_rescue :process_else
  alias :process_when   :process_else

  def process_if(exp)
    add_to_score :branch
    process exp.shift # cond
    penalize_by 0.1 do
      process exp.shift # true
      process exp.shift # false
    end
    s()
  end

  def process_iter(exp)
    context = (self.context - [:class, :module, :scope])
    context = context.uniq.sort_by { |s| s.to_s }

    exp.delete 0 # { || ... } has 0 in arg slot

    if context == [:block, :iter] or context == [:iter] then
      recv, = exp

      # DSL w/ names. eg task :name do ... end
      #   looks like s(:call, nil, :task, s(:lit, :name))
      #           or s(:call, nil, :task, s(:str, "name"))
      #           or s(:call, nil, :task, s(:hash, s(:lit, :name) ...))

      t, r, m, *a = recv

      if t == :call and r == nil and submsg = dsl_name?(a) then
        m = "#{m}(#{submsg})" if m and [String, Symbol].include?(submsg.class)
        in_klass m do                             # :task/namespace
          in_method submsg, exp.file, exp.line, exp.line_max do # :name
            process_until_empty exp
          end
        end
        return s()
      end
    end

    add_to_score :block_call

    process exp.shift # no penalty for LHS

    penalize_by 0.1 do
      process_until_empty exp
    end

    s()
  end

  Rational = Integer unless defined? Rational # 1.8 / 1.9

  def process_lit(exp)
    value = exp.shift
    case value
    when 0, -1 then
      # ignore those because they're used as array indicies instead of
      # first/last
    when Integer, Float, Rational, Complex then
      add_to_score :magic_number unless context[1] == :cdecl
    when Symbol, Regexp, Range then
      # do nothing
    else
      raise "Unhandled lit: #{value.inspect}:#{value.class}"
    end
    s()
  end

  def process_masgn(exp)
    add_to_score :assignment

    exp.map! { |s| Sexp === s ? s : s(:lasgn, s) }

    process_until_empty exp
    s()
  end

  def process_sclass(exp)
    super do
      penalize_by 0.5 do
        process exp.shift # recv
        process_until_empty exp
      end
    end

    add_to_score :sclass
    s()
  end

  def process_super(exp)
    add_to_score :super
    process_until_empty exp
    s()
  end

  def process_while(exp)
    add_to_score :branch
    penalize_by 0.1 do
      process exp.shift # cond
      process exp.shift # body
    end
    exp.shift # pre/post
    s()
  end
  alias :process_until :process_while

  def process_yield(exp)
    add_to_score :yield
    process_until_empty exp
    s()
  end
  # :startdoc:
end