railroader 4.3.4

data/lib/railroader/processors/lib/call_conversion_helper.rb

@@ -0,0 +1,90 @@
+module Railroader
+  module CallConversionHelper
+    def all_literals? exp, expected_type = :array
+      node_type? exp, expected_type and
+        exp.length > 1 and
+        exp.all? { |e| e.is_a? Symbol or node_type? e, :lit, :str }
+    end
+
+    # Join two array literals into one.
+    def join_arrays lhs, rhs, original_exp = nil
+      if array? lhs and array? rhs
+        result = Sexp.new(:array).line(lhs.line)
+        result.concat lhs[1..-1]
+        result.concat rhs[1..-1]
+        result
+      else
+        original_exp
+      end
+    end
+
+    # Join two string literals into one.
+    def join_strings lhs, rhs, original_exp = nil
+      if string? lhs and string? rhs
+        result = Sexp.new(:str).line(lhs.line)
+        result.value = lhs.value + rhs.value
+
+        if result.value.length > 50
+          # Avoid gigantic strings
+          lhs
+        else
+          result
+        end
+      elsif call? lhs and lhs.method == :+ and string? lhs.first_arg and string? rhs
+        joined = join_strings lhs.first_arg, rhs
+        lhs.first_arg = joined
+        lhs
+      elsif safe_literal? lhs or safe_literal? rhs
+        safe_literal(lhs.line)
+      else
+        original_exp
+      end
+    end
+
+    def math_op op, lhs, rhs, original_exp = nil
+      if number? lhs and number? rhs
+        if op == :/ and rhs.value == 0 and not lhs.value.is_a? Float
+          # Avoid division by zero
+          return original_exp
+        else
+          value = lhs.value.send(op, rhs.value)
+          Sexp.new(:lit, value).line(lhs.line)
+        end
+      elsif call? lhs and lhs.method == :+ and number? lhs.first_arg and number? rhs
+        # (x + 1) + 2 -> (x + 3)
+        lhs.first_arg = Sexp.new(:lit, lhs.first_arg.value + rhs.value).line(lhs.first_arg.line)
+        lhs
+      elsif safe_literal? lhs or safe_literal? rhs
+        safe_literal(lhs.line)
+      else
+        original_exp
+      end
+    end
+
+    # Process single integer access to an array.
+    #
+    # Returns the value inside the array, if possible.
+    def process_array_access array, args, original_exp = nil
+      if args.length == 1 and integer? args.first
+        index = args.first.value
+
+        #Have to do this because first element is :array and we have to skip it
+        array[1..-1][index] or original_exp
+      else
+        original_exp
+      end
+    end
+
+    # Process hash access by returning the value associated
+    # with the given argument.
+    def process_hash_access hash, index, original_exp = nil
+      if value = hash_access(hash, index)
+        value # deep_clone?
+      elsif all_literals? hash, :hash
+        safe_literal(hash.line)
+      else
+        original_exp
+      end
+    end
+  end
+end

data/lib/railroader/processors/lib/find_all_calls.rb

