methodmissing-scrooge 1.0.0

data/lib/scrooge/tracker/app.rb

@@ -0,0 +1,101 @@
+module Scrooge
+  module Tracker
+    class App < Scrooge::Tracker::Base
+      
+      # Application container for various Resources.
+      
+      GUARD = Monitor.new      
+      
+      attr_accessor :resources
+      
+      def initialize
+        super()
+        @resources = Set.new
+      end
+      
+      # Has any Resources been tracked ? 
+      #
+      def any?
+        GUARD.synchronize do
+          !@resources.empty?
+        end  
+      end
+      
+      # Add a Resource instance to this tracker.
+      #      
+      def <<( resource )
+        GUARD.synchronize do
+          @resources << setup_resource( resource )
+        end
+      end
+      
+      def marshal_dump #:nodoc:
+        GUARD.synchronize do
+          dumped_resources()
+        end
+      end
+      
+      def marshal_load( data ) #:nodoc:
+        GUARD.synchronize do
+          @resources = Set.new( restored_resources( data ) )
+        end
+        self
+      end
+      
+      # Track a given Resource.
+      #
+      def track( resource )
+        profile.log "Track with resource #{resource.inspect}"
+        begin
+          yield
+        ensure
+          self << resource if resource.any?
+        end     
+      end
+      
+      def inspect #:nodoc:
+        if any?
+          @resources.map{|r| r.inspect }.join( "\n\n" )
+        else
+          super
+        end  
+      end
+      
+      # If we've seen this resource before, return the original, else, returns
+      # the given resource.
+      #
+      def resource_for( resource )
+        @resources.detect{|r| r.signature == resource.signature } || resource
+      end
+      
+      private
+      
+        def setup_resource( resource ) #:nodoc:
+          GUARD.synchronize do
+            resource_for( resource )
+          end
+        end
+      
+        def environment #:nodoc:
+          profile.framework.environment
+        end
+      
+        def restored_resources( data ) #:nodoc:
+          GUARD.synchronize do
+            data.map do |resource|
+              Resource.new.marshal_load( resource )
+            end
+          end
+        end
+      
+        def dumped_resources #:nodoc:
+          GUARD.synchronize do
+            @resources.to_a.map do |resource|
+              resource.marshal_dump
+            end
+          end
+        end
+            
+    end
+  end
+end

data/lib/scrooge/tracker/base.rb

@@ -0,0 +1,56 @@
+require 'set'
+
+module Scrooge
+  module Tracker
+    
+    autoload :App, 'scrooge/tracker/app'
+    autoload :Resource, 'scrooge/tracker/resource'
+    autoload :Model, 'scrooge/tracker/model'
+    
+    class Base < Scrooge::Base
+      include Comparable      
+      
+      # Scrooge Tracker base class.
+      
+      class NotImplemented < StandardError
+      end
+      
+      attr_accessor :counter
+      
+      def initialize
+        @counter = 0
+      end
+      
+      def to_i
+        @counter  
+      end
+      
+      # Requires subclasses to implement a custom marshal_dump
+      #
+      def marshal_dump
+        raise NotImplemented
+      end
+
+      # Requires subclasses to implement a custom marshal_load
+      #      
+      def marshal_load( data )
+        raise NotImplemented
+      end
+      
+      # Compare trackers through their Marshal representations.
+      #
+      def ==( tracker )
+        compare_to( tracker )
+      end
+      alias :eql? :==
+      alias :<=> :==
+      
+      private
+        
+        def compare_to( tracker ) #:nodoc:
+          marshal_dump == tracker.marshal_dump
+        end
+          
+    end
+  end
+end

data/lib/scrooge/tracker/model.rb

