methodmissing-scrooge 1.0.4 → 2.0.0

data/spec/units/scrooge/strategy/stage_spec.rb

@@ -1,35 +0,0 @@
-require 'spec/spec_helper'
-
-describe Scrooge::Strategy::Stage do
-  
-  before(:each) do
-    @stage = Scrooge::Strategy::Stage.new( :test, :for => 0.5 ) do
-               'payload'
-             end
-  end
-  
-  it "should be able to determine if it's executeable" do
-    @stage.executeable?().should equal( true )
-  end
-  
-  it "should be able to determine if it's initialized" do
-    @stage.initialized?().should equal( true )
-  end
-  
-  it "should be able to determine if it's in execution" do
-    @stage.running?().should equal( false )
-    @stage.execute!
-    @stage.running?().should equal( false )
-  end
-  
-  it "should be able to execute itself" do
-    @stage.execute!().should eql( "payload" )
-  end
-  
-  it "should be able to determine if it's terminated" do
-    @stage.terminated?().should equal( false )
-    @stage.execute!
-    @stage.terminated?().should equal( true )
-  end
-  
-end

data/spec/units/scrooge/strategy/track_spec.rb

@@ -1,19 +0,0 @@
-require 'spec/spec_helper'
-
-describe Scrooge::Strategy::Track do
-  
-  before(:each) do
-    Scrooge::Base.profile.stub!(:warmup).and_return( 1 )
-    @track = Scrooge::Strategy::Track.new
-    @controller = Scrooge::Strategy::Controller.new( @track )
-    Scrooge::Base.profile.framework.stub!(:install_tracking_middleware).and_return('installed')
-    Scrooge::Base.profile.stub!(:start_tracking!).and_return('tracking')
-  end
-  
-  it "should be able to execute a given strategy" do
-    with_rails do
-      lambda{ @controller.run!().value }.should raise_error( SystemExit )
-    end
-  end
-  
-end

data/spec/units/scrooge/strategy/track_then_scope_spec.rb

@@ -1,22 +0,0 @@
-require 'spec/spec_helper'
-
-describe Scrooge::Strategy::TrackThenScope do
-  
-  before(:each) do
-    Scrooge::Base.profile.stub!(:warmup).and_return( 1 )    
-    @track_then_scope = Scrooge::Strategy::TrackThenScope.new
-    @controller = Scrooge::Strategy::Controller.new( @track_then_scope )
-    Scrooge::Base.profile.framework.stub!(:install_tracking_middleware).and_return('installed')
-    Scrooge::Base.profile.framework.stub!(:uninstall_tracking_middleware).and_return('installed')    
-    Scrooge::Base.profile.framework.stub!(:install_scope_middleware).and_return('installed')
-  end
-  
-  it "should be able to execute a given strategy" do
-    Scrooge::Base.profile.stub!(:synchronize!).and_return([])
-    Scrooge::Base.profile.stub!(:aggregate!).and_return([])
-    with_rails do
-      @controller.run!().value.should include( 'installed' )
-    end
-  end
-  
-end

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

@@ -1,68 +0,0 @@
-require 'spec/spec_helper'
-
-describe Scrooge::Tracker::App do
-  
-  before(:each) do
-    @app = Scrooge::Tracker::App.new
-    @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 resources has been tracked" do
-    @app.any?().should equal( false )
-  end
-  
-  it "should initialize with an empty set of resources" do
-    @app.resources.should eql( Set.new )
-  end
-  
-  it "should be able to accept resources" do
-    lambda { @app << 'a_resource' }.should change( @app.resources, :size ).from(0).to(1)
-  end
-  
-  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_public" => { :method => :get,
-                                                                     :models => [],
-                                                                     :format => :html,
-                                                                     :action => "show",
-                                                                     :controller => "products",
-                                                                     :is_public => true } } ] )
-    end
-  end
-
-  it "should be able to restore itself from a serialized representation" do
-    @app << @resource
-    with_rails do
-      Marshal.load( Marshal.dump( @app ) ).should eql( @app )
-    end  
-  end
-
-  it "should be able to compare itself to other app trackers" do
-    with_rails do
-      @app.should eql( @app )
-    end  
-  end
-  
-  it "should implemented a custom Object#inspect" do  
-    @app << @resource
-    @app.inspect().should match( /GET/ )  
-    @app.inspect().should match( /products/ )
-  end
-  
-  it "should be able to determine if a resource's been seen before" do
-    @app.resource_for( @resource ).should eql( @resource )
-  end
-  
-  it "should be able to find a resource" do
-    @app << @resource
-    @app.resource( @resource ).should eql( @resource )
-  end
-  
-end

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

