methodmissing-scrooge 1.0.0

data/lib/scrooge/framework/rails.rb

@@ -0,0 +1,107 @@
+module Scrooge
+  module Framework
+    class Rails < Base
+      
+      # Look for RAILS_ROOT and Rails.
+      
+      signature do
+        defined?(RAILS_ROOT)
+      end
+      
+      signature do
+        Object.const_defined?( "Rails" )
+      end
+      
+      def environment
+        ::RAILS_ENV
+      end
+      
+      def root
+        ::Rails.root
+      end
+      
+      def tmp
+        @tmp ||= File.join( ::Rails.root, 'tmp' )
+      end
+      
+      def config
+        @config ||= File.join( ::Rails.root, 'config' )
+      end
+      
+      def logger
+        ::Rails.logger
+      end
+      
+      def resource( env, request = nil )
+        GUARD.synchronize do
+          # TODO: Wonky practice to piggy back on this current Edge / 2.3 hack
+          request = request || env['action_controller.rescue.request']
+          supplement_current_resource!( request )
+          Thread.scrooge_resource = Scrooge::Base.profile.tracker.resource_for( Thread.scrooge_resource )      
+        end
+      end      
+      
+      def read_cache( key )
+        ::Rails.cache.read( key )
+      end      
+      
+      def write_cache( key, value )
+        ::Rails.cache.write( key, value )
+      end
+      
+      def middleware
+        ::Rails.configuration.middleware
+      end    
+      
+      # Push the Tracking middleware into the first slot. 
+      #      
+      def install_tracking_middleware
+        GUARD.synchronize do
+          ActionController::Dispatcher.to_prepare( :scrooge_install_tracking_middleware ) do
+            ApplicationController.prepend_around_filter Scrooge::Middleware::Tracker
+          end
+        end
+      end
+      
+      # Install per Resource scoping middleware.
+      #
+      def install_scope_middleware( tracker )
+        GUARD.synchronize do
+          ActionController::Dispatcher.to_prepare( :scrooge_install_scope_middleware ) do
+            tracker.resources.each do |resource|
+              install_scope_middleware_for_resource!( resource )
+            end
+          end  
+        end  
+      end
+      
+      def initialized( &block )
+        begin
+          ::Rails.configuration.after_initialize( &block )
+        rescue NameError
+          # No cofig initialized - plugin installation etc.
+        end  
+      end
+      
+      def controller( resource )
+        "#{resource.controller}_controller".classify.constantize
+      end
+      
+      private 
+      
+        def install_scope_middleware_for_resource!( resource ) #:nodoc:
+          resource.middleware.each do |resource_middleware|
+            controller( resource ).prepend_around_filter resource_middleware, :only => resource.action
+          end
+        end
+      
+        def supplement_current_resource!( request ) #:nodoc:
+          Thread.scrooge_resource.controller = request.path_parameters['controller']
+          Thread.scrooge_resource.action = request.path_parameters['action']
+          Thread.scrooge_resource.method = request.method
+          Thread.scrooge_resource.format = request.format.to_s  
+        end
+      
+    end
+  end
+end

data/lib/scrooge/middleware/tracker.rb

@@ -0,0 +1,47 @@
+module Scrooge
+  module Middleware 
+    class Tracker < Scrooge::Base
+    
+      class << self
+        
+        # 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 )
+          Scrooge::Base.profile.tracker.track( Thread.scrooge_resource ) do
+            begin
+              Scrooge::Base.profile.framework.resource( {}, controller.request )
+              Scrooge::Base.profile.log "Track for Resource #{Thread.scrooge_resource.inspect}"
+              block.call
+            ensure
+              Thread.reset_scrooge_resource!
+            end
+          end
+        end
+        
+      end
+    
+      def initialize(app, options = {})
+        @app = app
+      end
+      
+      # Assign a default Resource Tracker instance to Thread.current[:scrooge_resource] 
+      # and supplement it with request specific details ( format, action && controller )
+      # after yielding to the app.Flush Thread.current[:scrooge_resource] on completion.
+      #
+      def call(env)    
+        Scrooge::Base.profile.tracker.track( Thread.scrooge_resource ) do
+          begin
+            result = @app.call(env)
+            Scrooge::Base.profile.framework.resource( env )
+            result
+          ensure
+            Thread.reset_scrooge_resource!
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/scrooge/orm/active_record.rb

