maiha-scoped_access 0.1

data/README

@@ -0,0 +1,4 @@
+ScopedAccess
+============
+
+See http://habtm.com/articles/2006/02/22/nested-with_scope

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the scoped_access plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the scoped_access plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ScopedAccess'
+  rdoc.options << '--line-numbers --inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/init.rb

@@ -0,0 +1,42 @@
+ActionController::Base.instance_eval do
+  def scoped_access (*args, &block)
+    options = (Hash === args.last && !(args.last.keys & [:only, :except]).empty?) ? args.pop : {}
+    send(:around_filter, ScopedAccess::Filter.new(*args, &block), options)
+  end
+end
+
+require 'dispatcher'
+if ActionController.const_defined?(:Dispatcher)
+  # Rails2.1
+  ActionController::Dispatcher.class_eval do
+    class << self
+      def define_dispatcher_callbacks_with_reset(cache_classes)
+        define_dispatcher_callbacks_without_reset(cache_classes)
+        ScopedAccess.reset
+      end
+      alias_method_chain :define_dispatcher_callbacks, :reset
+   end
+  end
+
+else
+  # Rails1.2 or Rails2.0
+  class ::Dispatcher
+    app = respond_to?(:prepare_application, true) ? (class << self; self end) : self
+    app.class_eval do
+      private
+      def prepare_application_with_reset
+        ScopedAccess.reset
+        prepare_application_without_reset
+      end
+
+      alias_method :prepare_application_without_reset, :prepare_application
+      alias_method :prepare_application, :prepare_application_with_reset
+    end
+  end
+end
+
+ActiveRecord::Base.instance_eval do
+  def reset_scope
+    scoped_methods.clear
+  end
+end

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/lib/scoped_access.rb

