dsl_block 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6c00534daad8cd4a27d4f3855c4d9a03fad82595
+  data.tar.gz: 4dfb593b99f4653aecd81b661e4a04533068a87e
+SHA512:
+  metadata.gz: bb9421a382aca361db5ff31e801d5f064a5789077d68b994aee65a92d87e4385c26631da68466203c5030f6271371db9444a59c9da991e46fcd41f111da462bf
+  data.tar.gz: 227ebf931eca9fdb584fc51dea8a422a74bfa9fad5823af7127937ef69f0c277efc3c152ebd781f19f4a75cd76c5e0e802d65cfbd5e3783f0215868a965a4376

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+--format documentation

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in dsl_block.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Frank Hall
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,82 @@
+# DslBlock
+
+DslBlock allows you to use classes to define blocks with commands for a Domain Specific Language. The commands are automatically relayed to your instance method.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'dsl_block'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dsl_block
+
+## Usage
+
+    class Foo < DslBlock
+      commands :show_foo
+      def show_foo(x)
+        puts "Mr. T says you are a foo times #{x.to_i}"
+      end
+    end
+
+    class Bar < DslBlock
+      commands :show_bar
+      def show_bar(x)
+        puts "Ordering #{x.to_i} Shirley Temples from the bar"
+      end
+    end
+
+    class Baz < DslBlock
+      commands :show_baz
+      def show_baz(x)
+        puts "Baz spaz #{x.inspect}"
+      end
+    end
+
+    Baz.add_command_to(Bar)
+    Bar.add_command_to(Foo, true)
+    Foo.add_command_to(self)
+
+
+    foo do
+      puts self.inspect       # => #<Foo:0x007f98f187e240 @block=#<Proc:0x...>, @parent=nil>
+      x = 10/10
+      show_foo x              # => Mr. T says you are a foo times 1
+
+      bar do
+        x *= 2
+        show_bar x            # => Ordering 2 Shirley Temples from the bar
+        x += 1
+        show_foo x            # => Mr. T says you are a foo times 3
+
+        baz do
+          x *= 4
+          x /= 3
+          show_baz x          # => Baz spaz 4
+          begin
+            x += 1
+            show_bar 5        # This will throw a NameError
+          rescue NameError
+            puts 'No bar for us'
+          end
+
+        end
+
+      end
+
+    end
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,16 @@
+require 'bundler/gem_tasks'
+require 'rdoc/task'
+require 'rspec/core/rake_task'
+require 'rdoc/task'
+
+RDoc::Task.new do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.main = 'DslBlock.html'
+  rdoc.rdoc_files.include 'lib'
+end
+
+
+RSpec::Core::RakeTask.new
+
+task :default => :spec
+task :test => :spec

data/dsl_block.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dsl_block/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'dsl_block'
+  spec.version       = DslBlock::VERSION
+  spec.authors       = ['Frank Hall']
+  spec.email         = ['ChapterHouse.Dune@gmail.com']
+  spec.summary       = %q{Quick and simple DSL creator.}
+  spec.description   = %q{DslBlock is a quick and simple DSL creator.}
+  spec.homepage      = 'http://chapterhouse.github.io/dsl_block'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activesupport', '~> 4.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 2.14.1'
+  spec.add_development_dependency 'simplecov', '~> 0.7.1'
+  spec.add_development_dependency 'rdoc', '~> 4.0.0'
+
+end

data/lib/dsl_block/executor.rb

@@ -0,0 +1,37 @@
+class DslBlock
+
+  # The Executor class is designed to run a block of code in isolation
+  # for the DslBlock class. By running it in a 'sandbox', the block
+  # of code cannot inadvertently access protected and private methods
+  # within the DslBlock without explicate declaration by the DslBlock.
+  # To the user, it will appear that the block runs directly in the
+  # DslBlock but in a partly restricted manner if they care to investigate.
+  # In this fashion, executor is effectively a transparent proxy.
+  class Executor < BasicObject
+
+    def initialize(dsl_block)
+      @dsl_block = dsl_block
+    end
+
+    def method_missing(method, *args, &block)
+      # If the dsl block lists the method as a callable command
+      if @dsl_block._commands.include?(method)
+        # Attempt to call it
+        begin
+          @dsl_block.send(method, *args, &block)
+        rescue => e
+          # If there is any type of error, remove ourselves from the callstack to reduce confusion.
+          e.set_backtrace(::Kernel.caller.select { |x| !x.include?(__FILE__)})
+          ::Kernel.raise e
+        end
+      else
+        # Otherwise raise a no method error as if the method does not really exist, regardless of reality.
+        name_error = ::NameError.new("undefined local variable or method `#{method}' for #{self.inspect}")
+        name_error.set_backtrace(::Kernel.caller.select { |x| !x.include?(__FILE__)})
+        ::Kernel::raise name_error
+      end
+    end
+
+  end
+
+end

