ScopedProxy 1.0.0

data/History.txt

@@ -0,0 +1,18 @@
+== 1.0.0 / 2007-12-16
+
+First official release. 
+
+* Added default_proxy method.
+
+* Added delegation/answer to respond_to?
+
+== 0.5.2
+
+Inofficial release on our blog neotrivium.com. Fixing a few bugs due to user reports. 
+
+* v0.4 Fixed a bug with scoping (another one) pointed out to me by Severin Schoepke. 
+  Scoping will now even work in situations where an AssociationProxy sets the context. 
+  
+* v0.3 Fixed a scoping bug pointed out by fractious; now scoping should work as advertised. Thanks go 
+  to Florian Hanke for teaming up with me on this. 
+

data/Manifest.txt

@@ -0,0 +1,7 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/scoped_proxy.rb
+spec/scoped_proxy_spec.rb
+spec/spec_helper.rb

data/README.txt

@@ -0,0 +1,105 @@
+ScopedProxy
+
+== SUMMARY
+
+Finally, long awaited, scoped proxies as a release. Which you say. Admitted, there are about 15 plugins
+that are called scoped_proxy, but only one comes with a full suite of tests that is full 40 lines longer
+than the actual code. That is the scoped proxy you are looking at. It is y2k compliant and works as a gem.
+Magnificent, isn't it?
+
+This gem is all about simplicity; you won't find a whole toolbox here, just another valued screwdriver. 
+But we happen to encounter a lot of screws - hopefully you do too - and find this very useful. If you
+want to skip all this summary that is really longer than all the other texts in this release, have a look 
+at the synopsis below. 
+
+== SYNOPSIS:
+  
+Allows storing scopes as names; that way you can address subsets of your model space by meaningful names. 
+
+  require 'scoped_proxy'    # Railsers: You might want to call this in environment.rb
+
+  class User < ActiveRecord::Base
+    scoped_proxy :role do |role|
+      {
+        :find => { :conditions => ['role = ?', role] }
+      }
+    end
+    scoped_proxy :deleted, :find => {
+      :conditions => 'deleted_at is not null'
+    }
+  end
+  
+  admins = User.role('admin')
+  admins.count              # => 12
+  admins.find(:all)         # => [ ... ]
+  
+  User.deleted.count        # => a number
+  
+This implementation also brings (NEW, SHINY) default proxies. That means you can have a proxy in effect
+when no other proxy is in effect. 
+
+  class User < ActiveRecord::Base
+    default_proxy :find => { :conditions => 'deleted_at is null' }
+  end
+  
+  User.find(:all)   # only finds users that aren't deleted
+
+== REQUIREMENTS:
+
+* gem install metaid
+
+== TESTING
+
+If you want to run the rspec tests, you must have a database on localhost called 'test' and a user
+called 'developer' that is allowed to (write)access it. Caution: running the tests will delete at least
+your 'users' table in said database. But I hope you wouldn't run this on production, nor call your 
+production database 'test'. Warned you. 
+
+Details can be changed in spec/spec_helper.rb
+
+== THANKS
+
+Special Thanks to Florian Hanke (florian at restorm dot com) and Severin Schoepke (severin at restorm dot com). 
+They have played an enormous role in keeping this mean and lean. Thanks also to the rest of the gang - please
+visit us at labs.restorm.com.
+
+== CONTACT
+
+Rubyforge Project:
+
+http://rubyforge.org/projects/swissrb
+
+Documentation:
+
+upcoming...
+
+Bugs:
+
+http://rubyforge.org/tracker/?atid=19774&group_id=5130&func=browse
+
+
+== LICENSE:
+
+(The MIT License or the Ruby License, choose)
+
+Copyright (c) 2007 Kaspar Schiess, all rights reserved
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/Rakefile

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'hoe'
+require './lib/scoped_proxy'
+
+namespace :hoe do 
+  Hoe.new('ScopedProxy', ScopedProxy::VERSION) do |p|
+    p.rubyforge_name = 'swissrb'
+    p.author = 'Kaspar Schiess'
+    p.email = 'eule@space.ch'
+    p.summary = p.paragraphs_of('README.txt', 1..3).join("\n\n")
+    p.description = p.paragraphs_of('README.txt', 4..7).join(' ')
+    p.url = p.paragraphs_of('README.txt', 17).join(' ')
+    p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+  end
+end
+
+require 'spec/rake/spectask'
+require 'spec/translator'
+
+task :default => :spec
+
+desc "Run all specs in spec directory (excluding plugin specs)"
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end

