dsl_accessor 0.3.3 → 0.4.0

data/{LICENSE → MIT-LICENSE}

@@ -1,4 +1,4 @@
-Copyright (c) 2008 [maiha@wota.jp]
+Copyright (c) 2010 [maiha@wota.jp]
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/Rakefile

@@ -1,30 +1,3 @@
-require 'rake'
-require 'rake/testtask'
-require 'rake/rdoctask'
-
-desc 'Default: run unit tests.'
-task :default => :test
-
-desc 'Test the dsl_accessor plugin.'
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = true
-end
-
-desc 'Generate documentation for the dsl_accessor plugin.'
-Rake::RDocTask.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'DslAccessor'
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include('README')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
-
-######################################################################
-### for gem
-
 require 'rubygems'
 require 'rake/gempackagetask'
 
@@ -33,22 +6,24 @@ AUTHOR = "maiha"
 EMAIL = "maiha@wota.jp"
 HOMEPAGE = "http://github.com/maiha/dsl_accessor"
 SUMMARY = "This plugin gives hybrid accessor class methods to classes by DSL like definition"
-GEM_VERSION = "0.3.3"
+GEM_VERSION = "0.4.0"
 
 spec = Gem::Specification.new do |s|
-#  s.rubyforge_project = 'merb'
-  s.name             = GEM_NAME
-  s.version          = GEM_VERSION
-  s.platform         = Gem::Platform::RUBY
-  s.has_rdoc         = true
-  s.extra_rdoc_files = ["README", "LICENSE"]
-  s.summary          = SUMMARY
-  s.description      = s.summary
-  s.author           = AUTHOR
-  s.email            = EMAIL
-  s.homepage         = HOMEPAGE
-  s.require_path     = 'lib'
-  s.files            = %w(LICENSE README Rakefile) + Dir.glob("{core_ext,lib,spec,tasks,test}/**/*")
+  s.rubyforge_project = 'asakusarb'
+  s.executables = []
+  s.name = GEM_NAME
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README", "MIT-LICENSE"]
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  s.require_path = 'lib'
+  s.add_dependency('optionize', '>= 0.1.0')
+  s.files = %w(MIT-LICENSE README Rakefile) + Dir.glob("{lib,spec,core_ext}/**/*")
 end
 
 Rake::GemPackageTask.new(spec) do |pkg|
@@ -72,3 +47,6 @@ task :gemspec do
   end
 end
 
+require 'spec/rake/spectask'
+desc 'Default: run spec examples'
+task :default => 'spec'

data/lib/dsl_accessor.rb

@@ -1,11 +1,17 @@
-unless Class.new.respond_to?(:write_inheritable_attribute)
-  require File.dirname(__FILE__) + "/../core_ext/duplicable" unless Object.new.respond_to?(:duplicable?)
-  require File.dirname(__FILE__) + "/../core_ext/class/inheritable_attributes"
-end
-
 unless Module.new.respond_to?(:delegate)
   require File.dirname(__FILE__) + "/../core_ext/module/delegation"
 end
 
-require File.dirname(__FILE__) + '/../core_ext/class/dsl_accessor'
+require File.dirname(__FILE__) + '/dsl_accessor/accessor'
+require File.dirname(__FILE__) + '/dsl_accessor/stores'
+
+class Module
+  include DslAccessor
+  include DslAccessor::Stores::Basic
+end
+
+class Class
+  include DslAccessor
+  include DslAccessor::Stores::Inherit
+end
 

data/lib/dsl_accessor/accessor.rb

