railroader 4.3.4

data/lib/railroader/processors/lib/route_helper.rb

@@ -0,0 +1,68 @@
+module Railroader::RouteHelper
+  #Manage Controller prefixes
+  #@prefix is an Array, but this method returns a string
+  #suitable for prefixing onto a controller name.
+  def prefix
+    if @prefix.length > 0
+      @prefix.join("::") << "::"
+    else
+      ''
+    end
+  end
+
+  #Sets the controller name to a proper class name.
+  #For example
+  # self.current_controller = :session
+  # @controller == :SessionController #true
+  #
+  #Also prepends the prefix if there is one set.
+  def current_controller= name
+    @current_controller = (prefix + camelize(name) + "Controller").to_sym
+    @tracker.routes[@current_controller] ||= Set.new
+  end
+
+  #Add route to controller. If a controller is specified,
+  #the current controller will be set to that controller.
+  #If no controller is specified, uses current controller value.
+  def add_route route, controller = nil
+    if node_type? route, :str, :lit
+      route = route.value
+    end
+
+    return unless route.is_a? String or route.is_a? Symbol
+
+    if route.is_a? String and controller.nil? and route.include? ":controller"
+      controller = ":controller"
+    end
+
+    route = route.to_sym
+
+    if controller
+      self.current_controller = controller
+    end
+
+    routes = @tracker.routes[@current_controller]
+    
+    if routes and not routes.include? :allow_all_actions
+      routes << route
+    end
+  end
+
+  #Add default routes
+  def add_resources_routes
+    existing_routes = @tracker.routes[@current_controller]
+
+    unless existing_routes.is_a? Array and existing_routes.first == :allow_all_actions
+      existing_routes.merge [:index, :new, :create, :show, :edit, :update, :destroy]
+    end
+  end
+
+  #Add default routes minus :index
+  def add_resource_routes
+    existing_routes = @tracker.routes[@current_controller]
+
+    unless existing_routes.is_a? Array and existing_routes.first == :allow_all_actions
+      existing_routes.merge [:new, :create, :show, :edit, :update, :destroy]
+    end
+  end
+end

data/lib/railroader/processors/lib/safe_call_helper.rb

@@ -0,0 +1,16 @@
+module Railroader
+  module SafeCallHelper
+    [[:process_safe_call, :process_call],
+     [:process_safe_attrasgn, :process_attrasgn],
+     [:process_safe_op_asgn, :process_op_asgn],
+     [:process_safe_op_asgn2, :process_op_asgn2]].each do |call, replacement|
+       define_method(call) do |exp|
+         if self.respond_to? replacement
+           self.send(replacement, exp)
+         else
+           process_default exp
+         end
+       end
+     end
+  end
+end

data/lib/railroader/processors/library_processor.rb

@@ -0,0 +1,74 @@
+require 'railroader/processors/base_processor'
+require 'railroader/processors/alias_processor'
+require 'railroader/processors/lib/module_helper'
+require 'railroader/tracker/library'
+
+#Process generic library and stores it in Tracker.libs
+class Railroader::LibraryProcessor < Railroader::BaseProcessor
+  include Railroader::ModuleHelper
+
+  def initialize tracker
+    super
+    @file_name = nil
+    @alias_processor = Railroader::AliasProcessor.new tracker
+    @current_module = nil
+    @current_class = nil
+    @intializer_env = nil
+  end
+
+  def process_library src, file_name = nil
+    @file_name = file_name
+    process src
+  end
+
+  def process_class exp
+    handle_class exp, @tracker.libs, Railroader::Library
+  end
+
+  def process_module exp
+    handle_module exp, Railroader::Library
+  end
+
+  def process_defn exp
+    if exp.method_name == :initialize
+      @alias_processor.process_safely exp.body_list
+      @initializer_env = @alias_processor.only_ivars
+    elsif node_type? exp, :defn
+      exp = @alias_processor.process_safely exp, @initializer_env
+    else
+      exp = @alias_processor.process exp
+    end
+
+    if @current_class
+      exp.body = process_all! exp.body
+      @current_class.add_method :public, exp.method_name, exp, @file_name
+    elsif @current_module
+      exp.body = process_all! exp.body
+      @current_module.add_method :public, exp.method_name, exp, @file_name
+    end
+
+    exp
+  end
+
+  alias process_defs process_defn
+
+  def process_call exp
+    if process_call_defn? exp
+      exp
+    else
+      process_default exp
+    end
+  end
+
+  def process_iter exp
+    res = process_default exp
+
+    if node_type? res, :iter and call? exp.block_call # sometimes this changes after processing
+      if exp.block_call.method == :included and (@current_module or @current_class)
+        (@current_module || @current_class).options[:included] = res.block
+      end
+    end
+
+    res
+  end
+end

