dsl_maker 0.0.1

data/spec/error_spec.rb

@@ -0,0 +1,47 @@
+# This verifies the various error-handling situations.
+
+describe "DSL::Maker validation" do
+  it "requires a block for :add_entrypoint" do
+    expect {
+      Class.new(DSL::Maker) do
+        add_entrypoint(:pizza)
+      end
+    }.to raise_error('Block required for add_entrypoint')
+  end
+
+  it "requires a block for :generate_dsl" do
+    expect {
+      Class.new(DSL::Maker) do
+        add_entrypoint(:first, {
+          :second => generate_dsl({})
+        }) {}
+      end
+    }.to raise_error('Block required for generate_dsl')
+  end
+
+  it "requires a recognized type for attributes" do
+    expect {
+      Class.new(DSL::Maker) do
+        add_entrypoint(:pizza, {
+          :cheese => true,
+        }) do
+          Pizza.new(cheese, nil, nil, nil)
+        end
+      end
+    }.to raise_error("Unrecognized element type 'true'")
+  end
+
+  it "rejects attributes which block Boolean helper methods" do
+    %w(yes no on off __apply).each do |name|
+      expect {
+        Class.new(DSL::Maker) do
+          add_entrypoint(:pizza, {
+            name => String,
+          }) do
+            Pizza.new(cheese, nil, nil, nil)
+          end
+        end
+      }.to raise_error("Illegal attribute name '#{name}'")
+    end
+  end
+end

data/spec/multi_level_spec.rb