@@ -0,0 +1,143 @@
+module Scrooge
+  module Orm
+    class ActiveRecord < Base
+      module ScroogeAttributes
+        
+        module SingletonMethods
+          
+          private
+     
+            # Attach to generated attribute reader methods.
+        
+            def define_read_method(symbol, attr_name, column)
+              register_with_scrooge!( attr_name, 'define read method' )
+              super(symbol, attr_name, column)
+            end
+          
+            def define_read_method_for_time_zone_conversion(attr_name)
+              register_with_scrooge!( attr_name, 'define read method for time zone conversion' )
+              super(attr_name)
+            end
+
+            def define_read_method_for_serialized_attribute(attr_name)
+              register_with_scrooge!( attr_name, 'define read method for serialized attribute' )
+              super(attr_name)
+            end  
+
+            private 
+            
+              def register_with_scrooge!( attr_name, caller ) #:nodoc:
+                if ::Scrooge::Base.profile.orm.track?
+                  logger.info "[Scrooge] #{caller} #{attr_name.to_s}"
+                  Thread.scrooge_resource << [self.base_class, attr_name]
+                end
+              end
+
+        end
+        
+        module InstanceMethods        
+    
+          # Attach to AR::Base#read_attribute.
+          #
+          def read_attribute(attr_name)
+            register_with_scrooge!( attr_name, 'read attribute' )
+            super( attr_name )
+          end
+
+          # Attach to AR::Base#read_attribute_before_typecast.
+          #
+          def read_attribute_before_type_cast(attr_name)
+            register_with_scrooge!( attr_name, 'read attribute before type cast' )
+            super(attr_name)
+          end
+          
+          private
+          
+            def register_with_scrooge!( attr_name, caller ) #:nodoc:
+              if ::Scrooge::Base.profile.orm.track?
+                logger.info "[Scrooge] #{caller} #{attr_name.to_s}"
+                Thread.scrooge_resource << [self.class.base_class, attr_name]
+              end
+            end
+            
+            def missing_attribute(attr_name, stack) #:nodoc:
+              if Scrooge::Base.profile.raise_on_missing_attribute?
+                super(attr_name, stack)
+              else
+                logger.info "[Scrooge] missing attribute #{attr_name.to_s}"
+                reload( :select => '*' )
+              end    
+            end
+          
+        end
+      
+      end
+      
+      class << self
+        
+        # Inject Scrooge ActiveRecord attribute tracking.
+        #
+        def install!
+          ::ActiveRecord::Base.send( :extend, Scrooge::Orm::ActiveRecord::ScroogeAttributes::SingletonMethods )
+          ::ActiveRecord::Base.send( :include, Scrooge::Orm::ActiveRecord::ScroogeAttributes::InstanceMethods )
+        end
+        
+        # Determine if the ActiveRecord attribute tracker has already been installed.
+        #
+        def installed?
+          begin
+            ::ActiveRecord::Base.included_modules.include?( Scrooge::Orm::ActiveRecord::ScroogeAttributes )
+          rescue => exception
+          end
+        end
+        
+      end
+      
+      # Generate scope helpers for a given resource.
+      #
+      def scope_to( resource )
+        resource.models.each do |model|
+          scope_resource_to_model( resource, model ) 
+        end  
+      end
+      
+      # Generate scope helpers for a given model and resource.
+      #
+      def scope_resource_to_model( resource, model )
+        method_name = resource_scope_method( resource )
+        klass = model.model.to_const!(false) if model.model.is_a?(String)
+        unless resource_scope_method?( resource, klass ) 
+          klass.instance_eval(<<-EOS, __FILE__, __LINE__)
+            def #{method_name}(&block)
+              with_scope( { :find => { :select => '#{model.to_sql}' } }) do
+                block.call
+              end 
+            end  
+          EOS
+        end
+      end      
+      
+      # Returns a lookup key from a given String or AR klass 
+      #
+      def name( model )
+        model = model.to_const!(false) if model.is_a?(String)
+        model.respond_to?(:base_class) ? model.base_class.to_s : model.to_s
+      end
+      
+      # Returns a table name from a given String or AR klass 
+      #
+      def table_name( model )
+        model = model.to_const!(false) if model.is_a?(String)
+        model.table_name
+      end
+      
+      # Returns a primary key from a given String or AR klass 
+      #
+      def primary_key( model )
+        model = model.to_const!(false) if model.is_a?(String)
+        model.primary_key
+      end      
+      
+    end  
+  end  
+end

data/lib/scrooge/orm/base.rb