@@ -0,0 +1,90 @@
+module Scrooge
+  module Tracker
+    class Model < Base
+      
+      GUARD = Monitor.new
+      
+      attr_accessor :model,
+                    :attributes 
+
+      def initialize( model )
+        super()
+        @model = model
+        @attributes = Set.new 
+      end
+
+      # Has any Attributes been tracked ? 
+      #
+      def any?
+        GUARD.synchronize do
+          !@attributes.empty?
+        end  
+      end
+   
+      # Add a Model attribute to this tracker.
+      #
+      def <<( attribute )
+        GUARD.synchronize do
+          Array( attribute ).each do |attr|
+            attributes << attr
+          end
+        end  
+      end     
+      
+      def marshal_dump #:nodoc:
+        GUARD.synchronize do
+          { name() => @attributes.to_a }
+        end
+      end
+      
+      def marshal_load( data ) #:nodoc:
+        GUARD.synchronize do
+          @model = data.keys.first
+          @attributes = Set.new( data[@model] )
+          self
+        end
+      end
+      
+      # Memoize the name lookup.
+      #
+      def name
+        @name ||= profile.orm.name( @model )
+      end
+      
+      # Memoize the table name lookup.
+      #
+      def table_name
+        @table_name ||= profile.orm.table_name( @model )
+      end
+      
+      # Memoize the primary key lookup.
+      #
+      def primary_key
+        @primary_key ||= profile.orm.primary_key( @model )
+      end
+      
+      # Dump to a SQL SELECT snippet.
+      #
+      def to_sql
+        GUARD.synchronize do
+          attributes_with_primary_key().map{|a| "#{table_name}.#{a.to_s}" }.join(', ')
+        end
+      end
+      
+      def inspect #:nodoc:
+        "#<#{name()} #{attributes_for_inspect}>"
+      end
+      
+      private
+       
+        def attributes_for_inspect #:nodoc:
+          @attributes.map{|a| ":#{a}" }.join(', ')
+        end
+      
+        def attributes_with_primary_key #:nodoc:
+          @attributes << primary_key
+        end
+      
+    end    
+  end
+end

data/lib/scrooge/tracker/resource.rb

@@ -0,0 +1,201 @@
+module Scrooge
+  module Tracker
+    class Resource < Base
+      
+      # A Resource tracker is scoped to a
+      #
+      # * controller
+      # * action
+      # * request method
+      # * content type
+      #
+      # and is a container for any Models referenced during the active
+      # request / response cycle.
+      
+      GET = /get/i
+      
+      GUARD = Monitor.new
+            
+      attr_accessor :controller,
+                    :action,
+                    :method,
+                    :format,
+                    :models      
+      
+      def initialize
+        super()
+        @models = Set.new
+        yield self if block_given?
+      end
+
+      # Has any Models been tracked ? 
+      #
+      def any?
+        GUARD.synchronize do
+          !@models.empty?
+        end  
+      end
+      
+      # Generates a signature / lookup key.
+      #
+      def signature
+        @signature ||= "#{controller.to_s}_#{action.to_s}_#{method.to_s}"
+      end
+      
+      # Only track GET requests
+      #
+      def trackable?
+        !( method || '' ).to_s.match( GET ).nil?
+      end
+      
+      # Add a Model to this resource.
+      #
+      def <<( model )
+        GUARD.synchronize do
+          @models << track_model_from( model )
+        end
+      end
+      
+      def marshal_dump #:nodoc:
+        GUARD.synchronize do
+          { signature => { :controller => @controller,
+                           :action => @action,
+                           :method => @method,
+                           :format => @format,
+                           :models => dumped_models() } }
+        end
+      end      
+      
+      def marshal_load( data ) #:nodoc:
+        GUARD.synchronize do
+          data = data.to_a.flatten.last
+          @controller = data[:controller]
+          @action = data[:action]
+          @method = data[:method]
+          @format = data[:format]
+          @models = restored_models( data[:models] )
+          self
+        end  
+      end
+      
+      # Yields a collection of Rack middleware to scope Model attributes to the
+      # tracked dataset.
+      #
+      def middleware
+        @middleware ||= begin
+          GUARD.synchronize do
+            models.map do |model|
+              middleware_for_model( model )
+            end
+          end  
+        end
+      end      
+      
+      # Return a valid Rack middleware instance for a given model.
+      #
+      def middleware_for_model( model )
+        resource = self  
+        profile.orm.scope_resource_to_model( resource, model )
+        klass = Class.new
+        klass.class_eval(<<-EOS, __FILE__, __LINE__)
+          
+          class << self
+            
+            def inspect
+              "#<Scrooge::Middleware #{model.inspect}>"
+            end
+            
+            # Around Filter compatible implementation for Rails as Dispatcher is 
+            # the root Rack application and as such don't provide access to the Rails
+            # Routing internals from other middleware.
+            #
+            def filter( controller, &block )
+              #{model.model.to_s}.#{profile.orm.resource_scope_method( resource ).to_s} do
+                Scrooge::Base.profile.log "Scope for Model #{model.inspect}"
+                block.call
+              end
+            end
+            
+          end
+          
+          def initialize(app)
+            @app = app
+          end
+
+          def call(env)
+            if scope?( env )
+              #{model.model.to_s}.#{profile.orm.resource_scope_method( resource ).to_s} do
+                @app.call(env)
+              end
+            else
+              @app.call(env)
+            end  
+          end
+          
+          private
+            
+            def scope?( env )
+              Scrooge::Base.profile.orm.resource_scope_method( resource( env ) ) == :#{profile.orm.resource_scope_method( resource ).to_s}                 
+            end  
+            
+            def resource( env )
+              Scrooge::Base.profile.framework.resource( env )
+            end
+          
+        EOS
+        klass
+      end
+      
+      def inspect #:nodoc:
+        "#<#{@method.to_s.upcase} :#{@controller}/#{@action} (#{@format})\n#{models_for_inspect()}"
+      end
+      
+      private
+      
+        def track_model_from( model ) #:nodoc:
+          model.is_a?( Array ) ? model_from_enumerable( model ) : setup_model( model )
+        end
+      
+        def model_from_enumerable( model ) #:nodoc:
+          model, attribute = model
+          model = setup_model( model )
+          model << attribute
+          model
+        end
+      
+        def models_for_inspect #:nodoc:
+          models.map{|m| " - #{m.inspect}" }.join( "\n" )
+        end
+      
+        def dumped_models #:nodoc:
+          GUARD.synchronize do
+            @models.to_a.map{|m| m.marshal_dump }
+          end
+        end
+        
+        def restored_models( models ) #:nodoc:
+          GUARD.synchronize do
+            models.map do |model|
+              m = model.keys.first # TODO: cleanup
+              Model.new( m ).marshal_load( model )
+            end
+          end  
+        end
+        
+        def setup_model( model ) #:nodoc:
+          GUARD.synchronize do
+            if model.is_a?( Scrooge::Tracker::Model )
+              model
+            else
+              model_for( model ) || Scrooge::Tracker::Model.new( model )
+            end
+          end       
+        end
+      
+        def model_for( model ) #:nodoc:
+          @models.detect{|m| m.model.name == model.name }
+        end
+      
+    end
+  end
+end

