dsl_maker 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2f42b67736e6299fee74ad059d995f9f0e9e71dc
-  data.tar.gz: cc54596f31ec4278eb33c5a11d504b1774556634
+  metadata.gz: fd8b809906f6bde7d8b1839095dc2ad018148190
+  data.tar.gz: 13708d81d5f96de3f5744736c77f4b55ef2d5748
 SHA512:
-  metadata.gz: ffe540380885b22fd3dc7a7d118ada0ae1ac958502619cbbea19f2c42b2546ccd60e9147a3475dc58d83c2b69982c87f08a7e6251ea172b141b7bf5bcda6e007
-  data.tar.gz: a0950aa163fe8b9c8b41b311c85ee369c229bd32099f6ce742a2e7f62f3b954effefcbfc7a90777287dc67ea84a482951dd5672a567cfb3d3ae10ad845dc6556
+  metadata.gz: d0c2f6464bc5d08693a7298dae3074c9f89f00c9f2959bb1366b86a5cfdf211bc6fc779c045cb111fd04f0e0e7aff1aa8304ccd895d084fa32119e4fdba7c951
+  data.tar.gz: c9ecc30fba1b36b6c6aac878de49a6191df39180ef05dd96996a411e82c5c52e44ef202254ba08736755e95fe9d8df3fba94ad512adc51ddc6d139d96f1a987a

data/Changes

@@ -1,5 +1,15 @@
 Revision history for DSL::Maker (ordered by revision number).
 
+0.0.8 Aug 07 2015
+   - Make sure to provide a unique value for each type name.
+      - Allow 'Object' to be used as an alias for 'Any'
+   - Signficant refactorings (Thanks, "Alex Burkhart <saterus@gmail.com>"!!)
+      - Test globals are properly segregated
+      - Properly separated the control and DSL classes
+   - Verifications can be used at every DSL class level
+   - Moved build_dsl_element() into private. It can still be used within the
+     control class under construction.
+
 0.0.7 Aug 06 2015
    - Added the 'Any' type coercion.
    - Added a TL;DR section at the top of the README.

data/lib/dsl/maker.rb

@@ -2,6 +2,13 @@ require 'dsl/maker/version'
 
 require 'docile'
 
+# Children of DSL::Maker are the "control class". All of the classes that inherit
+# from DSL::Maker::Base are "dsl classes" - classes that are passed to Docile and
+# which represent levels of the DSL. In order for :parse_dsl/:execute_dsl to
+# return back the accumulated values in the order provided, we need to "pierce the
+# veil" (so to speak) between the control and dsl classes. That's done using the
+# parent_class class attribute in the dsl classes.
+
 # This is the base class we provide.
 class DSL::Maker
   # This is the base class for all DSL-parsing classes.
@@ -11,10 +18,32 @@ class DSL::Maker
 
     # 21 character method names are obscene. Make it easier to read.
     alias :___get :instance_variable_get
+
+    def get_binding
+      binding
+    end
+
+    define_singleton_method(:add_verification) do |&block|
+      # FIXME: This throws regardless. Is this because of the difference between
+      # proc and block?
+      #raise "Block required for add_verification" unless block_given?
+
+      @verifications ||= []
+
+      # This craziness converts the block provided into a proc that can be called
+      # in add_entrypoint(). Taken from http://stackoverflow.com/a/2946734/1732954
+      # Note: self is not preserved. This should be okay because the verification
+      # should be idempotent relative to the value provided (side-effect-free).
+      obj = Object.new
+      obj.define_singleton_method(:_, &block)
+      @verifications.push(obj.method(:_).to_proc)
+
+      return
+    end
   end
 
-  # Create the DSL::Maker::Any type identifier
-  Any = nil
+  # Create the DSL::Maker::Any type identifier, equivalent to Object.
+  Any = Object
 
   # This is a useful module that contains all the Boolean handling we need.
   module Boolean
@@ -44,8 +73,11 @@ class DSL::Maker
   # @param dsl [String] The DSL to be parsed by this class.
   #
   # @return    [Object] Whatever is returned by the block defined in this class.
-  def self.parse_dsl(dsl)
-    __run_dsl { eval dsl, self.get_binding }
+  def self.parse_dsl(dsl=nil)
+    raise 'Must call add_entrypoint before parse_dsl' unless @klass
+    raise 'String required for parse_dsl' unless dsl.instance_of? String
+
+    run_dsl() { eval dsl, @klass.new.get_binding }
   end
 
   # Execute the DSL provided in the block.
@@ -57,18 +89,15 @@ class DSL::Maker
   #
   # @return    [Object] Whatever is returned by &block
   def self.execute_dsl(&block)
+    raise 'Must call add_entrypoint before execute_dsl' unless @klass
     raise 'Block required for execute_dsl' unless block_given?
 
-    __run_dsl { instance_eval(&block) }
+    run_dsl() { @klass.new.instance_eval(&block) }
   end
 
-  # FIXME: This may have to be changed when the elements can be altered because
-  # it is global to the hierarchy. But, that may be desirable.
-  @@types = {}
-
   # This adds a type coercion that's used when creating the DSL.
   #