data/lib/dsl_block/version.rb

@@ -0,0 +1,10 @@
+class DslBlock
+  # 1.0.0
+  VERSION = '1.0.0'
+
+  module Version # :nodoc: all
+    MAJOR, MINOR, PATCH, *OTHER = VERSION.split('.')
+    NUMBERS = [MAJOR, MINOR, PATCH, *OTHER]
+  end
+
+end

data/lib/dsl_block.rb

@@ -0,0 +1,159 @@
+require 'dsl_block/version'
+require 'dsl_block/executor'
+require 'active_support/core_ext/string/inflections'
+
+# DslBlock is a base class for defining a Domain Specific Language. Subclasses of DslBlock define the desired dsl.
+# These methods become available to ruby code running in the context of the subclass.
+# The block execution is automatically isolated to prevent the called block from accessing instance methods unless
+# specifically designated as callable. DslBlocks can be nested and parent blocks can allow their methods to be exposed to child block.
+#
+# ==== Example
+#    # Define three DslBlocks each with at least one command in each block
+#    class Foo < DslBlock
+#      commands :show_foo
+#      def show_foo(x)
+#        "Mr. T says you are a foo times #{x.to_i}"
+#      end
+#    end
+#
+#    class Bar < DslBlock
+#      commands :show_bar
+#      def show_bar(x)
+#        "Ordering #{x.to_i} Shirley Temples from the bar"
+#      end
+#    end
+#
+#    class Baz < DslBlock
+#      commands :show_baz
+#      def show_baz(x)
+#        "Baz spaz #{x.inspect}"
+#      end
+#    end
+#
+#    # Connect the blocks to each other so they can be easily nested
+#    Baz.add_command_to(Bar)
+#    Bar.add_command_to(Foo, true) # Let Bar blocks also respond to foo methods
+#    Foo.add_command_to(self)
+#
+#    # Use the new DSL
+#    foo do
+#      self.inspect       # => #<Foo:0x007fdbd52b54e0 @block=#<Proc:0x007fdbd52b5530@/home/fhall/wonderland/alice.rb:29>, @parent=nil>
+#      x = 10/10
+#      show_foo x         # => Mr. T says you are a foo times 1
+#
+#      bar do
+#        x *= 2
+#        show_bar x       # => Ordering 2 Shirley Temples from the bar
+#
+#        x += 1
+#        show_foo x       # => Mr. T says you are a foo times 3
+#
+#        baz do
+#
+#          x *= 4
+#          x /= 3
+#          show_baz x     # => Baz spaz 4
+#
+#          begin
+#            x += 1
+#            show_bar x   # => NameError
+#          rescue NameError
+#            'No bar for us'
+#          end
+#        end
+#
+#      end
+#
+#    end
+#
+class DslBlock
+  # Parent object providing additional commands to the block.
+  attr_accessor :parent
+  # Block of code that will be executed upon yield.
+  attr_accessor :block
+
+  # With no arguments, returns an array of command names that this DslBlock makes available to blocks either directly or indirectly.
+  # With arguments, adds new names to the array of command names, then returns the new array.
+  def self.commands(*args)
+    @commands ||= []
+    @commands = (@commands + args.map(&:to_sym)).uniq
+    @commands
+  end
+
+  # This is a convenience command that allows this DslBlock to inject itself as a method into another DslBlock or Object.
+  # If the parent is also a DslBlock, the new method will automatically be added to the available commands.
+  #
+  # Params:
+  # +destination+:: The object to receive the new method
+  # +propigate_local_commands+:: Allow methods in the destination to be called by the block. (default: false)
+  # +command_name+:: The name of the method to be created or nil to use the default which is based off of the class name. (default: nil)
+  def self.add_command_to(destination, propigate_local_commands=false, command_name=nil)
+    # Determine the name of the method to create
+    command_name = (command_name || name).to_s.underscore.to_sym
+    # Save a reference to our self so we will have something to call in a bit when self will refer to someone else.
+    this_class = self
+    # Define the command in the destination.
+    destination.send(:define_method, command_name) do |&block|
+      # Create a new instance of our self with the callers 'self' passed in as an optional parent.
+      # Immediately after initialization, yield the block.
+      this_class.new(propigate_local_commands ? self : nil, &block).yield
+    end
+    # Add the new command to the parent if it is a DslBlock.
+    destination.commands << command_name if destination.is_a?(Class) && destination < DslBlock
+  end
+
+  # Create a new DslBlock instance.
+  # +parent+:: Optional parent DslBlock or Object that is providing additional commands to the block. (default: nil)
+  # +block+:: Required block of code that will be executed when yield is called on the new DslBlock instance.
+  def initialize(parent = nil, &block)
+    raise ArgumentError, 'block must be provided' unless block_given?
+    @block = block
+    @parent = parent
+  end
+
+  # This is the entire list of commands that this instance makes available to the block of code to be run.
+  # It is a combination of three distinct sources.
+  # 1. The class's declared commands
+  # 2. If there is a parent of this DslBock instance...
+  #    * The parents declared commands if it is a DslBlock
+  #    * The parents public_methods if it is any other type of object
+  # 3. Kernel.methods
+  #
+  # This method is prefixed with an underscore in an attempt to avoid collisions with commands in the given block.
+  def _commands
+    cmds = self.class.commands.dup
+    if @parent
+      if @parent.is_a?(DslBlock)
+        cmds += @parent._commands
+      else
+        cmds +=  @parent.public_methods
+      end
+    end
+    (cmds + Kernel.methods).uniq
+  end
+
+  # Yield the block given.
+  def yield
+    begin
+      # Evaluate the block in an executor to provide isolation
+      # and prevent accidental interference with ourselves.
+      Executor.new(self).instance_eval(&@block)
+    rescue Exception => e
+      e.set_backtrace(caller.select { |x| !x.include?(__FILE__)})
+      raise e
+    end
+  end
+
+  # :nodoc:
+  def respond_to_missing?(method, include_all)
+    @parent && @parent.respond_to?(method, include_all) || super
+  end
+
+  def method_missing(name, *args, &block)
+    if @parent && @parent.respond_to?(name)
+      @parent.send(name, *args, &block)
+    else
+      super
+    end
+  end
+end

