caesars 0.4.2 → 0.5.1

data/CHANGES.txt

@@ -1,6 +1,27 @@
 CAESAR -- CHANGES
 
 
+#### 0.5.1 (2009-03-11) ###############################
+
+* FIX: Method-syntax was broken for attributes of top level method
+* FIX: Caesars::Hash#refresh was setting @options to nil
+* UPDATED: docs and bin/example to reflect Caesars::Hash changes. 
+* FIX: instance_variables in Ruby 1.9.1 returns Symbols 
+
+#### 0.5.0 (2009-03-11) ###############################
+
+* FIX: find_deferred now gracefully handles nil errors
+* NEW: empty? method in Caesars::Config
+* NEW: post processing hook in Caesars::Config#refresh
+* NEW: Caesars::Hash#to_hash now recursively casts children to ::Hash.
+* FIX: Added Array support to Caesars::Hash
+* NEW: Setters for Caesars attributes
+* NEW: Caesars::Config supports multiple config files
+* NEW: Top level methods used more than once now merges values
+rather than overwrites. 
+* NEW: Caesars::Config supports reloading config files on the fly
+
+
 #### 0.4.2 (2009-03-05) ###############################
 
 * FIX: missing bin/party.conf in gem release
@@ -14,11 +35,11 @@ food :extra do; end; # => food_extra
 
 * CHANGE: Removed bloody method. We now parse blocks immediately.
 * CHANGE: Renamed virgin method to chill.
-* NEW: Caesar::Config class for loading DSLs as config files. 
+* NEW: Caesars::Config class for loading DSLs as config files. 
 See Example 3. 
 * NEW: Added find_deferred method to automatically jump up the
 heirarchy when looking for a specific attribute. 
-* NEW: Added to_hash and [] methods to Caesar::Glass to make it 
+* NEW: Added to_hash and [] methods to Caesars to make it 
 more hashlike. 
 * FIX: "chilled" attributes weren't available by method name
 

data/README.rdoc

@@ -1,4 +1,4 @@
-= Caesars - v0.4
+= Caesars - v0.5
 
 A simple class for rapid DSL prototyping in Ruby.
 
@@ -123,13 +123,17 @@ Or for GitHub fans:
      end
      
      conffile = File.join(File.dirname(__FILE__), 'party.conf')
-     @config = PartyConfig.new(:path => conffile)
+     @config = PartyConfig.new(conffile)
      
-     p @config.food.order.call   # => 8kg
+     p @config.food.order.call   # => 10kg
      p @config[:drink][:wine]    # => 12L
      p @config                   # => <PartyConfig:0x3f780c ...>
      p @config.keys              # => [:food, :drink]