@@ -0,0 +1,197 @@
+module ScopedAccess
+  class SqlCondition
+    attr_reader :attributes, :constrains
+
+    Constrain = Struct.new(:statement, :parameters)
+
+    def initialize (attributes = nil)
+      if attributes.is_a?(SqlCondition)
+        constrains = attributes.constrains.dup
+        attributes = attributes.attributes
+      end
+
+      @attributes = HashWithIndifferentAccess.new(attributes ? attributes.dup : {})
+      @constrains = constrains || []
+      @cached     = nil
+    end
+
+    def add (statement, *parameters)
+      @constrains << Constrain.new(normalize_statement(statement), parameters)
+      updated
+    end
+
+    def []= (key, val)
+      @attributes[key] = val
+      updated
+    end
+
+    def generate
+      @cached ||= parse
+    end
+
+    def + (other)
+      other.attributes.to_a.inject(self.class.new(@attributes)){|obj, (key, val)| obj[key] = val; obj}
+    end
+
+    def empty?
+      @attributes.empty? && @constrains.empty?
+    end
+
+    protected
+      def normalize_column_name (column_name)
+        column_name
+      end
+
+      def normalize_statement (statement)
+#        statement.sub(/\A\s*\(\s*(.*?)\s*\)\s*\Z/) {$2} # strip parentheses
+        # this is buggy for the case: "(date1 <= ?) AND (date2 BETWEEN ? AND ?)"
+        statement
+      end
+
+      def updated
+        @cached = nil
+      end
+
+      def parse
+        constrains = @attributes.keys.sort.inject(@constrains.dup) {|array, key| array << parse_attribute(key, @attributes[key])}
+        statements = constrains.collect{|constrain| "( %s )" % constrain.statement}
+        parameters = constrains.inject([]){|array, constrain| array += constrain.parameters unless constrain.parameters.empty?; array}
+        [statements.join(" AND ")] + parameters
+      end
+
+      def parse_attribute (column_name, value)
+        column_name = normalize_column_name(column_name)
+        if value.nil?
+          Constrain.new("#{column_name} is NULL", [])
+        elsif value.is_a? Array
+          Constrain.new("#{column_name} in (?)", value)
+        else
+          Constrain.new("#{column_name} = ?", [value])
+        end
+      end
+  end
+
+  class MethodScoping < SqlCondition
+    attr_accessor :find_options, :options
+
+    def initialize (attributes = nil, options = {}, finder_options = {})
+      super(attributes)
+      @options      = HashWithIndifferentAccess.new(options || {})
+      @find_options = finder_options || {}
+    end
+
+    def method_scoping
+      constrains = {
+        :find   => construct_finder,
+        :create => @attributes,
+      }
+      constrains.delete(:find) if constrains[:find] == {:conditions => [""]}
+      return constrains
+    end
+
+  protected
+    def construct_finder
+      (generate == [""]) ? @find_options : @find_options.merge(:conditions => generate)
+    end
+  end
+
+  class ClassScoping < MethodScoping
+    def initialize (klass, *args)
+      (@klass = klass).is_a?(Class) or
+        raise ArgumentError, "A subclass of ActiveRecord::Base is required for '#{klass.class}'"
+      super(*args)
+    end
+
+    protected
+      def normalize_column_name (column_name)
+        "#{ @klass.table_name }.#{ column_name }"
+      end
+
+      def column_name_regexp_string
+        @column_name_regexp_string ||= "(%s)" % @klass.column_names.join('|')
+      end
+
+      def normalize_statement (statement)
+        super.sub(/\A#{column_name_regexp_string}(\s*=|\s+(is|in)\s+)/mi) {
+          "%s%s" % [normalize_column_name($1), $2]
+        }
+      end
+
+  end
+
+  class Filter
+    @applied_classes = Set.new
+    class << self
+      def reset
+        ActiveRecord::Base.logger.debug("ScopedAccess: reset %s" % @applied_classes.to_a.inspect)
+        @applied_classes.each(&:reset_scope)
+        @applied_classes.clear
+      end
+
+      def mark(klass)
+        @applied_classes << klass
+        ActiveRecord::Base.logger.debug("ScopedAccess: mark %s" % klass)
+      end
+
+      def unmark(klass)
+        @applied_classes.delete(klass)
+        ActiveRecord::Base.logger.debug("ScopedAccess: unmark %s" % klass)
+      end
+    end
+
+    def initialize (klass, scoping = :method_scoping, &block)
+      @klass   = klass
+      @scoping = block || scoping
+    end
+
+    def before (controller)
+      constrain = self.class.generate_constrain(@klass, @scoping, :table_name=>@klass.table_name, :controller=>controller)
+      @klass.logger.debug("ScopedAccessFilter#before (called from %s):\n\t[%s] scope becomes %s" %
+                          [controller.class, @klass, constrain.inspect])
+      @klass.instance_eval do
+        Filter.mark(self)
+        scoped_methods << with_scope(constrain){current_scoped_methods}
+      end
+    end
+
+    def after (controller)
+      @klass.instance_eval do
+        scoped_methods.pop
+      end
+      @klass.logger.debug("ScopedAccess::Filter#after (called from %s):\n\t[%s] scope is restored to %s" %
+                          [controller.class, @klass, @klass.send(:scoped_methods).inspect])
+    end
+
+    class << self
+      def generate_constrain (klass, scoping, scoping_options = {})
+        case scoping
+        when Symbol
+          controller = scoping_options[:controller] or raise RuntimeError, "[plugin bug???] missing controller"
+          method_scoping = controller.__send__(scoping)
+          raise RuntimeError, "generate_constrain got infinite loop!" if method_scoping.is_a?(Symbol)
+          return generate_constrain(klass, method_scoping, scoping_options)
+        when Proc
+          method_scoping = scoping.call(scoping_options[:controller])
+          raise RuntimeError, "generate_constrain got infinite loop!" if method_scoping.is_a?(Proc)
+          return generate_constrain(klass, method_scoping, scoping_options)
+        when Hash, ClassScoping
+          return scoping
+        when SqlCondition
+          method_scoping = ClassScoping.new(klass, scoping, scoping_options.reject{|k,| k==:controller})
+          return generate_constrain(klass, method_scoping)
+        when Array, String
+          method_scoping = ClassScoping.new(klass, {}, scoping_options.reject{|k,| k==:controller})
+          method_scoping.add(*scoping)
+          return generate_constrain(klass, method_scoping)
+        else
+          raise TypeError, "cannot generate constrain from this type: (%s)" % scoping.class
+        end
+      end
+    end
+  end
+
+  module_function
+  def reset
+    Filter.reset
+  end
+end

