maiha-dsl_accessor 0.3.0 → 0.3.1

data/Rakefile

@@ -33,7 +33,7 @@ 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.0"
+GEM_VERSION = "0.3.1"
 
 spec = Gem::Specification.new do |s|
 #  s.rubyforge_project = 'merb'
@@ -49,7 +49,6 @@ spec = Gem::Specification.new do |s|
   s.homepage         = HOMEPAGE
   s.require_path     = 'lib'
   s.files            = %w(LICENSE README Rakefile) + Dir.glob("{core_ext,lib,spec,tasks,test}/**/*")
-  s.add_dependency('activesupport', '>= 2.0.0')
 end
 
 Rake::GemPackageTask.new(spec) do |pkg|

data/core_ext/class/dsl_accessor.rb

@@ -1,4 +1,7 @@
-require 'active_support'
+unless Class.new.respond_to?(:class_inheritable_accessor)
+  require File.dirname(__FILE__) + "/../duplicable" unless Object.new.respond_to?(:duplicable?)
+  require File.dirname(__FILE__) + "/inheritable_attributes"
+end
 
 module DslAccessor
   def dsl_accessor(*args)

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.extract_options!
+    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.extract_options!
+    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.extract_options!
+    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/test/default_test.rb

@@ -5,7 +5,7 @@ class DslDefaultAccessorTest < Test::Unit::TestCase
 
   class CoolActiveRecord
     dsl_accessor :primary_key, :default=>"id"
-    dsl_accessor :table_name,  :default=>proc{|klass| klass.name.demodulize.underscore.pluralize}
+    dsl_accessor :table_name,  :default=>proc{|klass| klass.name.split(/::/).last.downcase+"s"}
   end
 
   class Item < CoolActiveRecord
@@ -48,7 +48,7 @@ end
 class DslOverwritenDefaultAccessorTest < Test::Unit::TestCase
   class CoolActiveRecord
     dsl_accessor :primary_key, :default=>"id"
-    dsl_accessor :table_name,  :default=>proc{|klass| klass.name.demodulize.underscore.pluralize}
+    dsl_accessor :table_name,  :default=>proc{|klass| klass.name+"s"}
   end
 
   class Item < CoolActiveRecord

data/test/test_helper.rb

@@ -1,14 +1,5 @@
 require 'test/unit'
 
 def __DIR__; File.dirname(__FILE__); end
-
-begin
-  require 'rubygems'
-  require 'active_support'
-rescue LoadError
-  $:.unshift(__DIR__ + '/../../../rails/activesupport/lib')
-  require 'active_support'
-end
-
 require File.dirname(__FILE__) + '/../init'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: maiha-dsl_accessor
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors: 
 - maiha
@@ -9,18 +9,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-24 00:00:00 -08:00
+date: 2009-02-11 00:00:00 -08:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: activesupport
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 2.0.0
-    version: 
+dependencies: []
+
 description: This plugin gives hybrid accessor class methods to classes by DSL like definition
 email: maiha@wota.jp
 executables: []
@@ -34,8 +26,10 @@ files:
 - LICENSE
 - README
 - Rakefile
+- core_ext/duplicable.rb
 - core_ext/class
 - core_ext/class/dsl_accessor.rb
+- core_ext/class/inheritable_attributes.rb
 - lib/dsl_accessor.rb
 - spec/auto_declared_spec.rb
 - spec/spec_helper.rb