stratagem 0.1.8 → 0.1.9

data/lib/stratagem/model/components/controller.rb

@@ -11,11 +11,15 @@ module Stratagem::Model::Component
       @models_rendered = {} # model => [MethodInvocation]
     end
 
-    def model_invocations
-      Stratagem::ApplicationExtensions::Models::Tracing.invocations_audit.select {|invocation|
-        (invocation.controller_path == controller.path) &&
-          (invocation.controller_action.to_s == self.name.to_s)
-      }.uniq
+    def model_invocations(type=nil)
+      invocations = []
+      Stratagem::ApplicationExtensions::Models::Tracing.invocations_audit.each {|invocation|
+        if ((invocation.controller_path == controller.path) && (invocation.controller_action.to_s == self.name.to_s))
+          invocations << invocation unless invocations.include?(invocation) 
+        end
+      }
+      invocations = invocations.select {|i| i.type == type } if type
+      invocations
     end
 
   end
@@ -30,6 +34,10 @@ module Stratagem::Model::Component
       @actions = []
     end
 
+    def action(name)
+      @actions.find {|a| a.name.to_s == name.to_s }
+    end
+
     def add_routable_action(name, method)
       @actions << Action.new(self, name, method)
     end
@@ -37,69 +45,15 @@ module Stratagem::Model::Component
     def export
       {
         :external_id => self.object_id,
-        :type => :controller, 
-        :path => @path.gsub(RAILS_ROOT+'/', ''), 
-        :class_name => @klass.name, 
+        :component_type => :controller, 
+        :path => @path ? @path.gsub(RAILS_ROOT+'/', '') : nil, 
+        :class_name => klass.name, 
         :invalid_routes => @invalid_routes 
       }
     end
 
-    # returns a list of references that create or update the specified model.
-    # see deletes? for destruction of model
-    def modifies(model)
-      # @modifies ||= {}
-      # @modifies[model] ||= begin
-      #   outline = {} # method keys, value is hash of variables and values
-      #   current_method = nil
-      #   references = Set.new
-      # 
-      #   # return [] unless ((model.klass == WineFollow) && (self.klass == FollowsController))
-      # 
-      #   self.parse_tree.walk {|parent,i,subi,node|
-      #     case node
-      #     when RedParse::MethodNode #... do something with method calls
-      #       current_method = node.name
-      #       outline[current_method] = {}
-      #       # puts "CURRENTMETHOD: #{current_method}"
-      #     when RedParse::AssignNode
-      #       if (node.left.kind_of?(RedParse::VarNode))
-      #           begin
-      #             # puts "assigning:#{node.left.name} -> #{node.right.dereference}"
-      #             deref = node.right.dereference
-      #             ((outline[current_method][node.left.name] ||= []) << deref) if current_method && deref
-      #           rescue
-      #             puts $!.message
-      #             puts $!.backtrace
-      #             logger.error("Cannot dereference node #{node.right.to_s}")
-      #           end
-      #       end
-      #     when RedParse::CallNode
-      #       ['update','create','new'].each {|m| 
-      #         # then this is a crud operation (excluding destroy)
-      #         if (node.name.include?(m))
-      #           if (node.talking_about? model)
-      #             references << create_reference(node, current_method, model)
-      #             break
-      #           elsif (node.receiver && node.receiver.methods_include?(:name) && outline[current_method])
-      #             if ((outline[current_method][node.receiver.name] || []).include?(model.klass))
-      #               references << create_reference(node, current_method, model)
-      #               break
-      #             end
-      #           end
-      #         end
-      #       }
-      #     end
-      #     node
-      #   }
-      #   references.to_a
-      # end
-      []
-    end
-   
     def references
-      actions.map {|action| 
-        action.model_invocations.map {|inv| inv.to_reference }
-      }.flatten
+      actions.map {|action| action.model_invocations }.flatten.uniq.map {|inv| inv.to_reference }
     end
    
     private

data/lib/stratagem/model/components/model.rb

@@ -94,44 +94,44 @@ module Stratagem::Model::Component
     end
 
     # References to the find and find_x methods on the model
