railroader 4.3.4

data/lib/railroader/tracker/constants.rb

@@ -0,0 +1,171 @@
+require 'railroader/processors/output_processor'
+
+module Railroader
+  class Constant
+    attr_reader :name, :name_array, :file, :value, :context
+
+    def initialize name, value, context = {}
+      set_name name, context
+      @value = value
+      @context = context
+
+      if @context
+        if @context[:class].is_a? Railroader::Controller
+          @context[:class] = @context[:class].name
+        end
+
+        @file = @context[:file]
+      end
+    end
+
+    def line
+      if @value.is_a? Sexp
+        @value.line
+      end
+    end
+
+    def set_name name, context
+      @name = name
+      @name_array = Constants.constant_as_array(name)
+    end
+
+    def match? name
+      if name == @name
+        return true
+      elsif name.is_a? Sexp and name.node_type == :const and name.value == @name
+        return true
+      elsif name.is_a? Symbol and name.value == @name
+        return true
+      elsif name.class == Array
+        name == @name_array or
+          @name_array.reverse.zip(name.reverse).reduce(true) { |m, a| a[1] ? a[0] == a[1] && m : m }
+      else
+        false
+      end
+    end
+  end
+
+  class Constants
+    include Railroader::Util
+
+    def initialize
+      @constants = Hash.new { |h, k| h[k] = [] }
+    end
+
+    def size
+      @constants.length
+    end
+
+    def [] exp
+      return unless constant? exp
+      match = find_constant exp
+
+      if match
+        match.value
+      else
+        nil
+      end
+    end
+
+    def find_constant exp
+      base_name = Constants.get_constant_base_name(exp)
+
+      if @constants.key? base_name
+        @constants[base_name].find do |c|
+          if c.match? exp
+            return c
+          end
+        end
+
+        name_array = Constants.constant_as_array(exp)
+
+        # Avoid losing info about dynamic constant values
+        return unless name_array.all? { |n| constant? n or n.is_a? Symbol }
+
+        @constants[base_name].find do |c|
+          if c.match? name_array
+            return c
+          end
+        end
+      end
+
+      nil
+    end
+
+    def find_all exp
+      base_name = Constants.get_constant_base_name(exp)
+      @constants[base_name]
+    end
+
+    def add name, value, context = nil
+      if call? value and value.method == :freeze
+        value = value.target
+      end
+
+      base_name = Constants.get_constant_base_name(name)
+      @constants[base_name] << Constant.new(name, value, context)
+    end
+
+    LITERALS = [:lit, :false, :str, :true, :array, :hash]
+    def literal? exp
+      exp.is_a? Sexp and LITERALS.include? exp.node_type
+    end
+
+    def get_literal name
+      if x = self[name] and literal? x
+        x
+      else
+        nil
+      end
+    end
+
+    def each
+      @constants.each do |name, values|
+        values.each do |constant|
+          yield constant
+        end
+      end
+    end
+
+    def self.constant_as_array exp
+      res = []
+      while exp
+        if exp.is_a? Sexp
+          case exp.node_type
+          when :const
+            res << exp.value
+            exp = nil
+          when :colon3
+            res << exp.value << :""
+            exp = nil
+          when :colon2
+            res << exp.last
+            exp = exp[1]
+          else
+            res << exp
+            exp = nil
+          end
+        else
+          res << exp
+          exp = nil
+        end
+      end
+
+      res.reverse!
+      res
+    end
+
+    def self.get_constant_base_name exp
+      return exp unless exp.is_a? Sexp
+
+      case exp.node_type
+      when :const, :colon3
+        exp.value
+      when :colon2
+        exp.last
+      else
+        exp
+      end
+    end
+  end
+end

data/lib/railroader/tracker/controller.rb