-  # Note: These type coercions are global to all DSLs.
+  # @note These type coercions are global to all DSLs.
   #
   # @param type   [Object] the name of the helper
   # @param &block [Block]  The function to be executed when the coercion is exercised.
@@ -96,44 +125,6 @@ class DSL::Maker
     return
   end
 
-  # Add a single element of a DSL to a class representing a level in a DSL.
-  #
-  # Each of the types represents a coercion - a guarantee and check of the value
-  # in that name. The standard type coercions are:
-  #
-  #   * String  - whatever you give is returned.
-  #   * Integer - the integer value of whatever you give is returned.
-  #   * Boolean - the truthiness of whatever you give is returned.
-  #   * generate_dsl() - this represents a new level of the DSL.
-  #
-  # @param klass [Class]  The class representing this level in the DSL.
-  # @param name  [String] The name of the element we're working on.
-  # @param type  [Class]  The type of this element we're working on.
-  #                       This is the type coercion spoken above.
-  #
-  # @return   nil
-  def self.build_dsl_element(klass, name, type)
-    if @@types.has_key?(type)
-      @@types[type].call(klass, name, type)
-    elsif __is_dsl(type)
-      as_attr = '@' + name.to_s
-      klass.class_eval do
-        define_method(name.to_sym) do |*args, &dsl_block|
-          unless (args.empty? && !dsl_block)
-            obj = type.new
-            Docile.dsl_eval(obj, &dsl_block) if dsl_block
-            ___set(as_attr, obj.__apply(*args))
-          end
-          ___get(as_attr)
-        end
-      end
-    else
-      raise "Unrecognized element type '#{type}'"
-    end
-
-    return
-  end
-
   # Add the meat of a DSL block to some level of this class's DSL.
   #
   # In order for Docile to parse a DSL, each level must be represented by a
@@ -149,15 +140,13 @@ class DSL::Maker
   def self.generate_dsl(args={}, &defn_block)
     raise 'Block required for generate_dsl' unless block_given?
 
-    # Inherit from the Boolean class to gain access to the useful methods
-    # TODO: Convert DSL::Maker::Boolean into a Role
-    # TODO: Create a DSL::Maker::Base class to inherit from
     dsl_class = Class.new(DSL::Maker::Base) do
       include DSL::Maker::Boolean
 
-      # This instance method exists because we cannot seem to inline its work
-      # where we call it. Could it be a problem of incorrect binding?
-      # It has to be defined here because it needs access to &defn_block
+      class << self
+        attr_accessor :parent_class, :verifications
+      end
+
       define_method(:__apply) do |*args|
         instance_exec(*args, &defn_block)
       end
@@ -189,11 +178,11 @@ class DSL::Maker
   def self.add_entrypoint(name, args={}, &defn_block)
     symname = name.to_sym
 
-    if self.respond_to?(symname)
+    if is_entrypoint(symname)
       raise "'#{name.to_s}' is already an entrypoint"
     end
 
-    if __is_dsl(args)
+    if is_dsl(args)
       dsl_class = args
     else
       # Without defn_block, there's no way to give back the result of the
@@ -203,21 +192,20 @@ class DSL::Maker
       raise "Block required for add_entrypoint" unless block_given?
       dsl_class = generate_dsl(args, &defn_block)
     end
-
-    define_singleton_method(symname) do |*args, &dsl_block|
-      obj = dsl_class.new
-      Docile.dsl_eval(obj, &dsl_block) if dsl_block
-      rv = obj.__apply(*args)
-
-      if @verifications && @verifications.has_key?(symname)
-        @verifications[symname].each do |verify|
-          failure = verify.call(rv)
-          raise failure if failure
-        end
-      end
-
-      @accumulator.push(rv)
-      return rv
+    
+    if @klass
+      build_dsl_element(@klass, symname, dsl_class)
+    else
+      # FIXME: We shouldn't need the blank block here ...
+      # This blank block is representative of the implicit (and missing) outermost
+      # block around the DSL that we are not putting into place in :parse_dsl or
+      # :execute_dsl.
+      @klass = generate_dsl({
+        symname => dsl_class
+      }) {}
+
+      # This marks @klass as the root DSL class.
+      @klass.parent_class = self
     end
 
     @entrypoints ||= {}
@@ -230,7 +218,7 @@ class DSL::Maker
   # 
   # @return      [Class]  The class that implements this name's DSL definition.
   def self.entrypoint(name)
-    unless __is_entrypoint(name)
+    unless is_entrypoint(name)
       raise "'#{name.to_s}' is not an entrypoint"
     end
 
@@ -265,8 +253,13 @@ class DSL::Maker
   # execution. If the verification returns a true value (of any kind), then that
   # will be raised as a runtime exception.
   #
-  # Note: These verifications are specific to the DSL you add them to.
-  # Note: Verifications are called in the order you specify them.
+  # You can also call add_verification on the return values from generate_dsl() or
+  # add_entrypoint(). In those cases, omit the :name because you have already
+  # chosen the DSL layer you're adding the verification to.
+  #
+  # @note These verifications are specific to the DSL you add them to.
+  #
+  # @note Verifications are called in the order you specify them.
   #
   # @param name   [String] the name of the entrypoint to add a verification to
   # @param &block [Block]  The function to be executed when verifications execute
