moro-scope_do 0.1.1

data/ChangeLog

@@ -0,0 +1,8 @@
+== 0.1.1 / 2009-02-18
+* [FEATURE] add free_or_accessible scope
+* [BUG] fixed hard-coded blog_id in User#accessible?
+
+== 0.1.0 / 2009-01-09
+
+* initial release
+

data/README.rdoc

@@ -0,0 +1,103 @@
+
+= scope_do
+
+named_scope utilities.
+
+== Description
+
+scope_do is a tiny utilities to define useful named_scope.
+scope_do provides
+
+- named_acl : enable User - Group - Target style access control list.
+- chained_scope : enable defined named_scope method chain.
+- has_children  : define scope to load child records
+
+== Installation
+
+=== Archive Installation
+
+	rake install
+
+=== Gem Installation
+
+	gem install scope_do
+
+
+== Features/Problems
+=== named_acl
+named_acl provides Target.accessible_by(users) scope that load target model accessible by the user.
+And also provides User#accessible_#{target} methods which call Target.accessible_by(self).
+
+ class User < ActiveRecord::Base
+   scope_do :named_acl
+   named_acl :blogs
+ end
+
+now you write below in controller.
+
+ class BlogsController < ApplicationCotnroller
+   def index
+     @blogs = current_user.accessible_blogs
+     # or method chain
+     # @blogs = current_user.accessible_blogs.find_by_keyword(params[:keyword])
+   end
+ end
+
+=== chained_scope
+chained_scope provides named_scope macro that skip condition when all args are blank.
+and it enable named_scope method-chainable.
+
+ class Blog < ActiveRecord::Base
+   scope_do :chained_scope
+   named_scope :title_like, proc{|part|
+     {:conditions => ["#{quoted_table_name}.title LIKE ?", "%#{part}%"]}
+   }
+   ...and more...
+
+   chainable_scope :title_like
+ end
+
+without chained_scope, you must write below (or reject blank in each scope)
+
+ def index # In some controller
+   @blogs = Blog.some_scope
+   @blogs = @blogs.title_like(params[:q]) unless params[:q].blank?
+   @blogs = @blogs.month_in(params[:month]) unless params[:month].blank?
+   ...
+   @blogs = scope.find(:all, ...)
+ end
+
+chained_scope enable below style
+
+ def index # In some controller
+   @blogs = Blog.some_scope.
+              title_like(params[:q]).
+              month_in(params[:month]).
+              find(:all, ...)
+ end
+
+=== has_children
+define scope that have children records.
+
+ class Blog < ActiveRecord::Base
+   scope_do :has_children
+   has_many :entries
+   has_children :entries
+ end
+
+add "has_entries" scope that have one or more entries.
+
+ Blog.has_entries.all?{|b| not b.entries.blank? }  # => true
+
+"has_entires" also accept children numbers
+
+ Blog.has_entries(2).all?{|b| b.entries.size >= 2 }  # => true
+
+== Synopsis
+see spec/**/*_spec.rb
+
+== Copyright
+
+Author::    MOROHASHI Kyosuke <moronatural@>gmail.com
+Copyright:: Copyright (c) 2009 MOROHASHI Kyosuke
+License:: MIT

data/Rakefile

