methodmissing-scrooge 1.0.4 → 2.0.0

metadata

@@ -1,20 +1,21 @@
 --- !ruby/object:Gem::Specification 
 name: methodmissing-scrooge
 version: !ruby/object:Gem::Version 
-  version: 1.0.4
+  version: 2.0.0
 platform: ruby
 authors: 
 - "Lourens Naud\xC3\xA9"
+- Stephen Sykes
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-03-05 00:00:00 -08:00
+date: 2009-03-12 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
-description: A Framework and ORM agnostic Model / record attribute tracker to ensure production Ruby applications only fetch the database content needed to minimize wire traffic and reduce conversion overheads to native Ruby types.
-email: lourens@methodmissing.com
+description: An ActiveRecord attribute tracker to ensure production Ruby applications only fetch the database content needed to minimize wire traffic and reduce conversion overheads to native Ruby types.
+email: lourens@methodmissing.com or sds@switchstep.com
 executables: []
 
 extensions: []
@@ -26,80 +27,14 @@ files:
 - README
 - README.textile
 - VERSION.yml
-- lib/scrooge
-- lib/scrooge/core
-- lib/scrooge/core/string.rb
-- lib/scrooge/core/symbol.rb
-- lib/scrooge/core/thread.rb
-- lib/scrooge/framework
-- lib/scrooge/framework/base.rb
-- lib/scrooge/framework/rails.rb
-- lib/scrooge/middleware
-- lib/scrooge/middleware/tracker.rb
-- lib/scrooge/orm
-- lib/scrooge/orm/active_record.rb
-- lib/scrooge/orm/base.rb
-- lib/scrooge/profile.rb
-- lib/scrooge/storage
-- lib/scrooge/storage/base.rb
-- lib/scrooge/storage/memory.rb
-- lib/scrooge/strategy
-- lib/scrooge/strategy/base.rb
-- lib/scrooge/strategy/controller.rb
-- lib/scrooge/strategy/scope.rb
-- lib/scrooge/strategy/stage.rb
-- lib/scrooge/strategy/track.rb
-- lib/scrooge/strategy/track_then_scope.rb
-- lib/scrooge/tracker
-- lib/scrooge/tracker/app.rb
-- lib/scrooge/tracker/base.rb
-- lib/scrooge/tracker/model.rb
-- lib/scrooge/tracker/resource.rb
+- lib/attributes_proxy.rb
 - lib/scrooge.rb
-- spec/fixtures
-- spec/fixtures/config
-- spec/fixtures/config/scrooge
-- spec/fixtures/config/scrooge/scopes
-- spec/fixtures/config/scrooge/scopes/1234567891
-- spec/fixtures/config/scrooge/scopes/1234567891/scope.yml
-- spec/fixtures/config/scrooge.yml
-- spec/helpers
-- spec/helpers/framework
-- spec/helpers/framework/rails
-- spec/helpers/framework/rails/cache.rb
-- spec/spec_helper.rb
-- spec/units
-- spec/units/scrooge
-- spec/units/scrooge/core
-- spec/units/scrooge/core/string_spec.rb
-- spec/units/scrooge/core/symbol_spec.rb
-- spec/units/scrooge/core/thread_spec.rb
-- spec/units/scrooge/framework
-- spec/units/scrooge/framework/base_spec.rb
-- spec/units/scrooge/framework/rails_spec.rb
-- spec/units/scrooge/orm
-- spec/units/scrooge/orm/base_spec.rb
-- spec/units/scrooge/profile_spec.rb
-- spec/units/scrooge/storage
-- spec/units/scrooge/storage/base_spec.rb
-- spec/units/scrooge/storage/memory_spec.rb
-- spec/units/scrooge/strategy
-- spec/units/scrooge/strategy/base_spec.rb
-- spec/units/scrooge/strategy/controller_spec.rb
-- spec/units/scrooge/strategy/scope_spec.rb
-- spec/units/scrooge/strategy/stage_spec.rb
-- spec/units/scrooge/strategy/track_spec.rb
-- spec/units/scrooge/strategy/track_then_scope_spec.rb
-- spec/units/scrooge/tracker
-- spec/units/scrooge/tracker/app_spec.rb
-- spec/units/scrooge/tracker/base_spec.rb
-- spec/units/scrooge/tracker/model_spec.rb
-- spec/units/scrooge/tracker/resource_spec.rb
-- spec/units/scrooge_spec.rb
+- test/helper.rb
+- test/models
+- test/models/mysql_user.rb
+- test/scrooge_test.rb
+- test/setup.rb
 - rails/init.rb