data/lib/scoped_proxy.rb

@@ -0,0 +1,142 @@
+require 'metaid'
+require 'active_record'
+
+# Smart scoping for AR models
+# Author: Kaspar Schiess, (c) by Neotrivium AG, 2007
+# Distributed under the terms of the Ruby License
+
+module ScopedProxy
+  VERSION = '1.0.0'
+
+  # Allows you to create scoped proxies in models. 
+  # 
+  # Example
+  #
+  #   class User < ActiveRecord::Base
+  #     scoped_proxy :woman, :find => { :conditions => ['sex=?', 'f'] } 
+  # 
+  # Allowed options
+  #   * :exclusive    if set to true, this proxy will not apply if there is another proxy active. 
+  #
+  class Proxy
+    cattr_accessor :active_proxy
+    @@active_proxy = false
+    
+    def initialize(klass, scope={}, old_scope=nil, options={})
+      @klass, @scope, @old_scope = klass, scope, old_scope
+      @options = options
+    end
+
+    def method_missing(message, *args, &block)
+      exclusive_scope = @options[:exclusive] || false
+      activate_proxy = (! exclusive_scope) || (exclusive_scope && no_other_proxy_active?)
+            
+      conditional_scope(@old_scope) do                    # Install previous scope 
+        conditional_scope(@scope, activate_proxy) do      # Install this scope
+          with_proxy do                                   # Track active proxies
+            @klass.send(message, *args, &block)
+          end
+        end
+      end
+    end
+    
+    def respond_to_with_delegation?(symbol)
+      self.respond_to_without_delegation?(symbol) || @klass.respond_to?(symbol)
+    end
+    alias_method_chain :respond_to?, :delegation
+    
+    # Mark the installation of a proxy. This information can be used to make proxies dependent upon context, as in 
+    # the default proxy. 
+    # 
+    def with_proxy
+      begin
+        old_value = self.class.active_proxy
+        self.class.active_proxy = true
+        yield
+      ensure
+        self.class.active_proxy = old_value
+      end
+    end
+    
+    # Is there no other proxy than this one active?
+    # 
+    def no_other_proxy_active?
+      ! self.class.active_proxy
+    end
+        
+    # Install given scope if it is not nil and the predicate is true. Then yield. 
+    # 
+    def conditional_scope(scope, pred=true)
+      if scope && pred
+        klass_with_scope(@klass, scope) do
+          yield
+        end
+      else
+        yield
+      end
+    end
+    
+    # Permit access to with_scope from outside the AR::Base class. This is an exception to the rule ;) 
+    # 
+    def klass_with_scope(klass, scope, &block)
+      klass.send(:with_scope, scope, &block) 
+    end
+  end
+  
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  
+  module ClassMethods
+    
+    private
+    
+      # Add a default proxy to the object. A default proxy is a proxy that is always in effect, unless another proxy is 
+      # used. 
+      # 
+      # Example
+      # 
+      #   class User
+      #     default_proxy :find => { :conditions => { :deleted_at => nil } }
+      #   end
+      # 
+      # The example only returns users that haven't been marked as deleted - unless you use another proxy on the User
+      # object. 
+      # 
+      def default_proxy(scope=nil)
+        scoped_proxy :default_proxy, scope, :exclusive => true
+        
+        [:find, :count].each do |meth|
+          meth_name = "#{meth}_with_default_proxy"
+          meth_without = "#{meth}_without_default_proxy"
+          metaclass.class_eval %Q{
+            def #{meth_name}(*args, &block)
+              default_proxy.#{meth_without}(*args, &block)
+            end
+            alias_method_chain :#{meth}, :default_proxy
+          }
+        end
+      end
+    
+      # Install a scoped proxy with the given name. 
+      # 
+      # Example
+      #
+      #   class User < ActiveRecord::Base
+      #     scoped_proxy :woman, :find => { :conditions => ['sex=?', 'f'] } 
+      # 
+      def scoped_proxy(name, scope=nil, opts={}, &block)
+        meta_def(name) do |*args|
+          resulting_scope = scope
+          resulting_scope = block.call(*args) if block
+        
+          target = self
+          Proxy.new(target, resulting_scope, self.current_scoped_methods, opts)
+        end
+      end
+  end
+end
+
+class ActiveRecord::Base
+  include ScopedProxy
+end