data/tasks/scoped_access_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :scoped_access do
+#   # Task goes here
+# end

data/test/database.yml

@@ -0,0 +1,22 @@
+sqlite:
+  :adapter: sqlite
+  :dbfile: scoped_access_plugin_test.sqlite.db
+
+sqlite3:
+  :adapter: sqlite3
+  :dbfile: scoped_access_plugin_test.sqlite3.db
+
+postgresql:
+  :adapter: postgresql
+  :username: postgres
+  :password: postgres
+  :database: scoped_access_plugin_test
+  :min_messages: ERROR
+
+mysql:
+  :adapter: mysql
+  :host: localhost
+  :username: rails
+  :password:
+  :database: scoped_access_plugin_test
+

data/test/filter_test.rb

@@ -0,0 +1,143 @@
+require File.dirname(__FILE__) + '/test_helper'
+require __DIR__ + '/fixtures/member'
+
+class FilterGenerateConstrainTest < Test::Unit::TestCase
+  def test_generate_constrain_from_hash
+    scoping  = Filter.generate_constrain(Member, {:find=>{:limit=>10}})
+    expected = {
+      :find   => { :limit => 10 }
+    }
+    assert_equal expected, scoping
+  end
+
+  def test_generate_constrain_from_string
+    scoping  = Filter.generate_constrain(Member, 'name = "Maiha"').method_scoping
+    expected = {
+      :find   => { :conditions => ['( members.name = "Maiha" )'] },
+      :create => { },
+    }
+    assert_equal expected, scoping
+  end
+
+  def test_generate_constrain_from_array
+    scoping  = Filter.generate_constrain(Member, ['name = ?', "Maiha"]).method_scoping
+    expected = {
+      :find   => { :conditions => ['( members.name = ? )', "Maiha"] },
+      :create => { },
+    }
+    assert_equal expected, scoping
+  end
+
+  def test_generate_constrain_from_symbol
+    assert_raise(NoMethodError) {
+      Filter.generate_constrain(Member, :method_scoping, :controller=>:dummy)
+    }
+  end
+
+  def test_generate_constrain_from_proc
+    expected = {:find=>{}, :create=>{}}
+    proc     = Proc.new{expected}
+    assert_equal expected, Filter.generate_constrain(Member, proc)
+  end
+
+  def test_generate_constrain_from_sql_condition
+    condition = SqlCondition.new(:name => "Maiha")
+
+    scoping = Filter.generate_constrain(Member, condition).method_scoping
+    expected = {
+      :find   => { :conditions => ['( members.name = ? )', "Maiha"] },
+      :create => { 'name' => "Maiha" },
+    }
+    assert_equal expected, scoping
+  end
+
+  def test_generate_constrain_from_method_scoping
+    method_scoping = MethodScoping.new(:name => "Maiha")
+
+    scoping = Filter.generate_constrain(Member, method_scoping).method_scoping
+    expected = {
+      :find   => { :conditions => ['( members.name = ? )', "Maiha"] },
+      :create => { 'name' => "Maiha" },
+    }
+    assert_equal expected, scoping
+  end
+end
+
+
+
+class FilterWithMethodScopingTest < Test::Unit::TestCase
+  def setup
+    @controller   = Struct.new(:method_scoping).new # faked
+    @class        = Member
+    @filter       = Filter.new(@class)
+    @nested_depth = @class.instance_eval{scoped_methods}.size
+  end
+
+  def teardown
+    current_scopings = @class.instance_eval{scoped_methods}
+    nested_depth     = current_scopings.size - @nested_depth
+    @class.instance_eval{nested_depth.times{scoped_methods.pop}}
+  end
+
+  def test_generate_constrain_from_hash
+    @controller.method_scoping = {:find=>{:limit=>10}}
+    scoping  = @filter.before(@controller).last
+    expected = {
+      :find   => { :limit => 10 }
+    }
+    assert_equal expected, scoping
+  end
+
+  def test_generate_constrain_from_string
+    @controller.method_scoping = 'name = "Maiha"'
+    scoping  = @filter.before(@controller).last
+    expected = {
+      :find   => { :conditions => ['( members.name = "Maiha" )'] },
+      :create => { },
+    }
+    assert_equal expected, scoping
+  end
+
+  def test_generate_constrain_from_array
+    @controller.method_scoping = ['name = ?', "Maiha"]
+    scoping  = @filter.before(@controller).last
+    expected = {
+      :find   => { :conditions => ['( members.name = ? )', "Maiha"] },
+      :create => { },
+    }
+    assert_equal expected, scoping
+  end
+
+  def test_generate_constrain_from_symbol
+    expected = {:find=>{}, :create=>{}}
+    @controller.method_scoping = expected
+    assert_equal expected, scoping  = @filter.before(@controller).last
+  end
+
+  def test_generate_constrain_from_proc
+    expected = {:find=>{}, :create=>{}}
+    @controller.method_scoping = Proc.new{expected}
+    assert_equal expected, scoping  = @filter.before(@controller).last
+  end
+
+  def test_generate_constrain_from_sql_condition
+    @controller.method_scoping = SqlCondition.new(:name => "Maiha")
+    scoping  = @filter.before(@controller).last
+    expected = {
+      :find   => { :conditions => ['( members.name = ? )', "Maiha"] },
+      :create => { 'name' => "Maiha" },
+    }
+    assert_equal expected, scoping
+  end
+
+  def test_generate_constrain_from_method_scoping
+    @controller.method_scoping = MethodScoping.new(:name => "Maiha")
+    scoping  = @filter.before(@controller).last
+    expected = {
+      :find   => { :conditions => ['( members.name = ? )', "Maiha"] },
+      :create => { 'name' => "Maiha" },
+    }
+    assert_equal expected, scoping
+  end
+end
+

