railroader 4.3.4

data/lib/railroader/processors/controller_processor.rb

@@ -0,0 +1,249 @@
+require 'railroader/processors/base_processor'
+require 'railroader/processors/lib/module_helper'
+require 'railroader/tracker/controller'
+
+#Processes controller. Results are put in tracker.controllers
+class Railroader::ControllerProcessor < Railroader::BaseProcessor
+  include Railroader::ModuleHelper
+
+  FORMAT_HTML = Sexp.new(:call, Sexp.new(:lvar, :format), :html)
+
+  def initialize app_tree, tracker
+    super(tracker)
+    @app_tree = app_tree
+    @current_class = nil
+    @current_method = nil
+    @current_module = nil
+    @visibility = :public
+    @file_name = nil
+    @concerns = Set.new
+  end
+
+  #Use this method to process a Controller
+  def process_controller src, file_name = nil
+    @file_name = file_name
+    process src
+  end
+
+  #s(:class, NAME, PARENT, s(:scope ...))
+  def process_class exp
+    name = class_name(exp.class_name)
+    parent = class_name(exp.parent_name)
+
+    #If inside a real controller, treat any other classes as libraries.
+    #But if not inside a controller already, then the class may include
+    #a real controller, so we can't take this shortcut.
+    if @current_class and @current_class.name.to_s.end_with? "Controller"
+      Railroader.debug "[Notice] Treating inner class as library: #{name}"
+      Railroader::LibraryProcessor.new(@tracker).process_library exp, @file_name
+      return exp
+    end
+
+    if not name.to_s.end_with? "Controller"
+      Railroader.debug "[Notice] Adding noncontroller as library: #{name}"
+      #Set the class to be a module in order to get the right namespacing.
+      #Add class to libraries, in case it is needed later (e.g. it's used
+      #as a parent class for a controller.)
+      #However, still want to process it in this class, so have to set
+      #@current_class to this not-really-a-controller thing.
+      process_module exp, parent
+
+      return exp
+    end
+
+    handle_class(exp, @tracker.controllers, Railroader::Controller) do
+      set_layout_name
+    end
+
+    exp
+  end
+
+  def process_module exp, parent = nil
+    handle_module exp, Railroader::Controller, parent
+  end
+
+  def process_concern concern_name
+    return unless @current_class
+
+    if mod = @tracker.find_class(concern_name)
+      if mod.options[:included] and not @concerns.include? concern_name
+        @concerns << concern_name
+        process mod.options[:included].deep_clone
+      end
+    end
+  end
+
+  #Look for specific calls inside the controller
+  def process_call exp
+    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
+    last_arg = exp.last_arg
+
+    #Methods called inside class definition
+    #like attr_* and other settings
+    if @current_method.nil? and target.nil? and @current_class
+      if first_arg.nil? #No args
+        case method
+        when :private, :protected, :public
+          @visibility = method
+        when :protect_from_forgery
+          @current_class.options[:protect_from_forgery] = true
+        else
+          #??
+        end
+      else
+        case method
+        when :include
+          if @current_class
+            concern = class_name(first_arg)
+            @current_class.add_include concern
+            process_concern concern
+          end
+        when :before_filter, :append_before_filter, :before_action, :append_before_action
+          if node_type? exp.first_arg, :iter
+            add_lambda_filter exp
+          else
+            @current_class.add_before_filter exp
+          end
+        when :prepend_before_filter, :prepend_before_action
+          if node_type? exp.first_arg, :iter
+            add_lambda_filter exp
+          else
+            @current_class.prepend_before_filter exp
+          end
+        when :skip_before_filter, :skip_filter, :skip_before_action, :skip_action_callback
+          @current_class.skip_filter exp
+        when :layout
+          if string? last_arg
+            #layout "some_layout"
+
+            name = last_arg.value.to_s
+            if @app_tree.layout_exists?(name)
+              @current_class.layout = "layouts/#{name}"
+            else
+              Railroader.debug "[Notice] Layout not found: #{name}"
+            end
+          elsif node_type? last_arg, :nil, :false
+            #layout :false or layout nil
+            @current_class.layout = false
+          end
+        else
+          @current_class.add_option method, exp
+        end
+      end
+
+      exp
+    elsif target == nil and method == :render
+      make_render exp
+    elsif exp == FORMAT_HTML and context[1] != :iter
+      #This is an empty call to
+      # format.html
+      #Which renders the default template if no arguments
+      #Need to make more generic, though.
+      call = Sexp.new :render, :default, @current_method
+      call.line(exp.line)
+      call
+    else
+      call = make_call target, method, process_all!(exp.args)
+      call.line(exp.line)
+      call
+    end
+  end
+
+  #Look for before_filters and add fake ones if necessary
+  def process_iter exp
+    if @current_method.nil? and call? exp.block_call
+      block_call_name = exp.block_call.method
+
+      if block_call_name == :before_filter  or block_call_name == :before_action
+        add_fake_filter exp
+      else
+        super
+      end
+    else
+      super
+    end
+  end
+
+  #Sets default layout for renders inside Controller
+  def set_layout_name
+    return if @current_class.layout
+
+    name = underscore(@current_class.name.to_s.split("::")[-1].gsub("Controller", ''))
+
+    #There is a layout for this Controller
+    if @app_tree.layout_exists?(name)
+      @current_class.layout = "layouts/#{name}"
+    end
+  end
+
+  #This is to handle before_filter do |controller| ... end
+  #
+  #We build a new method and process that the same way as usual
+  #methods and filters.
+  def add_fake_filter exp
+    unless @current_class
+      Railroader.debug "Skipping before_filter outside controller: #{exp}"
+      return exp
+    end
+
+    filter_name = ("fake_filter" + rand.to_s[/\d+$/]).to_sym
+    args = exp.block_call.arglist
+    args.insert(1, Sexp.new(:lit, filter_name))
+    before_filter_call = make_call(nil, :before_filter, args)
+
+    if exp.block_args.length > 1
+      block_variable = exp.block_args[1]
+    else
+      block_variable = :temp
+    end
+
+    if node_type? exp.block, :block
+      block_inner = exp.block[1..-1]
+    else
+      block_inner = [exp.block]
+    end
+
+    #Build Sexp for filter method
+    body = Sexp.new(:lasgn,
+                    block_variable,
+                    Sexp.new(:call, Sexp.new(:const, @current_class.name), :new))
+
+    filter_method = Sexp.new(:defn, filter_name, Sexp.new(:args), body).concat(block_inner).line(exp.line)
+
+    vis = @visibility
+    @visibility = :private
+    process_defn filter_method
+    @visibility = vis
+    process before_filter_call
+    exp
+  end
+
+  def add_lambda_filter exp
+    # Convert into regular block call
+    e = exp.dup
+    lambda_node = e.delete_at(3)
+    result = Sexp.new(:iter, e).line(e.line)
+
+    # Add block arguments
+    if node_type? lambda_node[2], :args
+      result << lambda_node[2].last
+    else
+      result << s(:args)
+    end
+
+    # Add block contents
+    if sexp? lambda_node[3]
+      result << lambda_node[3]
+    end
+
+    add_fake_filter result
+  end
+end

