methodmissing-scrooge 1.0.2 → 1.0.3

data/README.textile

@@ -20,7 +20,8 @@ There's 3 basic modes of operation :
 
 * Scope : Scope the process and related resources to a previously persisted scope profile.
 
-* Track then scope : A multi-stage strategy that tracks attribute access for 
+* Track then scope : A multi-stage strategy that tracks attribute access for a given warmup period, aggregates the results
+                     across multiple processes and enforce a scoping policy representative of the tracking phase.
 
 h2. Resources
 
@@ -29,6 +30,7 @@ A resource is :
 * A controller and action endpoint ( inferred through framework specific routing )
 * A content type / format - a PDF representation may have different Model attribute requirements than a vanilla ERB view.
 * Request method - typically popular public facing GET requests  
+* Public or Private as a logged in / authenticated representation likely have different attribute requirements.   
 
 All Model to attribute mappings is tracked on a per Resource basis.Multiple Models per Resource is supported.
 
@@ -75,6 +77,7 @@ An example scope / profile, saved to disk :
     :action: show
     :controller: hotels
     :method: :get
+    :is_public: true
     :format: "*/*"
     :models: 
     - Address: 
@@ -95,6 +98,7 @@ An example scope / profile, saved to disk :
     :action: index
     :controller: locations
     :method: :get
+    :is_public: true
     :format: "*/*"
     :models: 
     - Location: 
@@ -108,6 +112,7 @@ An example scope / profile, saved to disk :
     :action: index
     :controller: countries
     :method: :get
+    :is_public: true
     :format: "*/*"
     :models: 
     - Country: 
@@ -122,6 +127,7 @@ An example scope / profile, saved to disk :
     :action: index
     :controller: hotels
     :method: :get
+    :is_public: true
     :format: "*/*"
     :models: 
     - Hotel: 
@@ -371,6 +377,7 @@ Scrooge installs ( see recommended installation above ) a configuration file wit
     warmup: 600 # warmup / track for 10 minutes
     scope:
     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
@@ -379,6 +386,7 @@ Scrooge installs ( see recommended installation above ) a configuration file wit
     warmup: 600 # warmup / track for 10 minutes
     scope: 
     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
@@ -387,6 +395,7 @@ Scrooge installs ( see recommended installation above ) a configuration file wit
     warmup: 600 # warmup / track for 10 minutes
     scope:
     on_missing_attribute: :reload # or :raise
+    logged_in_session: :user_id # session key that represents the logged in user 
     enabled: true
 </code>
 </pre>
@@ -395,13 +404,31 @@ h4. ORM
 
 Scrooge is ORM agnostic and ships with an ActiveRecord layer.
 
+<pre>
+<code>
   orm: :active_record
+</pre>
+</code>
 
 h4. Storage backend
 
-Tracking results can be persisted to a given backend or storage option.Ships with a memory store, but can be extended to file system, memcached etc. as all Tracker components is designed to be Marshal friendly.
+Tracking results can be persisted to a given backend or storage option.Ships with a memory store, but can be extended to file system, memcached etc. as all Tracker components is designed to be Marshal friendly.A stub for future functionality.
 
+<pre>
+<code>
   storage: :memory
+</pre>
+</code>
+
+h4. Verbose
+
+Log all tracking interactions to the framework logger when enabled.Disabled for production.
+
+<pre>
+<code>
+  verbose: false
+</pre>
+</code>
 
 h4. Strategy
 
@@ -411,11 +438,21 @@ h4. Warmup
 
 The designated warmup period for the :track_then_scope strategy, given in seconds.Typically 600 to 3600.
 
+<pre>
+<code>
+  warmup: 600	
+</pre>
+</code>
+
 h4. Scope
 
 A scope is a reference to a timestamped Scrooge run where access to Model attributes is tracked on a per Resource basis.
 
+<pre>
+<code>
   scope: 1234567891
+</pre>
+</code>
 
 If not scope is given in the configuration, ENV['scope'] would also be considered to facilitate configuration through Capistrano etc.
 
@@ -423,13 +460,31 @@ h4. Handling Missing Attributes
 
 When the contents for a given Model attribute has not been retrieved from the database, most ORM frameworks raise an error by default.This is configurable to reloading the model with all it's columns or raise instead.
 
+<pre>
+<code>
   on_missing_attribute: :reload # or :raise
+</pre>
+</code>
+
+h4. Private and Public Resources
+
+An authenticated or logged in resource likely has different model requirements than it's public counterpart.
+
+<pre>
+<code>
+  logged_in_session: :user_id # session key that represents the logged in user 
+</pre>
+</code>
 
 h4. Status
 
 Scrooge can be disabled with :
 