@@ -274,34 +267,79 @@ class DSL::Maker
   # @return nil
   def self.add_verification(name, &block)
     raise "Block required for add_verification" unless block_given?
-    raise "'#{name.to_s}' is not an entrypoint for a verification" unless __is_entrypoint(name)
+    raise "'#{name.to_s}' is not an entrypoint for a verification" unless is_entrypoint(name)
 
-    @verifications ||= {}
-    @verifications[name.to_sym] ||= []
-
-    # This craziness converts the block provided into a proc that can be called
-    # in add_entrypoint(). Taken from http://stackoverflow.com/a/2946734/1732954
-    # Note: self is not preserved. This should be okay because the verification
-    # should only care about the value provided.
-    obj = Object.new
-    obj.define_singleton_method(:_, &block)
-    @verifications[name.to_sym].push(obj.method(:_).to_proc)
-
-    return
+    @entrypoints[name.to_sym].add_verification(&block)
   end
 
   private
 
-  # Returns the binding as needed by parse_dsl() and execute_dsl()
+  # This is deliberately global to the hierarchy in order for DSL::Maker to add
+  # the generic types. While this has the potential to cause userspace collisions,
+  # it's highly unlikely that DSLs with divergent types will coexist in the same
+  # Ruby process.
+  @@types = {}
+
+  # Add a single element of a DSL to a class representing a level in a DSL.
+  #
+  # Each of the types represents a coercion - a guarantee and check of the value
+  # in that name. The standard type coercions are:
   #
-  # @return [Binding] The binding of the invoking class.
-  def self.get_binding
-    binding
+  #   * Any  - whatever you give is returned.
+  #   * String  - the string value of whatever you give is returned.
+  #   * Integer - the integer value of whatever you give is returned.
+  #   * Boolean - the truthiness of whatever you give is returned.
+  #   * generate_dsl() - this represents a new level of the DSL.
+  #
+  # @param klass [Class]  The class representing this level in the DSL.
+  # @param name  [String] The name of the element we're working on.
+  # @param type  [Class]  The type of this element we're working on.
+  #                       This is the type coercion spoken above.
+  #
+  # @return   nil
+  def self.build_dsl_element(klass, name, type)
+    if @@types.has_key?(type)
+      @@types[type].call(klass, name, type)
+    elsif is_dsl(type)
+      as_attr = '@' + name.to_s
+      klass.class_eval do
+        define_method(name.to_sym) do |*args, &dsl_block|
+          if (!args.empty? || dsl_block)
+            obj = type.new
+            Docile.dsl_eval(obj, &dsl_block) if dsl_block
+            rv = obj.__apply(*args)
+
+            if v = type.instance_variable_get(:@verifications)
+              v.each do |verify|
+                failure = verify.call(rv)
+                raise failure if failure
+              end
+            end
+
+            # This is the one place where we pull out the entrypoint results and
+            # put them into the control class.
+            if klass.parent_class
+              # Use the full instance_variable_get() in order to avoid having to
+              # create accessors that could be misused outside this class.
+              klass.parent_class.instance_variable_get(:@accumulator).push(rv)
+            end
+
+            ___set(as_attr, rv)
+          end
+          ___get(as_attr)
+        end
+      end
+    else
+      raise "Unrecognized element type '#{type}'"
+    end
+
+    return
   end
 
-  def self.__run_dsl()
-    # add_entrypoint() will use @accumulator to handle multiple entrypoints.
-    # Reset it here so that we're only handling the values from this run.
+  def self.run_dsl()
+    # build_dsl_element() will use @accumulator to handle multiple entrypoints if
+    # the class in question is a root DSL class. Reset it here so that we're only
+    # handling the values from this run.
     @accumulator = []
 
     yield
@@ -312,16 +350,17 @@ class DSL::Maker
     return @accumulator
   end
 
-  def self.__is_dsl(proto)
+  def self.is_dsl(proto)
     proto.is_a?(Class) && proto.ancestors.include?(DSL::Maker::Base)
   end
 
-  def self.__is_entrypoint(name)
-    respond_to?(name.to_sym)
+  def self.is_entrypoint(name)
+    @entrypoints && @entrypoints.has_key?(name.to_sym)
+    #@klass && @klass.new.respond_to?(name.to_sym)
   end
 end
 
-# These are the default setups.
+# These are the default setups
 
 DSL::Maker.add_type(DSL::Maker::Any) do |attr, *args|
   ___set(attr, args[0]) unless args.empty?

data/lib/dsl/maker/version.rb

@@ -1,6 +1,6 @@
 module DSL
   class Maker
     # The current version of this library
-    VERSION = '0.0.7'
+    VERSION = '0.0.8'
   end
 end

data/spec/args_spec.rb

@@ -1,24 +1,23 @@
 # This will use a DSL that defines fruit
 
 describe "A DSL with argument handling describing fruit" do
-  $Color = Struct.new(:name)
-  $Fruit = Struct.new(:name, :color)
-
   describe "with one argument in add_entrypoint" do
