genki-dsl_accessor 0.4.2

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+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
+"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/README

@@ -0,0 +1,209 @@
+DslAccessor
+===========
+
+  This plugin gives hybrid accessor class methods to classes by DSL like definition,
+  here hybrid means getter and setter. The accessor method acts as getter method
+  if no argments given, otherwise it acts as setter one with the arguments.
+
+
+Install
+=======
+
+  gem install dsl_accessor
+
+
+Usage
+=====
+
+    class Foo
+      dsl_accessor "<METHOD NAME>" (, default_value)
+    end
+
+
+Example
+=======
+
+    class Foo
+      dsl_accessor :greeting
+    end
+  
+  This code gives 'greeting' class method to Foo class.
+  
+    Foo.greeting                 # means getter, and the default value is nil.
+    => nil
+  
+    Foo.greeting "I'm Foo."      # means setter with given arguments
+    => "I'm Foo."
+  
+    Foo.greeting
+    => "I'm Foo."
+
+
+Difference
+==========
+
+  I am convinced that you want to propose me to use 'cattr_accessor'.
+  Although the difference is just whether we needs '=' operation or not,
+  it makes a large different on class definition especially subclass.
+  
+    class Foo
+      cattr_accessor :greeting
+    end
+  
+    class Bar < Foo
+      self.greeting = "I am bar."
+    end
+  
+  We must write redundant code represented by "self." to distinguish
+  a local variable and a class method when we use 'cattr_accessor'.
+  This is ugly and boring work.
+  
+    class Foo
+      dsl_accessor :greeting
+    end
+  
+    class Bar < Foo
+      greeting "I am bar."
+    end
+  
+  There are no longer redundant prefix code like "self." and "set_".
+  How about this dsl-like coding with simple declaration?
+
+
+Special Options
+===============
+
+  'dsl_accessor' method can take two options, those are :writer and :default.
+  "writer" option means callback method used when setter is executed.
+  "default" option means default static value or proc that creates some value.
+  
+    class PseudoAR
+      dsl_accessor :primary_key, :default=>"id", :writer=>proc{|value| value.to_s}
+      dsl_accessor :table_name,  :default=>proc{|klass| klass.name.demodulize.underscore.pluralize}
+    end
+  
+    class Item < PseudoAR
+    end
+  
+    class User < PseudoAR
+      primary_key :user_code
+      table_name  :user_table
+    end
+  
+    Item.primary_key  # => "id"
+    Item.table_name   # => "items"
+    User.primary_key  # => "user_code"
+    User.table_name   # => :user_table
+  
+  Note that "User.primary_key" return a String by setter proc.
+
+
+Instance Method
+===============
+
+  "instance" option automatically defines its instance method
+  
+    class Search
+      dsl_accessor :url, :instance=>true, :default=>"http://localhost/"
+    end
+  
+    Search.url       # => "http://localhost/"
+    Search.new.url   # => "http://localhost/"
+  
+  and it uses @options instance variable with special value :options
+  
+    class Window
+      dsl_accessor :width, :default=>640, :instance=>:options
+      def initialize(options = {})
+        @options = options
+      end
+    end
+  
+    Window.width       # => 640
+    Window.new.width   # => 640
+  
+    window = Window.new(:width=>320)
+    window.width       # =>320
+
+
+Auto declared mode
+==================
+
+  It was removed at version 0.4.
+  In 0.4.1 or higher, use dsl_accessor block instead.
+
+
+with block
+==========
+
+  dsl_accessor method accepts block for auto declared mode.
+  In this mode, we can define methods like dsl.
+
+  [NOTE]
+    1. This affects only methods with a block and no other args.
+
+       class Foo
+         dsl_accessor do
+           foo {1}              # Foo.foo is defined
+           bar(a)               # NoMethodError
+           baz(a) {2}           # NoMethodError
+         end
+       end
+
+    2. When :instance is passed with block, it affects instance methods.
+
+       class Foo
+         dsl_accessor :instance do
+           foo {1}              # Foo#foo is defined
+           bar(a)               # NoMethodError (same as class)
+         end
+       end
+
+    3. This will damage on your class cause it easily updates existing methods.
+
+       Foo.name   # => 'Foo'
+       class Foo
+         dsl_accessor do
+           name {1}
+         end
+       end
+       Foo.name   # => 1
+
+
+  Although there is a risk on above, it helps you when many one-lined methods exist.
+  
+    class Foo
+      def last
+        num_pages
+      end
+  
+      def first?
+        page == 1
+      end
+  
+      def offset
+        model.proxy_options[:offset]
+      end
+    end
+  
+  Refactored with dsl_accessor
+
+    class Foo
+      dsl_accessor :instance do
+        last   {num_pages}
+        first? {page == 1}
+        offset {model.proxy_options[:offset]}
+      end
+    end
+
+
+Homepage
+========
+
+ http://github.com/maiha/dsl_accessor
+
+
+Author
+======
+Maiha <maiha@wota.jp>
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/core_ext/module/delegation.rb