data/spec/lib/dsl_block/dsl_executor_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe DslBlock::Executor do
+
+  context '.new' do
+
+    it 'inherits from BasicObject to constrain the block' do
+      expect(DslBlock::Executor.superclass).to equal(BasicObject)
+    end
+
+  end
+
+  context '#method_missing' do
+
+    it 'calls the method on the dsl_block if it contains the method in its #_commands' do
+      dsl_block = Object.new
+      dsl_block.stub(:foo).and_return('bar')
+      dsl_block.stub(:_commands).and_return([:foo, :inspect])
+      executor = DslBlock::Executor.new(dsl_block)
+      expect(executor.foo).to eql('bar')
+    end
+
+    it 'raises NameError if the dsl_block does not contain the method in its #_commands' do
+      dsl_block = Object.new
+      dsl_block.stub(:foo).and_return('bar')
+      dsl_block.stub(:_commands).and_return([:inspect])
+      executor = DslBlock::Executor.new(dsl_block)
+      expect { executor.bar }.to raise_error(NameError)
+    end
+
+  end
+
+  context 'any exception' do
+
+    it 'removes itself from the backtrace to make it easier to understand' do
+      begin
+        dsl_block = Object.new
+        dsl_block.stub(:_commands).and_return([:inspect])
+        executor = DslBlock::Executor.new(dsl_block)
+        executor.bar
+      rescue => e
+        expect(e.backtrace.any? { |x| x.include?('dsl_block/lib/dsl_block/executor.rb')} ).to be_false
+      end
+
+      begin
+        dsl_block = Object.new
+        dsl_block.stub(:foo) { raise 'Kaboom' }
+        dsl_block.stub(:_commands).and_return([:inspect, :foo])
+        executor = DslBlock::Executor.new(dsl_block)
+        executor.foo
+      rescue => e
+        expect(e.message).to eql('Kaboom')
+        expect(e.backtrace.any? { |x| x.include?('dsl_block/lib/dsl_block/executor.rb')} ).to be_false
+      end
+
+    end
+
+  end
+
+
+end

