railroader 4.3.4

data/lib/railroader/processors/lib/rails3_config_processor.rb

@@ -0,0 +1,132 @@
+
+require 'railroader/processors/lib/basic_processor'
+
+#Processes configuration. Results are put in tracker.config.
+#
+#Configuration of Rails via Rails::Initializer are stored in tracker.config.rails.
+#For example:
+#
+#  MyApp::Application.configure do
+#    config.active_record.whitelist_attributes = true
+#  end
+#
+#will be stored in
+#
+#  tracker.config.rails[:active_record][:whitelist_attributes]
+#
+#Values for tracker.config.rails will still be Sexps.
+class Railroader::Rails3ConfigProcessor < Railroader::BasicProcessor
+  RAILS_CONFIG = Sexp.new(:call, nil, :config)
+
+  def initialize *args
+    super
+    @inside_config = false
+  end
+
+  #Use this method to process configuration file
+  def process_config src, file_name
+    @file_name = file_name
+    res = Railroader::AliasProcessor.new(@tracker).process_safely(src, nil, @file_name)
+    process res
+  end
+
+  #Look for MyApp::Application.configure do ... end
+  def process_iter exp
+    call = exp.block_call
+
+    if node_type?(call.target, :colon2) and
+      call.target.rhs == :Application and
+      call.method == :configure
+
+      @inside_config = true
+      process exp.block if sexp? exp.block
+      @inside_config = false
+    end
+
+    exp
+  end
+
+  #Look for class Application < Rails::Application
+  def process_class exp
+    if exp.class_name == :Application
+      @inside_config = true
+      process_all exp.body if sexp? exp.body
+      @inside_config = false
+    end
+
+    exp
+  end
+
+  #Look for configuration settings
+  def process_attrasgn exp
+    return exp unless @inside_config
+
+    if exp.target == RAILS_CONFIG
+      #Get rid of '=' at end
+      attribute = exp.method.to_s[0..-2].to_sym
+      if exp.args.length > 1
+        #Multiple arguments?...not sure if this will ever happen
+        @tracker.config.rails[attribute] = exp.args
+      else
+        @tracker.config.rails[attribute] = exp.first_arg
+      end
+    elsif include_rails_config? exp
+      options = get_rails_config exp
+      level = @tracker.config.rails
+      options[0..-2].each do |o|
+        level[o] ||= {}
+
+        option = level[o]
+
+        if not option.is_a? Hash
+          Railroader.debug "[Notice] Skipping config setting: #{options.map(&:to_s).join(".")}"
+          return exp
+        end
+
+        level = level[o]
+      end
+
+      level[options.last] = exp.first_arg
+    end
+
+    exp
+  end
+
+  #Check if an expression includes a call to set Rails config
+  def include_rails_config? exp
+    target = exp.target
+    if call? target
+      if target.target == RAILS_CONFIG
+        true
+      else
+        include_rails_config? target
+      end
+    elsif target == RAILS_CONFIG
+      true
+    else
+      false
+    end
+  end
+
+  #Returns an array of symbols for each 'level' in the config
+  #
+  #  config.action_controller.session_store = :cookie
+  #
+  #becomes
+  #
+  #  [:action_controller, :session_store]
+  def get_rails_config exp
+    if node_type? exp, :attrasgn
+      attribute = exp.method.to_s[0..-2].to_sym
+      get_rails_config(exp.target) << attribute
+    elsif call? exp
+      if exp.target == RAILS_CONFIG
+        [exp.method]
+      else
+        get_rails_config(exp.target) << exp.method
+      end
+    else
+      raise "WHAT"
+    end
+  end
+end

data/lib/railroader/processors/lib/rails3_route_processor.rb