data/lib/scrooge.rb

@@ -0,0 +1,62 @@
+$:.unshift(File.dirname(__FILE__))
+
+require 'yaml'
+require 'fileutils'
+require 'scrooge/core/string'
+require 'scrooge/core/symbol'
+require 'scrooge/core/thread'
+require 'thread'
+
+module Scrooge
+  class Base
+    
+    GUARD = ::Mutex.new
+    
+    class << self
+      
+      # Active Profile reader
+      #
+      def profile
+        @@profile ||= Scrooge::Profile.new
+      end
+      
+      # Active Profile writer.
+      #
+      def profile=( profile )
+        @@profile = profile
+      end
+      
+      # Installs a YAML configuration template in the host framework's config
+      # directory.
+      #
+      def setup!
+        unless File.exist?( profile.framework.configuration_file )
+          FileUtils.cp( configuration_template(), profile.framework.configuration_file )
+        end  
+      end
+      
+      private
+      
+        def configuration_template #:nodoc:
+          File.join( File.dirname(__FILE__), '..', 'assets', 'config', 'scrooge.yml.template' )
+        end
+      
+    end
+    
+    def profile
+      self.class.profile
+    end
+    
+  end 
+
+  module Middleware
+    autoload :Tracker, 'scrooge/middleware/tracker'
+  end 
+
+end
+
+require 'scrooge/profile'
+require 'scrooge/storage/base'
+require 'scrooge/orm/base'
+require 'scrooge/framework/base'
+require 'scrooge/tracker/base'

data/spec/fixtures/config/scrooge/scopes/1234567891/scope.yml

@@ -0,0 +1,2 @@
+--- 
+test: []

data/spec/fixtures/config/scrooge.yml