data/test/fixtures/favorite.rb

@@ -0,0 +1,4 @@
+class Favorite < ActiveRecord::Base
+  belongs_to :member
+  validates_presence_of :name, :member_id
+end

data/test/fixtures/favorites.yml

@@ -0,0 +1,17 @@
+--- 
+record_1: 
+  name: "miso soup"
+  member_id: 1
+  id: 1
+record_2: 
+  name: "strawberry"
+  member_id: 2
+  id: 2
+record_3: 
+  name: "natto"
+  member_id: 3
+  id: 3
+record_4: 
+  name: "golf"
+  member_id: 10
+  id: 4

data/test/fixtures/group.rb

@@ -0,0 +1,4 @@
+class Group < ActiveRecord::Base
+  has_many :members, :include=>"favorites", :order=>"members", :dependent=>true
+  validates_presence_of :name
+end

data/test/fixtures/groups.yml

@@ -0,0 +1,13 @@
+--- 
+record_1: 
+  name: Berryz
+  id: 1
+  deleted: false
+record_2: 
+  name: Cute
+  id: 2
+  deleted: false
+record_5: 
+  name: ZYX
+  id: 5
+  deleted: false

data/test/fixtures/member.rb

@@ -0,0 +1,5 @@
+class Member < ActiveRecord::Base
+  belongs_to :group
+  has_many   :favorites, :dependent=>true
+  validates_presence_of :yomi, :name, :comments, :group_id
+end

data/test/fixtures/members.yml

@@ -0,0 +1,32 @@
+# Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
+saki:
+  id: 1
+  name: Saki
+  group_id: 1
+  grade: 2
+  deleted: false
+maiha:
+  id: 2
+  name: Maiha
+  group_id: 1
+  grade: 2
+  deleted: true
+yurina:
+  id: 3
+  name: Yurina
+  group_id: 1
+  grade: 1
+  deleted: false
+risako:
+  id: 4
+  name: Risako
+  group_id: 1
+  grade: 1
+  deleted: false
+airi:
+  id: 10
+  name: Airi
+  group_id: 2
+  grade: 2
+  deleted: false
+

data/test/fixtures/song.rb

@@ -0,0 +1,4 @@
+class Song < ActiveRecord::Base
+  belongs_to :group
+  validates_presence_of :name, :content, :group_id
+end