data/spec/lib/dsl_block_spec.rb

@@ -0,0 +1,241 @@
+require 'spec_helper'
+
+describe DslBlock do
+
+  before(:each) do
+    dsl_reset
+  end
+
+  context '.commands' do
+
+    it 'starts as an empty array' do
+      expect(dsl_class1.commands).to eql([])
+    end
+
+    it 'accepts multiple method names' do
+      dsl_class1.commands :a, :b, :c
+      expect(dsl_class1.commands).to eql([:a, :b, :c])
+    end
+
+    it 'appends the method names to the existing list' do
+      dsl_class1.commands :a, :b, :c
+      dsl_class1.commands :d, :e, :f
+      expect(dsl_class1.commands).to eql([:a, :b, :c, :d, :e, :f])
+    end
+
+    it 'returns the current method names when setting' do
+      expect(dsl_class1.commands(*[:a, :b, :c])).to eql([:a, :b, :c])
+      expect(dsl_class1.commands(*[:d, :e, :f])).to eql([:a, :b, :c, :d, :e, :f])
+    end
+
+    it 'removes duplicates' do
+      dsl_class1.commands :a, :b, :a
+      dsl_class1.commands :c, :b, :d
+      expect(dsl_class1.commands).to eql([:a, :b, :c, :d])
+    end
+
+  end
+
+  context '.add_command_to' do
+
+    it 'defines a method in the destination' do
+      dsl_class2.add_command_to(dsl_class1)
+      expect(dsl_class1.instance_methods.include?(dsl_class2_command)).to be_true
+    end
+
+    it 'allows for the name of the method to be chosen' do
+      dsl_class2.add_command_to(dsl_class1, nil, :foo)
+      expect(dsl_class1.instance_methods.include?(:foo)).to be_true
+    end
+
+    it 'adds to the commands in the destination if it is a DslBlock' do
+      dsl_class2.add_command_to(dsl_class1)
+      expect(dsl_class1.commands.include?(dsl_class2_command)).to be_true
+    end
+
+    it 'allows a non DslBlock destination' do
+      generic_class = Class.new
+      dsl_class2.add_command_to(generic_class)
+      expect(generic_class.instance_methods.include?(dsl_class2_command)).to be_true
+    end
+
+    context 'the method created' do
+
+      it 'creates a new instance of the target' do
+        dsl_class2.should_receive(:new).and_call_original
+        dsl12 {}
+      end
+
+      it 'calls the block given' do
+        expect(dsl12 { 1 }).to equal(1)
+      end
+
+      it 'executes the block in the context of the target' do
+        expect(dsl12 { self }).to be_instance_of(dsl_class2)
+      end
+
+    end
+
+    context 'propagate_commands' do
+
+      it 'by default is false and does not propagate parent block commands' do
+        dsl_class1.send(:define_method, :foo) { |x| 'foo' * x }
+        dsl_class1.commands :foo
+
+        dsl = dsl12(false) { foo(2) }
+
+        expect { dsl.yield }.to raise_error(NameError)
+        # Prove we can call it normally
+        expect( dsl.foo(1)).to eql('foo')
+      end
+
+      it 'can be true to propagate parent block commands' do
+        target = nil
+
+        dsl_class1.send(:define_method, :foo) { |x| 'foo' * x }
+        dsl_class1.commands :foo
+
+        dsl = dsl12(false, true) { foo(2) }
+
+        expect(dsl.yield).to eql('foofoo')
+        # Prove we can call it normally
+        expect(dsl.foo(1)).to eql('foo')
+      end
+
+      it 'will not propagate parent block commands that aren\'t marked as commands' do
+        dsl_class1.send(:define_method, :foo) { |x| 'foo' * x }
+        # Unlike above, :foo will not added to the list of commands at this point.
+
+        dsl = dsl12(false) { foo(2) }
+
+        expect { dsl.yield }.to raise_error(NameError)
+        # Prove we can call it normally
+        expect(dsl.foo(1)).to eql('foo')
+      end
+
+    end
+
+  end
+
+
+  context '.new' do
+
+    it 'requires a block' do
+      expect{dsl_class1.new}.to raise_error(ArgumentError, 'block must be provided')
+    end
+
+    it 'stores the block for later execution' do
+      block = Proc.new {}
+      dsl = dsl_class1.new(&block)
+      expect(dsl.instance_variable_get(:@block)).to equal(block)
+    end
+
+    it 'can also take a parent object' do
+      object = Object.new
+      dsl = dsl_class1.new(object) {}
+      expect(dsl.instance_variable_get(:@parent)).to equal(object)
+    end
+
+  end
+
+  context '#_commands' do
+
+    context 'without a parent object' do
+
+      it 'shows only the dsl class commands and the Kernel.methods available to the block passed' do
+        dsl_class1.commands :foo, :bar
+        dsl = dsl1(false) {}
+        expect(dsl._commands.sort).to eql((dsl_class1.commands + Kernel.methods).uniq.sort)
+      end
+
+    end
+
+    context 'with a DslBlock parent' do
+
+      it 'shows the dls class commands, the parent._commands, and the Kernel.methods available to the block passed' do
+        dsl_class2.send(:define_method, :true_self) { self }
+        dsl_class2.commands :true_self
+        dsl_class1.commands :foo, :bar
+        dsl2_instance = dsl12(true, true) { true_self }
+
+        expect(dsl2_instance._commands.sort).to eql((dsl_class1.commands + dsl_class2.commands + Kernel.methods).sort)
+      end
+
+    end
+
+    context 'with a generic Object parent' do
+
+      it 'shows the dls class commands, the object.public_methods, and the Kernel.methods available to the block passed' do
+        array = Array.new
+        dsl1_instance = dsl_class1.new(array) {}
+        expect(dsl1_instance._commands.sort).to eql((Kernel.methods + dsl_class1.commands + array.public_methods).sort.uniq)
+      end
+
+    end
+
+  end
+
+  context '#yield' do
+
+    it 'yields the block given at instantiation' do
+      dsl = dsl_class1.new { 3 }
+      expect(dsl.yield).to equal(3)
+    end
+
+    it 'creates an executor to evaluate the block' do
+      dsl = dsl_class1.new {}
+      DslBlock::Executor.should_receive(:new).with(dsl).and_call_original
+      dsl.yield
+    end
+
+    it 'isolates the block by evaluating it in the context of the executor' do
+      block = Proc.new {}
+      dsl = dsl_class1.new(&block)
+      executor = DslBlock::Executor.new(dsl)
+      executor.should_receive(:instance_eval).with(&block)
+      DslBlock::Executor.stub(:new).and_return(executor)
+      dsl.yield
+    end
+
+    it 'cleans up any backtraces by removing itself from the call stack' do
+      begin
+        dsl123 { raise 'Kaboom' }
+      rescue => e
+        expect(e.message).to eql('Kaboom')
+        expect(e.backtrace.any? { |x| x.include?('dsl_block/lib/dsl_block.rb')} ).to be_false
+      end
+    end
+  end
+
+  context '#respond_to_missing?' do
+
+    it 'behaves as normal if no parent is set' do
+      dsl = dsl_class1.new {}
+      expect(dsl.respond_to?(:each)).to equal(false)
+      expect(dsl.respond_to?(:to_s)).to equal(true)
+    end
+
+    it 'also checks with the parent if it is set' do
+      dsl = dsl_class1.new(Array.new) {}
+      expect(dsl.respond_to?(:each)).to equal(true)
+      expect(dsl.respond_to?(:to_s)).to equal(true)
+    end
+
+  end
+
+  context '#method_missing?' do
+
+    it 'behaves as normal if no parent is set' do
+      dsl = dsl_class1.new {}
+      expect { dsl.each }.to raise_error(NoMethodError)
+    end
+
+    it 'relays the call to the parent if it is set' do
+      dsl = dsl_class1.new(Array.new) {}
+      expect { dsl.each }.not_to raise_error
+    end
+
+  end
+
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,114 @@
+require 'simplecov'
+SimpleCov.start('test_frameworks')
+require 'rspec/autorun'
+require 'dsl_block'
+
+RSpec.configure do |config|
+  config.order = 'random'
+end
+
+# Due to the nature of these tests, the number of discreete classes involved, and scoping issues
+# the memoizaton will occur here instead of the standard rspec 'let' statements. Feel free to
+# move these back to standard let statements if the specs can be kept as clean or cleaner
+
+
+# Generic dsl class. Used in the specs as the outermost block
+def dsl_class1
+  @dsl_class1||= Class.new(DslBlock).tap do |klass|
+    def klass.name
+      'Dsl1'
+    end
+  end
+end
+
+# Generic dsl class. Used in the specs as the middle block
+def dsl_class2
+  @dsl_class2 ||= Class.new(DslBlock).tap do |klass|
+    def klass.name
+      'Dsl2'
+    end
+  end
+end
+
+# Generic dsl class. Used in the specs as the innermst block
+def dsl_class3
+  @dsl_class3 ||= Class.new(DslBlock).tap do |klass|
+    def klass.name
+      'Dsl3'
+    end
+  end
+end
+
+# The command the outermost dsl block is usually called by
+def dsl_class1_command
+  dsl_class1.name.underscore.to_sym
+end
+
+# The command the middle dsl block is usually called by
+def dsl_class2_command
+  dsl_class2.name.underscore.to_sym
+end
+
+# The command the innermost dsl block is usually called by
+def dsl_class3_command
+  dsl_class3.name.underscore.to_sym
+end
+
+# Reset all of the classes for a new test
+def dsl_reset
+  @dsl_class1 = nil
+  @dsl_class2 = nil
+  @dsl_class3 = nil
+end
+
+
+
+
+# The following are helpers to DRY up the tests.
+# The numbers after 'dsl' are references to the order the dsl blocks are nested.
+
+
+# No nested dsl. Block given is run at the ellipsis
+# dsl_class1 do
+#   ...
+# end
+def dsl1(auto_yield=true, &block)
+  dsl = dsl_class1.new(&block)
+  auto_yield ? dsl.yield : dsl
+end
+
+# Nested dsl. Block given is run at the ellipsis
+# dsl_class1 do
+#   dsl_class2 do
+#     ...
+#   end
+# end
+def dsl12(auto_yield=true, propigate12=false,&block)
+  dsl_class2.add_command_to(dsl_class1, propigate12)
+  command = dsl_class2_command
+  dsl = dsl_class1.new do
+    self.send(command, &block)
+  end
+  auto_yield ? dsl.yield : dsl
+end
+
+# Double nested dsl. Block given is run at the ellipsis
+# dsl_class1 do
+#   dsl_class2 do
+#     dsl_class3 do
+#       ...
+#     end
+#   end
+# end
+def dsl123(auto_yield=true, propigate12=false, propigate23=false, &block)
+  dsl_class2.add_command_to(dsl_class1, propigate12)
+  dsl_class3.add_command_to(dsl_class2, propigate23)
+  command2 = dsl_class2_command
+  command3 = dsl_class3_command
+  dsl = dsl_class1.new do
+    self.send(command2) do
+      self.send(command3, &block)
+    end
+  end
+  auto_yield ? dsl.yield : dsl
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: dsl_block
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Frank Hall
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+description: DslBlock is a quick and simple DSL creator.
+email:
+- ChapterHouse.Dune@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- dsl_block.gemspec
+- lib/dsl_block.rb
+- lib/dsl_block/executor.rb
+- lib/dsl_block/version.rb
+- spec/lib/dsl_block/dsl_executor_spec.rb
+- spec/lib/dsl_block_spec.rb
+- spec/spec_helper.rb
+homepage: http://chapterhouse.github.io/dsl_block
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Quick and simple DSL creator.
+test_files:
+- spec/lib/dsl_block/dsl_executor_spec.rb
+- spec/lib/dsl_block_spec.rb
+- spec/spec_helper.rb
+has_rdoc: