dsl_accessor 0.4.0 → 0.4.1

data/Gemfile

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

data/README

@@ -1,172 +1,206 @@
 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.
+  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>"
-  end
+    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."
+    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'm 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'm 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'm bar."
-  end
-
-There are no longer redundant prefix code like "self." and "set_".
-Don't you like this dsl-like coding with simple declaration?
+  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.
+  '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
+  "instance" option automatically defines its instance method
+  
+    class Search
+      dsl_accessor :url, :instance=>true, :default=>"http://localhost/"
     end
-  end
-
-  Window.width       # => 640
-  Window.new.width   # => 640
-
-  window = Window.new(:width=>320)
-  window.width       # =>320
-
-
-Install
-=======
-
- git://github.com/maiha/dsl_accessor.git  
+  
+    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
 ==================
 
-Calling dsl_accessor without args enters auto declared mode.
-In this mode, a method missing means instance method creation.
-This affects only methods with a block and no other args.
-
-  class Foo
-    dsl_accessor		# auto declared mode
-      foo{1}      		# define :foo
-      bar(a)			# NoMethodError
-      baz(a){2}			# NoMethodError
-  end
+  It was removed at version 0.4.
+  In 0.4.1 or higher, use dsl_accessor block instead.
 
-  Foo.new.foo # => 1
 
-This is useful when you have many methods those are one lined methods.
+with block
+==========
 
-  [without auto delared mode]
-  class Foo
-    def last
-      num_pages
+  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
-
-    def first?
-      page == 1
+  
+  Refactored with dsl_accessor
+
+    class Foo
+      dsl_accessor :instance do
+        last   {num_pages}
+        first? {page == 1}
+        offset {model.proxy_options[:offset]}
+      end
     end
 
-    def offset
-      model.proxy_options[:offset]
-    end
-  end
 
-  [with auto delared mode]
-  class Foo
-    dsl_accessor
-      last   {num_pages}
-      first? {page == 1}
-      offset {model.proxy_options[:offset]}
-  end
+Homepage
+========
 
+ http://github.com/maiha/dsl_accessor
 
 
 Author

data/Rakefile

@@ -1,52 +1 @@
-require 'rubygems'
-require 'rake/gempackagetask'
-
-GEM_NAME = "dsl_accessor"
-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.4.0"
-
-spec = Gem::Specification.new do |s|
-  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|
-  pkg.gem_spec = spec
-end
-
-desc "Install the gem"
-task :install do
-  Merb::RakeHelper.install(GEM_NAME, :version => GEM_VERSION)
-end
-
-desc "Uninstall the gem"
-task :uninstall do
-  Merb::RakeHelper.uninstall(GEM_NAME, :version => GEM_VERSION)
-end
-
-desc "Create a gemspec file"
-task :gemspec do
-  File.open("#{GEM_NAME}.gemspec", "w") do |file|
-    file.puts spec.to_ruby
-  end
-end
-
-require 'spec/rake/spectask'
-desc 'Default: run spec examples'
-task :default => 'spec'
+require "bundler/gem_tasks"

data/dsl_accessor.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "dsl_accessor/version"
+
+Gem::Specification.new do |s|
+  s.name        = "dsl_accessor"
+  s.version     = DslAccessor::VERSION
+  s.authors     = ["maiha"]
+  s.email       = ["maiha@wota.jp"]
+  s.homepage    = "https://github.com/maiha/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_dependency "blankslate", ">= 2.1.2"
+
+  s.add_development_dependency "rspec"
+end

data/lib/dsl_accessor.rb

@@ -2,6 +2,8 @@ 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'
 

data/lib/dsl_accessor/accessor.rb

@@ -1,25 +1,37 @@
 require 'optionize'
 
 module DslAccessor
-  def dsl_accessor_reader(key, *args)
+  def dsl_accessor_reader(key, *args, &block)
     key = key.to_s
-    if args.empty?
+    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)
-    else
-      # setter method
-      dsl_accessor_writer(key, *args)
     end
   end
 
