railroader 4.3.4

data/lib/railroader/processors/lib/module_helper.rb

@@ -0,0 +1,111 @@
+module Railroader::ModuleHelper
+  def handle_module exp, tracker_class, parent = nil
+    name = class_name(exp.module_name)
+
+    if @current_module
+      outer_module = @current_module
+      name = (outer_module.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]
+      @current_module.add_file @file_name, exp
+    else
+      @current_module = tracker_class.new name, parent, @file_name, exp, @tracker
+      @tracker.libs[name] = @current_module
+    end
+
+    exp.body = process_all! exp.body
+
+    if outer_module
+      @current_module = outer_module
+    else
+      @current_module = nil
+    end
+
+    exp
+  end
+
+  def handle_class exp, collection, tracker_class
+    name = class_name(exp.class_name)
+    parent = class_name exp.parent_name
+
+    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 collection[name]
+      @current_class = collection[name]
+      @current_class.add_file @file_name, exp
+    else
+      @current_class = tracker_class.new name, parent, @file_name, exp, @tracker 
+      collection[name] = @current_class
+    end
+
+    exp.body = process_all! exp.body
+
+    yield if block_given?
+
+    if outer_class
+      @current_class = outer_class
+    else
+      @current_class = nil
+    end
+
+    exp
+  end
+
+  def process_defs exp
+    name = exp.method_name
+
+    if node_type? exp[1], :self
+      if @current_class
+        target = @current_class.name
+      elsif @current_module
+        target = @current_module.name
+      else
+        target = nil
+      end
+    else
+      target = class_name exp[1]
+    end
+
+    @current_method = name
+    res = Sexp.new :defs, target, name, exp.formal_args, *process_all!(exp.body)
+    res.line(exp.line)
+    @current_method = nil
+
+    if @current_class
+      @current_class.add_method @visibility, name, res, @file_name
+    elsif @current_module
+      @current_module.add_method @visibility, name, res, @file_name
+    end
+    res
+  end
+
+  def process_defn exp
+    name = exp.method_name
+
+    @current_method = name
+    res = Sexp.new :defn, name, exp.formal_args, *process_all!(exp.body)
+    res.line(exp.line)
+    @current_method = nil
+
+    if @current_class
+      @current_class.add_method @visibility, name, res, @file_name
+    elsif @current_module
+      @current_module.add_method @visibility, name, res, @file_name
+    end
+
+    res
+  end
+end

data/lib/railroader/processors/lib/processor_helper.rb

@@ -0,0 +1,88 @@
+#Contains a couple shared methods for Processors.
+module Railroader::ProcessorHelper
+  def process_all exp
+    exp.each_sexp do |e|
+      process e
+    end
+    exp
+  end
+
+  def process_all! exp
+    exp.map! do |e|
+      if sexp? e
+        process e
+      else
+        e
+      end
+    end
+
+    exp
+  end
+
+  #Process the arguments of a method call. Does not store results.
+  #
+  #This method is used because Sexp#args and Sexp#arglist create new objects.
+  def process_call_args exp
+    exp.each_arg do |a|
+      process a if sexp? a
+    end
+
+    exp
+  end
+
+  def process_class exp
+    current_class = @current_class
+    @current_class = class_name exp[1]
+    process_all exp.body
+    @current_class = current_class
+    exp
+  end
+
+  #Sets the current module.
+  def process_module exp
+    module_name = class_name(exp.class_name).to_s
+    prev_module = @current_module
+
+    if prev_module
+      @current_module = "#{prev_module}::#{module_name}"
+    else
+      @current_module = module_name
+    end
+
+    if block_given?
+      yield
+    else
+      process_all exp.body
+    end
+
+    @current_module = prev_module
+
+    exp
+  end
+
+  # e.g. private defn
+  def process_call_defn? exp
+    if call? exp and exp.target.nil? and node_type? exp.first_arg, :defn, :defs and [:private, :public, :protected].include? exp.method
+      prev_visibility = @visibility
+      @visibility = exp.method
+      process exp.first_arg
+      @visibility = prev_visibility
+      exp
+    else
+      false
+    end
+  end
+
+  def current_file_name
+    case
+    when @file_name
+      @file_name
+    when @current_class.is_a?(Railroader::Collection)
+      @current_class.file
+    when @current_module.is_a?(Railroader::Collection)
+      @current_module.file
+    else
+      nil
+    end
+  end
+end

data/lib/railroader/processors/lib/rails2_config_processor.rb

