stratagem 0.1.7

data/lib/stratagem/framework_extensions/models/adapters/active_model/metadata.rb

@@ -0,0 +1,103 @@
+module Stratagem::ApplicationExtensions::Models::Adapters::ActiveModel
+
+  # prefix method names with  to avoid collision
+  class Metadata
+
+    attr_reader :model, :instance
+
+    def initialize(model)
+      @model = model
+      @instance = @model.new unless (@model == ActiveRecord::Base)
+    end
+    
+    def relations(relation_type=nil) # :belongs_to, :has_many
+      @relations ||= {}
+      @relations[relation_type || :all] ||= model.reflect_on_all_associations(relation_type).map {|a|
+        Stratagem::ApplicationExtensions::Models::Metadata::StratagemAssociation.new(a.name.to_sym, a.association_foreign_key.to_sym, a.klass, a.macro)
+      }
+    end
+
+    def unaccessible_attributes
+      attrs = []
+      if (model.accessible_attributes)
+        attrs = model.stratagem.attribute_names - model.accessible_attributes.map {|a| a.to_sym }
+      end
+      attrs += model.protected_attributes.map {|a| a.to_sym } if model.protected_attributes
+      attrs
+    end
+
+    # parses a database error and returns the columns that had problems
+    # this is typically a not null enforced by the database but not
+    # by the model
+    def column_from_error(database_error)
+      if (database_error.kind_of?(Mysql::Error) || database_error.kind_of?(::ActiveRecord::StatementInvalid))
+        database_error.message =~ /Column '(.*)?' cannot/
+        $1 ? $1.to_sym : nil
+      else
+        puts database_error.class.name
+        nil
+      end
+    end
+
+
+    def valid?
+      model.valid?
+    end
+  
+    def whitelists_attributes?
+      !model.accessible_attributes.nil?
+    end
+  
+    def blacklists_attributes?
+      !model.protected_attributes.nil?
+    end
+  
+    def attribute_names
+      instance.attribute_names.map {|a| a.to_sym}  - ignore_attributes
+    end
+
+    # junk attributes
+    def ignore_attributes
+      ["!".to_sym, :[]]
+    end
+
+    # Attributes generally used by the persistence mechanism that should not be human writable
+    # accessible from the class
+    def internal_attributes
+      attrs = [:id, :created_at, :updated_at]
+      attrs += attribute_names.select {|a|
+        (a.to_s =~ /_count$/) ||
+        (a.to_s =~ /_salt$/)  ||
+        (a.to_s =~ /_token$/)  ||
+        (a.to_s == 'type')
+      }.map {|a| a.to_sym }
+      attrs
+    end
+
+    def attribute_type(name)
+      column = instance.column_for_attribute(name.to_s)
+      if (!column.nil?)
+        if (model.stratagem.foreign_keys.include?(name.to_sym))
+          :integer
+        else
+          column.type
+        end
+      else
+        if (name =~ /password/)
+          :string
+        else
+          types = [:string, :boolean, :integer]
+          types[rand(3)]
+        end
+      end
+    end
+
+    def invalid_columns(instance)
+      instance.valid?
+      errors = []
+      instance.errors.each {|error,i| errors << error.to_s.to_sym }
+      errors & attribute_names 
+    end
+
+  end
+end

data/lib/stratagem/framework_extensions/models/adapters/active_model/tracing.rb