@@ -0,0 +1,308 @@
+require 'railroader/processors/lib/basic_processor'
+
+#Processes the Sexp from routes.rb. Stores results in tracker.routes.
+#
+#Note that it is only interested in determining what methods on which
+#controllers are used as routes, not the generated URLs for routes.
+class Railroader::Rails3RoutesProcessor < Railroader::BasicProcessor
+  include Railroader::RouteHelper
+
+  attr_reader :map, :nested, :current_controller
+
+  def initialize tracker
+    super
+    @map = Sexp.new(:lvar, :map)
+    @nested = nil  #used for identifying nested targets
+    @prefix = [] #Controller name prefix (a module name, usually)
+    @current_controller = nil
+    @with_options = nil #For use inside map.with_options
+    @controller_block = false
+    @file_name = "config/routes.rb"
+  end
+
+  def process_routes exp
+    process Railroader::AliasProcessor.new.process_safely(exp, nil, @file_name)
+  end
+
+  def process_call exp
+    case exp.method
+    when :resources
+      process_resources exp
+    when :resource
+      process_resource exp
+    when :root
+      process_root exp
+    when :member
+      process_default exp
+    when :get, :put, :post, :delete
+      process_verb exp
+    when :match
+      process_match exp
+    else
+      exp
+    end
+  end
+
+  def process_iter exp
+    case exp.block_call.method
+    when :namespace
+      process_namespace exp
+    when :resource
+      process_resource_block exp
+    when :resources
+      process_resources_block exp
+    when :scope
+      process_scope_block exp
+    when :controller
+      process_controller_block exp
+    else
+      process_default exp
+    end
+  end
+
+  def process_namespace exp
+    arg = exp.block_call.first_arg
+    return exp unless symbol? arg or string? arg 
+
+    name = arg.value
+    block = exp.block
+
+    @prefix << camelize(name)
+
+    process block
+
+    @prefix.pop
+
+    exp
+  end
+
+  #TODO: Need test for this
+  def process_root exp
+    if value = hash_access(exp.first_arg, :to)
+      if string? value
+        add_route_from_string value
+      end
+    end
+
+    exp
+  end
+
+  def process_match exp
+    first_arg = exp.first_arg
+    second_arg = exp.second_arg
+    last_arg = exp.last_arg
+
+    if string? first_arg
+
+      matcher = first_arg.value
+      if matcher == ':controller(/:action(/:id(.:format)))' or
+        matcher.include? ':controller' and action_route?(matcher)  #Default routes
+        @tracker.routes[:allow_all_actions] = first_arg
+        return exp
+      elsif action_route?(first_arg)
+          if hash? second_arg and controller_name = hash_access(second_arg, :controller)
+            loose_action(controller_name, "matched") #TODO: Parse verbs
+          end
+      elsif second_arg.nil? and in_controller_block? and not matcher.include? ":"
+        add_route matcher
+      end
+    end
+
+    if hash? last_arg
+      hash_iterate last_arg do |k, v|
+        if string? k
+          if string? v
+            add_route_from_string v
+          elsif in_controller_block? and symbol? v
+            add_route v
+          end
+        elsif symbol? k
+         case k.value
+         when :action
+          if string? v
+            add_route_from_string v
+          else
+            add_route v
+          end
+
+         when :to
+           if string? v
+             add_route_from_string v[1]
+           elsif in_controller_block? and symbol? v
+             add_route v
+           end
+         end
+        end
+      end
+    end
+
+    @current_controller = nil unless in_controller_block?
+    exp
+  end
+
+  def add_route_from_string value
+    value = value[1] if string? value
+
+    controller, action = extract_action value
+
+    if action
+      add_route action, controller
+    elsif in_controller_block?
+      add_route value
+    end
+  end
+
+  def process_verb exp
+    first_arg = exp.first_arg
+    second_arg = exp.second_arg
+
+    if symbol? first_arg and not hash? second_arg
+      add_route first_arg
+    elsif hash? second_arg
+      hash_iterate second_arg do |k, v|
+        if symbol? k and k.value == :to
+          if string? v
+            add_route_from_string v
+          elsif in_controller_block? and symbol? v
+            add_route v
+          end
+        elsif action_route?(first_arg)
+          if hash? second_arg and controller_name = hash_access(second_arg, :controller)
+            loose_action(controller_name, exp.method)
+          end
+        end
+      end
+    elsif string? first_arg
+      if first_arg.value.include? ':controller' and action_route?(first_arg) #Default routes
+        @tracker.routes[:allow_all_actions] = first_arg
+      end
+
+      route = first_arg.value.split "/"
+      if route.length != 2
+        add_route route[0]
+      else
+        add_route route[1], route[0]
+      end
+    elsif in_controller_block? and symbol? first_arg
+      add_route first_arg
+    else hash? first_arg
+      hash_iterate first_arg do |k, v|
+        if string? k
+          if string? v
+            add_route_from_string v
+          elsif in_controller_block?
+            add_route v
+          end
+        end
+      end
+    end
+
+    @current_controller = nil unless in_controller_block?
+    exp
+  end
+
+  def process_resources exp
+    first_arg = exp.first_arg
+    second_arg = exp.second_arg
+
+    return exp unless symbol? first_arg or string? first_arg
+
+    if second_arg and second_arg.node_type == :hash
+      self.current_controller = first_arg.value
+      #handle hash
+      add_resources_routes
+    elsif exp.args.all? { |s| symbol? s }
+      exp.each_arg do |s|
+        self.current_controller = s.value
+        add_resources_routes
+      end
+    end
+
+    @current_controller = nil unless in_controller_block?
+    exp
+  end
+
+  def process_resource exp
+    #Does resource even take more than one controller name?
+    exp.each_arg do |s|
+      if symbol? s
+        self.current_controller = pluralize(s.value.to_s)
+        add_resource_routes
+      else
+        #handle something else, like options
+        #or something?
+      end
+    end
+
+    @current_controller = nil unless in_controller_block?
+    exp
+  end
+
+  def process_resources_block exp
+    in_controller_block do
+      process_resources exp.block_call
+      process exp.block
+    end
+
+    @current_controller = nil
+    exp
+  end
+
+  def process_resource_block exp
+    in_controller_block do
+      process_resource exp.block_call
+      process exp.block
+    end
+
+    @current_controller = nil
+    exp
+  end
+
+  def process_scope_block exp
+    #How to deal with options?
+    process exp.block
+    exp
+  end
+
+  def process_controller_block exp
+    if string? exp or symbol? exp
+      self.current_controller = exp.block_call.first_arg.value
+
+      in_controller_block do
+        process exp[-1] if exp[-1]
+      end
+
+      @current_controller = nil
+    end
+
+    exp
+  end
+
+  def extract_action str
+    str.split "#"
+  end
+
+  def in_controller_block?
+    @controller_block
+  end
+
+  def in_controller_block
+    prev_block = @controller_block
+    @controller_block = true
+    yield
+    @controller_block = prev_block
+  end
+
+  def action_route? arg
+    if string? arg
+      arg = arg.value
+    end
+
+    arg.is_a? String and (arg.include? ":action" or arg.include? "*action")
+  end
+
+  def loose_action controller_name, verb = "any"
+    self.current_controller = controller_name.value
+    @tracker.routes[@current_controller] = [:allow_all_actions, {:allow_verb => verb}]
+  end
+end