data/test/method_scoping_test.rb

@@ -0,0 +1,87 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class MethodScopingTest < Test::Unit::TestCase
+  def test_no_conditions
+    assert_equal({ :find=>{}, :create=>{} }, MethodScoping.new(nil).method_scoping)
+    assert_equal({ :find=>{}, :create=>{} }, MethodScoping.new({}).method_scoping)
+  end
+
+  def test_create_method_scoping
+    method_scoping = MethodScoping.new(:name => "Maiha")
+    expected = {
+      :find   => { :conditions => ['( name = ? )', "Maiha"] },
+      :create => { 'name' => "Maiha" },
+    }
+    assert_equal expected, method_scoping.method_scoping
+  end
+
+  def test_create_method_scoping_with_attributed_and_conditioned_values
+    method_scoping = MethodScoping.new(:name => "Maiha")
+    method_scoping.add("grade IN ?", [1,2])
+    method_scoping[:group] = 'Berryz'
+
+    expected = {
+      :find   => { :conditions => ["( grade IN ? ) AND ( group = ? ) AND ( name = ? )", [1,2], "Berryz", "Maiha"] },
+      :create => { 'name' => "Maiha", 'group' => "Berryz" },
+    }
+    assert_equal expected, method_scoping.method_scoping
+  end
+
+  def test_plus_method_with_merge
+    scoping1 = MethodScoping.new(:name  => "Maiha")
+    scoping2 = MethodScoping.new(:group => "Berryz")
+
+    expected = {
+      "name"  => "Maiha",
+      "group" => "Berryz",
+    }
+    assert_equal expected, (scoping1 + scoping2).attributes
+  end
+
+  def test_plus_method_with_overwrite
+    scoping1 = MethodScoping.new(:name => "Maiha", :group => "Berryz")
+    scoping2 = MethodScoping.new(:name => "Saki")
+
+    expected = {
+      "name"  => "Saki",
+      "group" => "Berryz",
+    }
+    assert_equal expected, (scoping1 + scoping2).attributes
+  end
+end
+
+
+class ClassScopingTest < Test::Unit::TestCase
+  def test_create_class_scoping
+    class_scoping = ClassScoping.new(Member, :name => "Maiha")
+    expected = {
+      :find   => { :conditions => ['( members.name = ? )', "Maiha"] },
+      :create => { 'name' => "Maiha" },
+    }
+    assert_equal expected, class_scoping.method_scoping
+  end
+
+  def test_create_class_scoping_from_method_scoping
+    method_scoping = MethodScoping.new(:name => "Maiha")
+    class_scoping  = ClassScoping.new(Member, method_scoping.attributes)
+
+    expected = {
+      :find   => { :conditions => ['( members.name = ? )', "Maiha"] },
+      :create => { 'name' => "Maiha" },
+    }
+    assert_equal expected, class_scoping.method_scoping
+  end
+
+  def test_create_class_scoping_with_attributed_and_conditioned_values
+    class_scoping = ClassScoping.new(Member, :name => "Maiha")
+    class_scoping.add("grade IN ?", [1,2])
+    class_scoping[:group] = 'Berryz'
+
+    expected = {
+      :find   => { :conditions => ["( members.grade IN ? ) AND ( members.group = ? ) AND ( members.name = ? )",
+                                   [1,2], "Berryz", "Maiha"] },
+      :create => { 'name' => "Maiha", 'group' => "Berryz" },
+    }
+    assert_equal expected, class_scoping.method_scoping
+  end
+end

data/test/schema.rb

@@ -0,0 +1,20 @@
+ActiveRecord::Schema.define(:version => 2) do
+
+  create_table :groups, :force => true do |t|
+    t.column :name,    :string
+    t.column :deleted, :boolean, :default=>0
+  end
+
+  create_table :members, :force => true do |t|
+    t.column :name,    :string
+    t.column :grade,   :integer
+    t.column :deleted, :boolean, :default=>0
+    t.column :group_id,:integer
+  end
+
+  create_table :favorites, :force => true do |t|
+    t.column :name,     :string
+    t.column :member_id,:integer
+  end
+
+end