data/spec/scoped_proxy_spec.rb

@@ -0,0 +1,164 @@
+require 'spec'
+
+require File.join(File.dirname(__FILE__), 'spec_helper')
+require 'scoped_proxy'
+
+def silence
+  old_verbose, $VERBOSE = $VERBOSE, nil
+  yield
+ensure
+  $VERBOSE = old_verbose
+end
+
+# NOTE: Running these tests WILL destroy a database called test (overwriting tables and such). You have been warned. 
+
+describe ScopedProxy, " availability" do
+  it "should be a module" do
+    ScopedProxy.should be_kind_of(Module)
+  end
+end
+
+silence do 
+  ActiveRecord::Schema.define do 
+    create_table :users, :force => true do |t|
+      t.column :name, :string 
+      t.column :role, :string
+    end
+  end
+end
+class User < ActiveRecord::Base
+  scoped_proxy :johns, :find => {
+    :conditions => ['name like ?', 'john%']
+  }
+  scoped_proxy :janes, :find => {
+    :conditions => ['name like ?', 'jane%']
+  }
+end
+john1 = User.create!(:name => 'john1', :role => 'admin')
+john2 = User.create!(:name => 'john2', :role => 'user')
+jane1 = User.create!(:name => 'jane1', :role => 'user')
+
+describe User, " and users that are john" do
+  it "should have johns" do
+    User.should respond_to(:johns)
+  end
+  it "johns should return a proxy" do
+    User.johns.should be_kind_of(ScopedProxy::Proxy)
+  end
+  it "should allow us to find all johns" do
+    johns = User.find(:all, :conditions => 'name like \'john%\'')
+    
+    User.johns.find(:all).should eql(johns)
+  end
+  it "should have count and other methods" do
+    User.johns.find(:all)
+    User.johns.count
+  end
+  it "should respond to count and other methods" do
+    User.johns.should respond_to(:count)
+    User.johns.should respond_to(:find)
+    User.johns.should respond_to(:destroy_all)
+  end
+end
+
+class User
+  scoped_proxy :role do |role|
+    {
+      :find => { :conditions => ['role = ?', role] }
+    }
+  end
+end
+describe User, "extended scoping" do
+  it "should have role proxy" do
+    User.should respond_to(:role)
+  end
+  it "should select roles as a filter" do
+    ['admin', 'user'].each do |role|
+      expectation = User.find(:all, :conditions => {:role => role} )
+      User.role(role).find(:all).should eql(expectation)
+    end
+  end
+  it "should allow combining roles into a bigger filter" do
+    # try both orders
+    User.janes.role('user').find(:first).should eql(jane1)
+    User.role('user').janes.find(:first).should eql(jane1)
+  end
+  it "should allow storing proxy and later on using it" do
+    janes = User.janes
+    
+    janes.find(:first).should eql(jane1)
+  end
+  it "should capture its environment" do
+    johns = nil
+    User.send(:with_scope, :find => {:conditions => { :role => 'user'} } ) do 
+      johns = User.johns
+    end
+    
+    johns.find(:all).should eql([john2])
+  end
+  it "should capture a complex scoped environment" do
+    johns = nil
+    User.send(:with_scope, :find => {:conditions => { :role => 'user'} } ) do 
+      johns = User.johns.role('admin')
+    end
+    
+    johns.find(:all).should be_empty
+  end
+end
+
+silence do 
+  ActiveRecord::Schema.define do 
+    create_table :zebras, :force => true do |t|
+      t.column :stripes, :boolean
+    end
+  end
+end
+class Zebra < ActiveRecord::Base
+  default_proxy :find => {
+    :conditions => ['stripes = ?', true]
+  }
+
+  # Any further proxying will go back to unproxied default
+  scoped_proxy :bad
+end
+
+# All good zebras have stripes
+10.times do Zebra.create!(:stripes => true) end
+# Only some don't
+Zebra.create!(:stripes => false)
+
+describe Zebra, "default proxies"  do
+  it "should not have johns or janes - that's User" do
+    # NOTE to the confused reader: For johns to be a method on User, it can either be a method of User's class (== Class)
+    # or a method of the singleton metaclass of User (== an anonymous class that inherits from Class). Now, we don't want
+    # stuff we define for the user (like eat_at_a_table) to be defined for all Zebras too - this is why we need #meta_def and
+    # not class_def. The two solutions are otherwise identical - this expectation forces the decision.
+    # 
+    Zebra.should_not respond_to(:johns)
+    Zebra.should_not respond_to(:janes)
+  end
+    
+  it "should select only striped zebras by default" do
+    Zebra.count.should == 10
+    
+    Zebra.find(:all).each do |zebra|
+      zebra.stripes.should eql(true)
+    end
+  end
+  it "should select all zebras with any other proxy" do
+    Zebra.send(:with_scope, :find => { :conditions => ['id>0'] }) do 
+      Zebra.bad.count.should == 11
+    end
+    Zebra.bad.count.should == 11
+    Zebra.bad.bad.count.should == 11
+    
+    Zebra.bad.find(:all, :conditions => { :stripes => false }).each do |zebra|
+      zebra.stripes.should == false
+    end
+  end
+  it "should allow accessing the default proxy trough #default_proxy" do
+    default = Zebra.default_proxy
+    
+    default.count.should == 10
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+
+$:.unshift File.join(File.dirname(__FILE__), '../lib')
+
+require 'active_record'
+
+ActiveRecord::Base.connection = {
+  :user => 'developer', 
+  :adapter => 'mysql', 
+  :database => 'test', 
+  :host => '127.0.0.1'
+}
+

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: ScopedProxy
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ""
+authors: 
+- Kaspar Schiess
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2007-12-21 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.3.0
+    version: 
+description: "== SYNOPSIS:  Allows storing scopes as names; that way you can address subsets of your model space by meaningful names.    require 'scoped_proxy'    # Railsers: You might want to call this in environment.rb   class User < ActiveRecord::Base scoped_proxy :role do |role| { :find => { :conditions => ['role = ?', role] } } end scoped_proxy :deleted, :find => { :conditions => 'deleted_at is not null' } end  admins = User.role('admin') admins.count              # => 12 admins.find(:all)         # => [ ... ]  User.deleted.count        # => a number  This implementation also brings (NEW, SHINY) default proxies. That means you can have a proxy in effect when no other proxy is in effect.    class User < ActiveRecord::Base default_proxy :find => { :conditions => 'deleted_at is null' } end  User.find(:all)   # only finds users that aren't deleted"
+email: eule@space.ch
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/scoped_proxy.rb
+- spec/scoped_proxy_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://rubyforge.org/projects/swissrb
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: swissrb
+rubygems_version: 0.9.5
+signing_key: 
+specification_version: 2
+summary: == SUMMARY  Finally, long awaited, scoped proxies as a release. Which you say. Admitted, there are about 15 plugins that are called scoped_proxy, but only one comes with a full suite of tests that is full 40 lines longer than the actual code. That is the scoped proxy you are looking at. It is y2k compliant and works as a gem. Magnificent, isn't it?  This gem is all about simplicity; you won't find a whole toolbox here, just another valued screwdriver.  But we happen to encounter a lot of screws - hopefully you do too - and find this very useful. If you want to skip all this summary that is really longer than all the other texts in this release, have a look  at the synopsis below.
+test_files: []
+