@@ -0,0 +1,50 @@
+module Stratagem::ApplicationExtensions::Models::Adapters::ActiveModel
+  module Tracing
+    def self.included(model)
+      model.class_eval do
+        # inject read tracing
+        @@removed_finder_methods = [:first, :last]+methods.select {|m| m =~ /^find/ }.map {|m| m.to_sym }.uniq
+        @@removed_methods = [:method_missing]+@@removed_finder_methods
+        class << self
+          @@removed_methods.each do |m|
+            alias_method "old_#{m}", m
+            undef_method m
+          end
+        end
+        model.removed_methods = @@removed_methods
+        
+        # inject write tracing
+        [:create_or_update].each do |m|
+          alias_method "old_#{m}", m
+          undef_method m
+        end
+
+        # enhance method missing
+        class << self
+          def method_missing(method, *args, &block)
+            if (self.removed_methods.include?(method.to_sym))
+              # puts "read invocation: #{self.name} -> #{method} -> #{args.inspect}" 
+              stratagem.read_invocation(method, args) if (@@removed_finder_methods.include?(method))
+              send("old_"+method.to_s, *args, &block)
+            elsif (self.removed_validators.include?(method.to_sym))
+              stratagem.validator_called(method, args)
+              puts "calling validator #{method.to_s} with #{args.inspect}"
+              send("old_"+method.to_s, *args, &block)
+            else
+              old_method_missing(method, *args, &block)
+            end
+          end
+        end
+
+        # add logging of save methods
+        
+        def create_or_update(*args)
+          path,action,line = stratagem.controller_trace(/active_record\/base\.rb/)
+          stratagem.write_invocation(self, action.to_sym, args)
+          old_create_or_update(*args)
+        end
+      end
+    end
+
+  end
+end

data/lib/stratagem/framework_extensions/models/adapters/authlogic/detect.rb

@@ -0,0 +1,11 @@
+module Stratagem::ApplicationExtensions::Models::Adapters::Authlogic
+  class Detect < Stratagem::ApplicationExtensions::Models::Detect
+    def self.supports?(model)
+      begin
+        model.ancestors.include?(::Authlogic::ActsAsAuthentic::MagicColumns::Methods)
+      rescue
+        false
+      end
+    end
+  end
+end

data/lib/stratagem/framework_extensions/models/adapters/authlogic/extensions.rb

@@ -0,0 +1,10 @@
+if defined?(Authlogic)
+  module Authlogic::ActsAsAuthentic::MagicColumns::Methods
+    def self.included(model)
+      # automatically activate the account
+      model.class_eval do
+        before_save { |record| record.active = true if record.methods_include?(:active) }
+      end
+    end
+  end
+end

data/lib/stratagem/framework_extensions/models/adapters/authlogic/metadata.rb

@@ -0,0 +1,30 @@
+module Stratagem::ApplicationExtensions::Models::Adapters::Authlogic
+
+  # prefix method names with  to avoid collision
+  class Metadata
+    include Stratagem::ApplicationExtensions::Models::Adapters::Common::AuthenticationMetadata
+
+    VIRTUAL_COLUMNS = [:password, :password_confirmation]
+
+    def authenticates?
+      true
+    end
+
+    def initialize(model)
+      @model = model
+    end
+
+    def attribute_names
+      VIRTUAL_COLUMNS
+    end
+
+    def internal_attributes
+      [:crypted_password, :password_salt]
+    end
+
+    def attribute_type(name)
+      :string
+    end
+  end
+
+end

data/lib/stratagem/framework_extensions/models/adapters/authlogic/tracing.rb

@@ -0,0 +1,4 @@
+module Stratagem::ApplicationExtensions::Models::Adapters::Authlogic
+  module Tracing
+  end
+end

data/lib/stratagem/framework_extensions/models/adapters/common/authentication_metadata.rb

@@ -0,0 +1,21 @@
+module Stratagem::ApplicationExtensions::Models::Adapters::Common
+
+  # prefix method names with  to avoid collision
+  module AuthenticationMetadata
+    def exclude_attributes_for_mocking
+      # open id
+      attrs = @model.stratagem.attribute_names.select {|a|
+        (a =~ /open_id/ || a =~ /openid/ || a =~ /identity_url/)
+      }
+      attrs << :identity_url
+      attrs << :openid_identifier
+
+      # aasm
+      if (@model.methods_include?(:aasm_column))
+        attrs << @model.aasm_column
+      end
+      
+      attrs.uniq
+    end
+  end
+end

data/lib/stratagem/framework_extensions/models/adapters/restful_authentication/detect.rb

@@ -0,0 +1,13 @@
+
+
+module Stratagem::ApplicationExtensions::Models::Adapters::RestfulAuthentication
+  class Detect < Stratagem::ApplicationExtensions::Models::Detect
+    def self.supports?(model)
+      begin
+        model.ancestors.include?(::Authentication::ByPassword)
+      rescue
+        false
+      end
+    end
+  end
+end

data/lib/stratagem/framework_extensions/models/adapters/restful_authentication/extensions.rb