-    def references_to_finders()
-      references = []
-      method = nil
-      app_model.controllers.each {|controller|
-        controller.parse_tree.walk {|parent,i,subi,node|
-          case node
-          when RedParse::MethodNode
-            method = node
-          when RedParse::CallNode
-            if (!(parent.kind_of?(RedParse::AssignNode)) && (node.receiver) && (node.receiver.to_s == klass.name))
-              references << ControllerModelReference.new(controller, method.name, node.name, node)
-            end
-          end
-
-          case parent
-          when RedParse::AssignNode
-            # p parent
-            begin
-              if (node.kind_of?(RedParse::CallNode) && (node.receiver) && (node.receiver.name == klass.name))
-                references << ControllerModelReference.new(controller, method.name, node.name, node)
-              end
-            rescue
-              puts $!.message
-              puts $!.backtrace
-              # p parent
-            end
-          end
-          true
-        }
-      }
-      references
-    end
+    # def references_to_finders()
+    #   references = []
+    #   method = nil
+    #   app_model.controllers.each {|controller|
+    #     controller.parse_tree.walk {|parent,i,subi,node|
+    #       case node
+    #       when RedParse::MethodNode
+    #         method = node
+    #       when RedParse::CallNode
+    #         if (!(parent.kind_of?(RedParse::AssignNode)) && (node.receiver) && (node.receiver.to_s == klass.name))
+    #           references << ControllerModelReference.new(controller, method.name, node.name, node)
+    #         end
+    #       end
+    # 
+    #       case parent
+    #       when RedParse::AssignNode
+    #         # p parent
+    #         begin
+    #           if (node.kind_of?(RedParse::CallNode) && (node.receiver) && (node.receiver.name == klass.name))
+    #             references << ControllerModelReference.new(controller, method.name, node.name, node)
+    #           end
+    #         rescue
+    #           puts $!.message
+    #           puts $!.backtrace
+    #           # p parent
+    #         end
+    #       end
+    #       true
+    #     }
+    #   }
+    #   references
+    # end
 
     def export
       adapters = stratagem? ? klass.stratagem.callbacks.map {|c| c.class.name } : []
       {
         :external_id => self.object_id,
-        :type => :model, 
+        :component_type => :model, 
         :path => @path.gsub(RAILS_ROOT+'/', ''), 
         :class_name => @klass.name, 
         :superclass => @klass.superclass.name, 

data/lib/stratagem/model/components/reference.rb

@@ -2,16 +2,20 @@ module Stratagem::Model::Component
   class Reference
     attr_accessor :reference_type # :read, :write
     attr_accessor :from_component, :to_component
-    attr_accessor :line_number, :method, :function, :options, :stack_trace
+    attr_accessor :line_number, :request_method, :function, :options, :stack_trace
 
-    Vars = [:reference_type, :from_component, :to_component, :line_number, :method, :function, :options, :stack_trace]
+    EQUALITY_ATTRS = [:reference_type, :from_component, :to_component, :line_number, :method, :function]
     
     def initialize(args={})
       args.each {|key,val| self.send("#{key}=", val) }
     end
 
     def ==(other)
-      Vars.find {|attribute|
+      eql?(other)
+    end
+    
+    def eql?(other)
+      EQUALITY_ATTRS.find {|attribute|
         self.send(attribute) != other.send(attribute) 
       }.nil?
     end
@@ -23,7 +27,7 @@ module Stratagem::Model::Component
         :from_component_external_id => from_component.object_id,
         :to_component_external_id => to_component.object_id,
         :line_number => line_number,
-        :method => method,
+        :request_method => request_method,
         :function => function,
         :options => options ? options.to_json : nil,
         :stack_trace => reference_type == :write ? compressed_stack_trace : nil

data/lib/stratagem/model/components/route.rb

@@ -1,18 +1,49 @@
 module Stratagem::Model::Component
   class Route < Base
-    attr_reader :route
+    attr_reader :route, :segment_keys, :path, :verb, :controller_name, :controller_path, :action_name
 
     def initialize(route)
       @route = route
+      if (Stratagem.rails_3?)
+        @path = route.path
+        @controller_path = route.requirements[:controller]
+        @action_name = route.requirements[:action]
+        @verb = (route.verb || :GET).downcase.to_sym
+      elsif (Stratagem.rails_2?)
+        @path = route.segments.join.sub(/[\?\/]$/, '')
+        @controller_path = route.parameter_shell[:controller]
+        @action_name = route.parameter_shell[:action]
+        @verb = route.conditions[:method] || :get
+      end
+      
+      @segment_keys = route.segment_keys
+      @action_name = @action_name.to_sym if @action_name
+      if (@controller_path)
+        @controller_name = @controller_path.gsub('/','::').split('::').map {|part| part.camelcase }.join('::')
+        @controller_name << 'Controller'
+      end
+      puts "CONTROLLER INFO: #{@controller_name}, #{@action_name}, #{@verb}, #{controller}"
+    end
+
+    def responds_to?(path, request_method)
+      if (Stratagem.rails_3?)
+        begin
+          route.set.recognize_path(path, :method => request_method) == route.requirements
+        rescue ActionController::RoutingError
+          puts "ERROR: #{$!.message}"
+        end
+      elsif (Stratagem.rails_2?)
+        route.recognize(path, {:method => request_method}) 
+      end
     end
 
     def controller
-      if (route.requirements[:controller])
+      if (controller_name)
         begin
-          controller_class = "#{route.requirements[:controller].to_s.camelize}Controller".constantize
+          controller_class = controller_name.constantize
           Stratagem::Model::Application.instance.controllers.find {|c| c.klass == controller_class }
         rescue
-          puts "unable to determine controller #{route.requirements[:controller]}"
+          puts "unable to determine controller: #{route.requirements[:controller]}"
           puts $!.message
           nil
         end
@@ -21,15 +52,11 @@ module Stratagem::Model::Component
       end
     end
 
-    def action
-      route.requirements[:action] ? route.requirements[:action].to_sym : nil
-    end
-
     def ==(other)
       if (other.kind_of?(ActionController::Routing::Route))
         self.route == other
       elsif (other.kind_of?(Stratagem::Model::Component::Route))
-        self.route.requirements == other.route.requirements && self.route.segments == other.route.segments
+        self.route == other.route
       else
         raise "unknown comparison to #{other.class.name}"
       end
@@ -38,12 +65,11 @@ module Stratagem::Model::Component
     def export
       {
         :external_id => self.object_id,
-        :type => :route, 
-        :path => nil,
-        :requirements => @route.requirements,
-        :segments => @route.segments.map {|s| s.to_s },
+        :component_type => :route, 
+        :path => path,
+        :verb => verb,
         :controller_external_id => controller ? controller.object_id : nil,
-        :action => action,
+        :action => action_name,
       }
     end
   end

data/lib/stratagem/model/components/view.rb

@@ -33,7 +33,7 @@ module Stratagem::Model::Component
       begin
         {
           :external_id => self.object_id,
-          :type => :view, 
+          :component_type => :view, 
           :path => @path, 
           :render_path => @render_path, 
           :forms => forms.map {|form| form.export } 

data/lib/stratagem/model_builder.rb

@@ -1,6 +1,6 @@
 module Stratagem
   class ModelBuilder
-    attr_reader :parsed_models, :parsed_controllers
+    attr_reader :parsed_models, :parsed_controllers, :model
 
     def initialize
       @model = Stratagem::Model::Application.instance
@@ -33,9 +33,13 @@ module Stratagem
     end
 
     def load_plugins()
-      loader = Rails::Plugin::Loader.new(Rails::Initializer.new(Rails::Configuration.new))
-      loader.load_plugins
-      @model.plugins << loader.initializer.loaded_plugins
+      if (Stratagem.rails_3?)
+        @model.plugins << Rails.application.railties.plugins
+      else
+        loader = Rails::Plugin::Loader.new(Rails::Initializer.new(Rails::Configuration.new))
+        loader.load_plugins
+        @model.plugins << loader.initializer.loaded_plugins
+      end
     end
 
     def load_models()
@@ -46,13 +50,6 @@ module Stratagem
         models = Stratagem::Model::Component::Model.load_all(File.join(root, model))
         models.each do |c|
           log "\t#{c.klass.name} loaded from #{model}"
-
-          # references = []
-          # @model.controllers.each do |controller|
-          #   references += controller.modifies(c)
-          # end
-          # log "\t\t#{references.size} references from controllers"
-          # c.model_referenced_by = references
         end
         @model.models << models
       }
@@ -85,42 +82,53 @@ module Stratagem
       ActionController::Routing::Routes.routes.each {|route|
         route_container = Stratagem::Model::Component::Route.new(route)
         @model.routes << route_container 
-        begin
-          filename = File.join(root, "#{route.parameter_shell[:controller]}_controller.rb")
 
-          controllers = @model.controllers.select {|c| c.path == filename }
-          unless controllers.size > 0
-            controllers = Stratagem::Model::Component::Controller.load_all(filename)
-            puts "loading controllers from #{filename} -> controllers #{controllers.map {|c| c.klass.name }.inspect}"
-            @model.controllers << controllers
-          end
-      
-          controller_name = route.parameter_shell[:controller].gsub('/','::').split('::').map {|part| part.camelcase }.join('::')
-          controller_name << 'Controller'
-          controller_class = controllers.find {|controller| controller.klass.name == controller_name }
-          controller_object = controller_class ? controller_class.klass.new : nil
-          controller_action = route.parameter_shell[:action] ? route.parameter_shell[:action].to_sym : nil
-
-          if (controller_object && controller_action) && (controller_object.methods_include?(controller_action))
-            controllers.each do |controller|
-              controller.add_routable_action(controller_action, route.conditions[:method] || :get)
-            end
-          else
-            # if the controller does not contain the indicated method
-            # then check for a template that may be rendered anyway
-            log "\tinvalid route #{route.to_s}"
-            unless @model.views.find {|v| v.render_path == "#{route.parameter_shell[:controller]}/#{controller_action}" }
-              # route is invalid
-              @model.routes.invalid << Stratagem::Model::Component::Route.new(route)
-              log "\tinvalid route #{route.to_s}"
+        begin
+          controller = route_container.controller || begin
+            controller_class = route_container.controller_name.constantize
+            filename = File.join(root, "#{route_container.controller_path}_controller.rb")
+            if (File.exists?(filename))
+              parse_tree = RedParse.new(File.read(filename)).parse
+            else
+              parse_tree = nil
             end
+            controller_container = Stratagem::Model::Component::Controller.new(filename, parse_tree, controller_class)
+            configure_route(route_container, controller_container)
+            @model.controllers << controller_container
           end
-
-        rescue Errno::ENOENT
-          @model.routes.invalid << Stratagem::Model::Component::Route.new(route)
-        rescue MissingSourceFile
+        rescue
+          log "\tinvalid route #{route.to_s} - #{$!.message}"
           @model.routes.invalid << Stratagem::Model::Component::Route.new(route)
         end
+        
+        # begin
+        #   filename = File.join(root, "#{route_container.controller_path}_controller.rb")
+        #   controllers = @model.controllers.select {|c| c.path == filename }
+        # 
+        #   unless controllers.size > 0
+        #     controllers = Stratagem::Model::Component::Controller.load_all(filename)
+        #     puts "loading controllers from #{filename} -> controllers #{controllers.map {|c| c.klass.name }.inspect}"
+        #     @model.controllers << controllers
+        #   end
+        # 
+        #   configure_route(route_container, controllers)
+        # 
+        # rescue Errno::ENOENT, MissingSourceFile
+        #   begin
+        #     controller_class = route_container.controller
+        #     if (controller_class)
+        #       log "Attempting to load external controller for: #{route_container.controller_name}"
+        #       controllers = [Stratagem::Model::Component::Controller.new(nil, nil, controller_class)]
+        #       @model.controllers << controllers
+        #       configure_route(route_container, controllers)
+        #     else
+        #       log "\tinvalid route #{route.to_s} - unable to load external controller"
+        #     end
+        #   rescue
+        #     log "\tinvalid route #{route.to_s} - #{$!.message}"
+        #     @model.routes.invalid << Stratagem::Model::Component::Route.new(route)
+        #   end
+        # end
       }
       log ""
     end
@@ -140,5 +148,26 @@ module Stratagem
       end
       file_list
     end
+    
+    protected
+    
+    def configure_route(route_container, controller_container)
+      if (route_container.action_name)
+        controller_object = controller_container.klass ? controller_container.klass.new : nil
+        if (controller_object && controller_object.methods_include?(route_container.action_name))
+          controller_container.add_routable_action(route_container.action_name, route_container.verb)
+          log "\tvalid route #{route_container.route.to_s}"
+        else
+          # if the controller does not contain the indicated method
+          # then check for a template that may be rendered anyway
+          log "\tinvalid route #{route_container.route.to_s}"
+          unless @model.views.find {|v| v.render_path == "#{route_container.controller_path}/#{route_container.action_name.to_s}" }
+            # route is invalid
+            @model.routes.invalid << Stratagem::Model::Component::Route.new(route_container.route)
+            log "\tinvalid route #{route_container.route.to_s}"
+          end
+        end
+      end
+    end
   end
 end