config_accessor 0.0.2 → 0.0.3

data/README.rdoc

@@ -29,6 +29,22 @@ Class-level configuration DSL
   r.port             # => 81
   Remote.port        # => 80
   Remote.port = 82
+
+  # next expressions are equivalent
   r.port             # => 81
+  r.config[:port]    # => 81
+  r.config["port"]   # => 81
+  r.config.port      # => 81
+
+  # It supports inheritance, subclasses cannot change superclasses configurations
+  Local.port         # => 80
+
+  # You can do it with +configure+ method
+  Local.configure do
+    port 81
+  end
 
-  Local.port         # => 80
+  # or
+  Local.configure do |config|
+    config.port 81
+  end

data/config_accessor.gemspec

@@ -9,6 +9,7 @@ Gem::Specification.new do |s|
   s.email       = ["amikhailov83@gmail.com"]
   s.homepage    = "https://github.com/take-five/config_accessor"
   s.summary     = %q{Class-level configurations}
+  s.description = File.read(File.expand_path('../README.rdoc', __FILE__))
 
   s.rubyforge_project = "config_accessor"
 

data/lib/config_accessor.rb

@@ -1,4 +1,5 @@
 require "config_accessor/version"
+require "config_accessor/config"
 require "config_accessor/class_methods"
 require "config_accessor/instance_methods"
 

data/lib/config_accessor/class_methods.rb

@@ -17,7 +17,7 @@ module ConfigAccessor
       raise ArgumentError, 'config accessors names expected' unless names.length > 0
 
       raise ArgumentError, ':alias option should be set '\
-                         'if and only if one argument supplied' if options.has_key?(:alias) &&
+                           'if and only if one argument supplied' if options.has_key?(:alias) &&
           names.length != 1
 
       names.each do |name|
@@ -30,66 +30,41 @@ module ConfigAccessor
 
     # Defines an instance and a singleton method with (optionally) alias.
     # The method parameter can be a <tt>Proc</tt>, a <tt>Method</tt> or an <tt>UnboundMethod</tt> object.
-    def define_config_method(symbol, method, ali=nil)
-      define_method(symbol, method)
-      define_singleton_method(symbol, method)
-      define_config_accessor_aliases(symbol, ali.to_sym) if ali
-    end
-
-    # Clone class-level configuration for each instance
-    def new(*args, &block) #:nodoc:
-      instance = super(*args, &block)
-
-      # clone class-level variables
-      defined_config_accessors.each do |name, val|
-        instance.write_config_value(name, ConfigAccessor.try_duplicate(val))
-      end
-
-      instance
+    def define_config_method(symbol, ali=nil)
+      class_eval <<-CODE
+        class << self                           # class << self
+          def #{symbol}(*args, &block)          #   def port(*args, &block)
+            config.#{symbol}(*args, &block)     #     config.port(*args, &block)
+          end                                   #   end
+          alias #{symbol}= #{symbol}            #   alias port= port
+          #{"alias #{ali} #{symbol}" if ali}    #   alias inferred_port port
+          #{"alias #{ali}= #{symbol}" if ali}   #   alias inferred_port= port
+        end                                     # end
+
+        def #{symbol}(*args, &block)            # def port(*args, &block)
+          config.#{symbol}(*args, &block)       #   config.port(*args, &block)
+        end                                     # end
+        alias #{symbol}= #{symbol}              # alias port= port
+        #{"alias #{ali} #{symbol}" if ali}      # alias inferred_port port
+        #{"alias #{ali}= #{symbol}" if ali}     # alias inferred_port= port
+      CODE
     end
 
     private
     # create universal config accessor
     def define_config_accessor(name, options) #:nodoc:
-      transform = if t = options.delete(:transform)
-                    raise TypeError, 'transformer must be Symbol, Method or Proc' unless t.respond_to?(:to_proc)
-                    t.to_proc
-                  end
-
-      # create accessor
-      accessor = proc do |*args, &block|
-        if args.empty? && !block # reader
-          read_config_value(name)
-        else # writer
-          raise ArgumentError, 'Too many arguments (%s for 1)' % args.length if args.length > 1
-
-          val = args.first || block
-          # apply :transform
-          val = transform.call(val) if transform.is_a?(Proc)
-
-          # set
-          write_config_value(name, val)
-        end
+      if t = options.delete(:transform)
+        config.register_transformer(name, t)
       end
 
-      # set default value
-      accessor.call(options.delete(:default)) if options.has_key?(:default)
-
       # add method
-      define_config_method(name, accessor, options.delete(:alias))
+      define_config_method(name, options.delete(:alias))
+
+      # set default value
+      send(name, options.delete(:default)) if options.has_key?(:default)
 
       # return nil
       nil
     end
-
-    # create alias for both singleton and instance methods
-    def define_config_accessor_aliases(accessor_name, alias_name) #:nodoc:
-      class_eval <<-CODE
-      class << self
-        alias #{alias_name} #{accessor_name}
-      end
-      alias #{alias_name} #{accessor_name}
-      CODE
-    end
   end
 end

data/lib/config_accessor/config.rb