@@ -0,0 +1,161 @@
+require 'railroader/tracker/collection'
+
+module Railroader
+  module ControllerMethods
+    attr_accessor :layout
+
+    def initialize_controller
+      @options[:before_filters] = []
+      @options[:skip_filters] = []
+      @layout = nil
+      @skip_filter_cache = nil
+      @before_filter_cache = nil
+    end
+
+    def protect_from_forgery?
+      @options[:protect_from_forgery]
+    end
+
+    def add_before_filter exp
+      @options[:before_filters] << exp
+    end
+
+    def prepend_before_filter exp
+      @options[:before_filters].unshift exp
+    end
+
+    def before_filters
+      @options[:before_filters]
+    end
+
+    def skip_filter exp
+      @options[:skip_filters] << exp
+    end
+
+    def skip_filters
+      @options[:skip_filters]
+    end
+
+    def before_filter_list processor, method
+      controller = self
+      filters = []
+
+      while controller
+        filters = controller.get_before_filters(processor, method) + filters
+
+        controller = tracker.controllers[controller.parent] ||
+          tracker.libs[controller.parent]
+      end
+
+      remove_skipped_filters processor, filters, method
+    end
+
+    def get_skipped_filters processor, method
+      filters = []
+
+      if @skip_filter_cache.nil?
+        @skip_filter_cache = skip_filters.map do |filter|
+          before_filter_to_hash(processor, filter.args)
+        end
+      end
+
+      @skip_filter_cache.each do |f|
+        if filter_includes_method? f, method
+          filters.concat f[:methods]
+        else
+        end
+      end
+
+      filters
+    end
+
+
+    def remove_skipped_filters processor, filters, method
+      controller = self
+
+      while controller
+        filters = filters - controller.get_skipped_filters(processor, method)
+
+        controller = tracker.controllers[controller.parent] ||
+          tracker.libs[controller.parent]
+      end
+
+      filters
+    end
+
+    def get_before_filters processor, method
+      filters = []
+
+      if @before_filter_cache.nil?
+        @before_filter_cache = []
+
+        before_filters.each do |filter|
+          @before_filter_cache << before_filter_to_hash(processor, filter.args)
+        end
+      end
+
+      @before_filter_cache.each do |f|
+        if filter_includes_method? f, method
+          filters.concat f[:methods]
+        end
+      end
+
+      filters
+    end
+
+    def before_filter_to_hash processor, args
+      filter = {}
+
+      #Process args for the uncommon but possible situation
+      #in which some variables are used in the filter.
+      args.each do |a|
+        if sexp? a
+          a = processor.process_default a
+        end
+      end
+
+      filter[:methods] = []
+
+      args.each do |a|
+        filter[:methods] << a[1] if a.node_type == :lit
+      end
+
+      if args[-1].node_type == :hash
+        option = args[-1][1][1]
+        value = args[-1][2]
+        case value.node_type
+        when :array
+          filter[option] = value[1..-1].map {|v| v[1] }
+        when :lit, :str
+          filter[option] = value[1]
+        else
+          Railroader.debug "[Notice] Unknown before_filter value: #{option} => #{value}"
+        end
+      else
+        filter[:all] = true
+      end
+
+      filter
+    end
+
+    private
+
+    def filter_includes_method? filter_rule, method_name
+       filter_rule[:all] or
+       (filter_rule[:only] == method_name) or
+       (filter_rule[:only].is_a? Array and filter_rule[:only].include? method_name) or
+       (filter_rule[:except].is_a? Symbol and filter_rule[:except] != method_name) or
+       (filter_rule[:except].is_a? Array and not filter_rule[:except].include? method_name)
+    end
+  end
+
+  class Controller < Railroader::Collection
+    include ControllerMethods
+
+    def initialize name, parent, file_name, src, tracker
+      super
+      initialize_controller
+      @collection = tracker.controllers
+    end
+  end
+end

data/lib/railroader/tracker/library.rb

@@ -0,0 +1,17 @@
+require 'railroader/tracker/collection'
+require 'railroader/tracker/controller'
+require 'railroader/tracker/model'
+
+module Railroader
+  class Library < Railroader::Collection
+    include ControllerMethods
+    include ModelMethods
+
+    def initialize name, parent, file_name, src, tracker
+      super
+      initialize_controller
+      initialize_model
+      @collection = tracker.libs
+    end
+  end
+end

data/lib/railroader/tracker/model.rb

@@ -0,0 +1,90 @@
+require 'railroader/tracker/collection'
+
+module Railroader
+  module ModelMethods
+    attr_reader :associations, :attr_accessible, :role_accessible
+
+    def initialize_model
+      @associations = {}
+      @role_accessible = []
+      @attr_accessible = nil
+    end
+
+    def association? method_name
+      @associations.each do |name, args|
+        args.each do |arg|
+          if symbol? arg and arg.value == method_name
+            return true
+          end
+        end
+      end
+
+      false
+    end
+
+    def unprotected_model?
+      @attr_accessible.nil? and !parent_classes_protected? and ancestor?(:"ActiveRecord::Base")
+    end
+
+    # go up the chain of parent classes to see if any have attr_accessible
+    def parent_classes_protected? seen={}
+      seen[self.name] = true
+
+      if @attr_accessible or self.includes.include? :"ActiveModel::ForbiddenAttributesProtection"
+        true
+      elsif parent = tracker.models[self.parent] and !seen[self.parent]
+        parent.parent_classes_protected? seen
+      else
+        false
+      end
+    end
+
+    def set_attr_accessible exp = nil
+      if exp
+        args = []
+
+        exp.each_arg do |e|
+          if node_type? e, :lit
+            args << e.value
+          elsif hash? e
+            @role_accessible.concat args
+          end
+        end
+
+        @attr_accessible ||= []
+        @attr_accessible.concat args
+      else
+        @attr_accessible ||= []
+      end
+    end
+
+    def set_attr_protected exp
+      add_option :attr_protected, exp
+    end
+
+    def attr_protected
+      @options[:attr_protected]
+    end
+  end
+
+  class Model < Railroader::Collection
+    include ModelMethods
+
+    ASSOCIATIONS = Set[:belongs_to, :has_one, :has_many, :has_and_belongs_to_many]
+
+    def initialize name, parent, file_name, src, tracker
+      super
+      initialize_model
+      @collection = tracker.models
+    end
+
+    def add_option name, exp
+      if ASSOCIATIONS.include? name
+        @associations[name] ||= []
+        @associations[name].concat exp.args
+      else
+        super name, exp.arglist.line(exp.line)
+      end
+    end
+  end
+end

data/lib/railroader/tracker/template.rb

@@ -0,0 +1,33 @@
+require 'railroader/tracker/collection'
+
+module Railroader
+  class Template < Railroader::Collection
+    attr_accessor :type
+    attr_reader :render_path
+    attr_writer :src
+
+    def initialize name, called_from, file_name, tracker
+      super name, nil, file_name, nil, tracker
+      @render_path = called_from
+      @outputs = []
+    end
+
+    def add_output exp
+      @outputs << exp
+    end
+
+    def each_output
+      @outputs.each do |o|
+        yield o
+      end
+    end
+
+    def rendered_from_controller?
+      if @render_path
+        @render_path.rendered_from_controller?
+      else
+        false
+      end
+    end
+  end
+end