@@ -0,0 +1,19 @@
+if (defined?(Authentication))
+  Authentication.subclasses.each do |model|
+    model.class_eval do
+      # add support for aasm models
+      before_save { |record| 
+        begin
+          if (record.methods_include?(:active?) && !record.send(:active?))
+            Stratagem.logger.debug "Activating Restful Authentication model #{name}"; 
+            record.send("#{record.class.aasm_column}=", record.class.aasm_initial_state.values.first.to_s)
+            record.activate! unless record.active?
+          end
+        rescue
+          puts $!.message
+          puts $!.backtrace
+        end
+      }
+    end
+  end
+end

data/lib/stratagem/framework_extensions/models/adapters/restful_authentication/metadata.rb

@@ -0,0 +1,30 @@
+module Stratagem::ApplicationExtensions::Models::Adapters::RestfulAuthentication
+
+  # prefix method names with  to avoid collision
+  class Metadata
+    include Stratagem::ApplicationExtensions::Models::Adapters::Common::AuthenticationMetadata
+
+    VIRTUAL_COLUMNS = [:password, :password_confirmation]
+
+    def authenticates?
+      true
+    end
+
+    def initialize(model)
+      @model = model
+    end
+
+    def attribute_names
+      VIRTUAL_COLUMNS
+    end
+
+    def internal_attributes
+      [:crypted_password]
+    end
+
+    def attribute_type(name)
+      :string
+    end
+  end
+
+end

data/lib/stratagem/framework_extensions/models/adapters/restful_authentication/tracing.rb

@@ -0,0 +1,4 @@
+module Stratagem::ApplicationExtensions::Models::Adapters::RestfulAuthentication
+  module Tracing
+  end
+end

data/lib/stratagem/framework_extensions/models/annotations.rb

@@ -0,0 +1,79 @@
+# Defines the stratagem namespace attached to the model
+module Stratagem::ApplicationExtensions::Models
+  MethodInvocation = Struct.new(:method, :controller_path, :controller_action, :line_number, :model_instance, :model_class, :stack_trace, :args)
+  ValidatorDefinition = Struct.new(:validation, :field, :args, :model_class)
+
+  class InstanceAnnotations
+    include Mocking
+
+    def initialize(object)
+      @object = object
+    end
+
+    def method_missing(method, *args, &block)
+      @object.class.stratagem.send(method, *args, &block)
+    end
+  end
+
+  class Annotations
+    include Metadata
+    include Tracing
+
+    attr_reader :model
+
+    AdapterDescriptor = Struct.new(:tracing, :metadata, :detector)
+
+    class << self
+      def configure(model)
+        puts "configuring #{model.name}"
+
+        # add the stratagem namespace
+        model.class_eval do 
+          def self.stratagem
+            # one stratagem instance per subclass
+            @@stratagem ||= {}
+            @@stratagem[self] ||= Stratagem::ApplicationExtensions::Models::Annotations.new(self)
+          end
+
+
+          def stratagem
+            @stratagem ||= Stratagem::ApplicationExtensions::Models::InstanceAnnotations.new(self)
+          end
+        end
+      
+        # connect the adapters
+        detect_adapters(model).each {|adapter|
+          if adapter.detector.supports?(model)
+            model.send(:include, adapter.tracing) 
+          end
+        }
+      end
+
+      def detect_adapters(model)
+        Detect.subclasses.map do |detector|
+          namespace = detector.name.split('::')
+          namespace.pop
+          namespace = namespace.join('::')
+
+          tracing = module_eval(namespace+"::Tracing")
+          metadata = module_eval(namespace+"::Metadata").new(model)
+          
+          AdapterDescriptor.new(tracing, metadata, detector)
+        end
+      end
+    end
+
+    def initialize(model)
+      puts "initializing stratagem for #{model.name}"
+      @model = model
+    end
+
+    def adapters
+      # supported adapters may change throughout the lifecycle of a class / object
+      @adapters ||= self.class.detect_adapters(model)
+    end
+
+
+  end
+
+end

data/lib/stratagem/framework_extensions/models/detect.rb

@@ -0,0 +1,7 @@
+module Stratagem::ApplicationExtensions::Models
+  class Detect
+    def self.supports?(model)
+      false
+    end
+  end
+end

