methodmissing-scrooge 1.0.4 → 2.0.0

data/lib/scrooge/orm/active_record.rb

@@ -1,159 +0,0 @@
-module Scrooge
-  module Orm
-    class ActiveRecord < Base
-      module ScroogeAttributes
-        
-        module SingletonMethods
-          
-          private
-     
-          # Define an attribute reader method.  Cope with nil column.
-          def define_read_method(symbol, attr_name, column)
-            cast_code = column.type_cast_code('v') if column
-            access_code = cast_code ? "(v=@attributes['#{attr_name}']) && #{cast_code}" : "@attributes['#{attr_name}']"
-
-            unless attr_name.to_s == self.primary_key.to_s
-              access_code = access_code.insert(0, "missing_attribute('#{attr_name}', caller) unless @attributes.has_key?('#{attr_name}'); ")
-            end
-
-            if cache_attribute?(attr_name)
-              access_code = "@attributes_cache['#{attr_name}'] ||= (#{access_code})"
-            end
-            evaluate_attribute_method attr_name, "def #{symbol}; register_with_scrooge!(:#{attr_name}, 'define read method' ); #{access_code}; end"
-          end
-
-          # Define read method for serialized attribute.
-          def define_read_method_for_serialized_attribute(attr_name)
-            evaluate_attribute_method attr_name, "def #{attr_name}; register_with_scrooge!(:#{attr_name}, 'define read method for serialized attribute' ); unserialize_attribute('#{attr_name}'); end"
-          end
-
-          # Defined for all +datetime+ and +timestamp+ attributes when +time_zone_aware_attributes+ are enabled.
-          # This enhanced read method automatically converts the UTC time stored in the database to the time zone stored in Time.zone.
-          def define_read_method_for_time_zone_conversion(attr_name)
-            method_body = <<-EOV
-              def #{attr_name}(reload = false)
-                register_with_scrooge!(:#{attr_name}, 'define read method for time zone conversion' )
-                cached = @attributes_cache['#{attr_name}']
-                return cached if cached && !reload
-                time = read_attribute('#{attr_name}')
-                @attributes_cache['#{attr_name}'] = time.acts_like?(:time) ? time.in_time_zone : time
-              end
-            EOV
-            evaluate_attribute_method attr_name, method_body
-          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?
-                # Avoid string interpolation if not required
-                ::Scrooge::Base.profile.log( "Register attribute #{attr_name.inspect} from #{caller}" ) if ::Scrooge::Base.profile.verbose?
-                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 = klass_for_model( model )
-        unless resource_scope_method?( resource, klass ) 
-          klass.instance_eval(<<-EOS, __FILE__, __LINE__)
-            def #{method_name}
-              with_scope( { :find => { :select => '#{model.to_sql}' } }) do
-                yield
-              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      
-      
-      private
-      
-        def klass_for_model( model ) #:nodoc:
-          model.model.is_a?(String) ? model.model.to_const!(false) : model.model
-        end
-      
-    end  
-  end  
-end

data/lib/scrooge/orm/base.rb

@@ -1,102 +0,0 @@
-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

@@ -1,223 +0,0 @@
-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. 
-    
-    GUARD = Mutex.new
-    
-    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 Application Tracker.
-    #
-    def tracker
-      @tracker_instance ||= Scrooge::Tracker::App.new
-    end
-
-    # Yields a strategt instance.
-    #           
-    def strategy
-      @strategy_instance ||= "scrooge/strategy/#{@strategy.to_s}".to_const!  
-    end
-    
-    # Delegates to the current framework.
-    #
-    def framework
-      self.class.framework
-    end
-    
-    # Log a message to the framework's logger.
-    #
-    def log( message, flush = false )
-      framework.log( message, flush ) rescue ''
-    end
-       
-    # Log a message to the framework's logger.
-    #
-    def verbose_log( message, flush = false )
-      log( message, flush ) if verbose?
-    end       
-        
-    # Are we tracking ?
-    #
-    def track?
-      GUARD.synchronize do
-        @track == true
-      end
-    end
-
-    # Enable the tracking phase
-    #
-    def start_tracking!
-      GUARD.synchronize do
-        @track = true
-      end
-    end
-    
-    # Disable the tracking phase
-    #
-    def stop_tracking!
-      GUARD.synchronize do
-        @track = false
-      end
-    end
-    
-    # The active scope signature
-    #
-    def scope
-      @scope
-    end     
-    
-    # Assign the current scope from a given signature or tracker
-    #    
-    def scope=( signature_or_tracker )
-      if signature_or_tracker.kind_of?( Scrooge::Tracker::Base )
-        scope_to_tracker!( signature_or_tracker )
-      else
-        scope_to_signature!( signature_or_tracker  )
-      end
-    end    
-            
-    # Should Scrooge inject itself ?
-    #         
-    def enabled?
-      @enabled
-    end         
-
-    # Should Scrooge be chatty ?
-    #         
-    def verbose?
-      @verbose
-    end         
-    
-    # Should we raise on missing attributes ?
-    #
-    def raise_on_missing_attribute?
-      @on_missing_attribute == :raise
-    end        
-    
-    # Expose the warmup phase during which tracking occur.
-    #  
-    def warmup            
-      @warmup
-    end            
-    
-    # A session key that indicates a logged in / private session.
-    #            
-    def logged_in_session
-      @logged_in_session  
-    end            
-                
-    private
-    
-      def configure! #:nodoc:        
-        @orm = configure_with( @options['orm'], [:active_record], :active_record )
-        @storage = configure_with( @options['storage'], [:memory], :memory )
-        @strategy = configure_with( @options['strategy'], [:track, :scope, :track_then_scope], :track )
-        @scope = configure_with( @options['scope'].to_s, framework_scopes, ENV['scope'] )
-        @warmup = configure_with( @options['warmup'], 0..14400, 0 )    
-        @enabled = configure_with( @options['enabled'], [true, false], false )
-        @on_missing_attribute = configure_with( @options['on_missing_attribute'], [:reload, :raise], :reload )
-        @verbose = configure_with( @options['verbose'], [true, false], false )
-        @logged_in_session = configure_with( @options['logged_in_session'], nil, :user_id )
-        reset_backends!
-        memoize_backends!
-      end        
-          
-      def configure_with( given, valid, default ) #:nodoc:
-        if given
-          valid && valid.include?( given ) ? given : default
-        else
-          default
-        end    
-      end
-      
-      def framework_scopes #:nodoc:
-        framework.scopes rescue []
-      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() rescue nil
-        orm()
-        storage()
-        tracker()
-      end         
-        
-      def scope_to_signature!( scope_signature ) #:nodoc:
-        log "Scope to signature #{scope_signature} ..."
-        @tracker_instance = framework.from_scope!( scope_signature )      
-      end
-
-      def scope_to_tracker!( tracker ) #:nodoc:
-        log "Scope to tracker #{tracker.inspect} ..."
-        @tracker_instance = tracker
-      end
-                        
-  end
-end

data/lib/scrooge/storage/base.rb

@@ -1,46 +0,0 @@
-module Scrooge
-  module Storage
-   
-    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

@@ -1,25 +0,0 @@
-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

data/lib/scrooge/strategy/base.rb

@@ -1,74 +0,0 @@
-module Scrooge
-  module Strategy
-    
-    autoload :Controller, 'scrooge/strategy/controller'
-    autoload :Stage, 'scrooge/strategy/stage'
-    autoload :Scope, 'scrooge/strategy/scope'
-    autoload :Track, 'scrooge/strategy/track'
-    autoload :TrackThenScope, 'scrooge/strategy/track_then_scope'
-
-    class Base
-      
-      class NoStages < StandardError
-      end
-      
-      @@stages = Hash.new( [] )
-      @@stages[self.name] = []
-      
-      attr_reader :thread
-      
-      class << self
-        
-        # Stage definition macro.
-        #
-        # stage :track, :for => 10.minutes do
-        #   ....
-        # end
-        #
-        def stage( signature, options = {}, &block )
-          @@stages[self.name] << Scrooge::Strategy::Stage.new( signature, options, &block )
-        end
-        
-        # List all defined stages for this klass.
-        #
-        def stages
-          @@stages[self.name]
-        end
-        
-        # Are there any stages defined ?
-        #
-        def stages?
-          !stages.empty?
-        end
-        
-        # Test teardown helper.
-        #
-        def flush!
-          @@stages[self.name] = []
-        end
-        
-      end
-      
-      # Requires at least one stage definition.
-      #
-      def initialize
-        raise NoStages unless self.class.stages?
-      end 
-      
-      # Piggy back on stages defined for this klass.
-      #
-      def stages
-        self.class.stages
-      end
-      
-      # Enforce this strategy
-      #
-      def execute!
-        if Scrooge::Base.profile.enabled?
-          @thread = Scrooge::Strategy::Controller.new( self ).run!
-        end
-      end
-      
-    end
-  end
-end

data/lib/scrooge/strategy/controller.rb

@@ -1,31 +0,0 @@
-module Scrooge
-  module Strategy
-    class Controller
-      
-      attr_accessor :strategy
-      attr_reader :thread
-                    
-      def initialize( strategy )
-        @strategy = strategy
-      end
-      
-      # Execute a given strategy
-      #
-      def run!
-        @thread = Thread.new do
-          Thread.current.abort_on_exception = true
-          stages.map do |stage|
-            stage.execute!
-          end
-        end
-      end
-      
-      private
-      
-        def stages #:nodoc:
-          @strategy.stages
-        end
-      
-    end
-  end
-end

data/lib/scrooge/strategy/scope.rb

@@ -1,15 +0,0 @@
-module Scrooge
-  module Strategy
-    class Scope < Base
-    
-      stage :scope do
-        
-        log( "Scope ...", true )
-        self.scope = scope if framework.scope?( scope )
-        framework.install_scope_middleware( tracker )
-       
-      end    
-      
-    end
-  end
-end