@@ -0,0 +1,93 @@
+require 'optionize'
+
+module DslAccessor
+  def dsl_accessor_reader(key, *args)
+    key = key.to_s
+    if args.empty?
+      # getter method
+      if !dsl_accessor_key?(key)
+        default = dsl_accessor_get("#{key}_default")
+        value   = default ? default.call : nil
+        dsl_accessor_writer(key, value)
+      end
+      dsl_accessor_get(key)
+    else
+      # setter method
+      dsl_accessor_writer(key, *args)
+    end
+  end
+
+  def dsl_accessor_writer(key, *args)
+    case args.size
+    when 1
+      writer = dsl_accessor_get("#{key}_writer")
+      value  = writer ? writer.call(*args) : args.first
+      dsl_accessor_set("#{key}", value)
+    else
+      raise ArgumentError, "'#{key}=' expected one argument, but got #{args.size} args"
+    end
+  end
+
+  def dsl_accessor(*args, &block)
+    opts = Optionize.new(args, :name, :default)
+    name = opts.name
+
+    if !name and !block
+      raise "dsl_accessor expects at least one arg"
+    end
+
+    writer =
+      case opts.writer
+      when NilClass then Proc.new{|value| value}
+      when Symbol   then Proc.new{|value| __send__(opts.writer, value)}
+      when Proc     then opts.writer
+      else raise TypeError, "DSL Error: writer should be a symbol or proc. but got `#{opts.writer.class}'"
+      end
+    dsl_accessor_set("#{name}_writer", writer)
+
+    default =
+      case opts.default
+      when NilClass then nil
+      when []       then Proc.new{[]}
+      when {}       then Proc.new{{}}
+      when Symbol   then Proc.new{__send__(opts.default)}
+      when Proc     then opts.default
+      else Proc.new{opts.default}
+      end
+    dsl_accessor_set("#{name}_default", default)
+
+    meta_class = (class << self; self; end)
+
+    if opts.instance and !is_a?(Class)
+      raise ArgumentError, ":instance option is implemented in only Class"
+    end
+
+    case opts.instance
+    when nil
+      # nop
+    when true
+      delegate name, :to=>"self.class"
+    when Symbol
+      module_eval(<<-EOS, "(__DSL_ACCESSOR__)", 1)
+        def #{ name }
+          @#{opts.instance} or
+            raise TypeError, "DSL Error: missing @#{opts.instance} for %s##{name}" % self.class.name
+          @#{opts.instance}.respond_to?(:[]) or
+            raise TypeError, "DSL Error: expected @#{opts.instance}[] is implemented (%s##{name})" % self.class.name
+          @#{opts.instance}[:#{ name }] || self.class.#{ name }
+        end
+      EOS
+    else
+      raise TypeError, "DSL Error: :instance should be true or Symbol, but got `%s' class" % opts.instance.class
+    end
+
+    instance_eval <<-EOS
+      def #{name}(*args)
+        dsl_accessor_reader("#{name}", *args)
+      end
+      def #{name}=(*args)
+        dsl_accessor_writer("#{name}", *args)
+      end
+    EOS
+  end
+end

data/lib/dsl_accessor/stores.rb

@@ -0,0 +1,60 @@
+module DslAccessor
+  module Stores
+    module Basic
+      # testing
+      def dsl_accessor_attributes
+        @dsl_accessor_attributes ||= {}
+      end
+
+      def dsl_accessor_key?(key)
+        dsl_accessor_attributes.has_key?(key)
+      end
+
+      def dsl_accessor_get(key)
+        dsl_accessor_attributes[key]
+      end
+
+      def dsl_accessor_set(key, val)
+        dsl_accessor_attributes[key] = val
+      end
+    end
+
+    module Inherit
+      # testing
+      def dsl_accessor_attributes
+        @dsl_accessor_attributes ||= {}
+      end
+
+      def dsl_accessor_key?(key)
+        dsl_accessor_attributes.has_key?(key)
+      end
+
+      def dsl_accessor_get(key)
+        if dsl_accessor_key?(key)
+          dsl_accessor_attributes[key]
+        else
+          superclass ? superclass.dsl_accessor_get(key) : nil
+        end
+      end
+
+      def dsl_accessor_set(key, val)
+        dsl_accessor_attributes[key] = val
+      end
+    end
+
+    module InheritableAttributes
+      # testing
+      def dsl_accessor_key?(key)
+        inheritable_attributes.has_key?(key)
+      end
+
+      def dsl_accessor_get(key)
+        read_inheritable_attribute(key)
+      end
+
+      def dsl_accessor_set(key, val)
+        write_inheritable_attribute(key, val)
+      end
+    end
+  end
+end

data/spec/accessor_spec.rb