data/lib/stratagem/framework_extensions/models/metadata.rb

@@ -0,0 +1,85 @@
+
+module Stratagem::ApplicationExtensions::Models
+  module Metadata
+    StratagemAssociation = Struct.new(:name, :foreign_key, :klass, :macro)
+
+    INSTANCE_ENUMERATION_METHODS = [:relations, :attribute_names, :ignore_attributes, :internal_attributes, :unaccessible_attributes, :invalid_columns, :exclude_attributes_for_mocking]
+    INSTANCE_ENTITY_METHODS = [:attribute_type, :column_from_error, :authenticates?, :whitelists_attributes?, :blacklists_attributes?]
+
+    def Metadata.included(mod)
+      mod.class_eval do
+        INSTANCE_ENUMERATION_METHODS.each do |name|
+          define_method(name) do |*args|
+            run_callbacks(name, *args)
+          end
+        end
+
+        INSTANCE_ENTITY_METHODS.each do |name|
+          define_method(name) do |*args|
+            val = run_callbacks(name, *args).first
+            val ||= false if (name.to_s.include?('?'))
+            val
+          end
+        end
+
+      end
+    end
+
+    # Convenience methods
+
+    def foreign_keys
+      relations(:belongs_to).map {|relation| relation.foreign_key }
+    end
+
+    def relation(name)
+      relations.find {|relation| relation.name == name }
+    end
+
+    def relation_names(relation_type=nil)
+      @relation_names ||= {}
+      @relation_names[relation_type || :all] ||= relations(relation_type).map {|relation| relation.name }
+    end
+
+
+    # Tracking of validates_xyz methods. Population of this data can be found in the tracing library
+    
+    def validations(field=nil, validation=nil)
+      validators = self.validators
+    
+      if (field || validation)
+        validators.select {|v| 
+          conditions = []
+          conditions << (v.field == field) if field
+          conditions << (v.validation == validation) if validation
+          !conditions.include?(false)
+        }
+      else
+        validators
+      end
+    end
+
+    def callbacks
+      adapters.select {|a| a.detector.supports?(model) }.map {|a| a.metadata }
+    end
+
+    def validators
+      @validators ||= []
+    end
+    
+    private
+
+      def run_callbacks(method, *args)
+        results = callbacks.inject([]) {|memory,callback|
+          begin
+            memory << callback.send(method, *args) if callback.methods_include?(method) || callback.methods_include?(method.to_s)
+            memory
+          rescue
+            puts $!.message
+            puts $!.backtrace
+          end
+        }
+        (results || []).flatten.compact
+      end
+
+  end
+end

data/lib/stratagem/framework_extensions/models/mocking.rb

@@ -0,0 +1,23 @@
+module Stratagem::ApplicationExtensions::Models
+  module Mocking
+    def mock_attributes
+      @attributes ||= {}
+    end
+    
+    def write_mock_attribute(name, value)
+      mock_attributes[name] = value
+    end
+    
+    def read_mock_attribute(name)
+      mock_attributes[name]
+    end
+
+    def used_in_mock_relation
+      @available_for_mock_relation = false
+    end
+
+    def used_in_mock_relation?
+      @available_for_mock_relation ||= true
+    end
+  end
+end

data/lib/stratagem/framework_extensions/models/tracing.rb

