caesars 0.3.2 → 0.4.0

data/CHANGES.txt

@@ -1,14 +1,27 @@
 CAESAR -- CHANGES
 
 
+#### 0.4.0 (2009-03-05) ###############################
+
+* 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. 
+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 
+more hashlike. 
+* FIX: "chilled" attributes weren't available by method name
+
+
 #### 0.3.2 (2009-03-04) ###############################
 
 * FIX: Added file and line info for eval code (better debugging).
 * CHANGE: The top level DSL method names are now determined by
-          by the class name. Some::ClassName becomes classname. 
-          This is less confusing than allowing it to be anything
-          and makes it possible to use several DSLs in the same
-          namespace. 
+by the class name. Some::ClassName becomes classname. 
+This is less confusing than allowing it to be anything
+and makes it possible to use several DSLs in the same
+namespace. 
 
 
 #### 0.3.1 (2009-03-04) ###############################

data/README.rdoc

@@ -1,4 +1,4 @@
-= Caesars - v0.3
+= Caesars - v0.4
 
 A simple class for rapid DSL prototyping in Ruby.
 
@@ -17,21 +17,16 @@ Or for GitHub fans:
 * gem sources -a http://gems.github.com (you only have to do this once, ever...), then:
   * gem install delano-caesar
 
-		
-== Usage
-         
+== EXAMPLE 1 -- Flavour
+
 
-     # ------------------------------------------------------------------
-     #   EXAMPLE 1 -- Flavour
-     # 
-     
      class Flavour < Caesars  # Subclass Caesars. 
      end
      
      extend Flavour::DSL     # Bring the DSL into the current namespace. 
                              # This module is created dynamically based
                              # on the name of the subclass.
-                                  
+     
      flavour do              # Start drinking! I mean, start writing your
        spicy true            # domain specific language! 
        clamy true            # Use any attribute name you want.
@@ -41,19 +36,17 @@ Or for GitHub fans:
      
      p @flavour              # => #<Flavour:0x3f56b0 ...>
      p @flavour.spicy        # => true
+
+
+
+== EXAMPLE 2 -- Staff
+
+     require 'caesars'
      
+     class Staff < Caesars
      
-     
-     # ------------------------------------------------------------------
-     # EXAMPLE 2 -- Staff
-     #
-     
-     # Tell Caesars which attributes have children using Caesars#bloody and 
-     # which have blocks that you want to execute later using Caesars#virgin.
-     class Staff < Caesars 
-       bloody :location
-       bloody :person
-       virgin :calculate
+       chill :calculate      # Delay execution of the blocks for the calculate
+                             # attribute. They will be stored as Procs.                      
      end
      
      extend Staff::DSL
@@ -90,12 +83,13 @@ Or for GitHub fans:
            satisfaction :low
            calculate :salary do 
              self.splashdown.delano.rate.to_f * self.splashdown.delano.hours
+     
            end
          end
        end
      end
      
-     p @staff_fte                    # => #<KitchenStaff: ...>
+     p @staff_fte                    # => #<Staff: ...>
      p @staff_fte.desc               # => Our hard-working, "full-time" staff
      
      # Deeper attributes are also available via instance methods
@@ -107,18 +101,35 @@ Or for GitHub fans:
      # You can also access them using hash syntax
      p @staff_fte.splashdown[:steve][:role]  # => [:manager, :cook]
      
-     # The "bloody" attributes keep track of all values that are used. These are available as arrays
-     # via "NAME_values" methods. The goes for the virgin ones. 
-     p @staff_fte.location_values    # => [:splashdown]
-     p @staff_fte.person_values.uniq # => [:steve, :sheila, :delano, :angela]
-     p @staff_fte.calculate_values   # => [:salary, :salary]
-     
-     # The "virgin" methods store their blocks as Procs and are not executed automatically. 
+     # The "chilled" attributes store their blocks as Procs and are not executed automatically. 
      # You can call them manually and send arguments like you normally would. 
      p @staff_fte.splashdown.delano.salary.call             # => 475.95
      p @staff_fte.splashdown.sheila.salary.call(rand(100))  # => 549.77
