dsl_maker 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b6149b9dfdb94cd22dec949a542d68eaf6ab8a58
-  data.tar.gz: 688c84bd9102359e839b2884967c610f6435a726
+  metadata.gz: 0a86f0dfab03af6d1b25904ef7c7dd0ef4090b33
+  data.tar.gz: f63cd7dd2beaa1850851dba11a42d19ac67300a0
 SHA512:
-  metadata.gz: edd7f3990066e812e461e42981cc920517f434d34ceab0801f16dcd8f9ab385828b6faea8732cd7f9f638fa11a3e2e596075253d135b9063c9a1b5431bc08ec3
-  data.tar.gz: cf857c182b8145d4b47dcd8b08e12c3697f60f2ea9a50aed770607112178f40185ce23d0a9086c5147999341b18cbceb10512fa94cc2c0fe22b94435815b8036
+  metadata.gz: bb2d7b7e998e65c35b595904fe49fb0b42c549d8796d303a5ac9b5faa366f7b6fb12e4ba3a74fef8517c961eb5a9086b44fde8a1080481a4028e2eb6a9deeffb
+  data.tar.gz: 8a9aafadbc5c3c4a99e071609e49abf2b95f115b8106431e272500b96fad7afa26e913bd465fc762ff5525b1718dec33edcf1c8e83283c89cdf84a3cca43429a

data/Changes

@@ -0,0 +1,10 @@
+Revision history for DSL::Maker (ordered by revision number).
+
+0.0.2 Jul 22 2015
+   - Allow add_entrypoint() to take a DSL class instead of args
+   - Added execute_dsl() that takes a block
+   - Several refactorings to improve maintainability
+      - Recursive DSLs are now simpler to define and maintain
+
+0.0.1 Jul 21 2015
+   - Initial release

data/README.md

@@ -1,5 +1,9 @@
 # DSL::Maker
 