@@ -0,0 +1,71 @@
+module Stratagem::ApplicationExtensions::Models
+  module Tracing
+
+    @@invocations_audit = []
+
+    def invocations_audit
+      @@invocations_audit
+    end
+    
+    def read_invocations
+      @read_invocations ||= []
+    end
+    
+    def write_invocations
+      @write_invocations ||= []
+    end
+    
+    def validator_called(validation, args)
+      params = args.find {|a| a.kind_of?(Hash) } || {}
+      (args-[params]).each do |field|
+        self.validators << ValidatorDefinition.new(validation, field, params, model)
+      end
+    end
+    
+    def clear_invocations
+      read_invocations.clear
+      write_invocations.clear
+      invocations_audit.clear
+    end
+
+    def write_invocation(model_instance, method, args)
+      invocation(method, args, write_invocations, model_instance)
+    end
+
+    def read_invocation(method, *args)
+      # ensure that the read did not stem from a write operation
+      path,action,line = controller_trace(/active_record\/base\.rb/)
+      invocation(method, args, read_invocations) unless (action =~ /create/) || (action =~ /update/) || (action =~ /save/)
+    end
+
+    def invocation(method, args, enumeration, model_instance=nil)
+      path,action,line = controller_trace
+      args = args.first if args && (args.size == 1) && (args.first.kind_of?(Array))
+      add_invocation enumeration, MethodInvocation.new(method, path, action, line, model_instance, model, caller, args) if (path)
+    end
+
+    def controller_trace(regex = /_controller\.rb/)
+      controller_trace = caller.select {|c| c =~ regex }.last
+      if controller_trace
+        path,line,action = controller_trace.split(':')
+        action.gsub!(/[`']/, '').gsub!('in ', '')
+        line = line.to_i
+        [path,action,line]
+      else
+        []
+      end
+    end
+
+    def add_invocation(enumeration, invocation)
+      # puts "adding invocation: #{invocation.inspect}"
+      invocations = (enumeration ||= [])
+      existing = invocations.find {|i| 
+        i.controller_path == invocation.controller_path && 
+        i.controller_action == invocation.controller_action && 
+        i.line_number == invocation.line_number
+      }
+      invocations << invocation unless existing
+      invocations_audit << invocation
+    end
+  end
+end

data/lib/stratagem/framework_extensions/models.rb

@@ -0,0 +1,21 @@
+module Stratagem::ApplicationExtensions::Models; end
+module Stratagem::ApplicationExtensions::Models::Adapters; end
+
+require 'stratagem/framework_extensions/models/mocking'
+require 'stratagem/framework_extensions/models/metadata'
+require 'stratagem/framework_extensions/models/tracing'
+require 'stratagem/framework_extensions/models/annotations'
+require 'stratagem/framework_extensions/models/detect'
+
+base = File.join(File.dirname(__FILE__), 'models', 'adapters', 'common')
+Dir.entries(base).select {|s| s =~ /\.rb$/}.each {|helper|
+  require File.join(base, helper.gsub(/\.rb/, ''))
+}
+
+base = File.join(File.dirname(__FILE__), 'models', 'adapters')
+Dir.entries(base).select {|s| s !~ /^\./ && s != 'common' }.each {|adapter_dir|
+  require File.join(base, adapter_dir, 'detect')
+  require File.join(base, adapter_dir, 'tracing')
+  require File.join(base, adapter_dir, 'metadata')
+  require File.join(base, adapter_dir, 'extensions')
+}

data/lib/stratagem/framework_extensions/rails.rb

@@ -0,0 +1,8 @@
+module Rails
+  def self.stratagem_rails_version
+    rails_version = Rails.version.split('.')
+    rails_version << 0 while rails_version.size < 3
+    rails_version.pop while rails_version.size > 3
+    rails_version.join.to_i
+  end
+end

data/lib/stratagem/framework_extensions.rb

@@ -0,0 +1,6 @@
+module Stratagem::ApplicationExtensions; end
+
+require 'stratagem/framework_extensions/rails'
+require 'stratagem/framework_extensions/controllers'
+require 'stratagem/framework_extensions/models'
+

data/lib/stratagem/interface/browser.rb

@@ -0,0 +1,37 @@
+require 'rubygems'
+require 'sinatra'
+require 'erb'
+
+set :run, false
+enable :sessions
+disable :logging
+# log = File.new("log/sinatra.log", "a")
+# STDOUT.reopen(log)
+# STDERR.reopen(log)
+
+get '/' do
+  session[:instance_id] = Stratagem.session_id
+  Stratagem.analyze
+  haml :index
+end
+
+get '/credentials' do
+  Stratagem::Authentication.instance.store_credentials(params[:account], params[:api_key], params[:project])
+  redirect '/'
+end
+
+get '/logs' do
+  if (session[:instance_id] == Stratagem.session_id)
+    logger = Stratagem.logger
+    logs = [logger.pop]
+    logs << logger.pop until logger.empty?
+    logs.to_json
+  else
+    ""
+  end
+end
+
+
+Thread.new do
+  Sinatra::Application.run!
+end