+<pre>
+<code>
   enabled: false 
+</pre>
+</code>
 
 h2. Rails specific rake tasks.
 
@@ -464,4 +519,17 @@ methodmissing:superbreak_app lourens$ rake scope=1234735790 scrooge:inspect
 
 h2. Notes
 
-This is an initial release, has not yet been battle tested in production and is pending Ruby 1.9.1 compatibility.
+This is an initial release, has not yet been battle tested in production and is pending Ruby 1.9.1 compatibility.
+
+Developed on and for Rails 2.3, known to work with Rails 2.2.2
+
+h2. Known pending issues
+
+* Do not track columns that isn't explicitly defined ( AR counter caching checks etc. ) : 
+<code>
+<pre>
+ActiveRecord::StatementInvalid (Mysql::Error: Unknown column 'orders.brochures_count' in 'field list': SELECT orders.brochures_count, orders.id FROM `orders` WHERE (`orders`.`id` = 1688139)  LIMIT 1)
+</code>	
+</pre>
+
+* alias_attribute compatibility

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:patch: 2
 :major: 1
 :minor: 0
+:patch: 3

data/assets/config/scrooge.yml.template

@@ -1,24 +1,27 @@
 production:
   orm: :active_record
-  storage: :memory
   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
-  storage: :memory
   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
-  storage: :memory  
   strategy: :track
   warmup: 600 # warmup / track for 10 minutes
   scope:
+  verbose: true
   on_missing_attribute: :reload # or :raise
-  enabled: true    
+  logged_in_session: :user_id # session key that represents the logged in user 
+  enabled: true

data/lib/scrooge/core/symbol.rb

@@ -2,7 +2,7 @@ module Scrooge
   module Core
     module Symbol
       
-      # See Scrooge::Core::Symbol
+      # See Scrooge::Core::String
       
       def to_const
         to_s.to_const

data/lib/scrooge/framework/rails.rb

@@ -124,6 +124,7 @@ module Scrooge
           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

data/lib/scrooge/orm/active_record.rb

@@ -7,30 +7,40 @@ module Scrooge
           
           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)
+          # 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
-          
-            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)
+
+            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
 
-            def define_read_method_for_serialized_attribute(attr_name)
-              register_with_scrooge!( attr_name, 'define read method for serialized attribute' )
-              super(attr_name)
-            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
 
-            private 
-            
-              def register_with_scrooge!( attr_name, caller ) #:nodoc:
-                if ::Scrooge::Base.profile.orm.track?
-                  Thread.scrooge_resource << [self.base_class, attr_name]
-                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
         
@@ -54,6 +64,8 @@ module Scrooge
           
             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

data/lib/scrooge/profile.rb

@@ -89,6 +89,12 @@ module Scrooge
     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 ?
     #
@@ -135,6 +141,12 @@ module Scrooge
     def enabled?
       @enabled
     end         
+
+    # Should Scrooge be chatty ?
+    #         
+    def verbose?
+      @verbose
+    end         
     
     # Should we raise on missing attributes ?
     #
@@ -147,6 +159,12 @@ module Scrooge
     def warmup            
       @warmup
     end            
+    
+    # A session key that indicates a logged in / private session.
+    #            
+    def logged_in_session
+      @logged_in_session  
+    end            
                 
     private
     
@@ -158,22 +176,24 @@ module Scrooge
         @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 framework_scopes #:nodoc:
-        framework.scopes rescue []
-      end
-    
+          
       def configure_with( given, valid, default ) #:nodoc:
         if given
-          valid.include?( given ) ? given : default
+          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

data/lib/scrooge/storage/base.rb

@@ -1,7 +1,6 @@
 module Scrooge
   module Storage
    
-    autoload :Buffer, 'scrooge/storage/buffer'
     autoload :Memory, 'scrooge/storage/memory'
     
     class Base < Scrooge::Base

data/lib/scrooge/strategy/controller.rb

@@ -9,6 +9,8 @@ module Scrooge
         @strategy = strategy
       end
       
+      # Execute a given strategy
+      #
       def run!
         @thread = Thread.new do
           Thread.current.abort_on_exception = true

data/lib/scrooge/strategy/scope.rb

@@ -3,6 +3,7 @@ module Scrooge
     class Scope < Base
     
       stage :scope do
+        
         log( "Scope ...", true )
         self.scope = scope if framework.scope?( scope )
         framework.install_scope_middleware( tracker )

data/lib/scrooge/tracker/app.rb

@@ -143,7 +143,7 @@ module Scrooge
         def restored_resources( data ) #:nodoc:
           GUARD.synchronize do
             data.map do |resource|