@@ -0,0 +1,102 @@
+module Scrooge
+  module Orm
+    
+    autoload :ActiveRecord, 'scrooge/orm/active_record'
+        
+    class Base < Scrooge::Base
+      
+      # ORM agnostic base class.
+      
+      class NotImplemented < StandardError
+      end
+      
+      class << self
+        
+        # Instantiate and optionally install from a given ORM signature.
+        #
+        def instantiate( orm_signature )
+          orm_instance = "scrooge/orm/#{orm_signature.to_s}".to_const!
+          orm_instance.class.install! unless orm_instance.class.installed?
+          orm_instance
+        end
+        
+        # Subclasses is required to implemented an installation hook.
+        #
+        def install!
+          raise NotImplemented
+        end
+        
+        # Subclasses should be able to determine if it's already been injected into 
+        # the underlying ORM package.
+        #
+        def installed?
+          raise NotImplemented
+        end
+        
+      end
+
+      # Generate scope helpers for a Resource and it's related Model trackers.
+      #
+      def scope_to( resource )
+        raise NotImplemented
+      end
+      
+      # Generate scope helpers for a given Resource and Model tracker.
+      #
+      def scope_resource_to_model( resource, model )
+        raise NotImplemented
+      end
+   
+      # Returns a lookup key from a given String or class 
+      #      
+      def name( model )
+        raise NotImplemented
+      end
+
+      # Returns a table name from a given String or class 
+      #      
+      def table_name( model )
+        raise NotImplemented
+      end
+
+      # Returns a primary key from a given String or class
+      #
+      def primary_key( model )
+        raise NotImplemented
+      end
+
+      # Generates a sanitized method name for a given resource.
+      #
+      def resource_scope_method( resource )
+        "scope_to_#{resource.signature}".to_sym
+      end          
+      
+      # Determine if a scope method has already been generated for a given
+      # Resource and klass.
+      #
+      def resource_scope_method?( resource, klass )
+        klass.respond_to?( resource_scope_method( resource ) )
+      end
+      
+      # Only track if the current profile is configured for tracking and a tracker
+      # resource is active, iow. we're in the scope of a request.
+      #
+      def track?
+        profile.track? && resource?
+      end
+      
+      # Do we have access to Resource Tracker instance ?
+      # 
+      def resource?
+        !resource().nil?
+      end
+      
+      # Delegate to Thread.current
+      #
+      def resource
+        Thread.current[:scrooge_resource]
+      end
+      
+    end  
+  end  
+end

data/lib/scrooge/profile.rb