data/lib/railroader/processors/erb_template_processor.rb

@@ -0,0 +1,77 @@
+require 'railroader/processors/template_processor'
+
+#Processes ERB templates
+#(those ending in .html.erb or .rthml).
+class Railroader::ErbTemplateProcessor < Railroader::TemplateProcessor
+  
+  #s(:call, TARGET, :method, ARGS)
+  def process_call exp
+    target = exp.target
+    if sexp? target
+      target = process target
+    end
+    method = exp.method
+    
+    #_erbout is the default output variable for erb
+    if node_type? target, :lvar and target.value == :_erbout
+      if method == :concat or method == :<<
+        @inside_concat = true
+        exp.arglist = process(exp.arglist)
+        @inside_concat = false
+
+        if exp.second_arg
+          raise "Did not expect more than a single argument to _erbout.concat"
+        end
+
+        arg = normalize_output(exp.first_arg)
+
+        if arg.node_type == :str #ignore plain strings
+          ignore
+        else
+          add_output arg
+        end
+      elsif method == :force_encoding
+        ignore
+      else
+        abort "Unrecognized action on _erbout: #{method}"
+      end
+    elsif target == nil and method == :render
+      exp.arglist = process(exp.arglist)
+      make_render_in_view exp
+    else
+      exp.target = target
+      exp.arglist = process(exp.arglist)
+      exp
+    end
+  end
+
+  #Process block, removing irrelevant expressions
+  def process_block exp
+    exp = exp.dup
+    exp.shift
+    if @inside_concat
+      @inside_concat = false
+      exp[0..-2].each do |e|
+        process e
+      end
+      @inside_concat = true
+      process exp.last
+    else
+      exp.map! do |e|
+        res = process e
+        if res.empty? or res == ignore
+          nil
+        elsif node_type?(res, :lvar) and res.value == :_erbout
+          nil
+
+        else
+          res
+        end
+      end
+      block = Sexp.new(:rlist).concat(exp).compact
+      block.line(exp.line)
+      block
+    end
+  end
+
+end