@@ -1,29 +0,0 @@
-require 'spec/spec_helper'
-
-describe "Scrooge::Tracker::Base singleton" do
-  
-  it "should be able to yield an instance from given Marshalled data" do
-    lambda{ Scrooge::Tracker::Base.load( [] ) }.should raise_error( Scrooge::Tracker::Base::NotImplemented )
-  end
-  
-end
-
-describe Scrooge::Tracker::Base do
-  
-  before(:each) do
-    @base = Scrooge::Tracker::Base.new
-  end
-  
-  it "should have a numeric representation" do
-    @base.to_i.should equal(0)
-  end
-  
-  it "should be able to dump itself to serializeable representation" do
-    lambda{ @base.marshal_dump }.should raise_error( Scrooge::Tracker::Base::NotImplemented )
-  end
-  
-  it "should be able to restore itself from a serializeable representation" do
-    lambda{ @base.marshal_load( '' ) }.should raise_error( Scrooge::Tracker::Base::NotImplemented )
-  end  
-  
-end

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

@@ -1,79 +0,0 @@
-require 'spec/spec_helper'
-
-describe Scrooge::Tracker::Model do
-  
-  before(:each) do
-    @model = Scrooge::Tracker::Model.new( 'Post' )
-    @model.stub!(:name).and_return( 'Product' )
-    @model.stub!(:table_name).and_return( 'products' )
-    @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
-    @model.any?().should equal( false )
-  end
-  
-  it "should initialize with an empty set of attributes" do
-    @model.attributes.should eql( Set.new )
-  end
-  
-  it "should be able to accept attributes" do
-    lambda { @model << :name }.should change( @model.attributes, :size ).from(0).to(1)
-  end
-  
-  it "should be able to dump itself to a serializeable representation" do
-    @model << [:name, :description, :price]
-    @model.marshal_dump().should eql( { "Product" => [:price, :description, :name] } )
-  end
-  
-  it "should be able to restore itself from a serialized representation" do
-    @model << [:name, :description, :price]
-    @model.marshal_load( { "Product" => [:price] } )
-    @model.attributes.size.should eql( 1 )
-  end
-  
-  it "should be able to render a attribute selection SQL snippet from it's referenced attributes" do
-    @model << [:name, :description, :price]
-    @model.to_sql().should eql( "products.id, products.price, products.description, products.name" )
-  end
-  
-  it "should be able to compare itself to other model trackers" do
-    @model << [:name, :description, :price]
-    @model.should eql( @model )
-  end
-  
-  it "should implemented a custom Object#inspect" do
-    @model << [:name, :description]
-    @model.inspect().should match( /Product/ )
-    @model.inspect().should match( /:name/ )
-  end
-  
-  it "should be able to merge itself with another model tracker" do
-    @other_model << %w(name description)
-    @model.merge( @other_model )
-    @model.attributes.to_a.sort.should eql( %w(description name) )
-    @another_model.merge( @model )
-    @another_model.attributes.to_a.sort.should eql( %w(description name) )
-    @another_model.attributes.should_not_receive(:merge)
-    @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