@@ -0,0 +1,158 @@
+# This will use a DSL that parses a family tree.
+#
+# Notes:
+# 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, {
+        :name => String,
+        :child => generate_dsl({
+          :name => String,
+        }) {
+          Person.new(name)
+        },
+      }) do
+        Person.new(name, child)
+      end
+    end
+
+    person = dsl_class.parse_dsl('person { name "Tom" }')
+    expect(person).to be_instance_of(Person)
+    expect(person.name).to eq('Tom')
+    expect(person.child).to be_nil
+  end
+
+  it "can handle a two-level parse of a two-level DSL" do
+    dsl_class = Class.new(DSL::Maker) do
+      add_entrypoint(:person, {
+        :name => String,
+        :child => generate_dsl({
+          :name => String,
+        }) {
+          Person.new(name, nil)
+        },
+      }) do
+        Person.new(name, child)
+      end
+    end
+
+    person = dsl_class.parse_dsl("
+      person {
+        name 'Tom'
+        child {
+          name 'Bill'
+        }
+      }
+    ")
+    expect(person).to be_instance_of(Person)
+    expect(person.name).to eq('Tom')
+    expect(person.child).to be_instance_of(Person)
+    expect(person.child.name).to eq('Bill')
+  end
+
+  it "can handle a three-level parse of a three-level DSL" do
+    dsl_class = Class.new(DSL::Maker) do
+      add_entrypoint(:person, {
+        :name => String,
+        :child => generate_dsl({
+          :name => String,
+          :child => generate_dsl({
+            :name => String,
+          }) {
+            Person.new(name, nil)
+          },
+        }) {
+          Person.new(name, child)
+        },
+      }) do
+        Person.new(name, child)
+      end
+    end
+
+    person = dsl_class.parse_dsl("
+      person {
+        name 'Tom'
+        child {
+          name 'Bill'
+          child {
+            name 'Judith'
+          }
+        }
+      }
+    ")
+    expect(person).to be_instance_of(Person)
+    expect(person.name).to eq('Tom')
+    expect(person.child).to be_instance_of(Person)
+    expect(person.child.name).to eq('Bill')
+    expect(person.child.child).to be_instance_of(Person)
+    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)
+      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'
+          child {
+            name 'Enos'
+            child {
+              name 'Cainan'
+              child {
+                name 'Mahalaleel'
+                child {
+                  name 'Jared'
+                  child {
+                    name 'Enoch'
+                    child {
+                      name 'Methuselah'
+                      child {
+                        name 'Lamech'
+                        child {
+                          name 'Noah'
+                          child {
+                            name 'Shem'
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    ")
+
+    [
+      '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
+end

data/spec/multiple_invocation_spec.rb

@@ -0,0 +1,56 @@
+# This will use a DSL that defines Cars
+
+describe "A DSL describing cars used with multiple invocations" do
+  Car = Struct.new(:maker)
+  Truck = Struct.new(:maker)
+
+  it "returns two items in the right order" do
+    dsl_class = Class.new(DSL::Maker) do
+      add_entrypoint(:car, {
+        :maker => String,
+      }) do
+        Car.new(maker)
+      end
+    end
+
+    cars = dsl_class.parse_dsl("
+      car { maker 'Honda' }
+      car { maker 'Acura' }
+    ")
+    expect(cars).to be_instance_of(Array)
+    expect(cars.length).to eq(2)
+    expect(cars[0]).to be_instance_of(Car)
+    expect(cars[0].maker).to eq('Honda')
+    expect(cars[1]).to be_instance_of(Car)
+    expect(cars[1].maker).to eq('Acura')
+  end
+
+  it "returns items from different entrypoints in the right order" 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.parse_dsl("
+      truck { maker 'Ford' }
+      car { maker 'Honda' }
+      truck { maker 'Toyota' }
+    ")
+    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

@@ -0,0 +1,131 @@
+# This will use the pizza-maker DSL from Docile's documentation.
+# @sauce_level = :extra
+# pizza do
+#   cheese yes
+#   pepperoni yes
+#   sauce @sauce_level
+# end
+#=> #<Pizza:0x00001009dc398 @cheese=true, @pepperoni=true, @bacon=false, @sauce=:extra>
+
+# Notes:
+# 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)
+
+  def verify_pizza(pizza, values={})
+    expect(pizza).to be_instance_of(Pizza)
+    $toppings.each do |topping|
+      expect(pizza.send(topping)).to eq(values[topping])
+    end
+  end
+
+  it 'makes a blank pizza' do
+    dsl_class = Class.new(DSL::Maker) do
+      add_entrypoint(:pizza) { Pizza.new }
+    end
+
+    pizza = dsl_class.parse_dsl('pizza')
+    verify_pizza(pizza)
+  end
+
+  # This tests all the possible Boolean invocations
+  it 'makes a cheese(-less) pizza' do
+    dsl_class = Class.new(DSL::Maker) do
+      add_entrypoint(:pizza, {
+        :cheese => DSL::Maker::Boolean,
+      }) do
+        Pizza.new(cheese, nil, nil, nil)
+      end
+    end
+
+    # There is no way to tell if this is invocation is to set the value or to
+    # retrieve the value from within the DSL. Therefore, we assume it's a getter
+    # and don't default the value to true. Otherwise, false values wouldn't work.
+    pizza = dsl_class.parse_dsl('pizza { cheese }')
+    verify_pizza(pizza, :cheese => false)
+
+    # Test the Ruby booleans and falsey's.
+    [ true, false, nil ].each do |cheese|
+      pizza = dsl_class.parse_dsl("pizza { cheese #{cheese} }")
+      verify_pizza(pizza, :cheese => !!cheese)
+    end
+
+    # Test the true values we provide
+    %w(Yes On True yes on).each do |cheese|
+      pizza = dsl_class.parse_dsl("pizza { cheese #{cheese} }")
+      verify_pizza(pizza, :cheese => true)
+    end
+
+    # Test the false values we provide
+    %w(No Off False no off).each do |cheese|
+      pizza = dsl_class.parse_dsl("pizza { cheese #{cheese} }")
+      verify_pizza(pizza, :cheese => false)
+    end
+
+    # Test the boolean-ized strings we provide
+    %w(Yes On True yes on true).each do |cheese|
+      pizza = dsl_class.parse_dsl("pizza { cheese '#{cheese}' }")
+      verify_pizza(pizza, :cheese => true)
+    end
+    %w(No Off False no off false nil).each do |cheese|
+      pizza = dsl_class.parse_dsl("pizza { cheese '#{cheese}' }")
+      verify_pizza(pizza, :cheese => false)
+    end
+
+    # Test some other things which should all be true
+    pizza = dsl_class.parse_dsl("pizza { cheese 5 }")
+    verify_pizza(pizza, :cheese => true)
+  end
+
+  it 'makes a saucy pizza' do
+    dsl_class = Class.new(DSL::Maker) do
+      add_entrypoint(:pizza, {
+        :sauce => String,
+      }) do
+        Pizza.new(nil, nil, nil, sauce)
+      end
+    end
+
+    [ :extra, 'extra', :none ].each do |level|
+      pizza = case level
+        when String
+          dsl_class.parse_dsl("pizza { sauce '#{level}' }")
+        when Symbol
+          dsl_class.parse_dsl("pizza { sauce :#{level} }")
+        else
+          raise "Unexpected class #{level.class}"
+      end
+      verify_pizza(pizza, :sauce => level.to_s)
+    end
+  end
+
+  it 'makes a pizza with everything' do
+    dsl_class = Class.new(DSL::Maker) do
+      add_entrypoint(:pizza, {
+        :cheese => DSL::Maker::Boolean,
+        :bacon => DSL::Maker::Boolean,
+        :pepperoni => DSL::Maker::Boolean,
+        :sauce => String,
+      }) do
+        Pizza.new(cheese, pepperoni, bacon, sauce)
+      end
+    end
+
+    pizza = dsl_class.parse_dsl("
+      pizza {
+        cheese yes
+        pepperoni yes
+        bacon no
+        sauce :extra
+      }
+    ")
+    verify_pizza(pizza,
+      :sauce => 'extra',
+      :pepperoni => true,
+      :bacon => false,
+      :cheese => true,
+    )
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+require File.expand_path('on_what', File.dirname(File.dirname(__FILE__)))
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end
+
+unless on_1_8?
+  begin
+    require 'simplecov'
+
+    SimpleCov.configure do
+      add_filter '/spec/'
+      add_filter '/vendor/'
+      minimum_coverage 100
+      refuse_coverage_drop
+    end
+
+    if on_travis?
+      require 'codecov'
+      SimpleCov.formatter = SimpleCov::Formatter::Codecov
+    end
+
+    SimpleCov.start
+  rescue LoadError
+    puts "Coverage is disabled - install simplecov to enable."
+  end
+end
+
+require 'dsl/maker'

metadata

@@ -0,0 +1,172 @@
+--- !ruby/object:Gem::Specification
+name: dsl_maker
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Rob Kinyon
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: docile
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: github-markup
+  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'
+description: Easy multi-level DSLs, built on top of Docile
+email: rob.kinyon@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitattributes"
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- ".yardopts"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- dsl_maker.gemspec
+- lib/dsl/maker.rb
+- lib/dsl/maker/version.rb
+- on_what.rb
+- spec/args_spec.rb
+- spec/error_spec.rb
+- spec/multi_level_spec.rb
+- spec/multiple_invocation_spec.rb
+- spec/single_level_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/robkinyon/ruby-dsl-maker
+licenses:
+- GPL2
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Easy multi-level DSLs
+test_files: []