-  def dsl_accessor_writer(key, *args)
+  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)
@@ -32,8 +44,20 @@ module DslAccessor
     opts = Optionize.new(args, :name, :default)
     name = opts.name
 
-    if !name and !block
-      raise "dsl_accessor expects at least one arg"
+    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 =
@@ -82,11 +106,11 @@ module DslAccessor
     end
 
     instance_eval <<-EOS
-      def #{name}(*args)
-        dsl_accessor_reader("#{name}", *args)
+      def #{name}(*args, &block)
+        dsl_accessor_reader("#{name}", *args, &block)
       end
-      def #{name}=(*args)
-        dsl_accessor_writer("#{name}", *args)
+      def #{name}=(*args, &block)
+        dsl_accessor_writer("#{name}", *args, &block)
       end
     EOS
   end

data/lib/dsl_accessor/auto_declare.rb

@@ -0,0 +1,41 @@
+require 'blankslate'
+
+module DslAccessor
+  module AutoDeclare
+    class DefineClassMethod < BlankSlate
+      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 < BlankSlate
+      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/version.rb

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

data/spec/accessor_spec.rb

@@ -6,7 +6,6 @@ describe DslAccessor do
   end
 end
 
-
 describe "dsl_accessor(:foo)" do
   before do
     @klass = new_class { dsl_accessor :foo }
@@ -42,7 +41,6 @@ describe "dsl_accessor(:foo)" do
   end
 end
 
-
 describe "dsl_accessor(:foo, 1)" do
   before do
     @klass = new_class { dsl_accessor :foo, 1 }

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 'id'" do
+      Foo.new.object_id.should be_kind_of(Integer)
+      Foo.dsl_accessor(:instance) {
+        id { 'xxx' }
+      }
+      Foo.new.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/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

@@ -1,5 +1,5 @@
 require "rubygems"
-require "spec"
+require "rspec"
 
 require File.dirname(__FILE__) + "/../lib/dsl_accessor"
 

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

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: dsl_accessor
 version: !ruby/object:Gem::Version 
+  hash: 13
   prerelease: false
   segments: 
   - 0
   - 4
-  - 0
-  version: 0.4.0
+  - 1
+  version: 0.4.1
 platform: ruby
 authors: 
 - maiha
@@ -14,16 +15,18 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-23 00:00:00 +09:00
+date: 2012-05-10 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: optionize
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 27
         segments: 
         - 0
         - 1
@@ -31,32 +34,69 @@ dependencies:
         version: 0.1.0
   type: :runtime
   version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: blankslate
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 2
+        - 1
+        - 2
+        version: 2.1.2
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
 description: This plugin gives hybrid accessor class methods to classes by DSL like definition
-email: maiha@wota.jp
+email: 
+- maiha@wota.jp
 executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- README
-- MIT-LICENSE
+extra_rdoc_files: []
+
 files: 
+- Gemfile
 - MIT-LICENSE
 - README
 - Rakefile
-- lib/dsl_accessor/stores.rb
-- lib/dsl_accessor/accessor.rb
+- 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/writer_spec.rb
+- spec/auto_declared_spec.rb
+- spec/default_spec.rb
 - spec/inherit_spec.rb
-- spec/module_spec.rb
 - spec/instance_spec.rb
-- spec/default_spec.rb
+- spec/module_spec.rb
+- spec/setter_spec.rb
 - spec/spec_helper.rb
-- core_ext/module/delegation.rb
+- spec/writer_spec.rb
+- tasks/dsl_accessor_tasks.rake
 has_rdoc: true
-homepage: http://github.com/maiha/dsl_accessor
+homepage: https://github.com/maiha/dsl_accessor
 licenses: []
 
 post_install_message: 
@@ -65,23 +105,27 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
-rubyforge_project: asakusarb
-rubygems_version: 1.3.6
+rubyforge_project: dsl_accessor
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: This plugin gives hybrid accessor class methods to classes by DSL like definition