data/test/scoped_access_test.rb

@@ -0,0 +1,247 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+require File.join(File.dirname(__FILE__), '..', 'init')
+
+module Scopings
+  ActiveMember     = MethodScoping.new(:deleted => false)
+  ElementarySchool = MethodScoping.new(:grade => 1)
+  JuniorHighSchool = MethodScoping.new(:grade => 2)
+end
+
+class TestController <  ActionController::Base
+  attr_reader :members, :member
+
+  def list
+    @members = Member.find(:all, :order=>:id)
+    render :text=>''
+  end
+
+  def show
+    @member = Member.find(params[:id])
+    render :text=>''
+  end
+end
+
+class ScopedAccessTestCase < Test::Unit::TestCase
+  fixtures :members
+
+  def setup
+    Member.instance_eval{scoped_methods.clear}
+    @request  = ActionController::TestRequest.new
+    @response = ActionController::TestResponse.new
+  end
+
+  def test_dummy
+  end
+
+  private
+    def test_process(controller, action = "show")
+      request = ActionController::TestRequest.new
+      request.action = action
+      controller.process(request, ActionController::TestResponse.new)
+    end      
+
+end
+
+
+class WithoutFilterTest < ScopedAccessTestCase
+  class WithoutFilterController < TestController
+  end
+
+  def setup
+    super
+    @controller = WithoutFilterController.new
+  end
+
+  def test_filter_list
+    get :list
+    assert_response :success
+    assert_equal %w( Saki Maiha Yurina Risako Airi ), @controller.members.map{|o| o.name}
+  end
+
+  def test_filter_show
+    get :show, {'id' => "2"}
+    assert_response :success
+    assert_equal members(:maiha), @controller.member
+  end
+end
+
+class ActiveMemberTest < ScopedAccessTestCase
+  class ActiveMemberController < TestController
+    around_filter ScopedAccess::Filter.new(Member, Scopings::ActiveMember)
+
+    def nested_scoping_with_elementary_school
+      Member.with_scope(Scopings::ElementarySchool) do
+        @members = Member.find(:all)
+      end
+      render :text=>''
+    end
+  end
+
+  def setup
+    super
+    @controller = ActiveMemberController.new
+  end
+
+  def test_filter_list
+    get :list
+    assert_response :success
+    expected = %w( saki yurina risako airi ).collect{|name| members(name)}
+    assert_equal expected, @controller.members
+  end
+
+  def test_filter_show
+    assert_raises(ActiveRecord::RecordNotFound) {
+      get :show, {'id' => "2"}
+    }
+  end
+
+  def test_filter_nested_scoping
+    get :nested_scoping_with_elementary_school
+    assert_response :success
+    assert_equal [members(:yurina), members(:risako)], @controller.members
+  end
+end
+
+
+class DoubleAroundWithMergedScopedFilterTest < ScopedAccessTestCase
+  class DoubleAroundWithMergedScopedFilterController < TestController
+    scoped_access Member, Scopings::ActiveMember
+    scoped_access Member, Scopings::JuniorHighSchool
+
+    def list_with_exclusive_scope
+      Member.with_exclusive_scope(Scopings::ElementarySchool) do
+        @members = Member.find(:all)
+      end
+      render :text=>''
+    end
+  end
+
+  def setup
+    super
+    @controller = DoubleAroundWithMergedScopedFilterController.new
+  end
+
+  def test_filter_list
+    get :list
+    assert_response :success
+    assert_equal [members(:saki), members(:airi)], @controller.members
+  end
+
+  def test_filter_show_active_member
+    get :show, {'id' => "1"}
+    assert_response :success
+    assert_equal members(:saki), @controller.member
+  end
+
+  def test_filter_show_deleted_member
+    assert_raises(ActiveRecord::RecordNotFound) {    
+      get :show, {'id' => "2"}
+    }
+  end
+
+  def test_list_with_exclusive_scope
+    get :list_with_exclusive_scope
+    assert_response :success
+    assert_equal [members(:yurina), members(:risako)], @controller.members
+  end
+end
+
+
+class InheritedDoubleAroundFilterTest < ScopedAccessTestCase
+  class ParentAroundFilterController < TestController
+    scoped_access Member, Scopings::ActiveMember
+  end
+
+  class InheritedDoubleAroundFilterController < ParentAroundFilterController
+    scoped_access Member, Scopings::JuniorHighSchool
+
+    def list_with_conflicted_condition
+      Member.with_scope(Scopings::ElementarySchool) do
+        @members = Member.find(:all)
+      end
+      render :text=>''
+    end
+  end
+
+  def setup
+    super
+    @controller = InheritedDoubleAroundFilterController.new
+  end
+
+  def test_filter_list
+    get :list
+    assert_response :success
+    assert_equal [members(:saki), members(:airi)], @controller.members
+  end
+
+  def test_filter_show
+    assert_raises(ActiveRecord::RecordNotFound) {
+      get :show, {'id' => "2"}
+    }
+  end
+
+  def test_filter_list_with_conflicted_condition
+    get :list_with_conflicted_condition
+    assert_response :success
+    assert_equal [], @controller.members
+  end
+end
+
+
+class ConditionalAroundFilterTest < ScopedAccessTestCase
+  class ConditionalParentAroundFilterController < TestController
+    scoped_access Member, Scopings::ActiveMember, :except=>:all
+    scoped_access Member, Scopings::JuniorHighSchool
+  end
+
+  class InheritedDoubleConditionalAroundFilterController < ConditionalParentAroundFilterController
+    scoped_access Member, Scopings::ElementarySchool, :only=>:list_with_conflicted_condition
+
+    def list_with_conflicted_condition
+      @members = Member.find(:all)
+      render :text=>''
+    end
+
+    def list
+      @members = Member.find(:all)
+      render :text=>''
+    end
+
+    def all
+      @members = Member.find(:all)
+      render :text=>''
+    end
+  end
+
+  def setup
+    super
+    @controller = InheritedDoubleConditionalAroundFilterController.new
+  end
+
+  def test_filter_list_out_of_only_condition
+    expected = Member.with_exclusive_scope(Scopings::ActiveMember+Scopings::JuniorHighSchool){Member.find(:all)}
+    get :list
+    assert_response :success
+    assert_equal expected, @controller.members
+  end
+
+  def test_filter_show
+    assert_raises(ActiveRecord::RecordNotFound) {
+      get :show, {'id' => "2"}
+    }
+  end
+
+  def test_filter_list_with_conflicted_condition
+    get :list_with_conflicted_condition
+    assert_response :success
+    assert_equal [], @controller.members
+  end
+
+  def test_filter_except_condition
+    expected = Member.with_exclusive_scope(Scopings::JuniorHighSchool){Member.find(:all)}
+    get :all
+    assert_response :success
+    assert_equal expected, @controller.members
+  end
+end
+