+     p @staff_fte.splashdown.keys
+
 
+== EXAMPLE 3 -- External Config file
 
+     require 'caesars'
+     
+     class Food < Caesars
+       chill :order
+     end
+     class Drink < Caesars
+     end
+     
+     class PartyConfig < Caesars::Config
+       dsl Food::DSL
+       dsl Drink::DSL
+     end
+     
+     conffile = File.join(File.dirname(__FILE__), 'party.conf')
+     @config = PartyConfig.new(:path => conffile)
+     
+     p @config.food.order.call   # => 8kg
+     p @config[:drink][:wine]    # => 12L
+     p @config                   # => <PartyConfig:0x3f780c ...>
+     p @config.keys              # => [:food, :drink]
 
 == More Info
 

data/bin/example

@@ -1,12 +1,14 @@
 #!/usr/bin/env ruby
 
+# Caesars -- A working example
 #
-# Caesars Example
+# If your reading this via the rdocs you won't be able to see the code
+# See: http://github.com/delano/caesar/blob/master/bin/example
 #
 # Usage: bin/example
 #
 
-$:.unshift(File.join(File.join(File.dirname(__FILE__), '..'), 'lib')) # Make sure our local lib is first in line
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib')) # Make sure our local lib is first in line
 
 require 'caesars'
 
@@ -37,12 +39,10 @@ p @flavour.spicy        # => true
 # EXAMPLE 2 -- Staff
 #
 
-# Tell Caesars which attributes have children using Caesars#bloody and 
-# which have blocks that you want to execute later using Caesars#virgin.
 class Staff < Caesars
-  bloody :location
-  bloody :person
-  virgin :calculate
+  
+  chill :calculate      # Delay execution of the blocks for the calculate
+                        # attribute. They will be stored as Procs.                      
 end
 
 extend Staff::DSL
@@ -79,12 +79,13 @@ staff :fte do
       satisfaction :low
       calculate :salary do 
         self.splashdown.delano.rate.to_f * self.splashdown.delano.hours
+        
       end
     end
   end
 end
 
-p @staff_fte                    # => #<KitchenStaff: ...>
+p @staff_fte                    # => #<Staff: ...>
 p @staff_fte.desc               # => Our hard-working, "full-time" staff
 
 # Deeper attributes are also available via instance methods
@@ -96,14 +97,34 @@ p @staff_fte.splashdown.delano.satisfaction   # => :low
 # You can also access them using hash syntax
 p @staff_fte.splashdown[:steve][:role]  # => [:manager, :cook]
 
-# The "bloody" attributes keep track of all values that are used. These are available as arrays
-# via "NAME_values" methods. The goes for the virgin ones. 
-p @staff_fte.location_values    # => [:splashdown]
-p @staff_fte.person_values.uniq # => [:steve, :sheila, :delano, :angela]
-p @staff_fte.calculate_values   # => [:salary, :salary]
-
-# The "virgin" methods store their blocks as Procs and are not executed automatically. 
+# The "chilled" attributes store their blocks as Procs and are not executed automatically. 
 # You can call them manually and send arguments like you normally would. 
 p @staff_fte.splashdown.delano.salary.call             # => 475.95
 p @staff_fte.splashdown.sheila.salary.call(rand(100))  # => 549.77
-p @staff_fte.splashdown.keys
+p @staff_fte.splashdown.keys
+
+
+# ------------------------------------------------------------------
+# EXAMPLE 3 -- External Config file
+#
+
+class Food < Caesars
+  chill :order
+end
+class Drink < Caesars
+end
+
+class PartyConfig < Caesars::Config
+  dsl Food::DSL
+  dsl Drink::DSL
+end
+
+conffile = File.join(File.dirname(__FILE__), 'party.conf')
+@config = PartyConfig.new(:path => conffile)
+
+p @config.food.order.call   # => 8kg
+p @config[:drink][:wine]    # => 12L
+p @config                   # => <PartyConfig:0x3f780c ...>
+p @config.keys              # => [:food, :drink]
+
+