data/lib/railroader/processors/erubis_template_processor.rb

@@ -0,0 +1,92 @@
+require 'railroader/processors/template_processor'
+
+#Processes ERB templates using Erubis instead of erb.
+class Railroader::ErubisTemplateProcessor < Railroader::TemplateProcessor
+
+  #s(:call, TARGET, :method, ARGS)
+  def process_call exp
+    target = exp.target
+    if sexp? target
+      target = process target
+    end
+
+    exp.target = target
+    exp.arglist = process exp.arglist
+    method = exp.method
+
+    #_buf is the default output variable for Erubis
+    if node_type?(target, :lvar, :ivar) and (target.value == :_buf or target.value == :@output_buffer)
+      if method == :<< or method == :safe_concat
+
+        arg = normalize_output(exp.first_arg)
+
+        if arg.node_type == :str #ignore plain strings
+          ignore
+        elsif node_type? target, :ivar and target.value == :@output_buffer
+          add_escaped_output arg
+        else
+          add_output arg
+        end
+      elsif method == :to_s
+        ignore
+      else
+        abort "Unrecognized action on buffer: #{method}"
+      end
+    elsif target == nil and method == :render
+      make_render_in_view exp
+    else
+      exp
+    end
+  end
+
+  #Process blocks, ignoring :ignore exps
+  def process_block exp
+    exp = exp.dup
+    exp.shift
+    exp.map! do |e|
+      res = process e
+      if res.empty? or res == ignore
+        nil
+      else
+        res
+      end
+    end
+    block = Sexp.new(:rlist).concat(exp).compact
+    block.line(exp.line)
+    block
+  end
+
+  #Look for assignments to output buffer that look like this:
+  #  @output_buffer.append = some_output
+  #  @output_buffer.safe_append = some_output
+  #  @output_buffer.safe_expr_append = some_output
+  def process_attrasgn exp
+    if exp.target.node_type == :ivar and exp.target.value == :@output_buffer
+      if append_method?(exp.method)
+        exp.first_arg = process(exp.first_arg)
+        arg = normalize_output(exp.first_arg)
+
+        if arg.node_type == :str
+          ignore
+        elsif safe_append_method?(exp.method)
+          add_output arg
+        else
+          add_escaped_output arg
+        end
+      else
+        super
+      end
+    else
+      super
+    end
+  end
+
+  private
+  def append_method?(method)
+    method == :append= || safe_append_method?(method)
+  end
+
+  def safe_append_method?(method)
+    method == :safe_append= || method == :safe_expr_append=
+  end
+end

data/lib/railroader/processors/gem_processor.rb

@@ -0,0 +1,64 @@
+require 'railroader/processors/lib/basic_processor'
+
+#Processes Gemfile and Gemfile.lock
+class Railroader::GemProcessor < Railroader::BasicProcessor
+
+  def initialize *args
+    super
+    @gem_name_version = /^\s*([-_+.A-Za-z0-9]+) \((\w(\.\w+)*)\)/
+  end
+
+  def process_gems gem_files
+    @gem_files = gem_files
+    @gemfile = gem_files[:gemfile][:file]
+    process gem_files[:gemfile][:src]
+
+    if gem_files[:gemlock]
+      process_gem_lock
+    end
+
+    @tracker.config.set_rails_version
+  end
+
+  def process_call exp
+    if exp.target == nil
+      if exp.method == :gem
+        gem_name = exp.first_arg
+        return exp unless string? gem_name
+
+        gem_version = exp.second_arg
+
+        version = if string? gem_version
+                    gem_version.value
+                  else
+                    nil
+                  end
+
+        @tracker.config.add_gem gem_name.value, version, @gemfile, exp.line
+      elsif exp.method == :ruby
+        version = exp.first_arg
+        if string? version
+          @tracker.config.set_ruby_version version.value
+        end
+      end
+    end
+
+    exp
+  end
+
+  def process_gem_lock
+    line_num = 1
+    file = @gem_files[:gemlock][:file]
+    @gem_files[:gemlock][:src].each_line do |line|
+      set_gem_version_and_file line, file, line_num
+      line_num += 1
+    end
+  end
+
+  # Supports .rc2 but not ~>, >=, or <=
+  def set_gem_version_and_file line, file, line_num
+    if line =~ @gem_name_version
+      @tracker.config.add_gem $1, $2, file, line_num
+    end
+  end
+end

data/lib/railroader/processors/haml_template_processor.rb