-    dsl_class = Class.new(DSL::Maker) do
-      add_entrypoint(:fruit, {
-        :name => String,
-      }) do |*args|
-        default(:name, args, 0)
-        $Fruit.new(name, nil)
+    let(:dsl_class) {
+      Class.new(DSL::Maker) do
+        add_entrypoint(:fruit, {
+          :name => String,
+        }) do |*args|
+          default(:name, args, 0)
+          Structs::Fruit.new(name, nil)
+        end
       end
-    end
+    }
 
     it "can handle nil" do
       fruit = dsl_class.parse_dsl("
-        fruit
+        fruit {}
       ")
-      expect(fruit).to be_instance_of($Fruit)
+      expect(fruit).to be_instance_of(Structs::Fruit)
       expect(fruit.name).to be_nil
     end
 
@@ -26,7 +25,7 @@ describe "A DSL with argument handling describing fruit" do
       fruit = dsl_class.parse_dsl("
         fruit { name 'banana' }
       ")
-      expect(fruit).to be_instance_of($Fruit)
+      expect(fruit).to be_instance_of(Structs::Fruit)
       expect(fruit.name).to eq('banana')
     end
 
@@ -34,7 +33,7 @@ describe "A DSL with argument handling describing fruit" do
       fruit = dsl_class.parse_dsl("
         fruit 'banana'
       ")
-      expect(fruit).to be_instance_of($Fruit)
+      expect(fruit).to be_instance_of(Structs::Fruit)
       expect(fruit.name).to eq('banana')
     end
 
@@ -45,29 +44,31 @@ describe "A DSL with argument handling describing fruit" do
           name 'banana'
         end
       ")
-      expect(fruit).to be_instance_of($Fruit)
+      expect(fruit).to be_instance_of(Structs::Fruit)
       expect(fruit.name).to eq('banana')
     end
   end
 
   describe "with two arguments in add_entrypoint" do
-    dsl_class = Class.new(DSL::Maker) do
-      add_entrypoint(:fruit, {
-        :name => String,
-        :color => String,
-      }) do |*args|
-        default('name', args)
-        default('color', args, 1)
+    let(:dsl_class) {
+      Class.new(DSL::Maker) do
+        add_entrypoint(:fruit, {
+          :name => String,
+          :color => String,
+        }) do |*args|
+          default('name', args)
+          default('color', args, 1)
 
-        $Fruit.new(name, color)
+          Structs::Fruit.new(name, color)
+        end
       end
-    end
+    }
 
     it "can handle no arguments" do
       fruit = dsl_class.parse_dsl("
-        fruit
+        fruit {}
       ")
-      expect(fruit).to be_instance_of($Fruit)
+      expect(fruit).to be_instance_of(Structs::Fruit)
       expect(fruit.name).to be_nil
       expect(fruit.color).to be_nil
     end
@@ -79,7 +80,7 @@ describe "A DSL with argument handling describing fruit" do
           color 'yellow'
         }
       ")
-      expect(fruit).to be_instance_of($Fruit)
+      expect(fruit).to be_instance_of(Structs::Fruit)
       expect(fruit.name).to eq('banana')
       expect(fruit.color).to eq('yellow')
 
@@ -89,7 +90,7 @@ describe "A DSL with argument handling describing fruit" do
           color 'green'
         end
       ")
-      expect(fruit).to be_instance_of($Fruit)
+      expect(fruit).to be_instance_of(Structs::Fruit)
       expect(fruit.name).to eq('plantain')
       expect(fruit.color).to eq('green')
     end
@@ -98,27 +99,29 @@ describe "A DSL with argument handling describing fruit" do
       fruit = dsl_class.parse_dsl("
         fruit 'banana', 'yellow'
       ")
-      expect(fruit).to be_instance_of($Fruit)
+      expect(fruit).to be_instance_of(Structs::Fruit)
       expect(fruit.name).to eq('banana')
       expect(fruit.color).to eq('yellow')
     end
   end
 
   describe "with one argument in generate_dsl" do
-    dsl_class = Class.new(DSL::Maker) do
-      add_entrypoint(:fruit, {
-        :name => String,
-        :color => generate_dsl({
+    let (:dsl_class) {
+      Class.new(DSL::Maker) do
+        add_entrypoint(:fruit, {
           :name => String,
-        }) { |*args|
+          :color => generate_dsl({
+            :name => String,
+          }) { |*args|
+            default('name', args, 0)
+            Structs::Color.new(name)
+          }
+        }) do |*args|
           default('name', args, 0)
-          $Color.new(name)
-        }
-      }) do |*args|
-        default('name', args, 0)
-        $Fruit.new(name, color)
+          Structs::Fruit.new(name, color)
+        end
       end
-    end
+    }
 
     it "can handle arguments for fruit, but attribute for color" do
       fruit = dsl_class.parse_dsl("
@@ -128,9 +131,9 @@ describe "A DSL with argument handling describing fruit" do
           }
         end
       ")
-      expect(fruit).to be_instance_of($Fruit)
+      expect(fruit).to be_instance_of(Structs::Fruit)
       expect(fruit.name).to eq('banana')
-      expect(fruit.color).to be_instance_of($Color)
+      expect(fruit.color).to be_instance_of(Structs::Color)
       expect(fruit.color.name).to eq('yellow')
     end
 
@@ -140,9 +143,9 @@ describe "A DSL with argument handling describing fruit" do
           color 'yellow'
         end
       ")
-      expect(fruit).to be_instance_of($Fruit)
+      expect(fruit).to be_instance_of(Structs::Fruit)
       expect(fruit.name).to eq('banana')
-      expect(fruit.color).to be_instance_of($Color)
+      expect(fruit.color).to be_instance_of(Structs::Color)
       expect(fruit.color.name).to eq('yellow')
     end
 
@@ -154,9 +157,9 @@ describe "A DSL with argument handling describing fruit" do
           end
         end
       ")
-      expect(fruit).to be_instance_of($Fruit)
+      expect(fruit).to be_instance_of(Structs::Fruit)
       expect(fruit.name).to eq('banana')
-      expect(fruit.color).to be_instance_of($Color)
+      expect(fruit.color).to be_instance_of(Structs::Color)
       expect(fruit.color.name).to eq('green')
     end
   end

data/spec/class_as_subdsl_spec.rb

@@ -2,9 +2,6 @@
 # does the right thing.
 
 describe "Passing a class into generate_dsl" do
-  $Car = Struct.new(:maker, :wheel)
-  $Wheel = Struct.new(:maker, :size)
-
   it "can do it" do
     wheel_dsl = Class.new(DSL::Maker) do
       add_entrypoint(:wheel, {
@@ -12,7 +9,7 @@ describe "Passing a class into generate_dsl" do
         :maker => String,
       }) do |*args|
         default(:maker, args, 0)
-        $Wheel.new(maker, size)
+        Structs::Wheel.new(maker, size)
       end
     end
 
@@ -22,7 +19,7 @@ describe "Passing a class into generate_dsl" do
         :wheel => wheel_dsl.entrypoint(:wheel),
       }) do |*args|
         default(:maker, args, 0)
-        $Car.new(maker, wheel)
+        Structs::Car.new(maker, wheel)
       end
     end
 
@@ -33,9 +30,9 @@ describe "Passing a class into generate_dsl" do
         end
       end
     end
-    expect(car).to be_instance_of($Car)
+    expect(car).to be_instance_of(Structs::Car)
     expect(car.maker).to eq('honda')
-    expect(car.wheel).to be_instance_of($Wheel)
+    expect(car.wheel).to be_instance_of(Structs::Wheel)
     expect(car.wheel.maker).to eq('goodyear')
     expect(car.wheel.size).to eq(26)
   end
@@ -49,7 +46,7 @@ describe "Passing a class into generate_dsl" do
         :maker => String,
       }) do |*args|
         default(:maker, args, 0)