data/caesars.gemspec

@@ -1,6 +1,6 @@
 @spec = Gem::Specification.new do |s|
   s.name = %q{caesars}
-  s.version = "0.3.2"
+  s.version = "0.4.0"
   s.date = %q{2009-03-04}
   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

@@ -1,15 +1,13 @@
 
 # Caesars -- A simple class for rapid DSL prototyping.
 #
-# Subclass Caesars, then tell it which attributes have children using
-# Caesars.bloody and which have blocks that you want to execute later
-# using Caesars.virgin. That's it! Just start drinking! I mean, start 
-# writing your domain specific language!
+# Subclass Caesars and start drinking! I mean, start prototyping
+# your own domain specific language!
 #
-# See README.rdoc for a usage example.
+# See bin/example
 #
 class Caesars
-  VERSION = "0.3.2"
+  VERSION = "0.4.0"
   # A subclass of ::Hash that provides method names for hash parameters.
   # It's like a lightweight OpenStruct. 
   #     ch = Caesars::Hash[:tabasco => :lots!]
@@ -17,11 +15,15 @@ class Caesars
   #
   class Hash < ::Hash
     def method_missing(meth)
-      (self.has_key?(meth)) ? self[meth] : nil
+      self[meth] if self.has_key?(meth)
     end
   end
+
     # An instance of Caesars::Hash which contains the data specified by your DSL
   attr_accessor :caesars_properties
+  
+  @@caesars_chilled = []
+  
   # Creates an instance of Caesars. 
   # +name+ is . 
   def initialize(name=nil)
@@ -29,49 +31,107 @@ class Caesars
     @caesars_properties = Caesars::Hash.new
     @caesars_pointer = @caesars_properties
   end
+  
+  def keys
+    @caesars_properties.keys
+  end
+  
+  def to_hash
+    @caesars_properties
+  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.
+  #
+  #      # Looking for 'attribute'. 
+  #      # First checks at @caesars_properties[grandparent][parent][attribute]
+  #      # Then, @caesars_properties[grandparent][attribute]
+  #      # Finally, @caesars_properties[attribute]
+  #      find_deferred('grandparent', 'parent', 'attribute')
+  #
+  # Returns the attribute if found or nil
+  #
+  def find_deferred(*criteria)
+    # This is a nasty implementation. Sorry me! I'll enjoy a few
+    # caesars and be right with you. 
+    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})"
+      break if val
+      criteria.pop
+    end
+    # One last try in the root namespace
+    val = @caesars_properties[att.to_sym] if defined?(@caesars_properties[att.to_sym]) && !val
+    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
+
   # This method handles all of the attributes that do not contain blocks. 
-  def method_missing(name, *args, &b)
-    return @caesars_properties[name] if @caesars_properties.has_key?(name) && args.empty? && b.nil?
-    if @caesars_pointer[name]
-      @caesars_pointer[name] = [@caesars_pointer[name]] unless @caesars_pointer[name].is_a?(Array)
-      @caesars_pointer[name] += args
+  # 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)
+    return @caesars_properties[meth] if @caesars_properties.has_key?(meth) && args.empty? && b.nil?
+    return nil if args.empty? && b.nil?
+    
+    if b
+      # Use the name of the bloody method if no name is supplied. 
+      args << meth if args.empty?
+      args.each do |name|
+        prev = @caesars_pointer
+        @caesars_pointer[name] ||= Caesars::Hash.new
+        @caesars_pointer = @caesars_pointer[name]
+        b.call if b
+        @caesars_pointer = prev
+      end
+        
+    elsif @caesars_pointer[meth]
+      @caesars_pointer[meth] = [@caesars_pointer[meth]] unless @caesars_pointer[meth].is_a?(Array)
+      @caesars_pointer[meth] += args
     elsif !args.empty?