data/test/sql_condition_test.rb

@@ -0,0 +1,78 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class SqlConditionTest < Test::Unit::TestCase
+  def setup
+    attributes = { :name => 'Maiha' }
+    @condition = SqlCondition.new(attributes)
+  end
+
+  def test_immutable_attributes
+    assert_equal "Maiha", @condition.attributes[:name]
+    attributes = { :name => 'Saki' }
+    assert_equal "Maiha", @condition.attributes[:name]
+  end
+
+  def test_add_attribute
+    @condition[:group] = 'Berryz'
+    assert_equal({'name'=>"Maiha", 'group'=>'Berryz'}, @condition.attributes)
+  end
+
+  def test_overwrite_attribute
+    @condition[:name] = 'Saki'
+    assert_equal({'name'=>"Saki"}, @condition.attributes)
+  end
+
+  def test_generate_with_one_attribute
+    assert_equal(["( name = ? )", "Maiha"], @condition.generate)
+  end
+
+  def test_generate_with_one_condition
+    @condition = SqlCondition.new
+    @condition.add("name = 'Maiha'")
+    assert_equal ["( name = 'Maiha' )"], @condition.generate
+  end
+
+  def test_generate_with_one_attribute_and_one_condition
+    @condition.add("group = 'Berryz'")
+    assert_equal "( group = 'Berryz' ) AND ( name = 'Maiha' )", sanitize_sql(@condition.generate)
+  end
+
+  def test_generate_same_sqls_in_attributed_and_conditioned_ways
+    attributed  = @condition
+    conditioned = SqlCondition.new
+
+    conditioned.add("name = 'Maiha'")
+    assert_equal sanitize_sql(attributed.generate), sanitize_sql(conditioned.generate)
+  end
+
+  def test_generate_with_one_and_two_place_folders
+    @condition.add("group = ?", 'Berryz')
+    @condition.add("age BETWEEN ? AND ?", 12, 14)
+    expected_sql = "( group = 'Berryz' ) AND ( age BETWEEN 12 AND 14 ) AND ( name = 'Maiha' )"
+    assert_equal expected_sql, sanitize_sql(@condition.generate)
+  end
+
+  def test_generate_with_complex_constrains
+    @condition.add("group = ?", 'Berryz')
+    @condition.add("state IN (?)", [1,2])
+    @condition[:graduate] = 1
+    expected_sql = "( group = 'Berryz' ) AND ( state IN (1,2) ) AND ( graduate = 1 ) AND ( name = 'Maiha' )"
+    assert_equal expected_sql, sanitize_sql(@condition.generate)
+  end
+
+  def test_generate_from_sql_condition
+    @condition.add("group = ?", 'Berryz')
+    cond = SqlCondition.new(@condition)
+    assert_equal({"name"=>'Maiha'}, cond.attributes)
+    assert_equal([SqlCondition::Constrain.new("group = ?", ['Berryz'])], cond.constrains)
+  end
+
+private
+  def sanitize_sql (sql)
+    ActiveRecord::Base.instance_eval do 
+      sanitize_sql(sql)
+    end
+  end
+
+end
+