data/lib/railroader/processors/lib/render_helper.rb

@@ -0,0 +1,181 @@
+require 'digest/sha1'
+
+#Processes a call to render() in a controller or template
+module Railroader::RenderHelper
+
+  #Process s(:render, TYPE, OPTION?, OPTIONS)
+  def process_render exp
+    process_default exp
+    @rendered = true
+    case exp.render_type
+    when :action, :template, :inline
+      process_action exp[2][1], exp[3], exp.line
+    when :default
+      begin
+        process_template template_name, exp[3], nil, exp.line
+      rescue ArgumentError
+        Railroader.debug "Problem processing render: #{exp}"
+      end
+    when :partial, :layout
+      process_partial exp[2], exp[3], exp.line
+    when :nothing
+    end
+    exp
+  end
+
+  #Processes layout
+  def process_layout name = nil
+    if name.nil? and defined? layout_name
+      name = layout_name
+    end
+
+    return unless name
+
+    process_template name, nil, nil, nil
+  end
+
+  #Determines file name for partial and then processes it
+  def process_partial name, args, line
+    if name == "" or !(string? name or symbol? name)
+      return
+    end
+
+    names = name.value.to_s.split("/")
+    names[-1] = "_" + names[-1]
+    process_template template_name(names.join("/")), args, nil, line
+  end
+
+  #Processes a given action
+  def process_action name, args, line
+    if name.is_a? String or name.is_a? Symbol
+      process_template template_name(name), args, nil, line
+    end
+  end
+
+  #Processes a template, adding any instance variables
+  #to its environment.
+  def process_template name, args, called_from = nil, *_
+
+    Railroader.debug "Rendering #{name} (#{called_from})"
+    #Get scanned source for this template
+    name = name.to_s.gsub(/^\//, "")
+    template = @tracker.templates[name.to_sym]
+    unless template
+      Railroader.debug "[Notice] No such template: #{name}"
+      return
+    end
+
+    template_env = only_ivars(:include_request_vars)
+
+    #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 << name).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
+
+      #Process layout
+      if string? options[:layout]
+        process_template "layouts/#{options[:layout][1]}", nil, nil, nil
+      elsif node_type? options[:layout], :false
+        #nothing
+      elsif not template.name.to_s.match(/[^\/_][^\/]+$/)
+        #Don't do this for partials
+
+        process_layout
+      end
+
+      if hash? options[:locals]
+        hash_iterate options[:locals] do |key, value|
+          template_env[Sexp.new(:call, nil, key.value)] = 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].value.to_sym
+          end
+        end
+
+        collection = get_class_target(options[:collection]) || Railroader::Tracker::UNKNOWN_MODEL
+
+        template_env[Sexp.new(:call, nil, variable)] = Sexp.new(:call, Sexp.new(:const, collection), :new)
+      end
+
+      #Set original_line for values so it is clear
+      #that values came from another file
+      template_env.all.each do |_var, value|
+        unless value.original_line
+          #TODO: This has been broken for a while now and no one noticed
+          #so maybe we can skip it
+          value.original_line = value.line
+        end
+      end
+
+      #Run source through AliasProcessor with instance variables from the
+      #current environment.
+      #TODO: Add in :locals => { ... } to environment
+      src = Railroader::TemplateAliasProcessor.new(@tracker, template, called_from).process_safely(template.src, template_env)
+
+      digest = Digest::SHA1.new.update(name + src.to_s).to_s.to_sym
+
+      if @tracker.template_cache.include? digest
+        return
+      else
+        @tracker.template_cache << digest
+      end
+
+      #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.value] = value
+      end
+    end
+
+    options
+  end
+
+  def get_class_target sexp
+    if call? sexp
+      get_class_target sexp.target
+    else
+      klass = class_name sexp
+      if klass.is_a? Symbol
+        klass
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/railroader/processors/lib/render_path.rb