@@ -0,0 +1,112 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/contrib/rubyforgepublisher'
+require 'rake/contrib/sshpublisher'
+require 'fileutils'
+
+$:.unshift "lib"
+require 'scope_do'
+
+require 'spec/rake/spectask'
+include FileUtils
+
+NAME              = "scope_do"
+AUTHOR            = "MOROHASHI Kyosuke"
+EMAIL             = "moronatural@gmail.com"
+DESCRIPTION       = "named_scope utilities."
+HOMEPATH          = "http://github.com/moro/scope_do/tree/master"
+BIN_FILES         = %w(  )
+
+VERS              = ScopeDo::VERSION
+REV = File.read(".svn/entries")[/committed-rev="(d+)"/, 1] rescue nil
+CLEAN.include ['**/.*.sw?', '*.gem', '.config']
+RDOC_OPTS = [
+	'--title', "#{NAME} documentation",
+	"--charset", "utf-8",
+	"--opname", "index.html",
+	"--line-numbers",
+	"--main", "README.rdoc",
+	"--inline-source",
+]
+
+task :default => [:test]
+task :package => [:clean]
+
+desc "Run all specs in spec directory"
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts = %w[--colour --format progress --loadby --reverse]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+spec = Gem::Specification.new do |s|
+	s.name              = NAME
+	s.version           = VERS
+	s.platform          = Gem::Platform::RUBY
+	s.has_rdoc          = true
+	s.extra_rdoc_files  = ["README.rdoc", "ChangeLog"]
+	s.rdoc_options     += RDOC_OPTS + ['--exclude', '^(examples|extras)/']
+	s.summary           = DESCRIPTION
+	s.description       = DESCRIPTION
+	s.author            = AUTHOR
+	s.email             = EMAIL
+	s.homepage          = HOMEPATH
+	s.executables       = BIN_FILES
+	s.bindir            = "bin" unless BIN_FILES.empty?
+	s.require_path      = "lib"
+	s.test_files        = Dir["spec/**/*_spec.rb"]
+
+	s.files = %w(README.rdoc ChangeLog Rakefile) +
+		Dir.glob("{bin,doc,test,lib,templates,generator,extras,website,script}/**/*") + 
+		Dir.glob("spec/**/*.rb") +
+		Dir.glob("ext/**/*.{h,c,rb}") +
+		Dir.glob("examples/**/*.rb") +
+		Dir.glob("tools/*.rb") +
+		Dir.glob("rails/*.rb")
+
+	s.extensions = FileList["ext/**/extconf.rb"].to_a
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+	p.need_tar = true
+	p.gem_spec = spec
+end
+
+task :install do
+	name = "#{NAME}-#{VERS}.gem"
+	sh %{rake package}
+	sh %{sudo gem install pkg/#{name}}
+end
+
+task :uninstall => [:clean] do
+	sh %{sudo gem uninstall #{NAME}}
+end
+
+
+Rake::RDocTask.new do |rdoc|
+	rdoc.rdoc_dir = 'html'
+	rdoc.options += RDOC_OPTS
+	rdoc.template = "resh"
+	#rdoc.template = "#{ENV['template']}.rb" if ENV['template']
+	if ENV['DOC_FILES']
+		rdoc.rdoc_files.include(ENV['DOC_FILES'].split(/,\s*/))
+	else
+		rdoc.rdoc_files.include('README.rdoc', 'ChangeLog')
+		rdoc.rdoc_files.include('lib/**/*.rb')
+		rdoc.rdoc_files.include('ext/**/*.c')
+	end
+end
+
+desc 'Show information about the gem.'
+task :debug_gem do
+	puts spec.to_ruby
+end
+
+desc 'Update gem spec'
+task :gemspec do
+  open("#{NAME}.gemspec", 'w').write spec.to_ruby
+end

data/lib/scope_do.rb

@@ -0,0 +1,14 @@
+require 'scope_do/named_acl'
+require 'scope_do/chained_scope'
+
+module ScopeDo
+  VERSION = '0.1.1'
+  module Adapter
+    def scope_do *functions
+      functions.each do |function|
+        module_name = function.to_s.camelize
+        include ScopeDo.const_get(module_name)
+      end
+    end
+  end
+end

data/lib/scope_do/chained_scope.rb

@@ -0,0 +1,35 @@
+module ScopeDo
+  module ChainedScope
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      # Make specified named_scope(s) chainable
+      #
+      # options
+      #
+      # +halt+:: add always false condition (WHERE 1 = 2)
+      def chainable_scope(*scope_names)
+        opts = scope_names.extract_options!
+        opts.symbolize_keys!
+
+        scope_names.each do |scope_name|
+          if defined_scope = scopes[scope_name]
+            scopes[scope_name] = proc{|parent_scope, *args|
+              args.flatten.any?{|x| !x.blank? } ?
+                defined_scope.call(parent_scope, *args) : parent_scope.scoped(chain_condition(opts))
+            }
+          end
+        end
+      end
+
+      private
+      def chain_condition(options) # nodoc
+        options[:halt] ? {:conditions => "1 = 2"} : {}
+      end
+    end
+  end
+end
+

data/lib/scope_do/has_children.rb

@@ -0,0 +1,56 @@
+# vim:set fileencoding=utf-8 filetype=ruby
+
+module ScopeDo
+  module HasChildren
+    def self.included(base)
+      base.extend ClassMethods
+    end
+  end
+
+  class QueryBuilder
+    def self.has_children_condition(n, q)
+      select_cols, rest = q
+      if n
+      "#{n} <= (SELECT COUNT(#{select_cols}) #{rest})"
+      else
+        "EXISTS(SELECT #{select_cols} #{rest})"
+      end
+    end
+
+    def initialize(base, association)
+      @base = base
+      @association = association
+    end
+
+    def has_children_query_parts
+      if through = @association.through_reflection
+        query_parts(@base, through)
+      else
+        query_parts(@base, @association)
+      end
+    end
+
+    private
+    def query_parts(parent, association)
+      child_t = association.quoted_table_name
+      parent_t = parent.quoted_table_name
+      [
+        "#{child_t}.#{association.primary_key_name}",
+        "FROM #{child_t} WHERE #{parent_t}.#{parent.primary_key} = #{child_t}.#{association.primary_key_name}"
+      ]
+    end
+  end
+
+  module ClassMethods
+    def has_children(target)
+      association = reflections[target]
+      builder = QueryBuilder.new(self, association)
+      qs = builder.has_children_query_parts
+
+      named_scope "has_#{target}", proc{|*n|
+        {:conditions => QueryBuilder.has_children_condition(n.shift, qs)}
+      }
+    end
+  end
+end
+

data/lib/scope_do/named_acl.rb

@@ -0,0 +1,61 @@
+require 'scope_do/named_acl/builder'
+
+module ScopeDo
+  module NamedAcl
+    def self.included(base)
+      base.extend ClassMethods
+      base.cattr_accessor :acl_query_builder
+    end
+
+    module ClassMethods
+      def named_acl(target, options={})
+        t_klass = target.to_s.classify.constantize
+        self.acl_query_builder = Builder.new(self, target, options)
+
+        define_accessible_scope(t_klass, acl_query_builder.query)
+        class_eval(<<-EOS)
+        def accessible_#{target}; #{t_klass.name}.accessed_by(self) ; end
+        EOS
+
+        if free = t_klass.scopes[:free]
+          define_free_or_accessible_scope(t_klass, free.call(t_klass), acl_query_builder.query)
+          class_eval(<<-EOS)
+          def free_or_accessible_#{target}; #{t_klass.name}.free_or_accessed_by(self); end
+          EOS
+        end
+      end
+
+      private
+      def define_accessible_scope(klass, query)
+        klass.named_scope :accessed_by, proc{|*users|
+          user_ids = users.map(&:id)
+          {:conditions => ["#{klass.quoted_table_name}.id IN (#{query})", {:user_ids => user_ids}]}
+        }
+      end
+
+      def define_free_or_accessible_scope(klass, free_scope, query)
+        free = merge_conditions( free_scope.proxy_options[:conditions] )
+
+        klass.named_scope :free_or_accessed_by, proc{|*users|
+          accessible = merge_conditions( klass.accessed_by(*users).proxy_options[:conditions] )
+          {:conditions => "(#{free}) OR (#{accessible})"}
+        }
+      end
+    end
+
+    def accessible?(record)
+      @accessibilities ||= load_accessibilities
+
+      fk = acl_query_builder.accessibility_target_id(false)
+      @accessibilities.any?{|a| a[fk] == record.id }
+    end
+
+    private
+    def load_accessibilities
+      q = acl_query_builder
+      q.accessibility_klass.find(:all, :joins => "JOIN #{q.join_on_group_id}",
+                                       :conditions => ["#{q.where}", {q.label.to_sym=> self}])
+    end
+  end
+end
+

data/lib/scope_do/named_acl/builder.rb

@@ -0,0 +1,49 @@
+module ScopeDo
+  module NamedAcl
+    class Builder
+      attr_reader :label
+
+      def initialize(user_klass, target, options={})
+        options = {:via => :groups, :label => "user_ids"}.merge(options)
+        @label = options[:label]
+
+        @user = user_klass
+        @group = @user.reflections[options[:via]]
+        @membership = @user.reflections[options[:via]].through_reflection
+
+        @target = @group.klass.reflections[target]
+        @accessibility = @target.through_reflection
+      end
+
+      def accessibility_klass
+        @accessibility.klass
+      end
+
+      def query
+        "SELECT #{accessibility_target_id} FROM #{from} JOIN #{join_on_group_id} WHERE #{where}"
+      end
+
+      def accessibility_target_id(with_table_name = true)
+        if with_table_name
+          "#{@accessibility.quoted_table_name}.#{@target.association_foreign_key}"
+        else
+          @target.association_foreign_key
+        end
+      end
+
+      def where
+        "#{@membership.quoted_table_name}.#{@membership.primary_key_name} IN (:#{@label})"
+      end
+
+      def from
+        @accessibility.quoted_table_name
+      end
+
+      def join_on_group_id
+        "#{@membership.quoted_table_name} ON " +
+        "#{@membership.quoted_table_name}.#{@group.association_foreign_key} = " +
+        "#{@accessibility.quoted_table_name}.#{@accessibility.primary_key_name}"
+      end
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1,5 @@
+#require File.expand_path("..", File.dirname(__FILE__))
+require 'scope_do'
+
+ActiveRecord::Base.extend(ScopeDo::Adapter)
+

data/spec/record_extention_test_util.rb

@@ -0,0 +1,47 @@
+require 'rubygems'
+require 'active_record'
+require 'active_record/fixtures'
+
+RAILS_ENV = "test"
+
+module RecrodExtention
+  module TestUtil
+    MEMORY_DB_OPTIONS = {
+      :adapter => "sqlite3",
+      :database => ":memory:",
+    }.with_indifferent_access.freeze
+
+    def setup
+      memory_db!
+      log_or_silent!
+      ActiveRecord::Base.extend(ClassMethods)
+    end
+
+    def memory_db!(options = {})
+      ActiveRecord::Base.configurations = {"test" => MEMORY_DB_OPTIONS.merge(options) }
+      ActiveRecord::Base.establish_connection(:test)
+    end
+
+    def log_or_silent!(dir = "log")
+      ActiveRecord::Base.logger = Logger.new(dir && File.directory?(dir) ? "#{dir}/#{RAILS_ENV}.log" : "/dev/null")
+    end
+
+    def next_schema_version
+      begin
+        ActiveRecord::Base.connection.select_one("SELECT version FROM schema_migrations")["version"].succ
+      rescue ActiveRecord::StatementInvalid
+        "1"
+      end
+    end
+    module_function :setup, :memory_db!, :log_or_silent!, :next_schema_version
+
+    module ClassMethods
+      def define_table(table_name = self.name.tableize, &migration)
+        ActiveRecord::Schema.define(:version => TestUtil.next_schema_version) do
+          create_table(table_name, &migration)
+        end
+      end
+    end
+  end
+end
+

data/spec/scope_do/chained_scope_spec.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+# vim:set fileencoding=utf-8 filetype=ruby
+# $KCODE = 'u'
+
+require File.expand_path("../spec_helper", File.dirname(__FILE__))
+require 'scope_do/chained_scope'
+
+describe ScopeDo::ChainedScope do
+  before(:all) do
+    ::User.class_eval do
+      scope_do :chained_scope
+      named_scope :name_like, proc{|part|
+        {:conditions => ["#{quoted_table_name}.name LIKE ?", "%#{part}%"]}
+      }
+
+      named_scope :name_starts, proc{|part|
+        {:conditions => ["#{quoted_table_name}.name LIKE ?", "#{part}%"]}
+      }
+
+      chainable_scope :name_like
+      chainable_scope :name_starts, :halt => true
+    end
+
+    User.delete_all
+    u = Factory(:user)
+    Factory(:user, :name => "bob")
+  end
+
+  it "name_like('ali') should == [User.find_by_name('alice')]" do
+    User.name_like('ali').should == [User.find_by_name('alice')]
+  end
+
+  it "blank paramters (nil, [], '') on name_like should == User.all" do
+    [nil, [], ''].all?{|param| User.name_like(param) == User.all }.should be_true
+  end
+
+  it "blank paramters (nil, [], '') on name_starts should == []" do
+    [nil, [], ''].all?{|param| User.name_starts(param) == [] }.should be_true
+  end
+end
+

data/spec/scope_do/has_children_spec.rb

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+# vim:set fileencoding=utf-8 filetype=ruby
+# $KCODE = 'u'
+
+require File.expand_path("../spec_helper", File.dirname(__FILE__))
+require 'scope_do/has_children'
+
+describe ScopeDo::HasChildren do
+  before(:all) do
+    ::Blog.class_eval do
+      scope_do :has_children
+      has_children :entries
+    end
+  end
+
+  before do
+    [Blog, Entry, Group, User].each(&:delete_all)
+    @blog = Factory(:blog)
+    @blog.entries << (@entry = Factory(:entry))
+
+    @empty = Factory(:blog)
+  end
+
+  it do
+    Blog.first.should have(1).entries
+  end
+
+  it do
+    Blog.all.should == [@blog, @empty]
+  end
+
+  it ".has_entries" do
+    Blog.has_entries.should == [@blog]
+  end
+
+  describe "specify children numbers" do
+    before do
+      @three_children = Factory(:blog)
+      @three_children.entries = (0..2).map{ Factory(:entry) }
+    end
+
+    it ".has_entries(3)" do
+      Blog.has_entries(3).should == [@three_children]
+    end
+
+    it ".has_entries(4) should be_empty" do
+      Blog.has_entries(4).should be_empty
+    end
+  end
+
+  describe "Group / has_many :through children" do
+    before(:all) do
+      Group.class_eval do
+        scope_do :has_children
+        has_children :users
+      end
+    end
+    before do
+      @group = Group.first
+      @group.users = [Factory(:user)]
+      @another_group = Factory(:group)
+    end
+
+    it ".has_users" do
+      Group.has_users.should == [@group]
+    end
+
+    describe "specify n" do
+      before do
+        @group.users << Factory(:user, :name =>"bob")
+      end
+
+      it ".has_users(2).should == [@group]" do
+        Group.has_users(2).should == [@group]
+      end
+
+      it ".has_users(5).should be_empty" do
+        Group.has_users(5).should be_empty
+      end
+    end
+  end
+end
+

data/spec/scope_do/named_acl/builder_spec.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+# vim:set fileencoding=utf-8 filetype=ruby
+# $KCODE = 'u'
+
+require File.expand_path("../../spec_helper", File.dirname(__FILE__))
+require 'scope_do/named_acl/builder'
+
+describe ScopeDo::NamedAcl::Builder do
+  before do
+    @builder = ScopeDo::NamedAcl::Builder.new(User, :blogs, :via => :groups)
+  end
+
+  it do
+    @builder.should_not be_nil
+  end
+
+  it "#from" do
+    @builder.from.should == Accessibility.quoted_table_name
+  end
+
+  it "#join_on_group_id" do
+    @builder.join_on_group_id.should == "#{Membership.quoted_table_name} ON #{Membership.quoted_table_name}.group_id = #{Accessibility.quoted_table_name}.group_id"
+  end
+end
+

data/spec/scope_do/named_acl_spec.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+# vim:set fileencoding=utf-8 filetype=ruby
+# $KCODE = 'u'
+
+require File.expand_path("../spec_helper", File.dirname(__FILE__))
+require 'scope_do/named_acl'
+
+describe ScopeDo::NamedAcl do
+  before(:all) do
+    ::Blog.class_eval do
+      named_scope :free, :conditions => ["public = ?", true]
+    end
+    ::User.class_eval do
+      scope_do :named_acl
+      named_acl :blogs
+    end
+
+    [Blog, User].each(&:delete_all)
+    u = Factory(:user)
+    b = Factory(:blog)
+    b.accessibilities.map(&:group).first.users << u
+  end
+
+  before do
+    @alice = User.find_by_name("alice")
+    @bob   = Factory(:user, :name => "bob")
+    @blog  = Blog.find(:first)
+  end
+
+  it do
+    Blog.should be_respond_to(:accessed_by)
+  end
+
+  it "alice.accessible_blogs should include @blog" do
+    @alice.accessible_blogs.should include(@blog)
+  end
+
+  it "alice should be accessible @blog" do
+    @alice.should be_accessible(@blog)
+  end
+
+  it "bob.accessible_blogs should not include @blog" do
+    @bob.accessible_blogs.should_not include(@blog)
+  end
+
+  it "bob.free_or_accessible_blogs should not include @blog" do
+    @bob.free_or_accessible_blogs.should include(@blog)
+  end
+
+  it "bob should not be accessible @blog" do
+    @bob.should_not be_accessible(@blog)
+  end
+end
+

data/spec/setup_test_model.rb

@@ -0,0 +1,89 @@
+require 'rubygems'
+require 'active_record'
+require 'active_record/fixtures'
+require 'factory_girl'
+
+require File.expand_path("record_extention_test_util", File.dirname(__FILE__))
+RecrodExtention::TestUtil.setup
+
+class User < ActiveRecord::Base
+  define_table do |t|
+    t.string "name"
+    t.timestamps
+  end
+  has_many :memberships
+  has_many :groups, :through => :memberships
+end
+
+class Membership < ActiveRecord::Base
+  define_table do |t|
+    t.belongs_to :user
+    t.belongs_to :group
+  end
+  belongs_to :user
+  belongs_to :group
+end
+
+class Group < ActiveRecord::Base
+  define_table do |t|
+    t.string :name
+  end
+  has_many :memberships
+  has_many :users, :through => :memberships
+
+  has_many :accessibilities
+  has_many :blogs, :through => :accessibilities
+end
+
+class Accessibility < ActiveRecord::Base
+  define_table do |t|
+    t.belongs_to :blog
+    t.belongs_to :group
+  end
+  belongs_to :blog
+  belongs_to :group
+end
+
+class Blog < ActiveRecord::Base
+  define_table do |t|
+    t.string   "title"
+    t.boolean  "public"
+    t.timestamps
+  end
+  has_many :accessibilities
+  has_many :entries
+end
+
+class Entry < ActiveRecord::Base
+  define_table do |t|
+    t.string "title"
+    t.text   "body"
+    t.belongs_to "blog"
+  end
+
+  belongs_to :blog
+end
+
+Factory.define(:group) do |g|
+  g.name "collaborators"
+end
+
+Factory.define(:accessibility) do |a|
+  a.group{|g| g.association(:group) }
+end
+
+Factory.define(:blog) do |b|
+  b.title "My Blog"
+  b.public true
+  b.accessibilities{|as| [Factory.build(:accessibility)] }
+end
+
+Factory.define(:user) do |u|
+  u.name "alice"
+end
+
+Factory.define(:entry) do |e|
+  e.title "My Entry"
+  e.body  "!!! Body of the entry. !!!"
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+# ---- requirements
+$KCODE = 'u' #activate regex unicode
+require 'rubygems'
+require 'spec'
+$LOAD_PATH << File.expand_path("..", File.dirname(__FILE__))
+$LOAD_PATH << File.expand_path("../lib", File.dirname(__FILE__))
+
+# ---- bugfix
+#`exit?': undefined method `run?' for Test::Unit:Module (NoMethodError)
+#can be solved with require test/unit but this will result in extra test-output
+unless defined? Test::Unit
+  module Test
+    module Unit
+      def self.run?
+        true
+      end
+    end
+  end
+end
+
+# ---- load active record
+#gem 'activerecord', '2.0.2'
+if ENV["AR"]
+  gem 'activerecord', ENV["AR"]
+  $stderr.puts("Using ActiveRecord #{ENV["AR"]}")
+end
+require 'active_record'
+require "rails/init"
+
+load File.expand_path("setup_test_model.rb", File.dirname(__FILE__))
+
+# ---- fixtures
+Spec::Example::ExampleGroupMethods.module_eval do
+  def fixtures(*tables)
+    dir = File.expand_path("fixtures", File.dirname(__FILE__))
+    tables.each{|table| Fixtures.create_fixtures(dir, table.to_s) }
+  end
+end
+

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: moro-scope_do
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- MOROHASHI Kyosuke
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-18 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: named_scope utilities.
+email: moronatural@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- ChangeLog
+files: 
+- README.rdoc
+- ChangeLog
+- Rakefile
+- lib/scope_do
+- lib/scope_do/chained_scope.rb
+- lib/scope_do/has_children.rb
+- lib/scope_do/named_acl
+- lib/scope_do/named_acl/builder.rb
+- lib/scope_do/named_acl.rb
+- lib/scope_do.rb
+- spec/record_extention_test_util.rb
+- spec/scope_do/chained_scope_spec.rb
+- spec/scope_do/has_children_spec.rb
+- spec/scope_do/named_acl/builder_spec.rb
+- spec/scope_do/named_acl_spec.rb
+- spec/setup_test_model.rb
+- spec/spec_helper.rb
+- rails/init.rb
+has_rdoc: true
+homepage: http://github.com/moro/scope_do/tree/master
+post_install_message: 
+rdoc_options: 
+- --title
+- scope_do documentation
+- --charset
+- utf-8
+- --opname
+- index.html
+- --line-numbers
+- --main
+- README.rdoc
+- --inline-source
+- --exclude
+- ^(examples|extras)/
+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: named_scope utilities.
+test_files: 
+- spec/scope_do/chained_scope_spec.rb
+- spec/scope_do/has_children_spec.rb
+- spec/scope_do/named_acl/builder_spec.rb
+- spec/scope_do/named_acl_spec.rb