@@ -1,115 +0,0 @@
-require 'spec/spec_helper'
-
-describe Scrooge::Tracker::Resource do
-  
-  before(:each) do
-    @resource = Scrooge::Tracker::Resource.new do |resource|
-                  resource.controller = 'products'
-                  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' )
-    @model.stub!(:table_name).and_return( 'products' )  
-    @model.stub!(:primary_key).and_return( 'id' )      
-    @other_resource = Scrooge::Tracker::Resource.new do |resource|
-                        resource.controller = 'categories'
-                        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 )
-  end
-  
-  it "should be able to accept models" do
-    lambda { @resource << @model }.should change( @resource.models, :size ).from(0).to(1)
-  end
-  
-  it "should be able to wrap model objects" do
-    @resource << 'Model'
-    @resource.models.all?{|m| m.is_a?( Scrooge::Tracker::Model ) }.should equal( true )
-  end
-  
-  it "should be able to log an attribute access for a given model" do
-    @resource << ['Post', :title]
-    @resource.models.first.attributes.should eql( Set[:title] )
-  end
-  
-  it "should be able to determine if it's trackable" do
-    @resource.trackable?().should equal( true )
-    @resource.stub!(:method).and_return( :put )
-    @resource.trackable?().should equal( false )
-  end
-  
-  it "should be able to generate a lookup signature" do
-    @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_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
-    Marshal.load( Marshal.dump( @resource ) ).should eql( @resource )
-  end  
-  
-  it "should be able to compare itself to other resource trackers" do
-    @resource.should eql( @resource )
-  end
-  
-  it "should be able to setup Rack middleware" do
-    @resource.profile.orm.stub!(:resource_scope_method).and_return(:scoped_to_resource_method)
-    @resource << @model
-    @resource.middleware().class.should equal( Array )
-    @resource.middleware().first.class.should equal( Class )
-    @resource.middleware().first.inspect.should match( /Middleware/ )
-    @resource.middleware().first.inspect.should match( /Product/ )
-    @resource.middleware().first.new( @model ).should respond_to( :call )
-  end
-  
-  it "should implemented a custom Object#inspect" do
-    @resource << @model
-    @resource.inspect().should match( /GET/ )
-    @resource.inspect().should match( /products/ )
-    @resource.inspect().should match( /Product/ )
-  end  
-  
-  it "should be able to find a given model" do
-    @resource << @model
-    other_model = mock('model')
-    other_model.stub!(:name).and_return('Product')
-    @resource.model( other_model ).should == @model
-  end
-  
-  it "should be able to merge itself with another resource" do
-    @other_resource << @model
-    @resource.merge( @other_resource )
-    @resource.models.to_a.should eql( [@model] )
-    @resource.models.should_not_receive(:merge)
-    @resource.merge( nil )
-  end
-  
-end

data/spec/units/scrooge_spec.rb

@@ -1,13 +0,0 @@
-require 'spec/spec_helper'
-
-describe Scrooge::Base do
-  
-  before(:each) do
-    @base = Scrooge::Base
-  end
-  
-  it "should be able to instantiate it's profile" do
-    @base.profile.class.should == Scrooge::Profile
-  end
-  
-end

data/tasks/scrooge.rake

@@ -1,43 +0,0 @@
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-
-require 'scrooge'
-
-Scrooge::Framework::Rails
-
-namespace :scrooge do
-  
-  desc "Copies over the example scrooge.yml file to the host framework's configuration directory"
-  task :setup do
-    Scrooge::Base.setup!
-  end  
-
-  desc "List all available Scrooge scopes"
-  task :list do
-    any_scopes do
-      Scrooge::Profile.framework.scopes.each do |scope|
-        puts "- #{scope}"
-      end
-    end    
-  end
-
-  desc "Dumps Resources and Models for a given scope to a human friendly format.Assumes ENV['scope'] is set."
-  task :inspect do
-    any_scopes do
-      begin
-        Scrooge::Base.profile.scope = ENV['scope']
-        puts Scrooge::Base.profile.tracker.inspect
-      rescue Scrooge::Framework::Base::InvalidScopeSignature
-        puts "Please set ENV['scope'] to the scope you'd like to inspect."
-      end
-    end      
-  end
-
-  def any_scopes
-    if Scrooge::Profile.framework.scopes?
-      yield
-    else
-      puts "There's no existing Scrooge scopes!"
-    end      
-  end
-
-end