@@ -0,0 +1,145 @@
+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:
+#
+#  Rails::Initializer.run |config|
+#    config.action_controller.session_store = :cookie_store
+#  end
+#
+#will be stored in
+#
+#  tracker.config[:rails][:action_controller][:session_store]
+#
+#Values for tracker.config.rails will still be Sexps.
+class Railroader::Rails2ConfigProcessor < Railroader::BasicProcessor
+  #Replace block variable in
+  #
+  #  Rails::Initializer.run |config|
+  #
+  #with this value so we can keep track of it.
+  RAILS_CONFIG = Sexp.new(:const, :"!BRAKEMAN_RAILS_CONFIG")
+
+  def initialize *args
+    super
+  end
+
+  #Use this method to process configuration file
+  def process_config src, file_name
+    @file_name = file_name
+    res = Railroader::ConfigAliasProcessor.new.process_safely(src, nil, file_name)
+    process res
+  end
+
+  #Check if config is set to use Erubis
+  def process_call exp
+    target = exp.target
+    target = process target if sexp? target
+
+    if exp.method == :gem and exp.first_arg.value == "erubis"
+      Railroader.notify "[Notice] Using Erubis for ERB templates"
+      @tracker.config.erubis = true
+    end
+
+    exp
+  end
+
+  #Look for configuration settings
+  def process_attrasgn exp
+    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] ||= {}
+        level = level[o]
+      end
+
+      level[options.last] = exp.first_arg
+    end
+
+    exp
+  end
+
+  #Check for Rails version
+  def process_cdecl exp
+    #Set Rails version required
+    if exp.lhs == :RAILS_GEM_VERSION
+      @tracker.config.rails_version = exp.rhs.value
+    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
+
+#This is necessary to replace block variable so we can track config settings
+class Railroader::ConfigAliasProcessor < Railroader::AliasProcessor
+
+  RAILS_INIT = Sexp.new(:colon2, Sexp.new(:const, :Rails), :Initializer)
+
+  #Look for a call to 
+  #
+  #  Rails::Initializer.run do |config|
+  #    ...
+  #  end
+  #
+  #and replace config with RAILS_CONFIG
+  def process_iter exp
+    target = exp.block_call.target
+    method = exp.block_call.method
+
+    if sexp? target and target == RAILS_INIT and method == :run
+      env[Sexp.new(:lvar, exp.block_args.value)] = Railroader::Rails2ConfigProcessor::RAILS_CONFIG
+    end
+
+    process_default exp
+  end
+end

data/lib/railroader/processors/lib/rails2_route_processor.rb