-        $Wheel.new(maker, size)
+        Structs::Wheel.new(maker, size)
       end
     end
 
@@ -63,7 +60,7 @@ describe "Passing a class into generate_dsl" do
         :wheel => wheel_dsl.entrypoint(:wheel),
       }) do |*args|
         default(:maker, args, 0)
-        $Car.new(maker, wheel)
+        Structs::Car.new(maker, wheel)
       end
     end
 
@@ -74,9 +71,9 @@ describe "Passing a class into generate_dsl" do
         end
       end
     end
-    expect(car).to be_instance_of($Car)
+    expect(car).to be_instance_of(Structs::Car)
     expect(car.maker).to eq('honda')
-    expect(car.wheel).to be_instance_of($Wheel)
+    expect(car.wheel).to be_instance_of(Structs::Wheel)
     expect(car.wheel.maker).to eq('goodyear')
     expect(car.wheel.size).to eq(26)
   end

data/spec/error_spec.rb

@@ -11,10 +11,44 @@ describe "DSL::Maker validation" do
     }.to raise_error('Block required for generate_dsl')
   end
 
-  it "requires a block for execute_dsl" do
-    expect {
-      Class.new(DSL::Maker).execute_dsl
-    }.to raise_error('Block required for execute_dsl')
+  describe "for :parse_dsl" do
+    it "requires an entrypoint" do
+      expect {
+        Class.new(DSL::Maker).parse_dsl("")
+      }.to raise_error('Must call add_entrypoint before parse_dsl')
+    end
+
+    it "requires a string (check nil)" do
+      expect {
+        kls = Class.new(DSL::Maker)
+        kls.add_entrypoint(:x) {}
+        kls.parse_dsl
+      }.to raise_error('String required for parse_dsl')
+    end
+
+    it "requires a string (check number)" do
+      expect {
+        kls = Class.new(DSL::Maker)
+        kls.add_entrypoint(:x) {}
+        kls.parse_dsl(1)
+      }.to raise_error('String required for parse_dsl')
+    end
+  end
+
+  describe "for :execute_dsl" do
+    it "requires an entrypoint" do
+      expect {
+        Class.new(DSL::Maker).execute_dsl {}
+      }.to raise_error('Must call add_entrypoint before execute_dsl')
+    end
+
+    it "requires a block" do
+      expect {
+        kls = Class.new(DSL::Maker)
+        kls.add_entrypoint(:x) {}
+        kls.execute_dsl
+      }.to raise_error('Block required for execute_dsl')
+    end
   end
 
   describe "for attributes" do

data/spec/helper_spec.rb

@@ -1,15 +1,12 @@
 # This uses a DSL that also provides a set of useful helpers.
 #
 describe "A DSL with helpers" do