@@ -0,0 +1,66 @@
+module ConfigAccessor
+  class Config < Hash #:nodoc:
+    attr_reader :transformers
+
+    def initialize(parent)
+      super()
+
+      @transformers = parent.respond_to?(:transformers) ? parent.transformers.dup : {}
+
+      parent.each_pair do |k, v|
+        self[k] = try_duplicate(v)
+      end
+    end
+
+    # Make a deep copy of Config
+    def dup
+      Config.new(self)
+    end
+
+    def register_transformer(name, proc)
+      raise TypeError, 'transformer must be Symbol, Method or Proc' unless proc.respond_to?(:to_proc)
+
+      @transformers[name.to_sym] = proc.to_proc
+    end
+
+    # indifferent access
+    def [](key)
+      super(key.to_sym)
+    end
+
+    # indifferent access
+    def fetch(key)
+      super(key.to_sym)
+    end
+
+    # indifferent access
+    def []=(key, value)
+      super(key.to_sym, value)
+    end
+
+    # uniform access
+    #   c = Config.new
+    #   c.port 80
+    #   c.port # => 80
+    def access(key, *args, &block)
+      if args.empty? && !block
+        self[key]
+      else
+        raise ArgumentError, 'Too many arguments (%s for 1)' % args.length if args.length > 1
+
+        val = args.first || block
+        val = @transformers[key.to_sym].call(val) if @transformers[key.to_sym].respond_to?(:call)
+
+        self[key] = val
+      end
+    end
+    alias method_missing access
+
+    private
+    def try_duplicate(obj) #:nodoc:
+      duplicable = [NilClass, TrueClass, FalseClass, Numeric, Symbol, Class, Module].none? { |klass| obj.is_a?(klass) }
+
+      duplicable ? obj.dup : obj
+    end
+  end
+end

data/lib/config_accessor/instance_methods.rb

@@ -1,33 +1,42 @@
 module ConfigAccessor
   # Both instance and class-level methods
   module InstanceMethods
+    # Sexy notation:
+    #   class Tank
+    #     config_accessor :target
+    #   end
+    #
+    #   Tank.configure {
+    #     target "localhost:80"
+    #   }
+    #
+    # or (result is the same):
+    #   Tank.configure do |conf|
+    #     conf.target "localhost:80"
+    #   end
     def configure(&block)
       raise ArgumentError, 'Block expected' unless block_given?
 
-      self.instance_eval(&block)
-
-      self
-    end
-
-    # Writes names configuration value
-    def write_config_value(name, value)
-      (@_config_accessors ||= {})[name.to_sym] = value
+      if block.arity == 1
+        yield(config)
+      else
+        config.instance_eval(&block)
+      end
     end
 
-    # Reads configuration value (supports inheritance)
-    def read_config_value(name)
-      parent_config_accessors.merge(@_config_accessors || {})[name.to_sym]
+    # Direct access to configuration values
+    def config
+      if self.is_a?(Class)
+        @_config ||= ConfigAccessor::Config.new(parent_config)
+      else
+        @_config ||= self.class.config.dup
+      end
     end
 
     protected
-    # inheritable config accessors array
-    def defined_config_accessors #:nodoc:
-      @_config_accessors ||= {}
-    end
-
-    def parent_config_accessors #:nodoc:
+    def parent_config #:nodoc:
       superklass = (self.is_a?(Class) ? self : self.class).superclass
-      superklass.respond_to?(:defined_config_accessors) ? superklass.defined_config_accessors : {}
+      superklass.respond_to?(:config) ? superklass.config : {}
     end
   end
 end

data/lib/config_accessor/version.rb

@@ -1,3 +1,3 @@
 module ConfigAccessor
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/spec/config_accessor_spec.rb

@@ -103,4 +103,31 @@ describe ConfigAccessor do
     c.port "80"
     c.port.should eq(80)
   end
+
+  it "should be configurable through configure method" do
+    c = Class.new {
+      configurable!
+      config_accessor :port
+    }
+
+    c.configure {
+      port 80
+    }
+    c.port.should eq(80)
+  end
+
+  it "should be compatable with ActiveSupport::Configurable" do
+    c = Class.new {
+      configurable!
+      config_accessor :port
+    }
+
+    i = c.new
+    i.port = 80
+
+    i.config[:port].should eq(80)
+
+    i.configure { |conf| conf[:port] = 81 }
+    i.port.should eq(81)
+  end
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Alexei Mikhailov
@@ -30,7 +30,57 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id001
-description: 
+description: |-
+  == Synopsys
+  Class-level configuration DSL
+  
+  == Installation
+    gem install config_accessor
+  
+  == Examples
+    require 'config_accessor'
+  
+    class Remote
+      configurable!
+  
+      config_accessor :host, :default => "localhost"
+      config_accessor :port, :default => "80", :transform => :to_i
+      config_accessor :proxy_host, :proxy_port
+    end
+  
+    class Local < Remote
+      config_accessor :l_port
+    end
+  
+    Remote.host        # => "localhost"
+    Remote.port        # => 80
+    Remote.proxy_host  # => nil
+  
+    r = Remote.new
+  
+    r.port = "81"
+    r.port             # => 81
+    Remote.port        # => 80
+    Remote.port = 82
+  
+    # next expressions are equivalent
+    r.port             # => 81
+    r.config[:port]    # => 81
+    r.config["port"]   # => 81
+    r.config.port      # => 81
+  
+    # It supports inheritance, subclasses cannot change superclasses configurations
+    Local.port         # => 80
+  
+    # You can do it with +configure+ method
+    Local.configure do
+      port 81
+    end
+  
+    # or
+    Local.configure do |config|
+      config.port 81
+    end
 email: 
 - amikhailov83@gmail.com
 executables: []
@@ -48,6 +98,7 @@ files:
 - config_accessor.gemspec
 - lib/config_accessor.rb
 - lib/config_accessor/class_methods.rb
+- lib/config_accessor/config.rb
 - lib/config_accessor/instance_methods.rb
 - lib/config_accessor/version.rb
 - spec/config_accessor_spec.rb