@@ -0,0 +1,95 @@
+class Module
+  # Provides a delegate class method to easily expose contained objects' methods
+  # as your own. Pass one or more methods (specified as symbols or strings)
+  # and the name of the target object as the final <tt>:to</tt> option (also a symbol
+  # or string).  At least one method and the <tt>:to</tt> option are required.
+  #
+  # Delegation is particularly useful with Active Record associations:
+  #
+  #   class Greeter < ActiveRecord::Base
+  #     def hello()   "hello"   end
+  #     def goodbye() "goodbye" end
+  #   end
+  #
+  #   class Foo < ActiveRecord::Base
+  #     belongs_to :greeter
+  #     delegate :hello, :to => :greeter
+  #   end
+  #
+  #   Foo.new.hello   # => "hello"
+  #   Foo.new.goodbye # => NoMethodError: undefined method `goodbye' for #<Foo:0x1af30c>
+  #
+  # Multiple delegates to the same target are allowed:
+  #
+  #   class Foo < ActiveRecord::Base
+  #     belongs_to :greeter
+  #     delegate :hello, :goodbye, :to => :greeter
+  #   end
+  #
+  #   Foo.new.goodbye # => "goodbye"
+  #
+  # Methods can be delegated to instance variables, class variables, or constants
+  # by providing them as a symbols:
+  #
+  #   class Foo
+  #     CONSTANT_ARRAY = [0,1,2,3]
+  #     @@class_array  = [4,5,6,7]
+  #     
+  #     def initialize
+  #       @instance_array = [8,9,10,11]
+  #     end
+  #     delegate :sum, :to => :CONSTANT_ARRAY
+  #     delegate :min, :to => :@@class_array
+  #     delegate :max, :to => :@instance_array
+  #   end
+  #
+  #   Foo.new.sum # => 6
+  #   Foo.new.min # => 4
+  #   Foo.new.max # => 11
+  #
+  # Delegates can optionally be prefixed using the <tt>:prefix</tt> option. If the value
+  # is <tt>true</tt>, the delegate methods are prefixed with the name of the object being
+  # delegated to.
+  #
+  #   Person = Struct.new(:name, :address)
+  #
+  #   class Invoice < Struct.new(:client)
+  #     delegate :name, :address, :to => :client, :prefix => true
+  #   end
+  #
+  #   john_doe = Person.new("John Doe", "Vimmersvej 13")
+  #   invoice = Invoice.new(john_doe)
+  #   invoice.client_name    # => "John Doe"
+  #   invoice.client_address # => "Vimmersvej 13"
+  #
+  # It is also possible to supply a custom prefix.
+  #
+  #   class Invoice < Struct.new(:client)
+  #     delegate :name, :address, :to => :client, :prefix => :customer
+  #   end
+  #
+  #   invoice = Invoice.new(john_doe)
+  #   invoice.customer_name    # => "John Doe"
+  #   invoice.customer_address # => "Vimmersvej 13"
+  #
+  def delegate(*methods)
+    options = methods.pop
+    unless options.is_a?(Hash) && to = options[:to]
+      raise ArgumentError, "Delegation needs a target. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, :to => :greeter)."
+    end
+
+    if options[:prefix] == true && options[:to].to_s =~ /^[^a-z_]/
+      raise ArgumentError, "Can only automatically set the delegation prefix when delegating to a method."
+    end
+
+    prefix = options[:prefix] && "#{options[:prefix] == true ? to : options[:prefix]}_"
+
+    methods.each do |method|
+      module_eval(<<-EOS, "(__DELEGATION__)", 1)
+        def #{prefix}#{method}(*args, &block)
+          #{to}.__send__(#{method.inspect}, *args, &block)
+        end
+      EOS
+    end
+  end
+end

data/dsl_accessor.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "dsl_accessor/version"
+
+Gem::Specification.new do |s|
+  s.name        = "genki-dsl_accessor"
+  s.version     = DslAccessor::VERSION
+  s.authors     = ["genki"]
+  s.email       = ["genki@s21g.com"]
+  s.homepage    = "https://github.com/genki/dsl_accessor"
+  s.summary     = %q{This plugin gives hybrid accessor class methods to classes by DSL like definition}
+  s.description = %q{This plugin gives hybrid accessor class methods to classes by DSL like definition}
+
+  s.rubyforge_project = "dsl_accessor"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "optionize", ">= 0.1.0"
+
+  s.add_development_dependency "rspec"
+end