@@ -0,0 +1,58 @@
+require File.join( File.dirname(__FILE__), "spec_helper" )
+
+describe DslAccessor do
+  it "class should provide 'dsl_accessor'" do
+    Class.new.should respond_to(:dsl_accessor)
+  end
+end
+
+
+describe "dsl_accessor(:foo)" do
+  before do
+    @klass = new_class { dsl_accessor :foo }
+  end
+
+  it "should provide 'foo' method" do
+    @klass.should respond_to(:foo)
+  end
+
+  it "should accept nil for default value" do
+    @klass.foo.should == nil
+  end
+
+  it "should provide 'foo=' method" do
+    @klass.should respond_to(:foo=)
+  end
+
+  it "#foo= should raise ArgumentError" do
+    lambda { @klass.send(:foo=) }.should raise_error(ArgumentError)
+  end
+
+  it "#foo=(1) should not raise ArgumentError" do
+    lambda { @klass.foo = 1 }.should_not raise_error(ArgumentError)
+  end
+
+  it "#foo=(1) should set :foo to 1" do
+    @klass.foo = 1
+    @klass.foo.should == 1
+  end
+
+  it "#foo=(1, 2) should raise ArgumentError" do
+    lambda { @klass.send(:foo=,1,2) }.should raise_error(ArgumentError)
+  end
+end
+
+
+describe "dsl_accessor(:foo, 1)" do
+  before do
+    @klass = new_class { dsl_accessor :foo, 1 }
+  end
+
+  it "should provide 'foo' method" do
+    @klass.should respond_to(:foo)
+  end
+
+  it "should accept 1 for default value" do
+    @klass.foo.should == 1
+  end
+end

data/spec/default_spec.rb

@@ -0,0 +1,39 @@
+require File.join( File.dirname(__FILE__), "spec_helper" )
+
+describe DslAccessor do
+  it "should duplicate blank array automatically" do
+    k1 = Class.new
+
+    array = []
+    k1.dsl_accessor :foo, array
+
+    k1.foo.should == array
+    k1.foo.should_not equal(array)
+  end
+
+  it "should duplicate blank hash automatically" do
+    k1 = Class.new
+
+    hash = {}
+    k1.dsl_accessor :foo, :default=>hash
+
+    k1.foo.should == hash
+    k1.foo.should_not equal(hash)
+  end
+
+  it "should call the method when symbol given" do
+    k1 = Class.new
+    def k1.construct
+      1
+    end
+    k1.dsl_accessor :foo, :default=>:construct
+
+    k1.foo.should == 1
+  end
+
+  it "should call it when proc given" do
+    k1 = Class.new
+    k1.dsl_accessor :foo, :default=>proc{1}
+    k1.foo.should == 1
+  end
+end

data/spec/inherit_spec.rb

@@ -1,21 +1,48 @@
 require File.join( File.dirname(__FILE__), "spec_helper" )
 
 describe DslAccessor do
-  module Exts
-    class All
-    end
+  #        | foo | bar | baz | qux | quux |
+  # Bottom |  *  |  *  |  o  |  o  |      |
+  # Middle |     |  o  |     |  +  |   o  |
+  # Top    |  +  |     |  +  |  o  |   o  |
+  #
+  # *) dsl_accessor :foo
+  # o) dsl_accessor :foo, 'val'
+  # +) foo 'val'
 
-    class Base < All
-    end
+  class Bottom
+    dsl_accessor :foo
+    dsl_accessor :bar
+    dsl_accessor :baz, 'baz1'
+    dsl_accessor :qux, 'qux1'
   end
 
-  module Exts
-    class All
-      dsl_accessor :ext, "*"
-    end
+  class Middle < Bottom
+    dsl_accessor :bar, 'bar2'
+    qux 'qux2'
+    dsl_accessor :quux, 'quux2'
+  end
+
+  class Top < Middle
+    foo 'foo3'
+    baz 'baz3'
+    dsl_accessor :qux , 'qux3'
+    dsl_accessor :quux, 'quux3'
+  end
+
+  it "should define accessor methods" do
+    Bottom.foo.should == nil
+    Bottom.bar.should == nil
+    Bottom.baz.should == 'baz1'
+    Bottom.qux.should == 'qux1'
+    lambda { Bottom.quux }.should raise_error(NameError)
   end
 
   it "should inherit value" do
-    Exts::Base.ext.should == "*"
+    Middle.foo.should == nil
+    Middle.bar.should == 'bar2'
+    Middle.baz.should == 'baz1'
+    Middle.qux.should == 'qux2'
+    Middle.quux.should == 'quux2'
   end
 end

data/spec/instance_spec.rb