@@ -0,0 +1,224 @@
+require 'railroader/processors/lib/basic_processor'
+
+class Railroader::FindAllCalls < Railroader::BasicProcessor
+  attr_reader :calls
+
+  def initialize tracker
+    super
+    @current_class = nil
+    @current_method = nil
+    @in_target = false
+    @calls = []
+    @cache = {}
+  end
+
+  #Process the given source. Provide either class and method being searched
+  #or the template. These names are used when reporting results.
+  def process_source exp, opts
+    @current_class = opts[:class]
+    @current_method = opts[:method]
+    @current_template = opts[:template]
+    @current_file = opts[:file]
+    @current_call = nil
+    process exp
+  end
+
+  #Process body of method
+  def process_defn exp
+    return exp unless @current_method
+    process_all exp.body
+  end
+
+  alias process_defs process_defn
+
+  #Process body of block
+  def process_rlist exp
+    process_all exp
+  end
+
+  def process_call exp
+    @calls << create_call_hash(exp)
+    exp
+  end
+
+  def process_iter exp
+    call = exp.block_call
+
+    if call.node_type == :call
+      call_hash = create_call_hash(call)
+
+      call_hash[:block] = exp.block
+      call_hash[:block_args] = exp.block_args
+
+      @calls << call_hash
+
+      process exp.block
+    else
+      #Probably a :render call with block
+      process call
+      process exp.block
+    end
+
+    exp
+  end
+
+  #Calls to render() are converted to s(:render, ...) but we would
+  #like them in the call cache still for speed
+  def process_render exp
+    process exp.last if sexp? exp.last
+
+    add_simple_call :render, exp
+
+    exp
+  end
+
+  #Technically, `` is call to Kernel#`
+  #But we just need them in the call cache for speed
+  def process_dxstr exp
+    process exp.last if sexp? exp.last
+
+    add_simple_call :`, exp
+
+    exp
+  end
+
+  #:"string" is equivalent to "string".to_sym
+  def process_dsym exp
+    exp.each { |arg| process arg if sexp? arg }
+
+    add_simple_call :literal_to_sym, exp
+
+    exp
+  end
+
+  # Process a dynamic regex like a call
+  def process_dregx exp
+    exp.each { |arg| process arg if sexp? arg }
+
+    add_simple_call :railroader_regex_interp, exp
+
+    exp
+  end
+
+  #Process an assignment like a call
+  def process_attrasgn exp
+    process_call exp
+  end
+
+  private
+
+  def add_simple_call method_name, exp
+    @calls << { :target => nil,
+                :method => method_name,
+                :call => exp,
+                :nested => false,
+                :location => make_location,
+                :parent => @current_call }
+  end
+
+  #Gets the target of a call as a Symbol
+  #if possible
+  def get_target exp, include_calls = false
+    if sexp? exp
+      case exp.node_type
+      when :ivar, :lvar, :const, :lit
+        exp.value
+      when :true, :false
+        exp[0]
+      when :colon2
+        class_name exp
+      when :self
+        @current_class || @current_module || nil
+      when :params, :session, :cookies
+        exp.node_type
+      when :call, :safe_call
+        if include_calls
+          if exp.target.nil?
+            exp.method
+          else
+            t = get_target(exp.target, :include_calls)
+            if t.is_a? Symbol
+              :"#{t}.#{exp.method}"
+            else
+              exp
+            end
+          end
+        else
+          exp
+        end
+      else
+        exp
+      end
+    else
+      exp
+    end
+  end
+
+  #Returns method chain as an array
+  #For example, User.human.alive.all would return [:User, :human, :alive, :all]
+  def get_chain call
+    if node_type? call, :call, :attrasgn, :safe_call, :safe_attrasgn
+      get_chain(call.target) + [call.method]
+    elsif call.nil?
+      []
+    else
+      [get_target(call)]
+    end
+  end
+
+  def make_location
+    if @current_template
+      key = [@current_template, @current_file]
+      cached = @cache[key]
+      return cached if cached
+
+      @cache[key] = { :type => :template,
+        :template => @current_template,
+        :file => @current_file }
+    else
+      key = [@current_class, @current_method, @current_file]
+      cached = @cache[key]
+      return cached if cached
+      @cache[key] = { :type => :class,
+        :class => @current_class,
+        :method => @current_method,
+        :file => @current_file }
+    end
+
+  end
+
+  #Return info hash for a call Sexp
+  def create_call_hash exp
+    target = get_target exp.target
+
+    if call? target or node_type? target, :dxstr # need to index `` even if target of a call
+      already_in_target = @in_target
+      @in_target = true
+      process target
+      @in_target = already_in_target
+
+      target = get_target(target, :include_calls)
+    end
+
+    method = exp.method
+
+    call_hash = {
+      :target => target,
+      :method => method,
+      :call => exp,
+      :nested => @in_target,
+      :chain => get_chain(exp),
+      :location => make_location,
+      :parent => @current_call
+    }
+
+    old_parent = @current_call
+    @current_call = call_hash
+
+    process_call_args exp
+
+    @current_call = old_parent
+
+    call_hash
+  end
+end

data/lib/railroader/processors/lib/find_call.rb

@@ -0,0 +1,183 @@
+require 'railroader/processors/lib/basic_processor'
+
+#Finds method calls matching the given target(s).
+#   #-- This should be deprecated --#
+#   #--  Do not use for new code  --#
+#
+#Targets/methods can be:
+#
+# - nil: matches anything, including nothing
+# - Empty array: matches nothing
+# - Symbol: matches single target/method exactly
+# - Array of symbols: matches against any of the symbols
+# - Regular expression: matches the expression
+# - Array of regular expressions: matches any of the expressions
+#
+#If a target is also the name of a class, methods called on instances
+#of that class will also be matched, in a very limited way.
+#(Any methods called on Klass.new, basically. More useful when used
+#in conjunction with AliasProcessor.)
+#
+#Examples:
+#
+# #To find any uses of this class:
+# FindCall.new :FindCall, nil
+#
+# #Find system calls without a target
+# FindCall.new [], [:system, :exec, :syscall]
+#
+# #Find all calls to length(), no matter the target
+# FindCall.new nil, :length
+#
+# #Find all calls to sub, sub!, gsub, or gsub!
+# FindCall.new nil, /^g?sub!?$/
+class Railroader::FindCall < Railroader::BasicProcessor
+
+  def initialize targets, methods, tracker, in_depth = false
+    super tracker
+    @calls = []
+    @find_targets = targets
+    @find_methods = methods
+    @current_class = nil
+    @current_method = nil
+    @in_depth = in_depth
+  end
+
+  #Returns a list of results.
+  #
+  #A result looks like:
+  #
+  # s(:result, :ClassName, :method_name, s(:call, ...))
+  #
+  #or
+  #
+  # s(:result, :template_name, s(:call, ...))
+  def matches
+    @calls
+  end
+
+  #Process the given source. Provide either class and method being searched
+  #or the template. These names are used when reporting results.
+  #
+  #Use FindCall#matches to retrieve results.
+  def process_source exp, klass = nil, method = nil, template = nil
+    @current_class = klass
+    @current_method = method
+    @current_template = template
+    process exp
+  end
+
+  #Process body of method
+  def process_defn exp
+    process_all exp.body
+  end
+
+  alias :process_defs :process_defn
+
+  #Process body of block
+  def process_rlist exp
+    process_all exp
+  end
+
+  #Look for matching calls and add them to results
+  def process_call exp
+    target = get_target exp.target
+    method = exp.method
+
+    process_call_args exp
+
+    if match(@find_targets, target) and match(@find_methods, method)
+
+      if @current_template
+        @calls << Sexp.new(:result, @current_template, exp).line(exp.line)
+      else
+        @calls << Sexp.new(:result, @current_module, @current_class, @current_method, exp).line(exp.line)
+      end
+
+    end
+    
+    #Normally FindCall won't match a method invocation that is the target of
+    #another call, such as:
+    #
+    #  User.find(:first, :conditions => "user = '#{params['user']}').name
+    #
+    #A search for User.find will not match this unless @in_depth is true.
+    if @in_depth and call? exp.target
+      process exp.target
+    end
+
+    exp
+  end
+
+  #Process an assignment like a call
+  def process_attrasgn exp
+    process_call exp
+  end
+
+  private
+
+  #Gets the target of a call as a Symbol
+  #if possible
+  def get_target exp
+    if sexp? exp
+      case exp.node_type
+      when :ivar, :lvar, :const, :lit
+        exp.value
+      when :true, :false
+        exp.node_type
+      when :colon2
+        class_name exp
+      else
+        exp
+      end
+    else
+      exp
+    end
+  end
+
+  #Checks if the search terms match the given item
+  def match search_terms, item
+    case search_terms
+    when Symbol
+      if search_terms == item
+        true
+      elsif sexp? item
+        is_instance_of? item, search_terms
+      else
+        false
+      end
+    when Sexp
+      search_terms == item
+    when Enumerable
+      if search_terms.empty?
+        item == nil
+      else
+        search_terms.each do|term|
+          if match(term, item)
+            return true
+          end
+        end
+        false
+      end
+    when Regexp
+      search_terms.match item.to_s
+    when nil
+      true
+    else
+      raise "Cannot match #{search_terms} and #{item}"
+    end
+  end
+
+  #Checks if +item+ is an instance of +klass+ by looking for Klass.new
+  def is_instance_of? item, klass
+    if call? item
+      if sexp? item.target
+        item.method == :new and item.target.node_type == :const and item.target.value == klass
+      else
+        item.method == :new and item.target == klass
+      end
+    else
+      false
+    end
+  end
+end

data/lib/railroader/processors/lib/find_return_value.rb

@@ -0,0 +1,166 @@
+require 'railroader/processors/alias_processor'
+
+#Attempts to determine the return value of a method.
+#
+#Preferred usage:
+#
+#  Railroader::FindReturnValue.return_value exp
+class Railroader::FindReturnValue
+  include Railroader::Util
+
+  #Returns a guess at the return value of a given method or other block of code.
+  #
+  #If multiple return values are possible, returns all values in an :or Sexp.
+  def self.return_value exp, env = nil
+    self.new.get_return_value exp, env
+  end
+
+  def initialize
+    @uses_ivars = false
+    @return_values = []
+  end
+
+  def uses_ivars?
+    @uses_ivars
+  end
+
+  #Find return value of Sexp. Takes an optional starting environment.
+  def get_return_value exp, env = nil
+    process_method exp, env
+    value = make_return_value
+    value.original_line = exp.line
+    value
+  end
+
+  #Process method (or, actually, any Sexp) for return value.
+  def process_method exp, env = nil
+    exp = Railroader::AliasProcessor.new.process_safely exp, env
+
+    find_explicit_return_values exp
+
+    if node_type? exp, :defn, :defs
+      body = exp.body
+
+      unless body.empty?
+        @return_values << last_value(body)
+      else
+        Railroader.debug "FindReturnValue: Empty method? #{exp.inspect}"
+      end
+    elsif exp
+      @return_values << last_value(exp)
+    else
+       Railroader.debug "FindReturnValue: Given something strange? #{exp.inspect}"
+    end
+
+    exp
+  end
+
+  #Searches expression for return statements.
+  def find_explicit_return_values exp
+    todo = [exp]
+
+    until todo.empty?
+      current = todo.shift
+
+      @uses_ivars = true if node_type? current, :ivar
+
+      if node_type? current, :return
+        @return_values << last_value(current.value) if current.value
+      elsif sexp? current
+        todo = current[1..-1].concat todo
+      end
+    end
+  end
+
+  #Determines the "last value" of an expression.
+  def last_value exp
+    case exp.node_type
+    when :rlist, :block, :scope, Sexp
+      last_value exp.last
+    when :if
+      then_clause = exp.then_clause
+      else_clause = exp.else_clause
+
+      if then_clause.nil? and else_clause.nil?
+        nil
+      elsif then_clause.nil?
+        last_value else_clause
+      elsif else_clause.nil?
+        last_value then_clause
+      else
+        true_branch = last_value then_clause
+        false_branch = last_value else_clause
+
+        if true_branch and false_branch
+          value = make_or(true_branch, false_branch)
+          value.original_line = value.rhs.line
+          value
+        else #Unlikely?
+          true_branch or false_branch
+        end
+      end
+    when :lasgn, :iasgn, :op_asgn_or, :attrasgn
+      last_value exp.rhs
+    when :rescue
+      values = []
+
+      exp.each_sexp do |e|
+        if node_type? e, :resbody
+          if e.last
+            values << last_value(e.last)
+          end
+        elsif sexp? e
+          values << last_value(e)
+        end
+      end
+
+      values.reject! do |v|
+        v.nil? or node_type? v, :nil
+      end
+
+      if values.length > 1
+        values.inject do |m, v|
+          make_or(m, v)
+        end
+      else
+        values.first
+      end
+    when :return
+      if exp.value
+        last_value exp.value
+      else
+        nil
+      end
+    when :nil
+      nil
+    else
+      exp.original_line = exp.line unless exp.original_line
+      exp
+    end
+  end
+
+  def make_or lhs, rhs
+    #Better checks in future
+    if lhs == rhs
+      lhs
+    else
+      Sexp.new(:or, lhs, rhs)
+    end
+  end
+
+  #Turns the array of return values into an :or Sexp
+  def make_return_value
+    @return_values.compact!
+    @return_values.uniq!
+
+    if @return_values.empty?
+      Sexp.new(:nil)
+    elsif @return_values.length == 1
+      @return_values.first
+    else
+      @return_values.reduce do |value, sexp|
+        make_or value, sexp
+      end
+    end
+  end
+end