@@ -0,0 +1,313 @@
+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::Rails2RoutesProcessor < 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
+    @file_name = "config/routes.rb"
+  end
+
+  #Call this with parsed route file information.
+  #
+  #This method first calls RouteAliasProcessor#process_safely on the +exp+,
+  #so it does not modify the +exp+.
+  def process_routes exp
+    process Railroader::RouteAliasProcessor.new.process_safely(exp, nil, @file_name)
+  end
+
+  #Looking for mapping of routes
+  def process_call exp
+    target = exp.target
+
+    if target == map or (not target.nil? and target == nested)
+      process_map exp
+    else
+      process_default exp
+    end
+
+    exp
+  end
+
+  #Process a map.something call
+  #based on the method used
+  def process_map exp
+    args = exp.args
+
+    case exp.method
+    when :resource
+      process_resource args
+    when :resources
+      process_resources args
+    when :connect, :root
+      process_connect args
+    else
+      process_named_route args
+    end
+
+    exp
+  end
+
+  #Look for map calls that take a block.
+  #Otherwise, just do the default processing.
+  def process_iter exp
+    target = exp.block_call.target
+
+    if target == map or target == nested
+      method = exp.block_call.method
+      case method
+      when :namespace
+        process_namespace exp
+      when :resources, :resource
+        process_resources exp.block_call.args
+        process_default exp.block if exp.block
+      when :with_options
+        process_with_options exp
+      end
+      exp
+    else
+      process_default exp
+    end
+  end
+
+  #Process
+  # map.resources :x, :controller => :y, :member => ...
+  #etc.
+  def process_resources exp
+    controller = check_for_controller_name exp
+    if controller
+      self.current_controller = controller
+      process_resource_options exp[-1]
+    else
+      exp.each do |argument|
+        if node_type? argument, :lit
+          self.current_controller = exp.first.value
+          add_resources_routes
+          process_resource_options exp.last
+        end
+      end
+    end
+  end
+
+  #Process all the options that might be in the hash passed to
+  #map.resource, et al.
+  def process_resource_options exp
+    if exp.nil? and @with_options
+      exp = @with_options
+    elsif @with_options
+      exp = exp.concat @with_options[1..-1]
+    end
+    return unless exp.node_type == :hash
+
+    hash_iterate(exp) do |option, value|
+      case option[1]
+      when :controller, :requirements, :singular, :path_prefix, :as,
+        :path_names, :shallow, :name_prefix, :member_path, :nested_member_path,
+        :belongs_to, :conditions, :active_scaffold
+        #should be able to skip
+      when :collection, :member, :new
+        process_collection value
+      when :has_one
+        save_controller = current_controller
+        process_resource value[1..-1] #Verify this is proper behavior
+        self.current_controller = save_controller
+      when :has_many
+        save_controller = current_controller
+        process_resources value[1..-1]
+        self.current_controller = save_controller
+      when :only
+        process_option_only value
+      when :except
+        process_option_except value
+      else
+        Railroader.notify "[Notice] Unhandled resource option, please report: #{option}"
+      end
+    end
+  end
+
+  #Process route option :only => ...
+  def process_option_only exp
+    routes = @tracker.routes[@current_controller]
+    [:index, :new, :create, :show, :edit, :update, :destroy].each do |r|
+      routes.delete r
+    end
+
+    if exp.node_type == :array
+      exp[1..-1].each do |e|
+        routes << e.value
+      end
+    end
+  end
+
+  #Process route option :except => ...
+  def process_option_except exp
+    return unless exp.node_type == :array
+    routes = @tracker.routes[@current_controller]
+
+    exp[1..-1].each do |e|
+      routes.delete e.value
+    end
+  end
+
+  #  map.resource :x, ..
+  def process_resource exp
+    controller = check_for_controller_name exp
+    if controller
+      self.current_controller = controller
+      process_resource_options exp.last
+    else
+      exp.each do |argument|
+        if node_type? argument, :lit
+          self.current_controller = pluralize(exp.first.value.to_s)
+          add_resource_routes
+          process_resource_options exp.last
+        end
+      end
+    end
+  end
+
+  #Process
+  # map.connect '/something', :controller => 'blah', :action => 'whatever'
+  def process_connect exp
+    return if exp.empty?
+
+    controller = check_for_controller_name exp
+    self.current_controller = controller if controller
+
+    #Check for default route
+    if string? exp.first
+      if exp.first.value == ":controller/:action/:id"
+        @tracker.routes[:allow_all_actions] = exp.first
+      elsif exp.first.value.include? ":action"
+        @tracker.routes[@current_controller] = [:allow_all_actions, exp.line]
+        return
+      end
+    end
+
+    #This -seems- redundant, but people might connect actions
+    #to a controller which already allows them all
+    return if @tracker.routes[@current_controller].is_a? Array and @tracker.routes[@current_controller][0] == :allow_all_actions
+
+    exp.last.each_with_index do |e,i|
+      if symbol? e and e.value == :action
+        action = exp.last[i + 1]
+
+        if node_type? action, :lit
+          @tracker.routes[@current_controller] << action.value.to_sym
+        end
+
+        return
+      end
+    end
+  end
+
+  # map.with_options :controller => 'something' do |something|
+  #   something.resources :blah
+  # end
+  def process_with_options exp
+    @with_options = exp.block_call.last_arg
+    @nested = Sexp.new(:lvar, exp.block_args.value)
+
+    self.current_controller = check_for_controller_name exp.block_call.args
+
+    #process block
+    process exp.block
+
+    @with_options = nil
+    @nested = nil
+  end
+
+  # map.namespace :something do |something|
+  #   something.resources :blah
+  # end
+  def process_namespace exp
+    call = exp.block_call
+    formal_args = exp.block_args
+    block = exp.block
+
+    @prefix << camelize(call.first_arg.value)
+
+    if formal_args
+      @nested = Sexp.new(:lvar, formal_args.value)
+    end
+
+    process block
+
+    @prefix.pop
+  end
+
+  # map.something_abnormal '/blah', :controller => 'something', :action => 'wohoo'
+  def process_named_route exp
+    process_connect exp
+  end
+
+  #Process collection option
+  # :collection => { :some_action => :http_actions }
+  def process_collection exp
+    return unless exp.node_type == :hash
+    routes = @tracker.routes[@current_controller]
+
+    hash_iterate(exp) do |action, _type|
+      routes << action.value
+    end
+  end
+
+  private
+
+  #Checks an argument list for a hash that has a key :controller.
+  #If it does, returns the value.
+  #
+  #Otherwise, returns nil.
+  def check_for_controller_name args
+    args.each do |a|
+      if hash? a and value = hash_access(a, :controller)
+        return value.value if string? value or symbol? value
+      end
+    end
+
+    nil
+  end
+end
+
+#This is for a really specific case where a hash is used as arguments
+#to one of the map methods.
+class Railroader::RouteAliasProcessor < Railroader::AliasProcessor
+
+  #This replaces
+  # { :some => :hash }.keys
+  #with
+  # [:some]
+  def process_call exp
+    process_default exp
+
+    if hash? exp.target and exp.method == :keys
+      keys = get_keys exp.target
+      exp.clear
+      keys.each_with_index do |e,i|
+        exp[i] = e
+      end
+    end
+    exp
+  end
+
+  #Returns an array Sexp containing the keys from the hash
+  def get_keys hash
+    keys = Sexp.new(:array)
+    hash_iterate(hash) do |key, _value|
+      keys << key
+    end
+
+    keys
+  end
+end