stratagem 0.1.7

data/lib/stratagem/model/application.rb

@@ -0,0 +1,157 @@
+# Note that an exception may be raised when a Gem is missing
+# and not configured in environment.rb. Check for this case
+# when loading classes
+# Stratagem::Model
+
+require 'set'
+require 'singleton'
+
+module Stratagem::Model
+  # container for application 
+  class Application
+    include Singleton
+
+    attr_accessor :crawler
+    attr_reader :models, :controllers, :routes, :views, :static_files, :gems, :plugins
+
+    def initialize
+      log "initializing application model"
+      @models = ComponentContainer.new self
+      @controllers = ComponentContainer.new self
+      @routes = RouteContainer.new self
+      @views = ComponentContainer.new self
+      @static_files = ComponentContainer.new self
+      @gems = GemContainer.new self
+      @plugins = PluginContainer.new self
+    end
+    
+    def log(msg)
+      Stratagem.logger.debug(msg)
+    end
+    
+    def export
+      puts "exporting site model"
+      p crawler.export
+      puts "done."
+      h = {
+        :rails_version => rails_version,
+        :models => @models.export, 
+        :controllers => @controllers.export, 
+        :routes => @routes.export, 
+        :views => @views.export,
+        :gems => @gems.export,
+        :plugins => @plugins.export,
+        :site_model => crawler.export,
+        :references => []
+      }
+      h
+    end
+
+    def rails_version
+      Rails.stratagem_rails_version
+    end
+  end
+
+  protected
+
+  class GemContainer
+    include Enumerable
+    
+    def initialize(app_model)
+      @app_model = app_model
+      @gems = Gem.loaded_specs
+    end
+
+    def names
+      @gems.map {|g| g[0] }
+    end
+
+    def export(options=nil)
+      @gems.map {|g|
+        name, spec = g
+        [name, {:version => spec.version.version}]
+      }
+    end
+    
+    def each
+      @gems.each {|spec| yield spec }
+    end
+  end
+ 
+  class ComponentContainer
+    include Enumerable
+  
+    attr_reader :invalid, :missing, :parse_trees, :components, :errors
+
+    def initialize(app_model)
+      @app_model = app_model
+      @components = Set.new()
+      @parse_trees = {}
+      @invalid = []
+      @missing = {}
+    end
+
+    def export(options=nil)
+      {
+        :components => @components.to_a.map {|c| c.export }.compact,
+        :invalid => @invalid.map {|c| c.export }.compact 
+      }
+    end
+
+    def find
+      @components.find{|component| yield component } 
+    end
+
+    def size
+      @components.size
+    end
+
+    def -(other)
+      @components-other
+    end
+
+    def each
+      @components.each {|e| yield e }
+    end
+
+    def << (component)
+      if (component.kind_of?(Array))
+        component.each {|e| 
+          @components << e 
+          e.app_model = @app_model if e.methods_include?(:app_model=)
+        }
+      elsif (component.kind_of?(Exception))
+        errors << component
+      else
+        @components << component
+        component.app_model = @app_model if component.methods_include?(:app_model=)
+      end
+    end
+  end
+
+  class RouteContainer < ComponentContainer
+    def recognize(page, method=nil)
+      path = nil
+      if (page.kind_of?(Stratagem::Crawler::Page))
+        method = page.method
+        path = page.path
+      else
+        path = page
+      end
+      #ActionController::Routing::Routes.recognize_path('http://www.example.com/user_sessions/new', {:method => :get})
+      route = ActionController::Routing::Routes.routes.find {|r| r.recognize(path, {:method => method}) }
+      self.find {|r| r.route == route }
+    end
+  end
+  
+  class PluginContainer < ComponentContainer
+    def names
+      components.map {|plugin| plugin.name }
+    end
+
+    def export(options=nil)
+      names
+    end
+  end
+end
+

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