@@ -0,0 +1,107 @@
+module Railroader
+  class RenderPath
+    attr_reader :path
+
+    def initialize
+      @path = []
+    end
+
+    def add_controller_render controller_name, method_name, line, file
+      method_name ||= ""
+
+      @path << { :type => :controller,
+                 :class => controller_name.to_sym,
+                 :method => method_name.to_sym,
+                 :line => line,
+                 :file => file
+                }
+
+      self
+    end
+
+    def add_template_render template_name, line, file
+      @path << { :type => :template,
+                 :name => template_name.to_sym,
+                 :line => line,
+                 :file => file
+               }
+
+      self
+    end
+
+    def include_template? name
+      name = name.to_sym
+
+      @path.any? do |loc|
+        loc[:type] == :template and loc[:name] == name
+      end
+    end
+
+    def include_controller? klass
+      klass = klass.to_sym
+
+      @path.any? do |loc|
+        loc[:type] == :controller and loc[:class] == klass
+      end
+    end
+
+    def include_any_method? method_names
+      names = method_names.map(&:to_sym)
+
+      @path.any? do |loc|
+        loc[:type] == :controller and names.include? loc[:method]
+      end
+    end
+
+    def rendered_from_controller?
+      @path.any? do |loc|
+        loc[:type] == :controller
+      end
+    end
+
+    def each &block
+      @path.each(&block)
+    end
+
+    def join *args
+      self.to_a.join(*args)
+    end
+
+    def length
+      @path.length
+    end
+
+    def to_a
+      @path.map do |loc|
+        case loc[:type]
+        when :template
+          "Template:#{loc[:name]}"
+        when :controller
+          "#{loc[:class]}##{loc[:method]}"
+        end
+      end
+    end
+
+    def last
+      self.to_a.last
+    end
+
+    def to_s
+      self.to_a.to_s
+    end
+
+    def to_sym
+      self.to_s.to_sym
+    end
+
+    def to_json *args
+      require 'json'
+      JSON.generate(@path)
+    end
+
+    def initialize_copy original
+      @path = original.path.dup
+      self
+    end
+  end
+end