@@ -0,0 +1,12 @@
+production:
+  orm: :active_record
+  storage: :memory
+  scope: 1234567891 
+  on_missing_attribute: :reload
+  enabled: true  
+test:
+  orm: :active_record
+  storage: :memory
+  scope: 
+  on_missing_attribute: :reload      
+  enabled: true      

data/spec/helpers/framework/rails/cache.rb

@@ -0,0 +1,25 @@
+module Spec
+  module Helpers
+    module Framework
+      module Rails
+        class Cache
+          
+          attr_reader :storage
+          
+          def initialize
+            @storage = {}
+          end
+          
+          def read( key )
+            @storage[key]
+          end
+          
+          def write( key, value )
+            @storage[key] = value
+          end
+          
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,51 @@
+$:.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'rubygems'
+require 'fileutils'
+require 'logger'
+require 'stringio'
+require 'lib/scrooge'
+require 'spec/helpers/framework/rails/cache'
+
+#ActiveRecord::Base.logger = Logger.new(StringIO.new)
+
+Spec::Runner.configure do |config|
+  
+  Kernel.const_set :FIXTURES, "#{Dir.pwd}/spec/fixtures" unless defined?(FIXTURES)
+  Kernel.const_set :TMP, "#{Dir.pwd}/spec/tmp" unless defined?(TMP)
+  Kernel.const_set :CONFIG, "#{Dir.pwd}/spec/config" unless defined?(CONFIG)
+  
+  config.before :all do
+    [TMP, CONFIG].each do |dir|
+      FileUtils.mkdir_p dir
+    end
+  end
+  
+  config.before :each do
+  end
+  
+  config.after :each do
+  end    
+  
+  config.after :all do
+    [TMP, CONFIG].each do |dir|
+      FileUtils.rm_r( dir ) rescue nil
+    end
+  end
+  
+  def with_rails
+    begin
+      Kernel.const_set :RAILS_ROOT, "#{Dir.pwd}/spec" unless defined?(RAILS_ROOT)
+      Kernel.const_set :Rails, Class.new unless defined?(Rails)
+      Kernel.const_set :RAILS_ENV, "test" unless defined?(RAILS_ENV)
+      ::Rails.stub!(:cache).and_return( Spec::Helpers::Framework::Rails::Cache.new )
+      ::Rails.stub!(:root).and_return( RAILS_ROOT )
+      yield
+    ensure
+      [:RAILS_ROOT, :RAILS_ENV, :Rails].each do |const|  
+        Kernel.send( :remove_const, const )
+      end
+    end
+  end
+  
+end

data/spec/units/scrooge/core/string_spec.rb

@@ -0,0 +1,21 @@
+require 'spec/spec_helper'
+
+describe Scrooge::Core::String do
+  
+  before(:each) do
+    @string = 'scrooge/base'
+  end
+  
+  it "should be able to convert itself to a constant" do
+    @string.to_const().should == 'Scrooge::Base'
+  end
+  
+  it "should be able to convert itself to a class" do
+    @string.to_const!( false ).should == Scrooge::Base
+  end
+  
+  it "should return self if it's not able to constantize" do
+    'not/defined'.to_const!( false ).should == 'not/defined'
+  end
+  
+end

data/spec/units/scrooge/core/symbol_spec.rb

@@ -0,0 +1,13 @@
+require 'spec/spec_helper'
+
+describe Scrooge::Core::Symbol do
+  
+  before(:each) do
+    @symbol = :active_record
+  end
+  
+  it "should be able to convert itself to a constant" do
+    @symbol.to_const().should == 'ActiveRecord'
+  end
+  
+end

data/spec/units/scrooge/core/thread_spec.rb

@@ -0,0 +1,15 @@
+require 'spec/spec_helper'
+
+describe "Scrooge::Core::Thread singleton" do
+  
+  it "should be able to yield the current scrooge resource" do
+    Thread.scrooge_resource.class.should equal( Scrooge::Tracker::Resource )
+  end
+  
+  it "should be able to reset the current scrooge resource" do
+    @resource = Thread.scrooge_resource
+    Thread.reset_scrooge_resource!
+    @resource.object_id.should_not equal( Thread.scrooge_resource.object_id )
+  end
+  
+end