data/test/test_helper.rb

@@ -0,0 +1,39 @@
+def __DIR__; File.dirname(__FILE__); end
+
+$:.unshift(__DIR__ + '/../lib')
+# begin
+#   require 'rubygems'
+# rescue LoadError
+  $:.unshift(__DIR__ + '/../../../rails/activerecord/lib')
+  $:.unshift(__DIR__ + '/../../../rails/activesupport/lib')
+  $:.unshift(__DIR__ + '/../../../rails/actionpack/lib')
+#end
+require 'test/unit'
+require 'active_support'
+require 'active_record'
+require 'active_record/fixtures'
+
+config = YAML::load_file(__DIR__ + '/database.yml')
+ActiveRecord::Base.logger = Logger.new(__DIR__ + "/debug.log")
+ActiveRecord::Base.establish_connection(config[ENV['DB'] || 'sqlite3'])
+
+
+# create tables
+load(__DIR__ + "/schema.rb")
+
+# insert sample data to the tables from 'fixtures/*.yml'
+Test::Unit::TestCase.fixture_path = __DIR__ + "/fixtures/"
+$LOAD_PATH.unshift(Test::Unit::TestCase.fixture_path)
+Test::Unit::TestCase.use_instantiated_fixtures  = false
+
+# for controller test
+require 'action_pack'
+require 'action_controller'
+require 'action_controller/test_process'
+
+ActionController::Base.ignore_missing_templates = true
+ActionController::Routing::Routes.reload rescue nil
+class ActionController::Base; def rescue_action(e) raise e end; end
+
+include ScopedAccess
+

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: maiha-scoped_access
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- maiha
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-10-03 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: ""
+email: maiha@wota.jp
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- Rakefile
+- init.rb
+- install.rb
+- lib/scoped_access.rb
+- tasks/scoped_access_tasks.rake
+- test/database.yml
+- test/filter_test.rb
+- test/fixtures/favorite.rb
+- test/fixtures/favorites.yml
+- test/fixtures/group.rb
+- test/fixtures/groups.yml
+- test/fixtures/member.rb
+- test/fixtures/members.yml
+- test/fixtures/song.rb
+- test/method_scoping_test.rb
+- test/schema.rb
+- test/scoped_access_test.rb
+- test/sql_condition_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/maiha/scoped_access
+post_install_message: 
+rdoc_options: []
+
+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: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: ""
+test_files: []
+