@@ -0,0 +1,51 @@
+require File.join( File.dirname(__FILE__), "spec_helper" )
+
+describe "dsl_accessor(:foo, :instance=>true)" do
+  before do
+    klass = Class.new
+    klass.dsl_accessor :foo, :instance=>true
+    @klass = klass
+  end
+
+  it "should provide instance method 'foo'" do
+    @klass.new.should respond_to(:foo)
+  end
+
+  it "should delegate instance method to class method about reader" do
+    @klass.foo 1
+    @klass.new.foo.should == 1
+  end
+end
+
+describe "dsl_accessor(:foo, :instance=>:opts)" do
+  before do
+    klass = Class.new
+    klass.dsl_accessor :foo, :instance=>:opts
+    @klass = klass
+    @obj = @klass.new
+  end
+
+  it "should raise error when @opts is not set" do
+    lambda {
+      @obj.foo
+    }.should raise_error(/missing @opts/)
+  end
+
+  it "should raise error when @opts is present but not responds to []" do
+    @obj.instance_eval "@opts = true"
+    lambda {
+      @obj.foo
+    }.should raise_error(/expected @opts\[\]/)
+  end
+
+  it "should read value from @opts first" do
+    @obj.instance_eval "@opts = {:foo=>2}"
+    @obj.foo.should == 2
+  end
+
+  it "should read value from class when @opts value is blank" do
+    @klass.foo 1
+    @obj.instance_eval "@opts = {}"
+    @obj.foo.should == 1
+  end
+end

data/spec/module_spec.rb

@@ -0,0 +1,22 @@
+require File.join( File.dirname(__FILE__), "spec_helper" )
+
+describe Module do
+  it "should provide 'dsl_accessor'" do
+    Module.new.should respond_to(:dsl_accessor)
+  end
+
+  describe "#dsl_accessor(:foo, 1)" do
+    subject { 
+      mod = Module.new
+      mod.dsl_accessor :foo, 1
+      mod
+    }
+    # default value
+    its(:foo) { should == 1}
+
+    it "foo(2) should update value to 2" do
+      subject.foo 2
+      subject.foo.should == 2
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,5 +1,11 @@
 require "rubygems"
 require "spec"
 
-require File.dirname(__FILE__) + "/../init"
+require File.dirname(__FILE__) + "/../lib/dsl_accessor"
 
+######################################################################
+### Helper methods
+
+def new_class(&block)
+  Class.new(&block)
+end

data/spec/writer_spec.rb

@@ -0,0 +1,35 @@
+require File.join( File.dirname(__FILE__), "spec_helper" )
+
+describe DslAccessor do
+  it "should call writer" do
+    klass = new_class
+
+    klass.dsl_accessor :key, "bar", :writer=>proc{|value| "[#{value}]"}
+    klass.key.should == "[bar]"
+
+    klass.key 'foo'
+    klass.key.should == "[foo]"
+  end
+
+  it "should call writer even if no default values given" do
+    klass = new_class
+
+    klass.dsl_accessor :key, :writer=>proc{|value| "[#{value}]"}
+    klass.key.should == "[]"
+
+    klass.key 'foo'
+    klass.key.should == "[foo]"
+  end
+
+  it "should call the method when symbol given" do
+    klass = new_class
+
+    klass.dsl_accessor :key, :default=>"foo", :writer=>:labelize
+    def klass.labelize(val)
+      "[#{val}]"
+    end
+
+    klass.key.should == "[foo]"
+  end
+
+end

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: dsl_accessor
 version: !ruby/object:Gem::Version 
-  version: 0.3.3
+  prerelease: false
+  segments: 
+  - 0
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - maiha
@@ -9,10 +14,23 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-19 00:00:00 +09:00
+date: 2010-03-23 00:00:00 +09:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: optionize
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        - 0
+        version: 0.1.0
+  type: :runtime
+  version_requirements: *id001
 description: This plugin gives hybrid accessor class methods to classes by DSL like definition
 email: maiha@wota.jp
 executables: []
@@ -21,26 +39,22 @@ extensions: []
 
 extra_rdoc_files: 
 - README
-- LICENSE
+- MIT-LICENSE
 files: 
-- LICENSE
+- MIT-LICENSE
 - README
 - Rakefile
-- core_ext/duplicable.rb
-- core_ext/module/delegation.rb
-- core_ext/class/dsl_accessor.rb
-- core_ext/class/inheritable_attributes.rb
+- lib/dsl_accessor/stores.rb
+- lib/dsl_accessor/accessor.rb
 - lib/dsl_accessor.rb
+- spec/accessor_spec.rb
+- spec/writer_spec.rb
 - spec/inherit_spec.rb
-- spec/auto_declared_spec.rb
+- spec/module_spec.rb
+- spec/instance_spec.rb
+- spec/default_spec.rb
 - spec/spec_helper.rb
-- tasks/dsl_accessor_tasks.rake
-- test/instance_test.rb
-- test/default_test.rb
-- test/writer_test.rb
-- test/test_helper.rb
-- test/dsl_accessor_test.rb
-- test/instance_options_test.rb
+- core_ext/module/delegation.rb
 has_rdoc: true
 homepage: http://github.com/maiha/dsl_accessor
 licenses: []