-
+     
+     # [... make changes to party.conf ...]
+     
+     @config.refresh
+		
 == More Info
 
 * GitHub[http://github.com/delano/caesar]

data/bin/example

@@ -108,23 +108,28 @@ p @staff_fte.splashdown.keys
 # EXAMPLE 3 -- External Config file
 #
 
-class Food < Caesars #:nodoc: all
+require 'caesars'
+
+class Food < Caesars
   chill :order
 end
-class Drink < Caesars #:nodoc: all
+class Drink < Caesars
 end
 
-class PartyConfig < Caesars::Config #:nodoc: all
+class PartyConfig < Caesars::Config
   dsl Food::DSL
   dsl Drink::DSL
 end
 
 conffile = File.join(File.dirname(__FILE__), 'party.conf')
-@config = PartyConfig.new(:path => conffile)
+@config = PartyConfig.new(conffile)
 
-p @config.food.order.call   # => 8kg
+p @config.food.order.call   # => 10kg
 p @config[:drink][:wine]    # => 12L
 p @config                   # => <PartyConfig:0x3f780c ...>
 p @config.keys              # => [:food, :drink]
 
+# [... make changes to party.conf ...]
+
+@config.refresh
 

data/caesars.gemspec

@@ -1,7 +1,7 @@
 @spec = Gem::Specification.new do |s|
   s.name = %q{caesars}
-  s.version = "0.4.2"
-  s.date = %q{2009-03-05}
+  s.version = "0.5.1"
+  s.date = %q{2009-03-11}
   s.specification_version = 1 if s.respond_to? :specification_version=
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
 

data/lib/caesars.rb

@@ -7,7 +7,7 @@
 # See bin/example
 #
 class Caesars
-  VERSION = "0.4.2"
+  VERSION = "0.5.1"
   # A subclass of ::Hash that provides method names for hash parameters.
   # It's like a lightweight OpenStruct. 
   #     ch = Caesars::Hash[:tabasco => :lots!]
@@ -17,13 +17,29 @@ class Caesars
     def method_missing(meth)
       self[meth] if self.has_key?(meth)
     end
+    
+    # Returns a clone of itself and all children cast as ::Hash objects
+    def to_hash(hash=self)
+      return hash unless hash.is_a?(Caesars::Hash) # nothing to do
+      target = ::Hash[dup]
+      hash.keys.each do |key|
+        if hash[key].is_a? Caesars::Hash
+          target[key] = hash[key].to_hash
+          next
+        elsif hash[key].is_a? Array
+          target[key] = hash[key].collect { |h| to_hash(h) }  
+          next
+        end
+        target[key] = hash[key]
+      end
+      target
+    end
+    
   end
 
     # An instance of Caesars::Hash which contains the data specified by your DSL
   attr_accessor :caesars_properties
   
-  @@caesars_chilled = []
-  
   
   def initialize(name=nil)
     @caesars_name = name if name
@@ -37,12 +53,13 @@ class Caesars
   end
   
   def to_hash
-    @caesars_properties
+    @caesars_properties.to_hash
   end
 
   # Look for an attribute, bubbling up to the parent if it's not found
   # +criteria+ is an array of attribute names, orders according to their
-  # relationship.
+  # relationship. The last element is considered to the desired attribute.
+  # It can be an array.
   #
   #      # Looking for 'attribute'. 
   #      # First checks at @caesars_properties[grandparent][parent][attribute]
@@ -50,7 +67,7 @@ class Caesars
   #      # Finally, @caesars_properties[attribute]
   #      find_deferred('grandparent', 'parent', 'attribute')
   #
-  # Returns the attribute if found or nil
+  # Returns the attribute if found or nil.
   #
   def find_deferred(*criteria)
     # This is a nasty implementation. Sorry me! I'll enjoy a few
@@ -58,8 +75,7 @@ class Caesars
     att = criteria.pop
     val = nil
     while !criteria.empty?
-      str = criteria.collect { |v| "[:#{v}]" }.join << "[:#{att}]"
-      val = eval "@caesars_properties#{str} if defined?(@caesars_properties#{str})"
+      val = find(criteria, att)
       break if val
       criteria.pop
     end
@@ -67,19 +83,43 @@ class Caesars
     val = @caesars_properties[att.to_sym] if defined?(@caesars_properties[att.to_sym]) && !val
     val
   end
-
+  
+  # Looks for the specific attribute specified. 
+  # +criteria+ is an array of attribute names, orders according to their
+  # relationship. The last element is considered to the desired attribute.
+  # It can be an array.
+  #
+  # Unlike find_deferred, it will return only the value specified, otherwise nil. 
+  def find(*criteria)
+    criteria.flatten! if criteria.first.is_a?(Array)
+    str = criteria.collect { |v| "[:'#{v}']" if v }.join
+    val = eval "@caesars_properties#{str} if defined?(@caesars_properties#{str})"
+    val
+  end
+  
   # Act a bit like a hash for the case:
   # @subclass[:property]
   def [](name)
     return @caesars_properties[name] if @caesars_properties.has_key?(name)
     return @caesars_properties[name.to_sym] if @caesars_properties.has_key?(name.to_sym)
   end
-
+  
+  # Act a bit like a hash for the case:
+  # @subclass[:property] = value
+  def []=(name, value)
+    @caesars_properties[name] = value
+  end
+  
   # This method handles all of the attributes that do not contain blocks. 
   # It's used in the DSL for handling attributes dyanamically (that weren't defined
   # previously) and also in subclasses of Caesar for returning the appropriate
   # attribute values. 
   def method_missing(meth, *args, &b)
+    # Handle the setter, attribute=
+    if meth.to_s =~ /=$/ && @caesars_properties.has_key?(meth.to_s.chop.to_sym)
+      return @caesars_properties[meth.to_s.chop.to_sym] = (args.size == 1) ? args.first : args
+    end
+    
     return @caesars_properties[meth] if @caesars_properties.has_key?(meth) && args.empty? && b.nil?
     return nil if args.empty? && b.nil?
     
@@ -88,13 +128,15 @@ class Caesars
       args << meth if args.empty?
       args.each do |name|
         prev = @caesars_pointer
+        #(@caesars_pointer[:"#{meth}_values"] ||= []) << name
         @caesars_pointer[name] ||= Caesars::Hash.new
         @caesars_pointer = @caesars_pointer[name]
         b.call if b
         @caesars_pointer = prev
       end
         
-    elsif @caesars_pointer[meth]
+    elsif @caesars_pointer.kind_of?(Hash) && @caesars_pointer[meth]
+      
       @caesars_pointer[meth] = [@caesars_pointer[meth]] unless @caesars_pointer[meth].is_a?(Array)
       @caesars_pointer[meth] += args
     elsif !args.empty?
@@ -102,25 +144,43 @@ class Caesars
     end
   
   end
-
-  def self.chill(meth)
+  
+  # A class method which can be used by subclasses to specify which methods 
+  # should delay execution of their blocks. Here's an example:
+  # 
+  #      class Food < Caesars
+  #        chill :count
+  #      end
+  #      
+  #      food do
+  #        taste :delicious
+  #        count do |items|
+  #          puts items + 2
+  #        end
+  #      end
+  #
+  #      @config.food.order.call(3)     # => 5
+  #
+  def self.chill(caesars_meth)
     module_eval %Q{
-      def #{meth}(*names,&b)
-        # caesar.toplevel.unnamed_chilled_attribute
-        return @caesars_pointer[:'#{meth}'] if names.empty? && b.nil?
-      
+      def #{caesars_meth}(*caesars_names,&b)
+        # caesars.toplevel.unnamed_chilled_attribute
+        return @caesars_properties[:'#{caesars_meth}'] if @caesars_properties.has_key?(:'#{caesars_meth}') && caesars_names.empty? && b.nil?
+        
         # Use the name of the bloody method if no name is supplied. 
-        names << :'#{meth}' if names.empty?
-    
-        names.each do |name|
+        caesars_names << :'#{caesars_meth}' if caesars_names.empty?
+        
+        caesars_names.each do |name|
           @caesars_pointer[name] = b
         end
       
-        @caesars_pointer[:'#{meth}']
+        @caesars_pointer[:'#{caesars_meth}']
       end
     }
     nil
   end
+  
+  
   # Executes automatically when Caesars is subclassed. This creates the
   # YourClass::DSL module which contains a single method named after YourClass 
   # that is used to catch the top level DSL method. 
@@ -129,7 +189,7 @@ class Caesars
   # would be: highball.
   #
   #      highball :mine do
-  #        volume 9.oz
+  #        volume "9oz"
   #      end
   #
   def self.inherited(modname)
@@ -140,16 +200,16 @@ class Caesars
           name = !args.empty? ? args.first.to_s : nil
           varname = "@#{meth.to_s}"
           varname << "_\#{name}" if name
+          inst = instance_variable_get(varname)
           
           # When the top level DSL method is called without a block
           # it will return the appropriate instance variable name
-          if b.nil?
-            i = instance_variable_get(varname)
-          else
-            i = instance_variable_set(varname, #{modname.to_s}.new(name))
-            i.instance_eval(&b)
-          end
-          i
+          return inst if b.nil?
+          
+          # Add to existing instance, if it exists. Otherwise create one anew.
+          inst = instance_variable_set(varname, inst || #{modname.to_s}.new(name))
+          inst.instance_eval(&b)
+          inst
         end
         
         def self.methname
@@ -175,56 +235,102 @@ end
 #      p @config.staff    # => <Staff:0x7ea450 ... >
 #
 class Caesars::Config
-  attr_accessor :path 
+  attr_accessor :paths
+  attr_accessor :options
   attr_accessor :verbose
   
   @@glasses = []
   
-  def initialize(args={:path=>'', :verbose=>false})
-    args.each_pair do |n,v|
-      self.send("#{n}=", v)
-    end
+  # +args+ is a last of config file paths to load into this instance.
+  # If the last argument is a hash, it's assumed to be a list of 
+  # options. The available options are:
+  #
+  # <li>:verbose => true or false</li>
+  #
+  def initialize(*args)
+    # We store the options hash b/c we reapply them when we refresh.
+    @options = args.last.is_a?(Hash) ? args.pop : {}
+    @paths = args.empty? ? [] : args
+    @options = {}
     
     refresh
   end
-
-  def self.dsl(glass)
-    @@glasses << glass
-  end
   
-  def [](name)
-    self.send(name) if respond_to?(name)
-  end
+  def init
+    # Remove instance variables used to populate DSL data
+    instance_variables.each do |varname|
+      next if varname == :'@options' || varname == :'@paths'  # Ruby 1.9.1
+      next if varname == '@options' || varname == '@paths'  # Ruby 1.8
+      instance_variable_set(varname, nil)
+    end
     
-  def keys
-    @@glasses.collect { |glass| glass.methname }
+    # Re-apply options
+    @options.each_pair do |n,v|
+      self.send("#{n}=", v) if respond_to?("#{n}=")
+    end
+    
+    check_paths     # make sure files exist
+  end
+  
+  # This method is a stub. It gets called by refresh after the 
+  # config file has be loaded. You can use it to do some post 
+  # processing on the configuration before it's used elsewhere. 
+  def postprocess
   end
   
   def refresh
+    init 
     
-    if exists?
-      puts "Loading config from #{@path}" if @verbose 
+    @paths.each do |path|
+      puts "Loading config from #{path}" if @verbose 
       
       begin
         @@glasses.each { |glass| extend glass }
-        dsl = File.read @path
+        dsl = File.read path
         
         # We're using eval so the DSL code can be executed in this
         # namespace.
         eval %Q{
           #{dsl}
-        }
+        }, binding, __FILE__, __LINE__
+        
+        postprocess
         
       rescue SyntaxError => ex
-        puts "Syntax error in #{@path}."
+        puts "Syntax error in #{path}."
+        puts ex.message
         exit 1
       end
     end
   end
   
-  def exists?
-    File.exists?(@path)
+  def check_paths
+    @paths.each do |path|
+      raise "You provided a nil value" unless path
+      raise "Config file #{path} does not exist!" unless File.exists?(path)
+    end
   end
+  
+  
+  def empty?
+    keys.each do |obj|
+      return false if self.respond_to?(obj.to_sym)
+    end
+    true
+  end
+  
+  def self.dsl(glass)
+    @@glasses << glass
+  end
+  
+  def [](name)
+    self.send(name) if respond_to?(name)
+  end
+    
+  def keys
+    @@glasses.collect { |glass| glass.methname }
+  end
+  
 end
 
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: caesars
 version: !ruby/object:Gem::Version 
-  version: 0.4.2
+  version: 0.5.1
 platform: ruby
 authors: 
 - Delano Mandelbaum
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-05 00:00:00 -05:00
+date: 2009-03-11 00:00:00 -04:00
 default_executable: 
 dependencies: []