data/lib/dsl_accessor.rb

@@ -0,0 +1,19 @@
+unless Module.new.respond_to?(:delegate)
+  require File.dirname(__FILE__) + "/../core_ext/module/delegation"
+end
+
+require File.dirname(__FILE__) + '/dsl_accessor/version'
+require File.dirname(__FILE__) + '/dsl_accessor/auto_declare'
+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,117 @@
+require 'optionize'
+
+module DslAccessor
+  def dsl_accessor_reader(key, *args, &block)
+    key = key.to_s
+    if !args.empty? or block_given?
+      # setter method
+      dsl_accessor_writer(key, *args, &block)
+    else
+      # getter method
+      if !dsl_accessor_key?(key)
+        # load default value
+        default = dsl_accessor_get("#{key}_default")
+        value   = default ? default.call : nil
+        dsl_accessor_writer(key, value)
+      end
+      dsl_accessor_get(key)
+    end
+  end
+
+  def dsl_accessor_writer(key, *args, &block)
+    case args.size
+    when 0
+      unless block_given?
+        raise ArgumentError, "'#{key}=' expected one argument or block, but nothing passed"
+      end
+      writer = dsl_accessor_get("#{key}_writer")
+      value  = writer ? writer.call(block) : block
+      dsl_accessor_set("#{key}", value)
+    when 1
+      if block_given?
+        raise ArgumentError, "'#{key}=' got both arg and block, specify only one of them"
+      end
+
+      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 block
+      case name
+      when :class, NilClass
+        AutoDeclare::DefineClassMethod.new(self, &block)
+      when :instance
+        AutoDeclare::DefineInstanceMethod.new(self, &block)
+      else
+        raise ArgumentError, "dsl_accessor block expects :class or :instance for arg, but got #{name.inspect}"
+      end
+      return
+    end
+
+    if !name
+      raise ArgumentError, "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, &block)
+        dsl_accessor_reader("#{name}", *args, &block)
+      end
+      def #{name}=(*args, &block)
+        dsl_accessor_writer("#{name}", *args, &block)
+      end
+    EOS
+  end
+end

data/lib/dsl_accessor/auto_declare.rb

@@ -0,0 +1,41 @@
+require 'blankslate'
+
+module DslAccessor
+  module AutoDeclare
+    class DefineClassMethod < BasicObject
+      def initialize(context, &block)
+        @context = context
+        instance_eval(&block)
+      end
+
+      private
+        def method_missing(name, *args, &block)
+          if args.empty? and block
+            meta_class = (class << @context; self; end)
+            meta_class.class_eval{ define_method(name, &block) }
+          else
+            @context.__send__(name, *args, &block)
+          end
+        end
+    end
+
+    class DefineInstanceMethod < BasicObject
+      def initialize(klass, &block)
+        @klass = klass
+        instance_eval(&block)
+      end
+
+      private
+        def method_missing(name, *args, &block)
+          if args.empty? and block
+            @klass.class_eval{ define_method(name, &block) }
+          else
+            raise NameError, "undefined local variable or method `#{name}'"
+          end
+        end
+    end
+  end
+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/lib/dsl_accessor/version.rb

@@ -0,0 +1,4 @@
+module DslAccessor
+  VERSION = "0.4.2"
+end
+

data/spec/accessor_spec.rb

@@ -0,0 +1,56 @@
+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/auto_declared_spec.rb