@@ -54,18 +68,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
-rubyforge_project: 
-rubygems_version: 1.3.5
+rubyforge_project: asakusarb
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: This plugin gives hybrid accessor class methods to classes by DSL like definition

data/core_ext/class/dsl_accessor.rb

@@ -1,93 +0,0 @@
-module DslAccessor
-  def dsl_accessor(*args)
-    options = args.last.is_a?(Hash) ? args.pop : {}
-
-    # mark auto_declared
-    name = args.shift or
-      return @dsl_accessor_auto_declared = true
-
-    options[:default] = args.shift unless args.empty?
-
-    case options[:instance]
-    when nil
-      # nop
-    when :options
-      module_eval(<<-EOS, "(__DSL_ACCESSOR__)", 1)
-        def #{ name }
-          unless @options
-            raise TypeError, "DSL Error: missing @options for %s##{name}" % self.class.name
-          end
-          @options[:#{ name }] || self.class.#{ name }
-        end
-      EOS
-    when true
-      delegate name, :to=>"self.class"
-    else
-      raise TypeError, "DSL Error: :instance should be true or :instance, but got `%s' class" % options[:instance].class
-    end
-
-    raise TypeError, "DSL Error: options should be a hash. but got `#{options.class}'" unless options.is_a?(Hash)
-    writer = options[:writer] || options[:setter]
-    writer =
-      case writer
-      when NilClass then Proc.new{|value| value}
-      when Symbol   then Proc.new{|value| __send__(writer, value)}
-      when Proc     then writer
-      else raise TypeError, "DSL Error: writer should be a symbol or proc. but got `#{options[:writer].class}'"
-      end
-    write_inheritable_attribute(:"#{name}_writer", writer)
-
-    default =
-      case options[:default]
-      when NilClass then nil
-      when []       then Proc.new{[]}
-      when {}       then Proc.new{{}}
-      when Symbol   then Proc.new{__send__(options[:default])}
-      when Proc     then options[:default]
-      else Proc.new{options[:default]}
-      end
-    write_inheritable_attribute(:"#{name}_default", default)
-
-    (class << self; self end).class_eval do
-      define_method("#{name}=") do |value|
-        writer = read_inheritable_attribute(:"#{name}_writer")
-        value  = writer.call(value) if writer
-        write_inheritable_attribute(:"#{name}", value)
-      end
-
-      define_method(name) do |*values|
-        if values.empty?
-          # getter method
-          key = :"#{name}"
-          if !inheritable_attributes.has_key?(key)
-            default = read_inheritable_attribute(:"#{name}_default")
-            value   = default ? default.call(self) : nil
-            __send__("#{name}=", value)
-          end
-          read_inheritable_attribute(key)
-        else
-          # setter method
-          __send__("#{name}=", *values)
-        end
-      end
-    end
-  end
-
-  private
-    def dsl_accessor_auto_declared?
-      !!@dsl_accessor_auto_declared
-    end
-
-    def method_missing(*args, &block)
-      if dsl_accessor_auto_declared? and args.size == 1 and block
-        define_method(*args, &block)
-      else
-        super
-      end
-    end
-
-end
-
-class Class
-  include DslAccessor
-end

data/core_ext/class/inheritable_attributes.rb

@@ -1,140 +0,0 @@
-# Retain for backward compatibility.  Methods are now included in Class.
-module ClassInheritableAttributes # :nodoc:
-end
-
-# Allows attributes to be shared within an inheritance hierarchy, but where each descendant gets a copy of
-# their parents' attributes, instead of just a pointer to the same. This means that the child can add elements
-# to, for example, an array without those additions being shared with either their parent, siblings, or
-# children, which is unlike the regular class-level attributes that are shared across the entire hierarchy.
-class Class # :nodoc:
-  def class_inheritable_reader(*syms)
-    syms.each do |sym|
-      next if sym.is_a?(Hash)
-      class_eval <<-EOS
-        def self.#{sym}
-          read_inheritable_attribute(:#{sym})
-        end
-
-        def #{sym}
-          self.class.#{sym}
-        end
-      EOS
-    end
-  end
-
-  def class_inheritable_writer(*syms)
-    options = syms.last.is_a?(::Hash) ? syms.pop : {}
-    syms.each do |sym|
-      class_eval <<-EOS
-        def self.#{sym}=(obj)
-          write_inheritable_attribute(:#{sym}, obj)
-        end
-
-        #{"
-        def #{sym}=(obj)
-          self.class.#{sym} = obj
-        end
-        " unless options[:instance_writer] == false }
-      EOS
-    end
-  end
-
-  def class_inheritable_array_writer(*syms)
-    options = syms.last.is_a?(::Hash) ? syms.pop : {}
-    syms.each do |sym|
-      class_eval <<-EOS
-        def self.#{sym}=(obj)
-          write_inheritable_array(:#{sym}, obj)
-        end
-
-        #{"
-        def #{sym}=(obj)
-          self.class.#{sym} = obj
-        end
-        " unless options[:instance_writer] == false }
-      EOS
-    end
-  end
-
-  def class_inheritable_hash_writer(*syms)
-    options = syms.last.is_a?(::Hash) ? syms.pop : {}
-    syms.each do |sym|
-      class_eval <<-EOS
-        def self.#{sym}=(obj)
-          write_inheritable_hash(:#{sym}, obj)
-        end
-
-        #{"
-        def #{sym}=(obj)
-          self.class.#{sym} = obj
-        end
-        " unless options[:instance_writer] == false }
-      EOS
-    end
-  end
-
-  def class_inheritable_accessor(*syms)
-    class_inheritable_reader(*syms)
-    class_inheritable_writer(*syms)
-  end
-
-  def class_inheritable_array(*syms)
-    class_inheritable_reader(*syms)
-    class_inheritable_array_writer(*syms)
-  end
-
-  def class_inheritable_hash(*syms)
-    class_inheritable_reader(*syms)
-    class_inheritable_hash_writer(*syms)
-  end
-
-  def inheritable_attributes
-    @inheritable_attributes ||= EMPTY_INHERITABLE_ATTRIBUTES
-  end
-
-  def write_inheritable_attribute(key, value)
-    if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
-      @inheritable_attributes = {}
-    end
-    inheritable_attributes[key] = value
-  end
-
-  def write_inheritable_array(key, elements)
-    write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil?
-    write_inheritable_attribute(key, read_inheritable_attribute(key) + elements)
-  end
-
-  def write_inheritable_hash(key, hash)
-    write_inheritable_attribute(key, {}) if read_inheritable_attribute(key).nil?
-    write_inheritable_attribute(key, read_inheritable_attribute(key).merge(hash))
-  end
-
-  def read_inheritable_attribute(key)
-    inheritable_attributes[key]
-  end
-
-  def reset_inheritable_attributes
-    @inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
-  end
-
-  private
-    # Prevent this constant from being created multiple times
-    EMPTY_INHERITABLE_ATTRIBUTES = {}.freeze unless const_defined?(:EMPTY_INHERITABLE_ATTRIBUTES)
-
-    def inherited_with_inheritable_attributes(child)
-      inherited_without_inheritable_attributes(child) if respond_to?(:inherited_without_inheritable_attributes)
-
-      if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
-        new_inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
-      else
-        new_inheritable_attributes = inheritable_attributes.inject({}) do |memo, (key, value)|
-          memo.update(key => value.duplicable? ? value.dup : value)
-        end
-      end
-
-      child.instance_variable_set('@inheritable_attributes', new_inheritable_attributes)
-    end
-
-    alias inherited_without_inheritable_attributes inherited
-    alias inherited inherited_with_inheritable_attributes
-end

data/core_ext/duplicable.rb

@@ -1,43 +0,0 @@
-class Object
-  # Can you safely .dup this object?
-  # False for nil, false, true, symbols, and numbers; true otherwise.
-  def duplicable?
-    true
-  end
-end
-
-class NilClass #:nodoc:
-  def duplicable?
-    false
-  end
-end
-
-class FalseClass #:nodoc:
-  def duplicable?
-    false
-  end
-end
-
-class TrueClass #:nodoc:
-  def duplicable?
-    false
-  end
-end
-
-class Symbol #:nodoc:
-  def duplicable?
-    false
-  end
-end
-
-class Numeric #:nodoc:
-  def duplicable?
-    false
-  end
-end
-
-class Class #:nodoc:
-  def duplicable?
-    false
-  end
-end

data/spec/auto_declared_spec.rb

@@ -1,106 +0,0 @@
-require File.join( File.dirname(__FILE__), "spec_helper" )
-
-describe DslAccessor do
-  before(:each) do
-    Object.send(:remove_const, :Foo) if Object.const_defined?(:Foo)
-    class Foo
-    end
-  end
-
-  def foo_should_not_be_defined
-    Foo    .should_not respond_to(:foo)
-    Foo.new.should_not respond_to(:foo)
-  end
-
-  it "should provide .dsl_accessor_auto_declared as private method" do
-    Class.private_methods.should include("dsl_accessor_auto_declared?")
-  end
-
-  it "should provide .dsl_accessor" do
-    Class.should respond_to(:dsl_accessor)
-  end
-
-  describe " should raise NoMethodError when we call a method " do
-    it "without arugments" do
-      foo_should_not_be_defined
-      lambda { Foo.foo }.should raise_error(NoMethodError)
-      foo_should_not_be_defined
-    end
-    it "with arguments" do
-      foo_should_not_be_defined
-      lambda { Foo.foo(1) }.should raise_error(NoMethodError)
-      lambda { Foo.foo(1, 2) }.should raise_error(NoMethodError)
-      foo_should_not_be_defined
-    end
-    it "with block" do
-      foo_should_not_be_defined
-      lambda { Foo.foo{} }.should raise_error(NoMethodError)
-      foo_should_not_be_defined
-    end
-    it "with arguments and block" do
-      foo_should_not_be_defined
-      lambda { Foo.foo(1){} }.should raise_error(NoMethodError)
-      foo_should_not_be_defined
-    end
-  end
-
-  describe ".dsl_accessor without arguments" do
-    it "should be accepted" do
-      lambda {
-        Foo.dsl_accessor
-      }.should_not raise_error
-    end
-
-    it "should mark auto_declared" do
-      Foo.send(:dsl_accessor_auto_declared?).should be_false
-      Foo.dsl_accessor
-      Foo.send(:dsl_accessor_auto_declared?).should be_true
-    end
-  end
-
-  describe "auto_declared" do
-    before(:each) do
-      class Foo
-        dsl_accessor
-      end
-    end
-
-    it "should raise NoMethodError if unknown method with args is called" do
-      lambda {
-        Foo.foo(1)
-      }.should raise_error(NoMethodError)
-    end
-
-    it "should raise NoMethodError when unknown method is called with args and block" do
-      lambda {
-        Foo.foo(1){}
-      }.should raise_error(NoMethodError)
-    end
-
-    describe " when unknown method is called with a block" do
-      it "should trap NoMethodError" do
-        lambda {
-          Foo.foo{}
-        }.should_not raise_error(NoMethodError)
-      end
-
-      it "should define its instance method automatically" do
-        foo_should_not_be_defined
-        Foo.foo{1}
-        Foo.new.should respond_to(:foo)
-        Foo.new.foo.should == 1
-      end
-    end
-
-    it "should affect nothing to subclasses" do
-      class Bar < Foo
-      end
-
-      lambda { Bar.bar       }.should raise_error(NoMethodError)
-      lambda { Bar.bar(1)    }.should raise_error(NoMethodError)
-      lambda { Bar.bar(1, 2) }.should raise_error(NoMethodError)
-      lambda { Bar.bar{}     }.should raise_error(NoMethodError)
-      lambda { Bar.bar(1){}  }.should raise_error(NoMethodError)
-    end
-  end
-end

data/tasks/dsl_accessor_tasks.rake

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

data/test/default_test.rb

@@ -1,64 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-
-class DslDefaultAccessorTest < Test::Unit::TestCase
-
-  class CoolActiveRecord
-    dsl_accessor :primary_key, :default=>"id"
-    dsl_accessor :table_name,  :default=>proc{|klass| klass.name.split(/::/).last.downcase+"s"}
-  end
-
-  class Item < CoolActiveRecord
-  end
-
-  class User < CoolActiveRecord
-  end
-
-  class Folder
-    dsl_accessor :array_folder, :default=>[]
-    dsl_accessor :hash_folder,  :default=>{}
-  end
-
-  class SubFolder < Folder
-  end
-
-  def test_default_accessor_with_string
-    assert_equal "id", Item.primary_key
-    assert_equal "id", User.primary_key
-  end
-
-  def test_default_accessor_with_proc
-    assert_equal "items", Item.table_name
-    assert_equal "users", User.table_name
-  end
-
-  def test_default_accessor_should_duplicate_empty_array_or_hash
-    Folder.array_folder << 1
-    Folder.hash_folder[:name] = "maiha"
-
-    assert_equal([1], Folder.array_folder)
-    assert_equal({:name=>"maiha"}, Folder.hash_folder)
-
-    assert_equal([], SubFolder.array_folder)
-    assert_equal({}, SubFolder.hash_folder)
-  end
-end
-
-
-class DslOverwritenDefaultAccessorTest < Test::Unit::TestCase
-  class CoolActiveRecord
-    dsl_accessor :primary_key, :default=>"id"
-    dsl_accessor :table_name,  :default=>proc{|klass| klass.name+"s"}
-  end
-
-  class Item < CoolActiveRecord
-    primary_key :item_id
-    table_name  :item_table
-  end
-
-  def test_overwrite_default_accessor
-    assert_equal :item_id,    Item.primary_key
-    assert_equal :item_table, Item.table_name
-  end
-end
-

data/test/dsl_accessor_test.rb

@@ -1,47 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-
-class DslAccessorTest < Test::Unit::TestCase
-  class CoolActiveRecord
-    dsl_accessor :primary_key
-    dsl_accessor :table_name
-  end
-
-  class Item < CoolActiveRecord
-  end
-
-  class LegacyItem < CoolActiveRecord
-    primary_key :itcd
-    table_name  :item
-  end
-
-  class OtherClass
-  end
-
-  def test_dsl_accessor_doesnt_affect_other_classes
-    assert !OtherClass.respond_to?(:primary_key)
-  end
-
-  def test_accessor_without_initialization
-    assert_equal nil, Item.primary_key
-    assert_equal nil, Item.table_name
-
-    Item.primary_key :itcd
-    Item.table_name  :item
-
-    assert_equal :itcd, Item.primary_key
-    assert_equal :item, Item.table_name
-  end
-
-  def test_accessor_with_initialization
-    assert_equal :itcd, LegacyItem.primary_key
-    assert_equal :item, LegacyItem.table_name
-
-    LegacyItem.primary_key :item_id
-    LegacyItem.table_name  :item_table
-
-    assert_equal :item_id,    LegacyItem.primary_key
-    assert_equal :item_table, LegacyItem.table_name
-  end
-end
-

data/test/instance_options_test.rb

@@ -1,38 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-class DefineInstanceMethodWithOptionsTest < Test::Unit::TestCase
-  class Window
-    dsl_accessor :width, :default=>640, :instance=>:options
-  end
-
-  class OptionedWindow
-    dsl_accessor :width, :default=>640, :instance=>:options
-    def initialize(options = {})
-      @options = options
-    end
-  end
-
-  def test_class_method
-    assert_equal Window.width, 640
-    assert_equal OptionedWindow.width, 640
-  end
-
-  def test_instance_method
-    assert_raises(TypeError) { Window.new.width }
-    assert_equal OptionedWindow.new.width, 640
-  end
-
-  def test_use_options_variable_rather_than_default_value
-    window = OptionedWindow.new( :width => 320 )
-    assert_equal window.width, 320
-  end
-
-  def test_instance_options_value_doesnt_affect_to_class_method
-    window = OptionedWindow.new( :width => 320 )
-    assert_equal OptionedWindow.width, 640
-  end
-
-end
-
-
-

data/test/instance_test.rb

@@ -1,43 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-class DefineInstanceMethodTest < Test::Unit::TestCase
-  class Item
-    dsl_accessor :primary_key, "code", :instance=>true
-  end
-
-  class OtherClass
-  end
-
-  def test_dsl_accessor_doesnt_affect_other_classes
-    assert !OtherClass.respond_to?(:primary_key)
-  end
-
-  def test_dsl_accessor_doesnt_affect_other_instances
-    assert !OtherClass.new.respond_to?(:primary_key)
-  end
-
-  def test_class_method
-    assert Item.respond_to?(:primary_key)
-    assert_nothing_raised do
-      Item.primary_key
-    end
-  end
-
-  def test_class_method_value
-    assert_equal "code", Item.primary_key
-  end
-
-  def test_instance_method
-    assert Item.new.respond_to?(:primary_key)
-    assert_nothing_raised do
-      Item.new.primary_key
-    end
-  end
-
-  def test_instance_method_value
-    assert_equal "code", Item.new.primary_key
-  end
-end
-
-
-

data/test/test_helper.rb

@@ -1,5 +0,0 @@
-require 'test/unit'
-
-def __DIR__; File.dirname(__FILE__); end
-require File.dirname(__FILE__) + '/../init'
-

data/test/writer_test.rb

@@ -1,21 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-
-class DslWriterAccessorTest < Test::Unit::TestCase
-  class Item
-    dsl_accessor :primary_key, :writer=>proc{|value| value.to_s}
-  end
-
-  def test_string_writer
-    assert_equal "", Item.primary_key
-
-    Item.primary_key :id
-    assert_equal "id", Item.primary_key
-
-    Item.primary_key "id"
-    assert_equal "id", Item.primary_key
-  end
-end
-
-
-