-  $Car = Struct.new(:maker, :wheel)
-  $Wheel = Struct.new(:maker, :size)
-
   it "can add a helper that's useful" do
     dsl_class = Class.new(DSL::Maker) do
       add_entrypoint(:car, {
         :maker => String,
       }) do
-        $Car.new(maker)
+        Structs::Car.new(maker)
       end
 
       add_helper(:transform) do |name|
@@ -22,7 +19,7 @@ describe "A DSL with helpers" do
         maker transform('Honda')
       }
     ")
-    expect(car).to be_instance_of($Car)
+    expect(car).to be_instance_of(Structs::Car)
     expect(car.maker).to eq('HONDA')
   end
 
@@ -36,10 +33,10 @@ describe "A DSL with helpers" do
         :wheel => generate_dsl({
           :maker => String,
         }) do
-          $Wheel.new(maker)
+          Structs::Wheel.new(maker)
         end
       }) do
-        $Car.new(maker, wheel)
+        Structs::Car.new(maker, wheel)
       end
 
       add_helper(:transform2) do |name|
@@ -55,9 +52,9 @@ describe "A DSL with helpers" do
         }
       }
     ")
-    expect(car).to be_instance_of($Car)
+    expect(car).to be_instance_of(Structs::Car)
     expect(car.maker).to eq('Honda')
-    expect(car.wheel).to be_instance_of($Wheel)
+    expect(car.wheel).to be_instance_of(Structs::Wheel)
     expect(car.wheel.maker).to eq('GOODYEAR')
   end
 end

data/spec/multi_level_spec.rb

@@ -4,8 +4,6 @@
 # 1. Because we're creating classes on the fly, we must fully-qualify the Boolean
 # class name. If we created real classes, the context would be provided for us.
 describe 'A multi-level DSL making family-trees' do
-  $Person = Struct.new(:name, :child)
-
   it "can handle a simple single-level parse of a two-level DSL" do
     dsl_class = Class.new(DSL::Maker) do
       add_entrypoint(:person, {
@@ -13,15 +11,15 @@ describe 'A multi-level DSL making family-trees' do
         :child => generate_dsl({
           :name => String,
         }) {
-          $Person.new(name)
+          Structs::Person.new(name)
         },
       }) do
-        $Person.new(name, child)
+        Structs::Person.new(name, child)
       end
     end
 
     person = dsl_class.parse_dsl('person { name "Tom" }')
-    expect(person).to be_instance_of($Person)
+    expect(person).to be_instance_of(Structs::Person)
     expect(person.name).to eq('Tom')
     expect(person.child).to be_nil
   end
@@ -33,10 +31,10 @@ describe 'A multi-level DSL making family-trees' do
         :child => generate_dsl({
           :name => String,
         }) {
-          $Person.new(name, nil)
+          Structs::Person.new(name, nil)
         },
       }) do
-        $Person.new(name, child)
+        Structs::Person.new(name, child)
       end
     end
 
@@ -48,9 +46,9 @@ describe 'A multi-level DSL making family-trees' do
         }
       }
     ")
-    expect(person).to be_instance_of($Person)
+    expect(person).to be_instance_of(Structs::Person)
     expect(person.name).to eq('Tom')
-    expect(person.child).to be_instance_of($Person)
+    expect(person.child).to be_instance_of(Structs::Person)
     expect(person.child.name).to eq('Bill')
   end
 
@@ -63,13 +61,13 @@ describe 'A multi-level DSL making family-trees' do
           :child => generate_dsl({
             :name => String,
           }) {
-            $Person.new(name, nil)
+            Structs::Person.new(name, nil)
           },
         }) {
-          $Person.new(name, child)
+          Structs::Person.new(name, child)
         },
       }) do
-        $Person.new(name, child)
+        Structs::Person.new(name, child)
       end
     end
 
@@ -84,11 +82,11 @@ describe 'A multi-level DSL making family-trees' do
         }
       }
     ")
-    expect(person).to be_instance_of($Person)
+    expect(person).to be_instance_of(Structs::Person)
     expect(person.name).to eq('Tom')
-    expect(person.child).to be_instance_of($Person)
+    expect(person.child).to be_instance_of(Structs::Person)
     expect(person.child.name).to eq('Bill')
-    expect(person.child.child).to be_instance_of($Person)
+    expect(person.child.child).to be_instance_of(Structs::Person)
     expect(person.child.child.name).to eq('Judith')
   end
 
@@ -98,7 +96,7 @@ describe 'A multi-level DSL making family-trees' do
         person_dsl = add_entrypoint(:person, {
           :name => String,
         }) do
-          $Person.new(name, child)
+          Structs::Person.new(name, child)
         end
         build_dsl_element(person_dsl, :child, person_dsl)
       end
@@ -145,19 +143,18 @@ describe 'A multi-level DSL making family-trees' do
         'Adam', 'Seth', 'Enos', 'Cainan', 'Mahalaleel', 'Jared',
         'Enoch', 'Methuselah', 'Lamech', 'Noah', 'Shem',
       ].each do |name|
-        expect(person).to be_instance_of($Person)
+        expect(person).to be_instance_of(Structs::Person)
         expect(person.name).to eq(name)
         person = person.child
       end
     end
 
     it "can handle two axes of recursion" do
