brakeman 0.0.2

data/lib/processors/lib/processor_helper.rb

@@ -0,0 +1,36 @@
+#Contains a couple shared methods for Processors.
+module ProcessorHelper
+
+  #Sets the current module.
+  def process_module exp
+    @current_module = class_name(exp[1]).to_s
+    process exp[2] 
+    @current_module = nil
+    exp
+  end
+
+  #Returns a class name as a Symbol.
+  def class_name exp
+    case exp
+    when Sexp
+      case exp.node_type
+      when :const
+        exp[1]
+      when :colon2
+        "#{class_name(exp[1])}::#{exp[2]}".to_sym
+      when :colon3
+        "::#{exp[1]}".to_sym
+      when :call
+        process exp
+      else
+        raise "Error: Cannot get class name from #{exp}"
+      end
+    when Symbol
+      exp
+    when nil
+      nil
+    else
+      raise "Error: Cannot get class name from #{exp}"
+    end
+  end
+end

data/lib/processors/lib/render_helper.rb

@@ -0,0 +1,118 @@
+require 'digest/sha1'
+
+#Processes a call to render() in a controller or template
+module RenderHelper
+
+  #Process s(:render, TYPE, OPTIONS)
+  def process_render exp
+    process_default exp
+    @rendered = true
+    case exp[1]
+    when :action
+      process_action exp[2][1], exp[3]
+    when :default
+      process_template template_name, exp[3]
+    when :partial
+      process_partial exp[2], exp[3]
+    when :nothing
+    end
+    exp
+  end
+
+  #Determines file name for partial and then processes it
+  def process_partial name, args
+    if name == "" or !(string? name or symbol? name)
+      return
+    end
+
+    names = name[1].to_s.split("/")
+    names[-1] = "_" + names[-1]
+    process_template template_name(names.join("/")), args
+  end
+
+  #Processes a given action
+  def process_action name, args
+    process_template template_name(name), args
+  end
+
+  #Processes a template, adding any instance variables
+  #to its environment.
+  def process_template name, args, called_from = nil
+    #Get scanned source for this template
+    name = name.to_s.gsub(/^\//, "")
+    template = @tracker.templates[name.to_sym]
+    unless template
+      warn "[Notice] No such template: #{name}" if OPTIONS[:debug]
+      return 
+    end
+
+    template_env = only_ivars
+
+    #Hash the environment and the source of the template to avoid
+    #pointlessly processing templates, which can become prohibitively
+    #expensive in terms of time and memory.
+    digest = Digest::SHA1.new.update(template_env.instance_variable_get(:@env).to_a.sort.to_s << template[:src].to_s).to_s.to_sym
+
+    if @tracker.template_cache.include? digest
+      #Already processed this template with identical environment
+      return
+    else
+      @tracker.template_cache << digest
+
+      options = get_options args
+
+      if hash? options[:locals]
+        hash_iterate options[:locals] do |key, value|
+          template_env[Sexp.new(:call, nil, key[1], Sexp.new(:arglist))] = value
+        end
+      end
+
+      if options[:collection]
+
+        #The collection name is the name of the partial without the leading
+        #underscore.
+        variable = template[:name].to_s.match(/[^\/_][^\/]+$/)[0].to_sym
+
+        #Unless the :as => :variable_name option is used
+        if options[:as]
+          if string? options[:as] or symbol? options[:as]
+            variable = options[:as][1].to_sym
+          end
+        end
+
+        template_env[Sexp.new(:call, nil, variable, Sexp.new(:arglist))] = Sexp.new(:call, Sexp.new(:const, Tracker::UNKNOWN_MODEL), :new, Sexp.new(:arglist))
+      end
+
+      #Run source through AliasProcessor with instance variables from the
+      #current environment.
+      #TODO: Add in :locals => { ... } to environment
+      src = TemplateAliasProcessor.new(@tracker, template).process_safely(template[:src], template_env)
+
+      #Run alias-processed src through the template processor to pull out
+      #information and outputs.
+      #This information will be stored in tracker.templates, but with a name
+      #specifying this particular route. The original source should remain
+      #pristine (so it can be processed within other environments).
+      @tracker.processor.process_template name, src, template[:type], called_from
+    end
+  end
+
+  #Override to process name, such as adding the controller name.
+  def template_name name
+    raise "RenderHelper#template_name should be overridden."
+  end
+
+  #Turn options Sexp into hash
+  def get_options args
+    options = {}
+    return options unless hash? args
+
+    hash_iterate args do |key, value|
+      if symbol? key
+        options[key[1]] = value
+      end
+    end
+
+    options
+  end
+end

data/lib/processors/library_processor.rb

@@ -0,0 +1,117 @@
+require 'processors/base_processor'
+require 'processors/alias_processor'
+
+#Process generic library and stores it in Tracker.libs
+class LibraryProcessor < BaseProcessor
+
+  def initialize tracker
+    super
+    @file_name = nil
+    @alias_processor = AliasProcessor.new
+  end
+
+  def process_library src, file_name = nil
+    @file_name = file_name
+    process src
+  end
+
+  def process_class exp
+    name = class_name(exp[1])
+    
+    if @current_class
+      outer_class = @current_class
+      name = (outer_class[:name].to_s + "::" + name.to_s).to_sym
+    end
+
+    if @current_module
+      name = (@current_module[:name].to_s + "::" + name.to_s).to_sym
+    end
+
+    if @tracker.libs[name]
+      @current_class = @tracker.libs[name]
+    else
+      @current_class = { :name => name,
+                    :parent => class_name(exp[2]),
+                    :includes => [],
+                    :public => {},
+                    :private => {},
+                    :protected => {},
+                    :src => exp,
+                    :file => @file_name }
+    
+      @tracker.libs[name] = @current_class
+    end
+
+    exp[3] = process exp[3]
+
+    if outer_class
+      @current_class = outer_class
+    else
+      @current_class = nil
+    end
+
+    exp
+  end
+
+  def process_module exp
+    name = class_name(exp[1])
+
+    if @current_module
+      outer_class = @current_module
+      name = (outer_class[:name].to_s + "::" + name.to_s).to_sym
+    end
+
+    if @current_class
+      name = (@current_class[:name].to_s + "::" + name.to_s).to_sym
+    end
+
+    if @tracker.libs[name]
+      @current_module = @tracker.libs[name]
+    else
+      @current_module = { :name => name,
+                    :includes => [],
+                    :public => {},
+                    :private => {},
+                    :protected => {},
+                    :src => exp }
+    
+      @tracker.libs[name] = @current_module
+    end
+
+    exp[2] = process exp[2]
+
+    if outer_class
+      @current_module = outer_class
+    else
+      @current_module = nil
+    end
+
+    exp
+  end
+
+  def process_defn exp
+    exp[0] = :methdef
+    exp[3] = @alias_processor.process_safely process(exp[3]), SexpProcessor::Environment.new
+
+    if @current_class
+      @current_class[:public][exp[1]] = exp[3]
+    elsif @current_module
+      @current_module[:public][exp[1]] = exp[3]
+    end
+
+    exp
+  end
+
+  def process_defs exp
+    exp[0] = :selfdef
+    exp[4] = @alias_processor.process_safely process(exp[4]), SexpProcessor::Environment.new
+
+    if @current_class
+      @current_class[:public][exp[2]] = exp[4]
+    elsif @current_module
+      @current_module[:public][exp[3]] = exp[4]
+    end
+
+    exp
+  end
+end

data/lib/processors/model_processor.rb

@@ -0,0 +1,125 @@
+require 'processors/base_processor'
+
+#Processes models. Puts results in tracker.models
+class ModelProcessor < BaseProcessor
+  def initialize tracker
+    super 
+    @model = nil
+    @current_method = nil
+    @visibility = :public
+    @file_name = nil
+  end
+
+  #Process model source
+  def process_model src, file_name = nil
+    @file_name = file_name
+    process src
+  end
+
+  #s(:class, NAME, PARENT, s(:scope ...))
+  def process_class exp
+    if @model
+      warn "[Notice] Skipping inner class: #{class_name exp[1]}" if OPTIONS[:debug]
+      ignore
+    else
+      @model = { :name => class_name(exp[1]),
+        :parent => class_name(exp[2]),
+        :includes => [],
+        :public => {},
+        :private => {},
+        :protected => {},
+        :options => {},
+        :file => @file_name }
+      @tracker.models[@model[:name]] = @model
+      res = process exp[3]
+      @model = nil
+      res
+    end
+  end
+
+  #Handle calls outside of methods,
+  #such as include, attr_accessible, private, etc.
+  def process_call exp
+    return exp unless @model
+    target = exp[1]
+    if sexp? target
+      target = process target
+    end
+
+    method = exp[2]
+    args = exp[3]
+
+    #Methods called inside class definition
+    #like attr_* and other settings
+    if @current_method.nil? and target.nil?
+      if args.length == 1 #actually, empty
+        case method
+        when :private, :protected, :public
+          @visibility = method
+        else
+          #??
+        end
+      else
+        case method
+        when :include
+          @model[:includes] << class_name(args[1]) if @model
+        when :attr_accessible
+          @model[:attr_accessible] ||= []
+          args = args[1..-1].map do |e|
+            e[1]
+          end
+
+          @model[:attr_accessible].concat args
+        else
+          if @model
+            @model[:options][method] ||= []
+            @model[:options][method] << process(args)
+          end
+        end
+      end
+      ignore
+    else
+      call = Sexp.new :call, target, method, process(args)
+      call.line(exp.line)
+      call
+    end
+  end
+
+  #Add method definition to tracker
+  def process_defn exp
+    return exp unless @model
+    name = exp[1]
+
+    @current_method = name
+    res = Sexp.new :methdef, name, process(exp[2]), process(exp[3][1])
+    res.line(exp.line)
+    @current_method = nil
+    if @model
+      list = @model[@visibility]
+      list[name] = res
+    end
+    res
+  end
+
+  #Add method definition to tracker
+  def process_defs exp
+    return exp unless @model
+    name = exp[2]
+
+    if exp[1].node_type == :self
+      target = @model[:name]
+    else
+      target = class_name exp[1]
+    end
+
+    @current_method = name
+    res = Sexp.new :selfdef, target, name, process(exp[3]), process(exp[4][1])
+    res.line(exp.line)
+    @current_method = nil
+    if @model
+      @model[@visibility][name] = res unless @model.nil?
+    end
+    res
+  end
+
+end

data/lib/processors/output_processor.rb

@@ -0,0 +1,204 @@
+require 'rubygems'
+require 'ruby2ruby'
+require 'util'
+
+#Produces formatted output strings from Sexps.
+#Recommended usage is
+#
+#  OutputProcessor.new.format(Sexp.new(:str, "hello"))
+class OutputProcessor < Ruby2Ruby
+  include Util
+
+  #Copies +exp+ and then formats it.
+  def format exp
+    process exp.deep_clone
+  end
+
+  alias process_safely format
+
+  def process exp
+    begin
+      super exp if sexp? exp and not exp.empty?
+    rescue Exception => e
+      warn "While formatting #{exp}: #{e}\n#{e.backtrace.join("\n")}" if OPTIONS[:debug]
+    end
+  end
+
+  def process_call exp
+    if exp[0].is_a? Symbol
+      target = exp[0]
+
+      method = exp[1]
+
+      args = process exp[2]
+
+      out = nil
+
+      if method == :[]
+        if target
+          out = "#{target}[#{args}]"
+        else
+          raise Exception.new("Not sure what to do with access and no target: #{exp}")
+        end
+      else
+        if target
+          out = "#{target}.#{method}(#{args})"
+        else
+          out = "#{method}(#{args})"
+        end
+      end
+      exp.clear
+      out
+    else
+      super exp
+    end
+  end
+
+  def process_lvar exp
+    out = "(local #{exp[0]})"
+    exp.clear
+    out
+  end
+
+  def process_ignore exp
+    exp.clear
+    "[ignored]"
+  end
+
+  def process_params exp
+    exp.clear
+    "params"
+  end
+
+  def process_session exp
+    exp.clear
+    "session"
+  end
+
+  def process_cookies exp
+    exp.clear
+    "cookies"
+  end
+
+  def process_string_interp exp
+    out = '"'
+    exp.each do |e|
+      if e.is_a? String
+        out << e
+      else
+        res = process e
+        out << res unless res == "" 
+      end
+    end
+    out << '"'
+    exp.clear
+    out
+  end
+
+  def process_string_eval exp
+    out = "\#{#{process(exp[0])}}"
+    exp.clear
+    out
+  end
+
+  def process_dxstr exp
+    out = "`"
+    out << exp.map! do |e|
+      if e.is_a? String
+        e
+      elsif string? e
+        e[1]
+      else
+        process e
+      end
+    end.join
+    exp.clear
+    out << "`"
+  end
+
+  def process_rlist exp
+    out = exp.map do |e|
+      res = process e
+      if res == ""
+        nil
+      else
+        res
+      end
+    end.compact.join("\n")
+    exp.clear
+    out
+  end
+
+  def process_call_with_block exp
+    call = process exp[0]
+    block = process exp[1] if exp[1]
+    out = "#{call} do\n #{block}\n end"
+    exp.clear
+    out
+  end
+
+  def process_output exp
+    out = if exp[0].node_type == :str
+            ""
+          else
+            res = process exp[0]
+
+            if res == ""
+              ""
+            else
+              "[Output] #{res}"
+            end
+          end
+    exp.clear
+    out
+  end
+
+  def process_format exp
+    out = if exp[0].node_type == :str or exp[0].node_type == :ignore
+            ""
+          else
+            res = process exp[0]
+
+            if res == ""
+              ""
+            else
+              "[Format] #{res}"
+            end
+          end
+    exp.clear
+    out
+  end
+
+  def process_format_escaped exp
+    out = if exp[0].node_type == :str or exp[0].node_type == :ignore
+            ""
+          else
+            res = process exp[0]
+
+            if res == ""
+              ""
+            else
+              "[Escaped] #{res}"
+            end
+          end
+    exp.clear
+    out
+  end
+
+  def process_const exp
+    if exp[0] == Tracker::UNKNOWN_MODEL
+      exp.clear
+      "(Unresolved Model)"
+    else
+      super exp
+    end
+  end
+
+  def process_render exp
+    exp[1] = process exp[1] if sexp? exp[1]
+    exp[2] = process exp[2] if sexp? exp[2]
+    out = "render(#{exp[0]} => #{exp[1]}, #{exp[2]})"
+    exp.clear
+    out
+  end
+end