@@ -0,0 +1,204 @@
+require 'yaml'
+
+module Scrooge
+  class Profile
+    
+    # A Profile for Scrooge that holds configuration, determines if we're tracking or
+    # scoping and provides access to a Tracker, ORM, Storage and Framework instance. 
+    
+    class Signature      
+    end
+    
+    class << self
+      
+      # Setup a new instance from the path to a YAML configuration file and a
+      # given environment.
+      #
+      def setup( path, environment )
+        begin
+          new( read_config( path, environment ) )
+        rescue Errno::ENOENT
+          puts "Scrooge Configuration file not available."
+        end
+      end
+      
+      # Pairs profile setup with the host framework.
+      #
+      def setup!
+        setup( framework.configuration_file, framework.environment )
+      end
+      
+      # Yields an instance to a wrapper of the host framework.
+      #
+      def framework
+        @@framework ||= Scrooge::Framework::Base.instantiate
+      end
+      
+      private
+      
+        def read_config( path, environment ) #:nodoc:
+          YAML.load( IO.read( path ) )[environment.to_s]
+        end
+      
+    end
+               
+    attr_reader :options           
+               
+    def initialize( options = {} )           
+      self.options = options            
+    end
+    
+    # options writer that attempts to reconfigure for any configuration changes.
+    #
+    def options=( options )
+      @options = options
+      configure!
+    end  
+    
+    # Delegates to the underlying ORM framework.
+    #
+    def orm
+      @orm_instance ||= Scrooge::Orm::Base.instantiate( @orm )
+    end
+
+    # Delegates to the current storage backend. 
+    #
+    def storage
+      @storage_instance ||= Scrooge::Storage::Base.instantiate( @storage )
+    end
+    
+    # Delegates to the current framework.
+    #
+    def framework
+      self.class.framework
+    end
+    
+    # Log a message to the framework's logger.
+    #
+    def log( message )
+      framework.log( message ) rescue ''
+    end
+    
+    # Delegates to the Application Tracker.
+    #
+    def tracker
+      @tracker_instance ||= Scrooge::Tracker::App.new
+    end
+      
+    # Determine if this is a tracking or scope profile.
+    #  
+    def track_or_scope!
+      if enabled?
+        track? ? track! : scope!
+      end
+    end
+    
+    # Are we tracking ?
+    #
+    def track?
+      if enabled?
+        @track ||= (@scope || '').match( /\d{10}/ ).nil?
+      else
+        false
+      end  
+    end
+    
+    def track!
+      if track?
+        log "Tracking"
+        framework.install_tracking_middleware()
+        shutdown_hook!
+      end   
+    end      
+    
+    # The active scope signature
+    #
+    def scope_to
+      @scope
+    end
+        
+    # Are we scoping ?
+    #
+    def scope?
+      if enabled?
+        !track?
+      else
+        false
+      end    
+    end        
+        
+    # Scope the tracker environment to a given scope signature.
+    #
+    def scope_to_signature!( scope_signature )
+      log "Scope to #{scope_signature}"
+      @tracker_instance = framework.from_scope!( scope_signature )
+    end
+    
+    # Scope the tracker environment to a given scope signature and install
+    # scoping middleware.
+    #
+    def scope_to!
+      if scope?
+        scope_to_signature!( @scope )
+        framework.install_scope_middleware( tracker )        
+      end
+    end
+    alias :scope! :scope_to!
+    
+    # Should Scrooge inject itself ?
+    #         
+    def enabled?
+      @enabled
+    end         
+    
+    # Should we raise on missing attributes ?
+    #
+    def raise_on_missing_attribute?
+      @on_missing_attribute == :raise
+    end
+                
+    private
+    
+      def configure! #:nodoc:
+        @orm = configure_with( @options['orm'], [:active_record], :active_record )
+        @storage = configure_with( @options['storage'], [:memory], :memory )
+        @scope = configure_with( @options['scope'].to_s, framework.scopes, ENV['scope'] )
+        @enabled = configure_with( @options['enabled'], [true, false], false )
+        @on_missing_attribute = configure_with( @options['on_missing_attribute'], [:reload, :raise], :reload )
+        reset_backends!
+        memoize_backends!
+      end        
+      
+      def configure_with( given, valid, default ) #:nodoc:
+        if given
+          valid.include?( given ) ? given : default
+        else
+          default
+        end    
+      end
+      
+      def reset_backends! #:nodoc:
+        @orm_instance = nil
+        @tracker_instance = nil
+        @storage_instance = nil
+      end
+      
+      # Force constant lookups as autoload is not threadsafe.
+      #
+      def memoize_backends! #:nodoc:
+        framework()
+        orm()
+        storage()
+        tracker()
+      end
+                  
+      def shutdown_hook! #:nodoc:
+        # Registers an at_exit hook to persist the current application scope.
+        ::Kernel.at_exit do
+          log "shutdown ..."
+          framework.scope! if tracker.any? 
+        end        
+      end            
+                  
+  end
+end

data/lib/scrooge/storage/base.rb

@@ -0,0 +1,47 @@
+module Scrooge
+  module Storage
+   
+    autoload :Buffer, 'scrooge/storage/buffer'
+    autoload :Memory, 'scrooge/storage/memory'
+    
+    class Base < Scrooge::Base
+      class NotImplemented < StandardError
+      end 
+      
+      # A Single Mutex for all Storage subclasses as their's only one storage instance.
+      #
+      GUARD = Mutex.new
+      
+      NAMESPACE = 'scrooge_storage'.freeze 
+          
+      class << self
+        
+        # Yields a storage instance from a given signature.
+        #
+        def instantiate( storage_signature )
+          "scrooge/storage/#{storage_signature.to_s}".to_const!
+        end
+        
+      end    
+
+      # Retrieve a given tracker from storage.
+      #                 
+      def read( tracker )
+        raise NotImplemented
+      end      
+            
+      # Persist a given tracker to storage.
+      #      
+      def write( tracker, buffered = true )
+        raise NotImplemented
+      end
+      
+      # Namespace lookup keys. 
+      #
+      def expand_key( key )
+        "#{NAMESPACE}/#{key}"
+      end      
+      
+    end
+  end
+end  

data/lib/scrooge/storage/memory.rb

@@ -0,0 +1,25 @@
+module Scrooge
+  module Storage
+    class Memory < Base
+      
+      attr_reader :storage
+      
+      def initialize
+        @storage = {}
+      end
+      
+      def read( tracker )
+        GUARD.synchronize do
+          @storage[tracker.signature]
+        end
+      end
+                  
+      def write( tracker, buffered = true )
+        GUARD.synchronize do
+          @storage[tracker.signature] = tracker
+        end
+      end
+      
+    end
+  end
+end