@@ -0,0 +1,55 @@
+module Stratagem::Model::Component
+  class Base
+    include Stratagem::Model::ParseUtil
+
+    attr_reader :path, :source, :parse_tree, :klass
+    attr_accessor :app_model
+
+    def initialize(path, parse_tree, klass)
+      @path = path
+      @parse_tree = parse_tree
+      @klass = klass
+    end
+
+    def logger
+      Stratagem.logger
+    end
+
+    def self.logger
+      Stratagem.logger
+    end
+
+    def name
+      classname = @klass ? @klass.name : self.class.name.gsub(/.*[^A-Z0-9a-z]/, '')
+      "#{path}$#{classname}"
+    end
+
+    # loads all classes contained within a given filename 
+    def self.load_all(path)
+      if (path =~ /\.rb$/)
+        source = File.read(path)
+        begin
+          parse_tree = RedParse.new(source).parse
+          Stratagem::Model::ParseUtil.find_classes(parse_tree).map {|klass|
+            self.new(path, parse_tree, klass)
+          }
+        rescue
+          puts $!.message
+          logger.fatal "Unable to load parse tree for #{path}"
+          []
+        end
+      end
+    end
+
+    def ==(other)
+      if (other.kind_of?(String))
+        self.path == other
+      elsif (other.kind_of?(self.class))
+        self.path == other.path
+      else
+        raise "unknown comparison to #{other.class.name}"
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,118 @@
+require 'set'
+
+module Stratagem::Model::Component
+  class Action
+    def initialize(controller, name, method)
+      @name = name
+      @method = method # :put, :get, :post, :delete
+      @models_rendered = {} # model => [MethodInvocation]
+    end
+
+    def models_read
+      models(ActiveRecord::Base.stratagem.read_invocations)
+    end
+    
+    def models_modified
+      models(ActiveRecord::Base.stratagem.write_invocations)
+    end
+
+    def models(invocations)
+      invocations.values.select {|invocation|
+        (invocation.controller_path == controller.path) &&
+          (invocation.controller_action == self.name)
+      }.map {|invocation|
+        invocation.model_class
+      }.uniq
+    end
+
+  end
+  
+  class Controller < Base
+    attr_reader :clazz, :actions
+    attr_accessor :invalid_routes # named routes linked to the controller that are invalid
+
+    def initialize(*args)
+      super(*args)
+      @invalid_routes = {}
+      @actions = []
+    end
+
+    def add_routable_action(name, method)
+      @actions << Action.new(self, name, method)
+    end
+
+    def export
+      {
+        :external_id => self.object_id,
+        :type => :controller, 
+        :path => @path.gsub(RAILS_ROOT+'/', ''), 
+        :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
+   
+    private
+    
+    def create_reference(node, method, model)
+      Reference.new(
+        :from_class => self.klass, 
+        :to_class => model.klass, 
+        :method => method, 
+        :line_number => node.linerange.first,
+        :reference_type => :write
+      )
+    end
+  end
+end

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

@@ -0,0 +1,170 @@
+module Stratagem::Model::Component
+  class Model < Base
+    attr_reader :model_attributes # database attributes that the model contains
+    attr_reader :model_assignable_attributes # fields / methods that can be manipulated in Model.new(..)
+    attr_reader :model_internal_attributes
+    attr_reader :model_accessible_attributes
+    attr_accessor :model_referenced_by # other classes / libraries that reference this model
+
+    ModificationMethods = ['update','create','new']
+
+    def initialize(*args)
+      super(*args)
+      load_attributes
+      @model_assignable_attributes = find_assignable_attributes
+      @model_instance_methods = self.klass.instance_methods
+    end
+
+    def stratagem?
+      klass.methods_include?(:stratagem)
+    end
+
+    # iterate model's associations to see if there's an association with the specific
+    # name and class. This is used as an aproximation to determine whether or
+    # not a node in the parse tree could be talking about a specific relationship
+    def association_match?(association_name, desired_model)
+      @association_matches ||= {}
+      @association_matches[association_name+"_"+desired_model.klass.name] ||= begin
+        klass.stratagem.relations.select {|relation|  
+          (relation.name.to_sym == association_name.to_sym) && (relation.klass == desired_model.klass)
+        }.map {|relation| 
+          relation.klass.name 
+        }.first
+      rescue
+        Rails.logger.error("unable to lookup associations on #{self.klass.name} not active record model?")
+        Rails.logger.error($!)
+        false
+      end
+      @association_matches[association_name+"_"+desired_model.klass.name]
+    end
+
+    def load_attributes
+      @model_attributes = {}
+      if (stratagem?)
+        object = klass.new # used to look up metadata
+        object.stratagem.attribute_names.each {|attribute|
+          @model_attributes[attribute.to_sym] = object.stratagem.attribute_type(attribute.to_sym)
+        }
+        @model_foreign_keys = object.stratagem.foreign_keys
+        @model_internal_attributes = object.stratagem.internal_attributes
+        @model_accessible_attributes = object.stratagem.attribute_names - object.stratagem.unaccessible_attributes
+      end
+    end
+
+    # TODO - refactor into model persistence strategy
+    def find_assignable_attributes
+      assignable_attributes = []
+
+      # Using instance methods allows us to check for functions that would be mass assignable
+      # in addition to Active Record attributes
+      begin
+        if (stratagem?)
+          object = klass.new # used to look up metadata
+          if (object)
+            methods = nil
+            if (klass.stratagem.unaccessible_attributes)
+              assignable_attributes = (klass.stratagem.attribute_names - klass.stratagem.unaccessible_attributes).to_a
+            else
+              methods = klass.instance_methods + object.stratagem.attribute_names
+              methods.each {|method|
+                param_name = method.to_s.gsub('=','').to_sym
+                val = rand(100)
+                params = { param_name => val }
+                begin
+                  instance = klass.new(params)
+                  assignable_attributes << param_name.to_sym
+                rescue ActiveRecord::UnknownAttributeError
+                  # the attribute is not mass assignable
+                rescue
+                  # the function was called but an error was raised
+                  assignable_attributes << param_name.to_sym
+                end
+              }
+            end
+          end
+          assignable_attributes.uniq
+        end
+      rescue
+        puts "Unable to analyze model #{klass.name}"
+        puts $!.message
+       puts $!.backtrace
+        # raise $!
+        []
+      end
+    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 export
+      adapters = stratagem? ? klass.stratagem.callbacks.map {|c| c.class.name } : []
+      {
+        :type => :model, 
+        :path => @path.gsub(RAILS_ROOT+'/', ''), 
+        :class_name => @klass.name, 
+        :superclass => @klass.superclass.name, 
+        :included_modules => @klass.included_modules.map {|m| m.name},
+        :attributes => @model_attributes,
+        :foreign_keys => @model_foreign_keys,
+        :assignable_attributes => @model_assignable_attributes,
+        :internal_attributes => @model_internal_attributes,
+        :accessible_attributes => @model_accessible_attributes,
+        :whitelists_attributes => stratagem? ? @klass.stratagem.whitelists_attributes? : nil,
+        :blacklists_attributes => stratagem? ? @klass.stratagem.blacklists_attributes? : nil,
+        :instance_methods => @model_instance_methods,
+        :referenced_by => @model_referenced_by.map {|r| r.export },
+        :relations => relations.map {|r| r.export },
+        :adapters => adapters
+      }
+    end
+
+    private
+
+    def relations
+      if (stratagem?)
+        @relations ||= klass.stratagem.relations.map {|relation|
+          Reference.new(:reference_type => relation.macro, :from_class => self.klass, :to_class => relation.klass)
+        }
+      else
+        []
+      end
+    end
+
+    def assignable(object, assignable_attributes, attribute)
+      column = object.column_for_attribute(attribute)
+      assignable_attributes[attribute] = column ? column.type : nil
+    end
+
+  end
+end

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

@@ -0,0 +1,30 @@
+module Stratagem::Model::Component
+  class Reference
+    attr_accessor :reference_type # :read, :write
+    attr_accessor :from_class, :to_class
+    attr_accessor :line_number
+    attr_accessor :method
+
+    Vars = [:reference_type, :from_class, :to_class, :line_number, :method]
+    
+    def initialize(args={})
+      args.each {|key,val| self.send("#{key}=", val) }
+    end
+
+    def ==(other)
+      Vars.each do |attribute|
+        self.send(attribute) == other.send(attribute) 
+      end
+    end
+    
+    def export
+      h = {}
+      Vars.each do |key|
+        h[key.to_s] = self.send(key).to_s
+      end
+      h[:from_class.to_s] = from_class.name
+      h[:to_class.to_s] = to_class.name
+      h
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module Stratagem::Model::Component
+  class Route < Base
+    attr_reader :route
+
+    def initialize(route)
+      @route = route
+    end
+
+    def controller
+      if (route.requirements[:controller])
+        begin
+          controller_class = "#{route.requirements[:controller].to_s.camelize}Controller".constantize
+          Stratagem::Model::Application.instance.controllers.find {|c| c.klass == controller_class }
+        rescue
+          puts "unable to determine controller #{route.requirements[:controller]}"
+          puts $!.message
+          nil
+        end
+      else
+        nil
+      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
+      else
+        raise "unknown comparison to #{other.class.name}"
+      end
+    end
+
+    def export
+      p @route.requirements
+      p action
+      puts "--"
+      {
+        :external_id => self.object_id,
+        :type => :route, 
+        :path => nil,
+        :requirements => @route.requirements,
+        :segments => @route.segments.map {|s| s.to_s },
+        :controller_external_id => controller ? controller.object_id : nil,
+        :action => action,
+      }
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Stratagem::Model::Component
+  class StaticFile < Base
+
+    def initialize(public_path)
+      @path = public_path
+    end
+
+    def read
+      File.read(full_path)
+    end
+
+    def full_path
+      File.join(RAILS_ROOT, 'public', path)
+    end
+  end
+
+end
+