-              Resource.new.marshal_load( resource )
+              Resource.load( resource )
             end
           end
         end

data/lib/scrooge/tracker/model.rb

@@ -51,6 +51,59 @@ module Scrooge
           self
         end
       end
+
+      # Return a valid Rack middleware instance for this model.
+      #
+      def middleware( resource )
+        profile.orm.scope_resource_to_model( resource, self )
+        klass = Class.new
+        klass.class_eval(<<-EOS, __FILE__, __LINE__)
+          
+          class << self
+            
+            def inspect
+              "#<Scrooge::Middleware #{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.to_s}.#{profile.orm.resource_scope_method( resource ).to_s} do
+                block.call
+              end
+            end
+            
+          end
+          
+          def initialize(app)
+            @app = app
+          end
+
+          def call(env)
+            if scope?( env )
+              #{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
       
       # Memoize the name lookup.
       #

data/lib/scrooge/tracker/resource.rb

@@ -20,7 +20,8 @@ module Scrooge
                     :action,
                     :method,
                     :format,
-                    :models      
+                    :models,
+                    :is_public     
       
       def initialize
         super()
@@ -45,6 +46,18 @@ module Scrooge
           !@models.empty?
         end  
       end
+
+      # Is this a public ( not authenticated ) resource ?
+      #
+      def public?
+        @is_public == true
+      end
+      
+      # Is this a private ( authenticated ) resource ?
+      #      
+      def private?
+        !public?
+      end
       
       # Search for a given model instance
       #
@@ -55,7 +68,7 @@ module Scrooge
       # Generates a signature / lookup key.
       #
       def signature
-        @signature ||= "#{controller.to_s}_#{action.to_s}_#{method.to_s}"
+        @signature ||= "#{controller.to_s}_#{action.to_s}_#{method.to_s}_#{private_or_public}"
       end
       
       # Only track GET requests
@@ -78,7 +91,8 @@ module Scrooge
                            :action => @action,
                            :method => @method,
                            :format => @format,
-                           :models => dumped_models() } }
+                           :models => dumped_models(),
+                           :is_public => @is_public } }
         end
       end      
       
@@ -90,6 +104,7 @@ module Scrooge
           @method = data[:method]
           @format = data[:format]
           @models = restored_models( data[:models] )
+          @is_public = data[:is_public]
           self
         end  
       end
@@ -101,72 +116,22 @@ module Scrooge
         @middleware ||= begin
           GUARD.synchronize do
             models.map do |model|
-              middleware_for_model( model )
+              model.middleware( self )
             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
-                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()}"
+        "#<#{@method.to_s.upcase} #{private_or_public} :#{@controller}/#{@action} (#{@format})\n#{models_for_inspect()}"
       end
       
       private
       
+        def private_or_public #:nodoc:
+          @is_public ? 'public' : 'private'
+        end
+      
         def track_model_from( model ) #:nodoc:
           model.is_a?( Array ) ? model_from_enumerable( model ) : setup_model( model )
         end

data/spec/fixtures/config/scrooge.yml

@@ -1,16 +1,20 @@
 production:
   orm: :active_record
   storage: :memory
+  verbose: false
   scope: 1234567891 
   on_missing_attribute: :reload
   strategy: :track_then_scope
   warmup: 600 # warmup / track for 10 minutes
+  logged_in_session: :user_id # session key that represents the logged in user   
   enabled: true  
 test:
   orm: :active_record
   storage: :memory
+  verbose: true
   scope: 
   on_missing_attribute: :reload      
   strategy: :track_then_scope
   warmup: 600 # warmup / track for 10 minutes
+  logged_in_session: :user_id # session key that represents the logged in user  
   enabled: true  

data/spec/spec_helper.rb

@@ -11,9 +11,13 @@ require 'spec/helpers/framework/rails/cache'
 
 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)
+  def self.set_constant( const, value )
+    eval( "Kernel.const_set :#{const.to_s}, #{value.inspect} unless defined?( #{const.to_s} )" )
+  end
+  
+  set_constant( :FIXTURES, "#{Dir.pwd}/spec/fixtures" )
+  set_constant( :TMP, "#{Dir.pwd}/spec/tmp" )
+  set_constant( :CONFIG, "#{Dir.pwd}/spec/config" )
   
   config.before :all do
     [TMP, CONFIG].each do |dir|

data/spec/units/scrooge/profile_spec.rb

@@ -67,5 +67,13 @@ describe "Scrooge::Profile instance" do
   it "should be able to expose it's warmup tracking period" do
     @profile.warmup.should == 0
   end  