data/lib/railroader/processors/model_processor.rb

@@ -0,0 +1,91 @@
+require 'railroader/processors/base_processor'
+require 'railroader/processors/lib/module_helper'
+require 'railroader/tracker/model'
+
+#Processes models. Puts results in tracker.models
+class Railroader::ModelProcessor < Railroader::BaseProcessor
+  include Railroader::ModuleHelper
+
+  def initialize tracker
+    super
+    @current_class = nil
+    @current_method = nil
+    @current_module = 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, BODY)
+  def process_class exp
+    name = class_name(exp.class_name)
+    parent = class_name(exp.parent_name)
+
+    #If inside an inner class we treat it as a library.
+    if @current_class
+      Railroader.debug "[Notice] Treating inner class as library: #{name}"
+      Railroader::LibraryProcessor.new(@tracker).process_library exp, @file_name
+      return exp
+    end
+
+    handle_class exp, @tracker.models, Railroader::Model
+  end
+
+  def process_module exp
+    handle_module exp, Railroader::Model
+  end
+
+  #Handle calls outside of methods,
+  #such as include, attr_accessible, private, etc.
+  def process_call exp
+    return exp unless @current_class
+    return exp if process_call_defn? exp
+
+    target = exp.target
+    if sexp? target
+      target = process target
+    end
+
+    method = exp.method
+    first_arg = exp.first_arg
+
+    #Methods called inside class definition
+    #like attr_* and other settings
+    if @current_method.nil? and target.nil?
+      if first_arg.nil?
+        case method
+        when :private, :protected, :public
+          @visibility = method
+        when :attr_accessible
+          @current_class.set_attr_accessible
+        else
+          #??
+        end
+      else
+        case method
+        when :include
+          @current_class.add_include class_name(first_arg) if @current_class
+        when :attr_accessible
+          @current_class.set_attr_accessible exp
+        when :attr_protected
+          @current_class.set_attr_protected exp
+        else
+          if @current_class
+            @current_class.add_option method, exp
+          end
+        end
+      end
+
+      exp
+    else
+      call = make_call target, method, process_all!(exp.args)
+      call.line(exp.line)
+      call
+    end
+  end
+end

data/lib/railroader/processors/output_processor.rb

@@ -0,0 +1,144 @@
+Railroader.load_railroader_dependency 'ruby2ruby'
+require 'railroader/util'
+
+#Produces formatted output strings from Sexps.
+#Recommended usage is
+#
+#  OutputProcessor.new.format(Sexp.new(:str, "hello"))
+class Railroader::OutputProcessor < Ruby2Ruby
+  include Railroader::Util
+
+  #Copies +exp+ and then formats it.
+  def format exp, user_input = nil, &block
+    @user_input = user_input
+    @user_input_block = block
+    process(exp.deep_clone) || "[Format Error]"
+  end
+
+  alias process_safely format
+
+  def process exp
+    begin
+      if @user_input and @user_input == exp
+        @user_input_block.call(exp, super(exp))
+      else
+        super exp if sexp? exp and not exp.empty?
+      end
+    rescue => e
+      Railroader.debug "While formatting #{exp}: #{e}\n#{e.backtrace.join("\n")}"
+    end
+  end
+
+  def process_ignore exp
+    "[ignored]"
+  end
+
+  def process_params exp
+    "params"
+  end
+
+  def process_session exp
+    "session"
+  end
+
+  def process_cookies exp
+    "cookies"
+  end
+
+  def process_rlist exp
+    out = exp.map do |e|
+      res = process e
+      if res == ""
+        nil
+      else
+        res
+      end
+    end.compact.join("\n")
+
+    out
+  end
+
+  def process_defn exp
+    # Copied from Ruby2Ruby except without the whole
+    # "convert methods to attr_*" stuff
+    exp = exp.deep_clone
+    exp.shift
+    name = exp.shift
+    args = process exp.shift
+    args = "" if args == "()"
+
+    exp.shift if exp == s(s(:nil)) # empty it out of a default nil expression
+
+    body = []
+    until exp.empty? do
+      body << indent(process(exp.shift))
+    end
+
+    body << indent("# do nothing") if body.empty?
+
+    body = body.join("\n")
+
+    return "def #{name}#{args}\n#{body}\nend".gsub(/\n\s*\n+/, "\n")
+  end
+
+  def process_iter exp
+    call = process exp[1]
+    block = process_rlist exp[3..-1]
+    out = "#{call} do\n #{block}\n end"
+
+    out
+  end
+
+  def process_output exp
+    output_format exp, "Output"
+  end
+
+  def process_escaped_output exp
+    output_format exp, "Escaped Output"
+  end
+
+
+  def process_format exp
+    output_format exp, "Format"
+  end
+
+  def process_format_escaped exp
+    output_format exp, "Escaped"
+  end
+
+  def output_format exp, tag
+    out = if exp[1].node_type == :str or exp[1].node_type == :ignore
+            ""
+          else
+            res = process exp[1]
+
+            if res == ""
+              ""
+            else
+              "[#{tag}] #{res}"
+            end
+          end
+
+    out
+  end
+
+  def process_const exp
+    if exp[1] == Railroader::Tracker::UNKNOWN_MODEL
+      "(Unresolved Model)"
+    else
+      out = exp[1].to_s
+      out
+    end
+  end
+
+  def process_render exp
+    exp = exp.deep_clone
+    exp.shift
+
+    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]})"
+
+    out
+  end
+end