-      OtherPerson = Struct.new(:name, :mother, :father)
       dsl_class = Class.new(DSL::Maker) do
         person_dsl = add_entrypoint(:person, {
           :name => String,
         }) do
-          OtherPerson.new(name, mother, father)
+          Structs::OtherPerson.new(name, mother, father)
         end
         build_dsl_element(person_dsl, :mother, person_dsl)
         build_dsl_element(person_dsl, :father, person_dsl)
@@ -175,15 +172,15 @@ describe 'A multi-level DSL making family-trees' do
         }
       ")
 
-      expect(person).to be_instance_of(OtherPerson)
+      expect(person).to be_instance_of(Structs::OtherPerson)
       expect(person.name).to eq('John Smith')
 
       mother = person.mother
-      expect(mother).to be_instance_of(OtherPerson)
+      expect(mother).to be_instance_of(Structs::OtherPerson)
       expect(mother.name).to eq('Mary Smith')
 
       father = person.father
-      expect(father).to be_instance_of(OtherPerson)
+      expect(father).to be_instance_of(Structs::OtherPerson)
       expect(father.name).to eq('Tom Smith')
     end
   end

data/spec/multiple_invocation_spec.rb

@@ -1,15 +1,12 @@
-# This will use a DSL that defines $Cars
+# This will use a DSL that defines Structs::Cars
 
 describe "A DSL describing cars used with multiple invocations" do
-  $Car = Struct.new(:maker, :wheel)
-  $Truck = Struct.new(:maker, :wheel)
-
   it "returns two items in the right order" do
     dsl_class = Class.new(DSL::Maker) do
       add_entrypoint(:car, {
-        :maker => String,
+        :maker => DSL::Maker::Any,
       }) do
-        $Car.new(maker)
+        Structs::Car.new(maker)
       end
     end
 
@@ -19,9 +16,9 @@ describe "A DSL describing cars used with multiple invocations" do
     ")
     expect(cars).to be_instance_of(Array)
     expect(cars.length).to eq(2)
-    expect(cars[0]).to be_instance_of($Car)
+    expect(cars[0]).to be_instance_of(Structs::Car)
     expect(cars[0].maker).to eq('Honda')
-    expect(cars[1]).to be_instance_of($Car)
+    expect(cars[1]).to be_instance_of(Structs::Car)
     expect(cars[1].maker).to eq('Acura')
   end
 
@@ -30,12 +27,12 @@ describe "A DSL describing cars used with multiple invocations" do
       add_entrypoint(:car, {
         :maker => String,
       }) do
-        $Car.new(maker)
+        Structs::Car.new(maker)
       end
       add_entrypoint(:truck, {
         :maker => String,
       }) do
-        $Truck.new(maker)
+        Structs::Truck.new(maker)
       end
     end
 
@@ -46,11 +43,11 @@ describe "A DSL describing cars used with multiple invocations" do
     ")
     expect(vehicles).to be_instance_of(Array)
     expect(vehicles.length).to eq(3)
-    expect(vehicles[0]).to be_instance_of($Truck)
+    expect(vehicles[0]).to be_instance_of(Structs::Truck)
     expect(vehicles[0].maker).to eq('Ford')
-    expect(vehicles[1]).to be_instance_of($Car)
+    expect(vehicles[1]).to be_instance_of(Structs::Car)
     expect(vehicles[1].maker).to eq('Honda')
-    expect(vehicles[2]).to be_instance_of($Truck)
+    expect(vehicles[2]).to be_instance_of(Structs::Truck)
     expect(vehicles[2].maker).to eq('Toyota')
   end
 
@@ -59,12 +56,12 @@ describe "A DSL describing cars used with multiple invocations" do
       add_entrypoint(:car, {
         :maker => String,
       }) do
-        $Car.new(maker)
+        Structs::Car.new(maker)
       end
       add_entrypoint(:truck, {
         :maker => String,
       }) do
-        $Truck.new(maker)
+        Structs::Truck.new(maker)
       end
     end
 
@@ -75,11 +72,11 @@ describe "A DSL describing cars used with multiple invocations" do
     end
     expect(vehicles).to be_instance_of(Array)
     expect(vehicles.length).to eq(3)
-    expect(vehicles[0]).to be_instance_of($Truck)
+    expect(vehicles[0]).to be_instance_of(Structs::Truck)
     expect(vehicles[0].maker).to eq('Ford')
-    expect(vehicles[1]).to be_instance_of($Car)
+    expect(vehicles[1]).to be_instance_of(Structs::Car)
     expect(vehicles[1].maker).to eq('Honda')
-    expect(vehicles[2]).to be_instance_of($Truck)
+    expect(vehicles[2]).to be_instance_of(Structs::Truck)
     expect(vehicles[2].maker).to eq('Toyota')
   end
 end

data/spec/single_level_spec.rb

@@ -11,22 +11,46 @@
 # 1. Because we're creating classes on the fly, we must fully-qualify the Boolean
 # class name. If we created real classes, the context would be provided for us.
 describe 'A single-level DSL for pizza' do