-- assets/config
-- assets/config/scrooge.yml.template
-- tasks/scrooge.rake
 has_rdoc: true
 homepage: http://github.com/methodmissing/scrooge
 post_install_message: 

data/assets/config/scrooge.yml.template

@@ -1,27 +0,0 @@
-production:
-  orm: :active_record
-  strategy: :track_then_scope
-  warmup: 600 # warmup / track for 10 minutes
-  scope:
-  verbose: false
-  on_missing_attribute: :reload # or :raise
-  logged_in_session: :user_id # session key that represents the logged in user 
-  enabled: true    
-development:
-  orm: :active_record
-  strategy: :track
-  warmup: 600 # warmup / track for 10 minutes
-  scope: 
-  verbose: true
-  on_missing_attribute: :reload # or :raise
-  logged_in_session: :user_id # session key that represents the logged in user 
-  enabled: true    
-test:
-  orm: :active_record
-  strategy: :track
-  warmup: 600 # warmup / track for 10 minutes
-  scope:
-  verbose: true
-  on_missing_attribute: :reload # or :raise
-  logged_in_session: :user_id # session key that represents the logged in user 
-  enabled: true

data/lib/scrooge/core/string.rb

@@ -1,29 +0,0 @@
-module Scrooge
-  module Core
-    module String
-      
-      # Framework agnostic String <=> Constant helpers.
-      # Perhaps not the cleanest abstraction, but also not good practice to piggy
-      # back on or use a naming convention that may clash with and uproot the API
-      # any given framework ships with.
-      
-      def to_const
-        self.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
-      end
-      
-      def to_const!( instantiate = true )
-        begin
-          const = Object.module_eval(to_const, __FILE__, __LINE__)
-          instantiate ? const.new : const
-        rescue => exception 
-          exception.to_s.match( /uninitialized constant/ ) ? self : raise
-        end
-      end
-         
-    end
-  end
-end
-
-class String
-  include Scrooge::Core::String
-end

data/lib/scrooge/core/symbol.rb

@@ -1,21 +0,0 @@
-module Scrooge
-  module Core
-    module Symbol
-      
-      # See Scrooge::Core::String
-      
-      def to_const
-        to_s.to_const
-      end
-         
-      def to_const!
-        to_s.to_const!  
-      end   
-         
-    end
-  end
-end
-
-class Symbol
-  include Scrooge::Core::Symbol
-end

data/lib/scrooge/core/thread.rb

@@ -1,26 +0,0 @@
-module Scrooge
-  module Core
-    module Thread
-      
-      # Scrooge Resource tracker scoped to the current Thread for threadsafety in
-      # multi-threaded environments.
-      
-      def scrooge_resource
-        current[:scrooge_resource] ||= Scrooge::Tracker::Resource.new
-      end
-      
-      def scrooge_resource=( resource )
-        current[:scrooge_resource] = resource
-      end
-      
-      def reset_scrooge_resource!
-        current[:scrooge_resource] = nil
-      end  
-         
-    end
-  end
-end
-
-class Thread
-  extend Scrooge::Core::Thread
-end

data/lib/scrooge/framework/base.rb