data/lib/railroader/processors/route_processor.rb

@@ -0,0 +1,17 @@
+require 'railroader/processors/base_processor'
+require 'railroader/processors/alias_processor'
+require 'railroader/processors/lib/route_helper'
+require 'railroader/util'
+require 'railroader/processors/lib/rails3_route_processor.rb'
+require 'railroader/processors/lib/rails2_route_processor.rb'
+require 'set'
+
+class Railroader::RoutesProcessor
+  def self.new tracker
+    if tracker.options[:rails3]
+      Railroader::Rails3RoutesProcessor.new tracker
+    else
+      Railroader::Rails2RoutesProcessor.new tracker
+    end
+  end
+end

data/lib/railroader/processors/slim_template_processor.rb

@@ -0,0 +1,111 @@
+require 'railroader/processors/template_processor'
+require 'railroader/processors/lib/render_helper'
+
+class Railroader::SlimTemplateProcessor < Railroader::TemplateProcessor
+  include Railroader::RenderHelper
+
+  SAFE_BUFFER = s(:call, s(:colon2, s(:const, :ActiveSupport), :SafeBuffer), :new)
+  OUTPUT_BUFFER = s(:ivar, :@output_buffer)
+  TEMPLE_UTILS = s(:colon2, s(:colon3, :Temple), :Utils)
+  ATTR_MERGE = s(:call, s(:call, s(:array), :reject, s(:block_pass, s(:lit, :empty?))), :join, s(:str, " "))
+
+  def process_call exp
+    target = exp.target
+    method = exp.method
+
+    if method == :safe_concat and (target == SAFE_BUFFER or target == OUTPUT_BUFFER)
+      arg = normalize_output(exp.first_arg)
+
+      if is_escaped? arg
+        add_escaped_output arg.first_arg
+      elsif string? arg
+        ignore
+      elsif render? arg
+        add_output make_render_in_view arg
+      elsif string_interp? arg
+        process_inside_interp arg
+      elsif node_type? arg, :ignore
+        ignore
+      elsif internal_variable? arg
+        ignore
+      elsif arg == ATTR_MERGE
+        ignore
+      else
+        add_output arg
+      end
+    elsif is_escaped? exp
+      add_escaped_output arg
+    elsif target == nil and method == :render
+      exp.arglist = process exp.arglist
+      make_render_in_view exp
+    else
+      exp.arglist = process exp.arglist
+      exp
+    end
+  end
+
+  #Slim likes to interpolate output into strings then pass them to safe_concat.
+  #Better to pull those values out directly.
+  def process_inside_interp exp
+    exp.map! do |e|
+      if node_type? e, :evstr
+        e.value = process_interp_output e.value
+        e
+      else
+        e
+      end
+    end
+
+    exp
+  end
+
+  def process_interp_output exp
+    if sexp? exp
+      if node_type? exp, :if
+        process_interp_output exp.then_clause
+        process_interp_output exp.else_clause
+      elsif exp == SAFE_BUFFER
+        ignore
+      elsif render? exp
+        add_output make_render_in_view exp
+      elsif node_type? :output, :escaped_output
+        exp
+      elsif is_escaped? exp
+        add_escaped_output exp
+      else
+        add_output exp
+      end
+    end
+  end
+
+  def add_escaped_output exp
+    exp = normalize_output(exp)
+
+    return exp if string? exp or internal_variable? exp
+
+    super exp
+  end
+
+  def is_escaped? exp
+    call? exp and
+    exp.target == TEMPLE_UTILS and
+    (exp.method == :escape_html or exp.method == :escape_html_safe)
+  end
+
+  def internal_variable? exp
+    node_type? exp, :lvar and
+    exp.value =~ /^_(temple_|slim_)/
+  end
+
+  def render? exp
+    call? exp and
+    exp.target.nil? and
+    exp.method == :render
+  end
+
+  def process_render exp
+    #Still confused as to why this is not needed in other template processors
+    #but is needed here
+    exp
+  end
+end