-    
+  
+  it "should be able to return a session key that indicates a logged in session" do
+    @profile.logged_in_session.should == :user_id
+  end  
+  
+  it "should be able to determine if logging should be verbose" do
+    @profile.verbose?().should == false
+  end
+  
 end

data/spec/units/scrooge/tracker/app_spec.rb

@@ -9,6 +9,7 @@ describe Scrooge::Tracker::App do
                   resource.action = 'show'
                   resource.method = :get
                   resource.format = :html
+                  resource.is_public = true
                 end
   end
   
@@ -27,11 +28,12 @@ describe Scrooge::Tracker::App do
   it "should be able to dump itself to a serializeable representation" do
     @app << @resource
     with_rails do
-      @app.marshal_dump().should eql( [ { "products_show_get" => { :method => :get,
-                                                                   :models => [],
-                                                                   :format => :html,
-                                                                   :action => "show",
-                                                                   :controller => "products" } } ] )
+      @app.marshal_dump().should eql( [ { "products_show_get_public" => { :method => :get,
+                                                                     :models => [],
+                                                                     :format => :html,
+                                                                     :action => "show",
+                                                                     :controller => "products",
+                                                                     :is_public => true } } ] )
     end
   end
 

data/spec/units/scrooge/tracker/model_spec.rb

@@ -9,6 +9,13 @@ describe Scrooge::Tracker::Model do
     @model.stub!(:primary_key).and_return( 'id' )    
     @other_model = Scrooge::Tracker::Model.new( 'OtherPost' )
     @another_model = Scrooge::Tracker::Model.new( 'AnotherPost' )
+    @resource = Scrooge::Tracker::Resource.new do |resource|
+                  resource.controller = 'products'
+                  resource.action = 'show'
+                  resource.method = :get
+                  resource.format = :html
+                  resource.is_public = true
+                end    
   end
 
   it "should be able to determine if any attributes has been tracked" do
@@ -60,4 +67,13 @@ describe Scrooge::Tracker::Model do
     @another_model.merge( nil )
   end
   
+  it "should be able to setup Rack middleware" do
+    @model << %w(name description)
+    @model.middleware( @resource ).class.should equal( Class )
+    @model.middleware( @resource ).inspect.should match( /Middleware/ )
+    @model.middleware( @resource ).inspect.should match( /Product/ )
+    @model.middleware( @resource ).inspect.should match( /description/ )    
+    @model.middleware( @resource ).new( @model ).should respond_to( :call )
+  end
+  
 end

data/spec/units/scrooge/tracker/resource_spec.rb

@@ -8,6 +8,7 @@ describe Scrooge::Tracker::Resource do
                   resource.action = 'show'
                   resource.method = :get
                   resource.format = :html
+                  resource.is_public = true
                 end
     @model = Scrooge::Tracker::Model.new( 'Class' )
     @model.stub!(:name).and_return( 'Product' )
@@ -18,12 +19,21 @@ describe Scrooge::Tracker::Resource do
                         resource.action = 'show'
                         resource.method = :get
                         resource.format = :html
+                        resource.is_public = true
                       end
   end
   
   it "should be able to determine if any models has been tracked" do
     @resource.any?().should equal( false )
   end
+  
+  it "should be able to determine if it's a public resource" do
+    @resource.public?().should equal( true )
+  end
+  
+  it "should be able to determine if it's a private resource" do
+    @resource.private?().should equal( false )
+  end
     
   it "should initialize with an empty set of models" do
     @resource.models.should eql( Set.new )
@@ -50,15 +60,16 @@ describe Scrooge::Tracker::Resource do
   end
   
   it "should be able to generate a lookup signature" do
-    @resource.signature().should eql( "products_show_get" )
+    @resource.signature().should eql( "products_show_get_public" )
   end
   
   it "should be able to dump itself to a serializeable representation" do
-    @resource.marshal_dump().should eql( { "products_show_get" => { :models => [],
-                                                                    :method => :get,   
-                                                                    :format => :html,
-                                                                    :action => "show",   
-                                                                    :controller => "products"} } )
+    @resource.marshal_dump().should eql( { "products_show_get_public" => { :models => [],
+                                                                      :method => :get,   
+                                                                      :format => :html,
+                                                                      :action => "show",   
+                                                                      :controller => "products",
+                                                                      :is_public => true} } )
   end
   
   it "should be able to restore itself from a serialized representation" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: methodmissing-scrooge
 version: !ruby/object:Gem::Version 
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors: 
 - "Lourens Naud\xC3\xA9"
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-16 00:00:00 -08:00
+date: 2009-03-03 00:00:00 -08:00
 default_executable: 
 dependencies: []