@@ -1,315 +0,0 @@
-module Scrooge
-  module Framework
-    
-    # Scrooge is framework agnostic and attempts to abstract the following :
-    #
-    # * current environment
-    # * app root dir
-    # * app tmp dir
-    # * app config dir 
-    # * logging    
-    # * resource endpoints 
-    # * caching
-    # * injecting Rack MiddleWare 
-    #
-    # Framework Signatures 
-    #
-    # Scrooge will attempt to determine the current active framework it's deployed with
-    # through various framework specific hooks.
-    #
-    # module Scrooge
-    #    module Framework
-    #      module YetAnother < Base
-    #        ...
-    #        signature do
-    #          Object.const_defined?( "UnlikeAnyOther" )
-    #        end
-    #        ...
-    #      end
-    #    end
-    #  end 
-    
-    autoload :Rails, 'scrooge/framework/rails'
-    
-    class Base < Scrooge::Base
-      
-      GUARD = Mutex.new
-      
-      SCOPE_REGEX = /\d{10}/.freeze
-      
-      CONFIGURATION_FILE = 'scrooge.yml'.freeze
-      
-      SCOPE_FILE = 'scope.yml'.freeze
-      
-      class NotImplemented < StandardError
-      end
-      
-      class NoSupportedFrameworks < StandardError
-      end
-      
-      class InvalidScopeSignature < StandardError
-      end        
-   
-      # Per framework signature lookup.
-      #        
-      @@signatures = Hash.new( [] )
-      @@signatures[self.name] = []
-      
-      # Support none by default.
-      #
-      @@frameworks = [] 
-   
-      class << self  
-                
-        # Registers a framework signature.
-        #        
-        def signature( &block )
-          @@signatures[self.name] << block
-        end  
-        
-        # All signatures for the current klass. 
-        #
-        def signatures
-          @@signatures[self.name]
-        end
-        
-        # All supported frameworks.
-        #
-        def frameworks
-          @@frameworks
-        end
-        
-        # Infer the framework Scrooge attaches to in a first yield manner.
-        # A match of all defined signatures is required.
-        #
-        def which_framework?
-          iterate_frameworks() || raise( NoSupportedFrameworks )
-        end
-        
-        # Yield an instance of the current framework.
-        #
-        def instantiate
-          which_framework?().new
-        end
-        
-        private
-        
-          def inherited( subclass ) #:nodoc:
-            @@frameworks << subclass
-          end
-        
-          def iterate_frameworks #:nodoc:
-            frameworks.detect do |framework|
-              framework.signatures.all?{|sig| sig.call }
-            end
-          end  
-                        
-      end
-      
-      # The framework environment eg. test, development etc.
-      #
-      def environment
-        raise NotImplemented
-      end
-      
-      # Application root directory
-      #
-      def root
-        raise NotImplemented  
-      end
-      
-      # Application temp. directory
-      #
-      def tmp
-        raise NotImplemented
-      end      
-      
-      # Application configuration directory
-      #
-      def config
-        raise NotImplemented
-      end
-      
-      # Application logger instance.
-      # API compat with stdlib Logger assumed.
-      #
-      def logger
-        raise NotImplemented
-      end
-      
-      # Supplement the current Resource tracker with additional environment context. 
-      #
-      def resource( env, request = nil )
-        raise NotImplemented
-      end
-      
-      # Write to the framework cache.
-      #
-      def write_cache( key, value )
-        raise NotImplemented
-      end
-      
-      # Read from the framework cache.
-      #
-      def read_cache( key )
-        raise NotImplemented
-      end 
-      
-      # Access to the framework's Rack middleware stack.
-      #
-      def middleware
-        raise NotImplemented
-      end
-      
-      # Inject scoping middleware. 
-      #
-      def install_scope_middleware( tracker )
-        raise NotImplemented
-      end
-      
-      # Inject tracking middleware.
-      #
-      def install_tracking_middleware
-        raise NotImplemented
-      end
-      
-      # Remove tracking middleware
-      #
-      def uninstall_tracking_middleware
-        raise NotImplemented
-      end
-      
-      # Register a code block to run when the host framework is fully initialized.
-      #
-      def initialized( &block )
-        raise NotImplemented
-      end
-      
-      # Yields a controller constant from a given Resource Tracker
-      #
-      def controller( resource )
-        raise NotImplemented
-      end
-      
-      # Retrieve all previously persisted scopes tracked with Scrooge. 
-      #
-      def scopes
-        ensure_scopes_path do
-          Dir.entries( scopes_path ).grep( SCOPE_REGEX )
-        end  
-      end
-      
-      # Determine if there's any previously persisted scopes.
-      #
-      def scopes?
-        !scopes().empty?
-      end
-      
-      # Return the scopes storage path for the current framework.
-      #
-      def scopes_path
-        @scopes_path ||= File.join( config, 'scrooge', 'scopes' )
-      end
-
-      # Return the scopes storage path for a given scope and optional filename.
-      #
-      def scope_path( scope, filename = nil )
-        path = File.join( scopes_path, scope.to_s )
-        filename ? File.join( path, filename ) : path
-      end
-      
-      # Log a message to the logger.
-      #
-      def log( message, flush = false )
-        logger.info "[Scrooge] #{message}"
-        flush_logger! if flush
-      end
-      
-      # Persist the current tracker as scope or restore a previously persisted scope
-      # from a given signature. 
-      #
-      def scope!( scope = nil )
-        scope ? from_scope!( scope ) : to_scope!()
-      end
-      
-      # Do we have a valid scope signature ?
-      #
-      def scope?( scope )
-        scopes.include?( scope.to_s )
-      end
-      
-      # Restore a previously persisted scope to the current tracker from a given 
-      # signature.Raises Scrooge::Framework::InvalidScopeSignature if the signature
-      # could not be found.
-      #
-      def from_scope!( scope )
-        GUARD.synchronize do
-          if scope?( scope )
-            restore_scope!( scope )
-          else
-            raise InvalidScopeSignature
-          end
-        end    
-      end
-      
-      # Dump the current tracker to the filesystem.
-      #
-      def to_scope!
-        GUARD.synchronize do
-          scope = Time.now.to_i
-          dump_scope!( scope )
-          scope.to_s
-        end  
-      end      
-      
-      # Full path the scrooge configuration file.
-      #
-      def configuration_file
-        @configuration_file ||= File.join( config, CONFIGURATION_FILE )
-      end
-      
-      private
-       
-       def flush_logger! #:nodoc:
-         logger.flush if logger.respond_to?(:flush)
-       end
-       
-       def restore_scope!( scope ) #:nodoc:
-         tracker = Scrooge::Tracker::App.new
-         tracker.marshal_load( scope_from_yaml( scope ) )
-         tracker
-       end
-       
-       def dump_scope!( scope ) #:nodoc:
-         ensure_scope_path( scope ) do
-           File.open( scope_path( scope, SCOPE_FILE ), 'w' ) do |io|
-             scope_to_yaml( io )
-           end
-         end
-       end
-       
-       def scope_from_yaml( scope ) #:nodoc:
-         YAML.load( IO.read( scope_path( scope.to_s, SCOPE_FILE ) ) )
-       end
-       
-       def scope_to_yaml( io ) #:nodoc:
-         YAML.dump( Scrooge::Base.profile.tracker.marshal_dump, io )
-       end 
-       
-       def ensure_scope_path( scope ) #:nodoc:
-         makedir_unless_exist( scope_path( scope ) )
-         yield if block_given?  
-       end 
-       
-       def ensure_scopes_path #:nodoc:
-         makedir_unless_exist( scopes_path )
-         yield if block_given?
-       end
-           
-      def makedir_unless_exist( path ) #:nodoc:
-        FileUtils.makedirs( path ) unless File.exist?( path )
-      end     
-               
-    end
-  end
-end