@@ -0,0 +1,191 @@
+require 'railroader/processors/template_processor'
+
+#Processes HAML templates.
+class Railroader::HamlTemplateProcessor < Railroader::TemplateProcessor
+  HAML_FORMAT_METHOD = /format_script_(true|false)_(true|false)_(true|false)_(true|false)_(true|false)_(true|false)_(true|false)/
+  HAML_HELPERS = s(:colon2, s(:const, :Haml), :Helpers)
+  JAVASCRIPT_FILTER = s(:colon2, s(:colon2, s(:const, :Haml), :Filters), :Javascript)
+  COFFEE_FILTER = s(:colon2, s(:colon2, s(:const, :Haml), :Filters), :Coffee)
+
+  #Processes call, looking for template output
+  def process_call exp
+    target = exp.target
+    if sexp? target
+      target = process target
+    end
+
+    method = exp.method
+
+    if (call? target and target.method == :_hamlout)
+      res = case method
+            when :adjust_tabs, :rstrip!, :attributes #Check attributes, maybe?
+              ignore
+            when :options, :buffer
+              exp
+            when :open_tag
+              process_call_args exp
+            else
+              arg = exp.first_arg
+
+              if arg
+                @inside_concat = true
+                exp.first_arg = process(arg)
+                out = normalize_output(exp.first_arg)
+                @inside_concat = false
+              else
+                raise "Empty _hamlout.#{method}()?"
+              end
+
+              if string? out
+                ignore
+              else
+                r = case method.to_s
+                    when "push_text"
+                      build_output_from_push_text(out)
+                    when HAML_FORMAT_METHOD
+                      if $4 == "true"
+                        if string_interp? out
+                          build_output_from_push_text(out, :escaped_output)
+                        else
+                          Sexp.new :format_escaped, out
+                        end
+                      else
+                        if string_interp? out
+                          build_output_from_push_text(out)
+                        else
+                          Sexp.new :format, out
+                        end
+                      end
+
+                    else
+                      raise "Unrecognized action on _hamlout: #{method}"
+                    end
+
+                @javascript = false
+                r
+              end
+            end
+
+      res.line(exp.line)
+      res
+
+      #_hamlout.buffer <<
+      #This seems to be used rarely, but directly appends args to output buffer.
+      #Has something to do with values of blocks?
+    elsif sexp? target and method == :<< and is_buffer_target? target
+      @inside_concat = true
+      exp.first_arg = process(exp.first_arg)
+      out = normalize_output(exp.first_arg)
+      @inside_concat = false
+
+      if out.node_type == :str #ignore plain strings
+        ignore
+      else
+        add_output out
+      end
+    elsif target == nil and method == :render
+      #Process call to render()
+      exp.arglist = process exp.arglist
+      make_render_in_view exp
+    elsif target == nil and method == :find_and_preserve and exp.first_arg
+      process exp.first_arg
+    elsif method == :render_with_options
+      if target == JAVASCRIPT_FILTER or target == COFFEE_FILTER
+        @javascript = true
+      end
+
+      process exp.first_arg
+    else
+      exp.target = target
+      exp.arglist = process exp.arglist
+      exp
+    end
+  end
+
+  #If inside an output stream, only return the final expression
+  def process_block exp
+    exp = exp.dup
+    exp.shift
+    if @inside_concat
+      @inside_concat = false
+      exp[0..-2].each do |e|
+        process e
+      end
+      @inside_concat = true
+      process exp[-1]
+    else
+      exp.map! do |e|
+        res = process e
+        if res.empty?
+          nil
+        else
+          res
+        end
+      end
+      Sexp.new(:rlist).concat(exp).compact
+    end
+  end
+
+  #Checks if the buffer is the target in a method call Sexp.
+  #TODO: Test this
+  def is_buffer_target? exp
+    exp.node_type == :call and
+    node_type? exp.target, :lvar and
+    exp.target.value == :_hamlout and
+    exp.method == :buffer
+  end
+
+  #HAML likes to put interpolated values into _hamlout.push_text
+  #but we want to handle those individually
+  def build_output_from_push_text exp, default = :output
+    if string_interp? exp
+      exp.map! do |e|
+        if sexp? e
+          if node_type? e, :evstr and e[1]
+            e = e.value
+          end
+
+          get_pushed_value e, default
+        else
+          e
+        end
+      end
+    end
+  end
+
+  #Gets outputs from values interpolated into _hamlout.push_text
+  def get_pushed_value exp, default = :output
+    return exp unless sexp? exp
+
+    case exp.node_type
+    when :format
+      exp.node_type = :output
+      @current_template.add_output exp
+      exp
+    when :format_escaped
+      exp.node_type = :escaped_output
+      @current_template.add_output exp
+      exp
+    when :str, :ignore, :output, :escaped_output
+      exp
+    when :block, :rlist, :dstr
+      exp.map! { |e| get_pushed_value e }
+    when :if
+      clauses = [get_pushed_value(exp.then_clause), get_pushed_value(exp.else_clause)].compact
+
+      if clauses.length > 1
+        s(:or, *clauses)
+      else
+        clauses.first
+      end
+    else
+      if call? exp and exp.target == HAML_HELPERS and exp.method == :html_escape
+        add_escaped_output exp.first_arg
+      elsif @javascript and call? exp and (exp.method == :j or exp.method == :escape_javascript)
+        add_escaped_output exp.first_arg
+      else
+        add_output exp, default
+      end
+    end
+  end
+end

data/lib/railroader/processors/lib/basic_processor.rb

@@ -0,0 +1,37 @@
+require 'railroader/processors/lib/processor_helper'
+require 'railroader/processors/lib/safe_call_helper'
+require 'railroader/util'
+
+class Railroader::BasicProcessor < Railroader::SexpProcessor
+  include Railroader::ProcessorHelper
+  include Railroader::SafeCallHelper
+  include Railroader::Util
+
+  def initialize tracker
+    super()
+    @tracker = tracker
+    @current_template = @current_module = @current_class = @current_method = nil
+  end
+
+  def process_default exp
+    process_all exp
+  end
+
+  def process_if exp
+    condition = exp.condition
+
+    process condition
+
+    if true? condition
+      process exp.then_clause
+    elsif false? condition
+      process exp.else_clause
+    else
+      [exp.then_clause, exp.else_clause].compact.map do |e|
+        process e
+      end
+    end
+
+    exp
+  end
+end