dsl_accessor 0.1.0 → 0.3.3

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 [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,175 @@
+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.
+
+
+Usage
+=====
+
+  class Foo
+    dsl_accessor "<METHOD NAME>"
+  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'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?
+
+
+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
+
+
+Install
+=======
+
+ git://github.com/maiha/dsl_accessor.git  
+
+
+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
+
+  Foo.new.foo # => 1
+
+This is useful when you have many methods those are one lined methods.
+
+  [without auto delared mode]
+  class Foo
+    def last
+      num_pages
+    end
+
+    def first?
+      page == 1
+    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
+
+
+
+Author
+======
+Maiha <maiha@wota.jp>
+

data/Rakefile

@@ -1,49 +1,74 @@
-require 'rubygems'
 require 'rake'
-require 'rake/clean'
 require 'rake/testtask'
-require 'rake/packagetask'
-require 'rake/gempackagetask'
 require 'rake/rdoctask'
-require 'rake/contrib/rubyforgepublisher'
-require 'fileutils'
-require 'hoe'
-include FileUtils
-require File.join(File.dirname(__FILE__), 'lib', 'dsl_accessor', 'version')
-
-AUTHOR = ['Maiha', 'Alex Wayne']  # can also be an array of Authors
-EMAIL = "anna@wota.jp"
-DESCRIPTION = "This gem gives hybrid accessor class methods to classes by DSL like definition."
+
+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'
+
 GEM_NAME = "dsl_accessor"
-RUBYFORGE_PROJECT = "dsl-accessor"
-HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
-RELEASE_TYPES = %w( gem )
-
-
-NAME = "dsl_accessor"
-REV = nil # UNCOMMENT IF REQUIRED: File.read(".svn/entries")[/committed-rev="(d+)"/, 1] rescue nil
-VERS = ENV['VERSION'] || (DslAccessor::VERSION::STRING + (REV ? ".#{REV}" : ""))
-CLEAN.include ['**/.*.sw?', '*.gem', '.config']
-RDOC_OPTS = ['--quiet', '--title', "dsl_accessor documentation",
-    "--opname", "index.html",
-    "--line-numbers", 
-    "--main", "README",
-    "--inline-source"]
-
-# Generate all the Rake tasks
-# Run 'rake -T' to see list of generated tasks (from gem root directory)
-hoe = Hoe.new(GEM_NAME, VERS) do |p|
-  p.author = AUTHOR 
-  p.description = DESCRIPTION
-  p.email = EMAIL
-  p.summary = DESCRIPTION
-  p.url = HOMEPATH
-  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
-  p.test_globs = ["test/**/*_test.rb"]
-  p.clean_globs = CLEAN  #An array of file patterns to delete on clean.
-  
-  # == Optional
-  #p.changes        - A description of the release's latest changes.
-  p.extra_deps = %w( activesupport )
-  #p.spec_extras    - A hash of extra values to set in the gemspec.
-end
+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"
+
+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}/**/*")
+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
+

data/core_ext/class/dsl_accessor.rb

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,140 @@
+# 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

@@ -0,0 +1,43 @@
+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/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