-      @caesars_pointer[name] = args.size == 1 ? args.first : args
+      @caesars_pointer[meth] = args.size == 1 ? args.first : args
     end
+  
   end
-  # see bin/example for usage.
-  def self.virgin(meth)
-    self.bloody(meth, false)
-  end
-  # see bin/example for usage.
-  def self.bloody(meth, execute=true)
+
+  def self.chill(meth)
     define_method(meth) do |*names,&b|  # |*names,&b| syntax does not parse in Ruby 1.8
-      all = instance_variable_get("@" << meth.to_s) || []
+      # caesar.toplevel.unnamed_chilled_attribute
+      return @caesars_pointer[meth] if 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|
-        instance_variable_set("@" << meth.to_s, all << name)
-        
-        if execute
-          prev = @caesars_pointer
-          @caesars_pointer[name] ||= Caesars::Hash.new
-          @caesars_pointer = @caesars_pointer[name]
-          b.call if b
-          @caesars_pointer = prev
-        else
-          @caesars_pointer[name] = b
-        end
-        
+        @caesars_pointer[name] = b
       end
+      
       nil
     end
-    define_method("#{meth}_values") do ||
-      instance_variable_get("@" << meth.to_s) || []
-    end
+    #define_method("#{meth}_values") do ||
+    #  instance_variable_get("@" << meth.to_s) || []
+    #end
   end
   # Executes automatically when Caesars is subclassed. This creates the
-  # YourClass::DSL module which contains a single method: method_missing. 
-  # This is used to catch the top level DSL method. That's why you can 
-  # used any method name you like. 
+  # YourClass::DSL module which contains a single method named after YourClass 
+  # that is used to catch the top level DSL method. 
+  #
+  # For example, if your class is called Glasses::HighBall, your top level method
+  # would be: highball.
+  #
+  #      highball :mine do
+  #        volume 9.oz
+  #      end
+  #
   def self.inherited(modname)
     meth = (modname.to_s.split(/::/))[-1].downcase  # Some::ClassName => classname
     module_eval %Q{
@@ -80,13 +140,91 @@ class Caesars
           name = !args.empty? ? args.first.to_s : nil
           varname = "@#{meth.to_s}"
           varname << "_\#{name}" if name
-          i = instance_variable_set(varname, #{modname.to_s}.new(name))
-          i.instance_eval(&b) if b
+          
+          # 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
         end
+        
+        def self.methname
+          :"#{meth}"
+        end
+        
       end
     }, __FILE__, __LINE__
   end
+  
+end
+  
+  
+# A helper for loading a DSL from a config file.
+#
+# Usage:
+#
+#      class Staff < Caesars; end;
+#      class StaffConfig < Caesars::Config
+#        dsl Staff::DSL
+#      end
+#      @config = StaffConfig.new(:path => '/path/2/staff_dsl.rb')
+#      p @config.staff    # => <Staff:0x7ea450 ... >
+#
+class Caesars::Config
+  attr_accessor :path 
+  attr_accessor :verbose
+  
+  @@glasses = []
+  
+  def initialize(args={:path=>'', :verbose=>false})
+    args.each_pair do |n,v|
+      self.send("#{n}=", v)
+    end
+    
+    refresh
+  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
+  
+  def refresh
+    
+    if exists?
+      puts "Loading config from #{@path}" if @verbose 
+      
+      begin
+        @@glasses.each { |glass| extend glass }
+        dsl = File.read @path
+        
+        # We're using eval so the DSL code can be executed in this
+        # namespace.
+        eval %Q{
+          #{dsl}
+        }
+        
+      rescue SyntaxError => ex
+        puts "Syntax error in #{@path}."
+        exit 1
+      end
+    end
+  end
+  
+  def exists?
+    File.exists?(@path)
+  end
 end
 
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: caesars
 version: !ruby/object:Gem::Version 
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors: 
 - Delano Mandelbaum