data/lib/railroader/processors/template_alias_processor.rb

@@ -0,0 +1,118 @@
+require 'set'
+require 'railroader/processors/alias_processor'
+require 'railroader/processors/lib/render_helper'
+require 'railroader/processors/lib/render_path'
+require 'railroader/tracker'
+
+#Processes aliasing in templates.
+#Handles calls to +render+.
+class Railroader::TemplateAliasProcessor < Railroader::AliasProcessor
+  include Railroader::RenderHelper
+
+  FORM_METHODS = Set[:form_for, :remote_form_for, :form_remote_for]
+
+  def initialize tracker, template, called_from = nil
+    super tracker
+    @template = template
+    @called_from = called_from
+  end
+
+  #Process template
+  def process_template name, args, _, line = nil, file_name = nil
+    @file_name = file_name || relative_path(@template.file || @tracker.templates[@template.name])
+
+    if @called_from
+      if @called_from.include_template? name
+        Railroader.debug "Skipping circular render from #{@template.name} to #{name}"
+        return
+      end
+
+      super name, args, @called_from.dup.add_template_render(@template.name, line, @file_name)
+    else
+      super name, args, Railroader::RenderPath.new.add_template_render(@template.name, line, @file_name)
+    end
+  end
+
+  #Determine template name
+  def template_name name
+    if !name.to_s.include?('/') && @template.name.to_s.include?('/')
+      name = "#{@template.name.to_s.match(/^(.*\/).*$/)[1]}#{name}"
+    end
+    name
+  end
+
+  UNKNOWN_MODEL_CALL = Sexp.new(:call, Sexp.new(:const, Railroader::Tracker::UNKNOWN_MODEL), :new)
+  FORM_BUILDER_CALL = Sexp.new(:call, Sexp.new(:const, :FormBuilder), :new)
+
+  #Looks for form methods and iterating over collections of Models
+  def process_iter exp
+    process_default exp
+
+    call = exp.block_call
+
+    if call? call
+      target = call.target
+      method = call.method
+      arg = exp.block_args.first_param
+      block = exp.block
+
+      #Check for e.g. Model.find.each do ... end
+      if method == :each and arg and block and model = get_model_target(target)
+        if arg.is_a? Symbol
+          if model == target.target
+            env[Sexp.new(:lvar, arg)] = Sexp.new(:call, model, :new)
+          else
+            env[Sexp.new(:lvar, arg)] = UNKNOWN_MODEL_CALL
+          end
+
+          process block if sexp? block
+        end
+      elsif FORM_METHODS.include? method
+        if arg.is_a? Symbol
+          env[Sexp.new(:lvar, arg)] = FORM_BUILDER_CALL
+
+          process block if sexp? block
+        end
+      end
+    end
+
+    exp
+  end
+
+  COLLECTION_METHODS = [:all, :find, :select, :where]
+
+  #Checks if +exp+ is a call to Model.all or Model.find*
+  def get_model_target exp
+    if call? exp
+      target = exp.target
+
+      if COLLECTION_METHODS.include? exp.method or exp.method.to_s[0,4] == "find"
+        models = Set.new @tracker.models.keys
+        name = class_name target
+        return target if models.include?(name)
+      end
+
+      return get_model_target(target)
+    end
+
+    false
+  end
+
+  #Ignore `<<` calls on template variables which are used by the templating
+  #library (HAML, ERB, etc.)
+  def find_push_target exp
+    if sexp? exp
+      if exp.node_type == :lvar and (exp.value == :_buf or exp.value == :_erbout)
+        return nil
+      elsif exp.node_type == :ivar and exp.value == :@output_buffer
+        return nil
+      elsif exp.node_type == :call and call? exp.target and
+        exp.target.method == :_hamlout and exp.method == :buffer
+
+        return nil
+      end
+    end
+
+    super
+  end
+end