data/lib/scrooge/framework/rails.rb

@@ -1,132 +0,0 @@
-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
-          with_or_without_prepatation( :scrooge_install_tracking_middleware ) do
-            ApplicationController.prepend_around_filter Scrooge::Middleware::Tracker
-          end
-        end
-      end
-      
-      # Remove all tracking filters
-      #
-      def uninstall_tracking_middleware
-        GUARD.synchronize do
-          # Handle dev. mode
-          ActionController::Dispatcher.prepare_dispatch_callback_chain.delete( :scrooge_install_tracking_middleware )
-          ApplicationController.skip_filter Scrooge::Middleware::Tracker
-        end
-      end
-      
-      # Install per Resource scoping middleware.
-      #
-      def install_scope_middleware( tracker )
-        GUARD.synchronize do
-          with_or_without_prepatation( :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 config initialized - plugin installation etc.
-        end  
-      end
-      
-      def controller( resource )
-        "#{resource.controller}_controller".classify.constantize
-      end
-      
-      private 
-      
-        def with_or_without_prepatation( callback_signature, &block ) #:nodoc:
-          if development?
-            ActionController::Dispatcher.to_prepare( callback_signature ) do
-              block.call
-            end
-          else
-            block.call
-          end      
-        end
-      
-        def development? #:nodoc:
-          environment == 'development'
-        end
-      
-        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  
-          Thread.scrooge_resource.is_public = request.session[Scrooge::Base.profile.logged_in_session].nil?
-        end
-      
-    end
-  end
-end

data/lib/scrooge/middleware/tracker.rb

@@ -1,46 +0,0 @@
-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 )
-          Scrooge::Base.profile.tracker.track( Thread.scrooge_resource ) do
-            begin
-              Scrooge::Base.profile.framework.resource( {}, controller.request )
-              yield
-            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