@@ -0,0 +1,123 @@
+require File.join( File.dirname(__FILE__), "spec_helper" )
+
+describe DslAccessor do
+  before do
+    Object.send(:remove_const, :Foo) if Object.const_defined?(:Foo)
+    Foo = Class.new
+  end
+
+  def dsl_accessor(*args, &block)
+    Foo.dsl_accessor(*args, &block)
+  end
+
+  ######################################################################
+  ### Class Methods
+
+  describe "dsl_accessor(&block)" do
+    context " should raise NameError when" do
+      def dsl_accessor(*args, &block)
+        lambda { super }.should raise_error(NameError)
+      end
+
+      it "foo" do
+        dsl_accessor { foo }
+      end
+
+      it "foo(1)" do
+        dsl_accessor { foo(1) }
+      end
+
+      it "foo(1,2)" do
+        dsl_accessor { foo(1,2) }
+      end
+
+      it "foo(1) {}" do
+        dsl_accessor { foo(1) {} }
+      end
+    end
+
+    context " should define class method 'foo' when" do
+      def dsl_accessor(*args, &block)
+        super
+        Foo.should respond_to(:foo)
+      end
+
+      it "foo {}" do
+        dsl_accessor { foo {} }
+      end
+    end
+
+    it "should overwrite existing class methods such as 'name'" do
+      Foo.dsl_accessor {
+        name { 1 }
+      }
+      Foo.name.should == 1
+    end
+
+    it "should invoke the method in valid context" do
+      Foo.should_receive(:bar) { 2 }
+      dsl_accessor { foo { bar } }
+      Foo.foo.should == 2
+    end
+  end
+
+  ######################################################################
+  ### Instance Methods
+
+  describe "dsl_accessor(:instance, &block)" do
+    context " should raise NameError when" do
+      def dsl_accessor(*args, &block)
+        lambda { super }.should raise_error(NameError)
+      end
+
+      it "foo" do
+        dsl_accessor(:instance) { foo }
+      end
+
+      it "foo(1)" do
+        dsl_accessor(:instance) { foo(1) }
+      end
+
+      it "foo(1,2)" do
+        dsl_accessor(:instance) { foo(1,2) }
+      end
+
+      it "foo(1) {}" do
+        dsl_accessor(:instance) { foo(1) {} }
+      end
+    end
+
+    context " should define instance method 'foo' when" do
+      def dsl_accessor(*args, &block)
+        super
+        Foo.new.should respond_to(:foo)
+      end
+
+      it "foo {}" do
+        dsl_accessor(:instance) { foo {} }
+      end
+    end
+
+    it "should define instance method" do
+      Foo.dsl_accessor(:instance) {
+        foo { 'xxx' }
+      }
+      Foo.new.foo.should == 'xxx'
+    end
+
+    it "should orverwrite existed instance methods even if those are important like 'object_id'" do
+      Foo.new.object_id.should be_kind_of(Integer)
+      Foo.dsl_accessor(:instance) {
+        object_id { 'xxx' }
+      }
+      Foo.new.object_id.should == 'xxx'
+    end
+
+    it "should invoke the method in valid context" do
+      Foo.any_instance.should_receive(:bar) { 2 }
+      dsl_accessor(:instance) { foo { bar } }
+      Foo.new.foo.should == 2
+    end
+  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

@@ -0,0 +1,48 @@
+require File.join( File.dirname(__FILE__), "spec_helper" )
+
+describe DslAccessor do
+  #        | 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 Bottom
+    dsl_accessor :foo
+    dsl_accessor :bar
+    dsl_accessor :baz, 'baz1'
+    dsl_accessor :qux, 'qux1'
+  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
+    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/setter_spec.rb

@@ -0,0 +1,24 @@
+require File.join( File.dirname(__FILE__), "spec_helper" )
+
+describe "dsl_accessor :foo" do
+  before do
+    @klass = new_class { dsl_accessor :foo }
+  end
+
+  it "should accept foo(1)" do
+    @klass.foo 1
+    @klass.foo.should == 1
+  end
+
+  it "should reject foo(1, &block)" do
+    lambda {
+      @klass.foo(2) { 3 }
+    }.should raise_error(ArgumentError)
+  end
+
+  it "should accept foo(&block)" do
+    @klass.foo { 4 }
+    @klass.foo.should be_kind_of(Proc)
+    @klass.foo.call.should == 4
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require "rubygems"
+require "rspec"
+
+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

data/tasks/dsl_accessor_tasks.rake

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

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: genki-dsl_accessor
+version: !ruby/object:Gem::Version
+  version: 0.4.2
+  prerelease: 
+platform: ruby
+authors:
+- genki
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: optionize
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This plugin gives hybrid accessor class methods to classes by DSL like
+  definition
+email:
+- genki@s21g.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- MIT-LICENSE
+- README
+- Rakefile
+- core_ext/module/delegation.rb
+- dsl_accessor.gemspec
+- lib/dsl_accessor.rb
+- lib/dsl_accessor/accessor.rb
+- lib/dsl_accessor/auto_declare.rb
+- lib/dsl_accessor/stores.rb
+- lib/dsl_accessor/version.rb
+- spec/accessor_spec.rb
+- spec/auto_declared_spec.rb
+- spec/default_spec.rb
+- spec/inherit_spec.rb
+- spec/instance_spec.rb
+- spec/module_spec.rb
+- spec/setter_spec.rb
+- spec/spec_helper.rb
+- spec/writer_spec.rb
+- tasks/dsl_accessor_tasks.rake
+homepage: https://github.com/genki/dsl_accessor
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: dsl_accessor
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: This plugin gives hybrid accessor class methods to classes by DSL like definition
+test_files:
+- spec/accessor_spec.rb
+- spec/auto_declared_spec.rb
+- spec/default_spec.rb
+- spec/inherit_spec.rb
+- spec/instance_spec.rb
+- spec/module_spec.rb
+- spec/setter_spec.rb
+- spec/spec_helper.rb
+- spec/writer_spec.rb