-  $toppings = [:cheese, :pepperoni, :bacon, :sauce]
-  $Pizza = Struct.new(*$toppings)
-
+  # This uses $toppings defined in spec/spec_helper.rb
   def verify_pizza(pizza, values={})
-    expect(pizza).to be_instance_of($Pizza)
+    expect(pizza).to be_instance_of(Structs::Pizza)
     $toppings.each do |topping|
       expect(pizza.send(topping)).to eq(values[topping])
     end
   end
 
+  describe 'handles an empty DSL' do
+    it 'with :parse_dsl' do
+      dsl_class = Class.new(DSL::Maker) do
+        add_entrypoint(:pizza) {
+          Structs::Pizza.new
+        }
+      end
+
+      pizza = dsl_class.parse_dsl('')
+      expect(pizza).to be(nil)
+    end
+
+    it 'with :execute_dsl' do
+      dsl_class = Class.new(DSL::Maker) do
+        add_entrypoint(:pizza) {
+          Structs::Pizza.new
+        }
+      end
+
+      pizza = dsl_class.execute_dsl {}
+      expect(pizza).to be(nil)
+    end
+  end
+
   it 'makes a blank pizza' do
     dsl_class = Class.new(DSL::Maker) do
-      add_entrypoint(:pizza) { $Pizza.new }
+      add_entrypoint(:pizza) {
+        Structs::Pizza.new
+      }
     end
 
-    pizza = dsl_class.parse_dsl('pizza')
+    pizza = dsl_class.parse_dsl('pizza {}')
     verify_pizza(pizza)
   end
 
@@ -36,7 +60,7 @@ describe 'A single-level DSL for pizza' do
       add_entrypoint(:pizza, {
         :cheese => DSL::Maker::Boolean,
       }) do
-        $Pizza.new(cheese, nil, nil, nil)
+        Structs::Pizza.new(cheese, nil, nil, nil)
       end
     end
 
@@ -84,7 +108,7 @@ describe 'A single-level DSL for pizza' do
       add_entrypoint(:pizza, {
         :sauce => String,
       }) do
-        $Pizza.new(nil, nil, nil, sauce)
+        Structs::Pizza.new(nil, nil, nil, sauce)
       end
     end
 
@@ -109,7 +133,7 @@ describe 'A single-level DSL for pizza' do
         :pepperoni => DSL::Maker::Boolean,
         :sauce => String,
       }) do
-        $Pizza.new(cheese, pepperoni, bacon, sauce)
+        Structs::Pizza.new(cheese, pepperoni, bacon, sauce)
       end
 
       add_entrypoint(:pizza, toppings_dsl)
@@ -139,7 +163,7 @@ describe 'A single-level DSL for pizza' do
         :pepperoni => DSL::Maker::Boolean,
         :sauce => String,
       }) do
-        $Pizza.new(cheese, pepperoni, bacon, sauce)
+        Structs::Pizza.new(cheese, pepperoni, bacon, sauce)
       end
 
       add_entrypoint(:pizza, toppings_dsl)

data/spec/spec_helper.rb

@@ -29,3 +29,19 @@ unless on_1_8?
 end
 
 require 'dsl/maker'
+
+module Structs
+  Car = Struct.new(:maker, :wheel)
+  Truck = Struct.new(:maker, :wheel)
+  Wheel = Struct.new(:maker, :size)
+
+  Person = Struct.new(:name, :child)
+  OtherPerson = Struct.new(:name, :mother, :father)
+
+  $toppings = [:cheese, :pepperoni, :bacon, :sauce]
+  Pizza = Struct.new(*$toppings)
+
+  Color = Struct.new(:name)
+  Fruit = Struct.new(:name, :color)
+end
+

data/spec/validation_spec.rb

@@ -9,7 +9,7 @@ describe "Validations" do
         :pepperoni => DSL::Maker::Boolean,
         :sauce => String,
       }) do
-        $Pizza.new(cheese, pepperoni, bacon, sauce)
+        Structs::Pizza.new(cheese, pepperoni, bacon, sauce)
       end
 
       add_entrypoint(:pizza, toppings_dsl)
@@ -26,4 +26,30 @@ describe "Validations" do
       dsl_class.parse_dsl("pizza { sauce :extra }")
     }.to_not raise_error
   end
+
+  it "validates at the dsl_class level" do
+    dsl_class = Class.new(DSL::Maker) do
+      toppings_dsl = generate_dsl({
+        :cheese => DSL::Maker::Boolean,
+        :bacon => DSL::Maker::Boolean,
+        :pepperoni => DSL::Maker::Boolean,
+        :sauce => String,
+      }) do
+        Structs::Pizza.new(cheese, pepperoni, bacon, sauce)
+      end
+      toppings_dsl.add_verification do |item|
+        return "Pizza must have sauce" unless item.sauce
+      end
+
+      add_entrypoint(:pizza, toppings_dsl)
+    end
+
+    expect {
+      dsl_class.parse_dsl("pizza {}")
+    }.to raise_error("Pizza must have sauce")
+
+    expect {
+      dsl_class.parse_dsl("pizza { sauce :extra }")
+    }.to_not raise_error
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dsl_maker
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Rob Kinyon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-06 00:00:00.000000000 Z
+date: 2015-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: docile