+[![Gem Version](https://img.shields.io/gem/v/dsl_maker.svg)](https://rubygems.org/gems/dsl_maker)
+[![Gem Downloads](https://img.shields.io/gem/dt/dsl_maker.svg)](https://rubygems.org/gems/dsl_maker)
+[![Yard Docs](http://img.shields.io/badge/yard-docs-blue.svg)](http://rubydoc.info/github/robkinyon/ruby-dsl-maker)
+
 [![Build Status](https://img.shields.io/travis/robkinyon/ruby-dsl-maker.svg)](https://travis-ci.org/robkinyon/ruby-dsl-maker)
 [![Code Climate](https://img.shields.io/codeclimate/github/robkinyon/ruby-dsl-maker.svg)](https://codeclimate.com/github/robkinyon/ruby-dsl-maker)
 [![Code Coverage](https://img.shields.io/codecov/c/github/robkinyon/ruby-dsl-maker.svg)](https://codecov.io/github/robkinyon/ruby-dsl-maker)
@@ -157,7 +161,7 @@ best to explain.
 
 ```ruby
 Person = Struct.new(:name, :age, :mother, :father)
-class FamilyTree < DSL::Maker
+class FamilyTreeDSL < DSL::Maker
   parent = generate_dsl({
     :name => String,
     :age  => String,
@@ -177,7 +181,7 @@ class FamilyTree < DSL::Maker
   end
 end
 
-john_smith = FamilyTree.parse_dsl("
+john_smith = FamilyTreeDSL.parse_dsl("
   person 'John Smith' do
     age 20
     mother 'Mary Smith' do
@@ -193,6 +197,31 @@ john_smith = FamilyTree.parse_dsl("
 
 The result is exactly the same as before.
 
+### Recursive DSLs
+
+We're making an artificial distinction between `person` and `parent` in the
+`FamilyTreeDSL` example above. Really, we want to say "A person can have a mother
+and a father and those are also persons." So, let's say that.
+
+```ruby
+Person = Struct.new(:name, :age, :mother, :father)
+
+class FamilyTreeDSL < DSL::Maker
+  person_dsl = add_entrypoint(:person, {
+    :name => String,
+    :age  => String,
+  }) do |*args|
+    default(:name, args)
+    Person.new(name, age mother, father)
+  end
+
+  build_dsl_element(person_dsl, :mother, person_dsl)
+  build_dsl_element(person_dsl, :father, person_dsl)
+end
+```
+
+Now, we can handle an arbitrarily-deep family tree.
+
 ### Handling multiple items
 
 Chef's recipe files have many entries of different types in them. It doesn't do
@@ -239,7 +268,7 @@ you get back an `Array` with everything in the right order.
 
 ### Class Methods
 
-DSL::Maker provides three class methods - two for constructing your DSL and one
+DSL::Maker provides five class methods - three for constructing your DSL and two
 for parsing your DSL.
 
 * `add_entrypoint(Symbol, Hash={}, Block)`
@@ -261,13 +290,13 @@ This is normally called by `generate_dsl()` to actually construct the DSL elemen
 It is provided for you so that you can create recursive DSL definitions. Look at
 the tests in `spec/multi_level_spec.rb` for an example of this.
 
-* `parse_dsl(String)`
+* `parse_dsl(String)` / `execute_dsl(&block)`
 
 You call this on your DSL class when you're ready to invoke your DSL. It will
 return whatever the block provided `add_entrypoint()` returns.
 
 In the case of multiple DSL entrypoints (for example, a normal Chef recipe),
-`parse_dsl()` will return an array with all the return values in the order of
+these methods will return an array with all the return values in the order of
 invocation.
 
 ### Coercions

data/lib/dsl/maker/version.rb

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

data/lib/dsl/maker.rb

@@ -2,206 +2,228 @@ require 'dsl/maker/version'
 
 require 'docile'
 
-# The DSL namespace
-module DSL
-  # This is the base class we provide.
-  class Maker
-    # This is a useful class that contains all the Boolean handling we have.
-    class Boolean
-      {
-        :yes => true, :no  => false,
-        :on  => true, :off => false,
-      }.each do |name, result|
-        define_method(name) { result }
-      end
+# This is the base class we provide.
+class DSL::Maker
+  # This is a useful class that contains all the Boolean handling we have.
+  class Boolean
+    {
+      :yes => true, :no  => false,
+      :on  => true, :off => false,
+    }.each do |name, result|
+      define_method(name) { result }
+    end
 
-      # 21 character method names are obscene. Make it easier to read.
-      alias :___set :instance_variable_set
-
-      # 21 character method names are obscene. Make it easier to read.
-      alias :___get :instance_variable_get
-
-      # A helper method for handling defaults from args easily.
-      # 
-      # @param method_name [String]  The name of the attribute being defaulted.
-      # @param args        [Array]   The arguments provided to the block.
-      # @param position    [Integer] The index in args to work with, default 0.
-      #
-      # @return nil
-      def default(method_name, args, position=0)
-        method = method_name.to_sym
-        if args.length >= (position + 1) && !self.send(method)
-          self.send(method, args[position])
-        end
-        return
+    # 21 character method names are obscene. Make it easier to read.
+    alias :___set :instance_variable_set
+
+    # 21 character method names are obscene. Make it easier to read.
+    alias :___get :instance_variable_get
+
+    # A helper method for handling defaults from args easily.
+    # 
+    # @param method_name [String]  The name of the attribute being defaulted.
+    # @param args        [Array]   The arguments provided to the block.
+    # @param position    [Integer] The index in args to work with, default 0.
+    #
+    # @return nil
+    def default(method_name, args, position=0)
+      method = method_name.to_sym
+      if args.length >= (position + 1) && !self.send(method)
+        self.send(method, args[position])
       end
+      return
     end
-    Yes = On = True = true
-    No = Off = False = false
-    $to_bool = lambda do |value|
-      if value
-        return false if %w(no off false nil).include? value.to_s.downcase
-      end
-      # The bang-bang boolean-izes the value. We want this to be lossy.
-      !!value
+  end
+  Yes = On = True = true
+  No = Off = False = false
+  $to_bool = lambda do |value|
+    if value
+      return false if %w(no off false nil).include? value.to_s.downcase
     end
+    # The bang-bang boolean-izes the value. We want this to be lossy.
+    !!value
+  end
 
-    # TODO: Is this safe if the invoker doesn't use parse_dsl()?
+  # TODO: Is this safe if the invoker doesn't use parse_dsl()?
+  @@accumulator = []
+
+  # Parse the DSL provided in the parameter.
+  #
+  # @note If the DSL contains multiple entrypoints, then this will return an
+  # Array. This is desirable.
+  #
+  # @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)
+    # add_entrypoint() will use @@accumulator to handle multiple entrypoints.
+    # Reset it here so that we're only handling the values from this run.
     @@accumulator = []
+    eval dsl, self.get_binding
+    if @@accumulator.length <= 1
+      return @@accumulator[0]
+    end
+    return @@accumulator
+  end
 
-    # Parse the DSL provided in the parameter
-    #
-    # @note If the DSL contains multiple entrypoints, then this will return an
-    # Array. This is desirable.
-    #
-    # @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)
-      # add_entrypoint() will use @@accumulator to handle multiple entrypoints.
-      # Reset it here so that we're only handling the values from this run.
-      @@accumulator = []
-      eval dsl, self.get_binding
-      if @@accumulator.length <= 1
-        return @@accumulator[0]
-      end
-      return @@accumulator
+  # Execute the DSL provided in the block.
+  #
+  # @note If the DSL contains multiple entrypoints, then this will return an
+  # Array. This is desirable.
+  #
+  # @param &block [Block] The DSL to be executed by this class.
+  #
+  # @return    [Object] Whatever is returned by &block
+  def self.execute_dsl(&block)
+    @@accumulator = []
+    instance_eval(&block)
+    if @@accumulator.length <= 1
+      return @@accumulator[0]
     end
+    return @@accumulator
+  end
 
-    @@dsl_elements = {
-      String => ->(klass, name, type) {
-        as_attr = '@' + name.to_s
-        klass.class_eval do
-          define_method(name.to_sym) do |*args|
-            ___set(as_attr, args[0].to_s) unless args.empty?
-            ___get(as_attr)
-          end
+  @@dsl_elements = {
+    String => ->(klass, name, type) {
+      as_attr = '@' + name.to_s
+      klass.class_eval do
+        define_method(name.to_sym) do |*args|
+          ___set(as_attr, args[0].to_s) unless args.empty?
+          ___get(as_attr)
         end
-      },
-      Boolean => ->(klass, name, type) {
-        as_attr = '@' + name.to_s
-        klass.class_eval do
-          define_method(name.to_sym) do |*args|
-            ___set(as_attr, $to_bool.call(args[0])) unless args.empty?
-            # Ensure that the default nil returns as false.
-            !!___get(as_attr)
-          end
+      end
+    },
+    Boolean => ->(klass, name, type) {
+      as_attr = '@' + name.to_s
+      klass.class_eval do
+        define_method(name.to_sym) do |*args|
+          ___set(as_attr, $to_bool.call(args[0])) unless args.empty?
+          # Ensure that the default nil returns as false.
+          !!___get(as_attr)
         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 coercions are:
-    #
-    #   * String  - 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 coercion spoken above.
-    #
-    # @return   nil
-    def self.build_dsl_element(klass, name, type)
-      if @@dsl_elements.has_key?(type)
-        @@dsl_elements[type].call(klass, name, type)
-      elsif type.is_a?(Class) && type.ancestors.include?(Boolean)
-        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
-
-              # I don't know why this code doesn't work, but it's why __apply().
-              #___set(as_attr, obj.instance_exec(*args, &defn_block))
-              ___set(as_attr, obj.__apply(*args))
-            end
-            ___get(as_attr)
+      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 coercions are:
+  #
+  #   * String  - 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 coercion spoken above.
+  #
+  # @return   nil
+  def self.build_dsl_element(klass, name, type)
+    if @@dsl_elements.has_key?(type)
+      @@dsl_elements[type].call(klass, name, type)
+    elsif type.is_a?(Class) && type.ancestors.include?(Boolean)
+      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
+
+            # I don't know why this code doesn't work, but it's why __apply().
+            #___set(as_attr, obj.instance_exec(*args, &defn_block))
+            ___set(as_attr, obj.__apply(*args))
           end
+          ___get(as_attr)
         end
-      else
-        raise "Unrecognized element type '#{type}'"
       end
-
-      return
+    else
+      raise "Unrecognized element type '#{type}'"
     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
-    # different class. This method creates anonymous classes that each represents
-    # a different level in the DSL's structure.
-    #
-    # The creation of each DSL element is delegated to build_dsl_element.
-    #
-    # @param args  [Hash]   the elements of the DSL block (passed to generate_dsl)
-    # @param defn_block [Proc]   what is executed once the DSL block is parsed.
-    #
-    # @return      [Class]  The class that implements this level's DSL definition.
-    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
-      klass = Class.new(Boolean) do
-        # 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
-        define_method(:__apply) do |*args|
-          instance_exec(*args, &defn_block)
-        end
-      end
+    return
+  end
 
-      args.each do |name, type|
-        if klass.new.respond_to? name.to_sym
-          raise "Illegal attribute name '#{name}'"
-        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
+  # different class. This method creates anonymous classes that each represents
+  # a different level in the DSL's structure.
+  #
+  # The creation of each DSL element is delegated to build_dsl_element.
+  #
+  # @param args  [Hash]   the elements of the DSL block (passed to generate_dsl)
+  # @param defn_block [Proc]   what is executed once the DSL block is parsed.
+  #
+  # @return      [Class]  The class that implements this level's DSL definition.
+  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(Boolean) do
+      # 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
+      define_method(:__apply) do |*args|
+        instance_exec(*args, &defn_block)
+      end
+    end
 
-        build_dsl_element(klass, name, type)
+    args.each do |name, type|
+      if dsl_class.new.respond_to? name.to_sym
+        raise "Illegal attribute name '#{name}'"
       end
 
-      return klass
+      build_dsl_element(dsl_class, name, type)
     end
 
-    # Add an entrypoint (top-level DSL element) to this class's DSL.
-    #
-    # This delegates to generate_dsl() for the majority of the work.
-    #
-    # @param name  [String] the name of the entrypoint
-    # @param args  [Hash]   the elements of the DSL block (passed to generate_dsl)
-    # @param defn_block [Proc]   what is executed once the DSL block is parsed.
-    # 
-    # @return      nil
-    def self.add_entrypoint(name, args={}, &defn_block)
-      # Without defn_block, there's no way to give back the result of the
-      # DSL parsing. So, raise an error if we don't get one.
-      # TODO: Provide a default block that returns the datastructure as a HoH.
-      raise "Block required for add_entrypoint" unless block_given?
-
-      # Ensure that get_binding() exists in the child class. This is necessary to
-      # provide parse_dsl() so that eval works as expected. We have to do it here
-      # because this is the only place we know for certain will be called.
-      unless self.respond_to? :get_binding
-        define_singleton_method(:get_binding) { binding }
-      end
+    return dsl_class
+  end
 
-      # FIXME: This is a wart. Really, we should be pulling out name, then
-      # yielding to generate_dsl() in some fashion.
-      dsl_class = generate_dsl(args) {}
+  # Add an entrypoint (top-level DSL element) to this class's DSL.
+  #
+  # This delegates to generate_dsl() for the majority of the work.
+  #
+  # @note `args` could be a Hash (to be passed to generate_dsl()) or the result
+  # of a call to generate_dsl().
+  #
+  # @param name  [String] the name of the entrypoint
+  # @param args  [Hash]   the elements of the DSL block (passed to generate_dsl)
+  # @param defn_block [Proc]   what is executed once the DSL block is parsed.
+  # 
+  # @return      [Class]  The class that implements this level's DSL definition.
+  def self.add_entrypoint(name, args={}, &defn_block)
+    # Without defn_block, there's no way to give back the result of the
+    # DSL parsing. So, raise an error if we don't get one.
+    # TODO: Provide a default block that returns the datastructure as a HoH.
+    raise "Block required for add_entrypoint" unless block_given?
+
+    # Ensure that get_binding() exists in the child class. This is necessary to
+    # provide parse_dsl() so that eval works as expected. We have to do it here
+    # because this is the only place we know for certain will be called.
+    unless self.respond_to? :get_binding
+      define_singleton_method(:get_binding) { binding }
+    end
 
-      define_singleton_method(name.to_sym) do |*args, &dsl_block|
-        obj = dsl_class.new
-        Docile.dsl_eval(obj, &dsl_block) if dsl_block
-        rv = obj.instance_exec(*args, &defn_block)
-        @@accumulator.push(rv)
-        return rv
-      end
-      return
+    # FIXME: This is a wart. Really, we should be pulling out name, then
+    # yielding to generate_dsl() in some fashion.
+    if args.is_a?(Class) && args.ancestors.include?(Boolean)
+      dsl_class = args
+    else
+      dsl_class = generate_dsl(args, &defn_block)
     end
+
+    define_singleton_method(name.to_sym) do |*args, &dsl_block|
+      obj = dsl_class.new
+      Docile.dsl_eval(obj, &dsl_block) if dsl_block
+      rv = obj.instance_exec(*args, &defn_block)
+      @@accumulator.push(rv)
+      return rv
+    end
+
+    return dsl_class
   end
 end

data/spec/multi_level_spec.rb

@@ -92,47 +92,43 @@ describe 'A multi-level DSL making family-trees' do
     expect(person.child.child.name).to eq('Judith')
   end
 
-  it "can define things recursively" do
-    dsl_class = Class.new(DSL::Maker) do
-      person = generate_dsl({
-        :name => String,
-      }) {
-        Person.new(name, child)
-      }
-      build_dsl_element(person, :child, person)
-
-      add_entrypoint(:person, {
-        :name => String,
-        :child => person,
-      }) do
-        Person.new(name, child)
+  describe "with recursion" do
+    it "can handle a single axis of recursion" do
+      dsl_class = Class.new(DSL::Maker) do
+        person_dsl = add_entrypoint(:person, {
+          :name => String,
+        }) do
+          Person.new(name, child)
+        end
+        build_dsl_element(person_dsl, :child, person_dsl)
       end
-    end
 
-    # This is taken from https://en.wikipedia.org/wiki/Family_tree_of_the_Bible
-    person = dsl_class.parse_dsl("
-      person {
-        name 'Adam'
-        child {
-          name 'Seth'
+      # This list of names is taken from
+      # https://en.wikipedia.org/wiki/Family_tree_of_the_Bible
+      person = dsl_class.parse_dsl("
+        person {
+          name 'Adam'
           child {
-            name 'Enos'
+            name 'Seth'
             child {
-              name 'Cainan'
+              name 'Enos'
               child {
-                name 'Mahalaleel'
+                name 'Cainan'
                 child {
-                  name 'Jared'
+                  name 'Mahalaleel'
                   child {
-                    name 'Enoch'
+                    name 'Jared'
                     child {
-                      name 'Methuselah'
+                      name 'Enoch'
                       child {
-                        name 'Lamech'
+                        name 'Methuselah'
                         child {
-                          name 'Noah'
+                          name 'Lamech'
                           child {
-                            name 'Shem'
+                            name 'Noah'
+                            child {
+                              name 'Shem'
+                            }
                           }
                         }
                       }
@@ -143,16 +139,52 @@ 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.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)
+        end
+        build_dsl_element(person_dsl, :mother, person_dsl)
+        build_dsl_element(person_dsl, :father, person_dsl)
+      end
+
+      person = dsl_class.parse_dsl("
+        person {
+          name 'John Smith'
+          mother {
+            name 'Mary Smith'
+          }
+          father {
+            name 'Tom Smith'
+          }
+        }
+      ")
+
+      expect(person).to be_instance_of(OtherPerson)
+      expect(person.name).to eq('John Smith')
+
+      mother = person.mother
+      expect(mother).to be_instance_of(OtherPerson)
+      expect(mother.name).to eq('Mary Smith')
 
-    [
-      'Adam', 'Seth', 'Enos', 'Cainan', 'Mahalaleel', 'Jared',
-      'Enoch', 'Methuselah', 'Lamech', 'Noah', 'Shem',
-    ].each do |name|
-      expect(person).to be_instance_of(Person)
-      expect(person.name).to eq(name)
-      person = person.child
+      father = person.father
+      expect(father).to be_instance_of(OtherPerson)
+      expect(father.name).to eq('Tom Smith')
     end
   end
 end

data/spec/multiple_invocation_spec.rb

@@ -53,4 +53,33 @@ describe "A DSL describing cars used with multiple invocations" do
     expect(vehicles[2]).to be_instance_of(Truck)
     expect(vehicles[2].maker).to eq('Toyota')
   end
+
+  it "does all the same things with execute_dsl" do
+    dsl_class = Class.new(DSL::Maker) do
+      add_entrypoint(:car, {
+        :maker => String,
+      }) do
+        Car.new(maker)
+      end
+      add_entrypoint(:truck, {
+        :maker => String,
+      }) do
+        Truck.new(maker)
+      end
+    end
+
+    vehicles = dsl_class.execute_dsl do
+      truck { maker 'Ford' }
+      car { maker 'Honda' }
+      truck { maker 'Toyota' }
+    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].maker).to eq('Ford')
+    expect(vehicles[1]).to be_instance_of(Car)
+    expect(vehicles[1].maker).to eq('Honda')
+    expect(vehicles[2]).to be_instance_of(Truck)
+    expect(vehicles[2].maker).to eq('Toyota')
+  end
 end

data/spec/single_level_spec.rb

@@ -103,12 +103,15 @@ describe 'A single-level DSL for pizza' do
 
   it 'makes a pizza with everything' do
     dsl_class = Class.new(DSL::Maker) do
-      add_entrypoint(:pizza, {
+      toppings_dsl = generate_dsl({
         :cheese => DSL::Maker::Boolean,
         :bacon => DSL::Maker::Boolean,
         :pepperoni => DSL::Maker::Boolean,
         :sauce => String,
-      }) do
+      }) {}
+
+      # This is a wart - this block should be against toppings_dsl, not here.
+      add_entrypoint(:pizza, toppings_dsl) do
         Pizza.new(cheese, pepperoni, bacon, sauce)
       end
     end
@@ -128,4 +131,35 @@ describe 'A single-level DSL for pizza' do
       :cheese => true,
     )
   end
+
+  it 'can execute the DSL directly' 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,
+      }) {}
+
+      # This is a wart - this block should be against toppings_dsl, not here.
+      add_entrypoint(:pizza, toppings_dsl) do
+        Pizza.new(cheese, pepperoni, bacon, sauce)
+      end
+    end
+
+    pizza = dsl_class.execute_dsl do
+      pizza {
+        cheese yes
+        pepperoni yes
+        bacon no
+        sauce :extra
+      }
+    end
+    verify_pizza(pizza,
+      :sauce => 'extra',
+      :pepperoni => true,
+      :bacon => false,
+      :cheese => true,
+    )
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dsl_maker
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Rob Kinyon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-21 00:00:00.000000000 Z
+date: 2015-07-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: docile
@@ -131,6 +131,7 @@ files:
 - ".rspec"
 - ".travis.yml"
 - ".yardopts"
+- Changes
 - Gemfile
 - LICENSE
 - README.md