yourdsl 0.7.0

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

data/Gemfile

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

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Ryan Allen, Envato Pty Ltd
+
+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,106 @@
+# YourDSL
+
+## Assumptions.
+
+* People love libraries with DSLs like Sinatra and ActiveRecord and Babushka and AASM and (name your favourite Ruby library).
+* What they love about these is the small amount of Ruby syntax required to get a whole lot done.
+* They love that they can contextualise their definitions (that make the libraries do things) with natural Ruby syntax such as blocks.
+* To enable these kinds of libraries the use of so-called 'meta-programming' constructs are required (instance_eval, instance_exec).
+* Clever but inexperienced Ruby programmers often make very useful libraries with wonderful APIs but horrible internals
+
+## Goals.
+
+* Decouple the language definition of an internal DSL from its implementation
+* Allow library authors to dream up APIs and implement them without entering Ruby metaprogramming hell (it is a real place).
+
+## Example
+    class Feature < Test::Unit::TestCase
+      # Configuring lispy to geenrate an AST for our language
+
+      PROC_KEYWORDS = [:Given, :When, :Then, :And]
+      KEYWORDS = [:Scenario, :Tag] + PROC_KEYWORDS
+
+      extend YourDSL
+      record_your_dsl :only => KEYWORDS, :retain_blocks_for => PROC_KEYWORDS
+
+      # Using our language
+      Scenario "this gets lispyified" do
+        Given "something" do
+        end
+
+        Then "test something exists" do
+          fail "ohai"
+        end
+      end
+    end
+
+    # Barfing out the AST for the above
+    require 'rubygems'
+    require 'awesome_print'
+    ap Feature.output
+
+    # Example 'interpreter' for the AST generated above
+    # Executes the block on the Given and Then from above sequentially
+    # Spike on how an acceptance testing DSL could work
+    Feature.class_eval do
+      def test_something
+        scenario = Feature.output.expressions.first
+        steps = scenario.scope.expressions
+        instance_eval &steps[0].proc
+        instance_eval &steps[1].proc
+      end
+    end
+
+     OUTPUTS:
+     ➜  example git:(no_more_last_last_last) ✗ ruby feature.rb
+     {
+                :file => "feature.rb",
+         :expressions => [
+             [0] {
+                 :symbol => :Scenario,
+                   :args => "this gets lispyified",
+                 :lineno => "14",
+                   :proc => nil,
+                  :scope => {
+                     :expressions => [
+                         [0] {
+                             :symbol => :Given,
+                               :args => "something",
+                             :lineno => "15",
+                               :proc => #<Proc:0x000001010e9140@feature.rb:15>,
+                              :scope => nil
+                         },
+                         [1] {
+                             :symbol => :Then,
+                               :args => "test something exists",
+                             :lineno => "18",
+                               :proc => #<Proc:0x000001010e8ec0@feature.rb:18>,
+                              :scope => nil
+                         }
+                     ]
+                 }
+             }
+         ]
+     }
+     Loaded suite feature
+     Started
+     E
+     Finished in 0.006305 seconds.
+
+       1) Error:
+     test_something(Feature):
+     RuntimeError: ohai
+         feature.rb:19:in `block (2 levels) in <class:Feature>'
+         feature.rb:34:in `instance_eval'
+         feature.rb:34:in `test_something'
+
+     1 tests, 0 assertions, 0 failures, 1 errors, 0 skips
+
+## Credits
+
+* Lispy concept and original impl by Ryan Allen (http://github.com/ryan-allen/lispy)
+* Rewritten and extended by Evan Light (http://github.com/elight/yourdsl)
+
+## License.
+
+Released under the MIT license (see MIT-LICENSE).

data/Rakefile

@@ -0,0 +1,14 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+task :default do
+  Rake::Task['run_tests'].invoke
+end
+
+task :run_tests do
+  if RUBY_VERSION =~ /^1.9/
+    require_relative 'test/yourdsl_test'
+  else
+    require 'test/yourdsl_test'
+  end
+end

data/example/feature.rb

@@ -0,0 +1,82 @@
+load '../lib/yourdsl.rb'
+
+require 'test/unit'
+
+class Feature < Test::Unit::TestCase
+  PROC_KEYWORDS = [:Given, :When, :Then, :And]
+  KEYWORDS = [:Scenario, :Tag] + PROC_KEYWORDS
+
+  extend YourDSL
+  record_your_dsl :only => KEYWORDS, :retain_blocks_for => PROC_KEYWORDS
+
+  # Everything after this gets lispyified
+
+  Scenario "this gets lispyified" do
+    Given "something" do
+    end
+
+    Then "test something exists" do
+      fail "ohai"
+    end
+  end
+end
+
+require 'rubygems'
+require 'awesome_print'
+ap Feature.output
+
+Feature.class_eval do
+  # manually execute "Given" and "Then"
+  def test_something
+    scenario = Feature.output.expressions.first
+    steps = scenario.scope.expressions
+    instance_eval &steps[0].proc
+    instance_eval &steps[1].proc
+  end
+end
+
+# OUTPUTS:
+# ➜  example git:(no_more_last_last_last) ✗ ruby feature.rb
+# {
+#            :file => "feature.rb",
+#     :expressions => [
+#         [0] {
+#             :symbol => :Scenario,
+#               :args => "this gets lispyified",
+#             :lineno => "14",
+#               :proc => nil,
+#              :scope => {
+#                 :expressions => [
+#                     [0] {
+#                         :symbol => :Given,
+#                           :args => "something",
+#                         :lineno => "15",
+#                           :proc => #<Proc:0x000001010e9140@feature.rb:15>,
+#                          :scope => nil
+#                     },
+#                     [1] {
+#                         :symbol => :Then,
+#                           :args => "test something exists",
+#                         :lineno => "18",
+#                           :proc => #<Proc:0x000001010e8ec0@feature.rb:18>,
+#                          :scope => nil
+#                     }
+#                 ]
+#             }
+#         }
+#     ]
+# }
+# Loaded suite feature
+# Started
+# E
+# Finished in 0.006305 seconds.
+#
+#   1) Error:
+# test_something(Feature):
+# RuntimeError: ohai
+#     feature.rb:19:in `block (2 levels) in <class:Feature>'
+#     feature.rb:34:in `instance_eval'
+#     feature.rb:34:in `test_something'
+#
+# 1 tests, 0 assertions, 0 failures, 1 errors, 0 skips
+#

data/lib/yourdsl.rb

@@ -0,0 +1,74 @@
+module YourDSL
+  class Scope < Struct.new(:expressions); end
+  class Expression < Struct.new(:symbol, :args, :lineno, :proc, :scope); end
+  class Output < Struct.new(:file, :expressions); end
+
+  VERSION = '0.7.0'
+
+  METHODS_TO_KEEP = /^__/, /class/, /instance_/, /method_missing/, /object_id/
+
+  instance_methods.each do |m|
+    undef_method m unless METHODS_TO_KEEP.find { |r| r.match m }
+  end
+
+  def record_your_dsl(opts = {})
+    @@remember_blocks_starting_with = Array(opts[:retain_blocks_for])
+    @@only = Array(opts[:only])
+    @@exclude = Array(opts[:except])
+    @@output = Output.new
+    @@file = nil
+    @stack = []
+  end
+
+  def output
+    if @current_scope
+      @@output.expressions = @current_scope.expressions
+    end
+    @@output
+  end
+
+  def file=(file)
+    unless @@file
+      @@file = file
+      @@output.file = @@file
+    end
+  end
+
+  def method_missing(sym, *args, &block)
+    caller[0] =~ (/(.*):(.*):in?/)
+    file, lineno = $1, $2
+    self.file = file
+
+    if !@@only.empty? && !@@only.include?(sym)
+      fail(NoMethodError, sym.to_s)
+    end
+    if !@@exclude.empty? && @@exclude.include?(sym)
+      fail(NoMethodError, sym.to_s)
+    end
+
+    args = (args.length == 1 ? args.first : args)
+    @current_scope ||= Scope.new([])
+    @current_scope.expressions << Expression.new(sym, args, lineno)
+    if block
+      # there is some simpler recursive way of doing this, will fix it shortly
+      if @@remember_blocks_starting_with.include? sym
+        @current_scope.expressions.last.proc = block
+      else
+        nest(&block)
+      end
+    end
+  end
+
+private
+  def nest(&block)
+    @stack.push @current_scope
+
+    new_scope = Scope.new([])
+    @current_scope.expressions.last.scope = new_scope
+    @current_scope = new_scope
+
+    instance_exec(&block)
+
+    @current_scope = @stack.pop
+  end
+end

data/test/yourdsl_test.rb

@@ -0,0 +1,154 @@
+require 'test/unit'
+require 'yourdsl'
+
+class YourDSLTest < Test::Unit::TestCase
+  class Whatever
+    extend YourDSL
+    record_your_dsl
+
+    setup :workers => 30, :connections => 1024
+    http :access_log => :off do
+      server :listen => 80 do
+        location '/' do
+          doc_root '/var/www/website'
+        end
+        location '~ .php$' do
+          fcgi :port => 8877
+          script_root '/var/www/website'
+        end
+      end
+    end
+    ohai
+  end
+  @@whatever = Whatever.output
+
+  class MoarYourDSL
+    extend YourDSL
+    record_your_dsl
+
+    setup
+    setup do
+      lol
+      lol do
+        hi
+        hi
+      end
+    end
+  end
+  @@moar_yourdsl = MoarYourDSL.output
+
+  class RetainBlocks
+    extend YourDSL
+    record_your_dsl :retain_blocks_for => [:Given, :When, :Then]
+
+    Scenario "My first awesome scenario" do
+      Given "teh shiznit" do
+        #shiznit
+      end
+
+      When "I do something" do
+        #komg.do_something
+      end
+
+      Then "this is pending"
+    end
+  end
+  @@retain_blocks = RetainBlocks.output
+
+  begin
+    class OptInParsing
+      extend YourDSL
+      record_your_dsl :only => [:Foo]
+
+      Foo "bar" do
+        blech
+      end
+    end
+  rescue
+    @@opt_in_parsing_error = $!
+  end
+
+  begin
+    class OptOutParsing
+      extend YourDSL
+      record_your_dsl :except => [:blech]
+
+      Foo "bar" do
+        blech
+      end
+    end
+  rescue
+    @@opt_out_parsing_error = $!
+  end
+
+  def test_yourdsl
+    expected = YourDSL::Output.new(__FILE__, [
+      YourDSL::Expression.new(:setup, {:workers=>30, :connections=>1024}, "9"),
+      YourDSL::Expression.new(:http, {:access_log =>:off}, "10", nil,
+        YourDSL::Scope.new.tap { |s1| s1.expressions = [
+          YourDSL::Expression.new(:server, {:listen=>80}, "11", nil,
+            YourDSL::Scope.new.tap { |s2| s2.expressions = [
+              YourDSL::Expression.new(:location, '/', "12", nil,
+                YourDSL::Scope.new.tap { |s3| s3.expressions = [
+                  YourDSL::Expression.new(:doc_root, '/var/www/website', "13")
+                ]}
+              ),
+              YourDSL::Expression.new(:location, '~ .php$', "15", nil,
+                YourDSL::Scope.new.tap { |s4| s4.expressions = [
+                  YourDSL::Expression.new(:fcgi, {:port => 8877}, "16"),
+                  YourDSL::Expression.new(:script_root, '/var/www/website', "17")
+                ]}
+              )
+            ]}
+          )
+        ]}
+      ),
+      YourDSL::Expression.new(:ohai, [], "21")
+    ])
+    assert_equal expected, @@whatever
+  end
+
+  def test_moar_yourdsl
+    expected = YourDSL::Output.new(__FILE__, [
+      YourDSL::Expression.new(:setup, [], "29"),
+      YourDSL::Expression.new(:setup, [], "30", nil,
+        YourDSL::Scope.new.tap { |s1| s1.expressions = [
+          YourDSL::Expression.new(:lol, [], "31"),
+          YourDSL::Expression.new(:lol, [], "32", nil,
+            YourDSL::Scope.new.tap { |s2| s2.expressions = [
+              YourDSL::Expression.new(:hi, [], "33"),
+              YourDSL::Expression.new(:hi, [], "34")
+            ]}
+          )
+        ]}
+      )
+    ])
+    assert_equal expected, @@moar_yourdsl
+  end
+
+  def test_conditionally_preserving_procs
+    ast = @@retain_blocks
+    scenario = ast.expressions.first
+    assert_equal :Scenario, scenario.symbol
+    assert_equal "My first awesome scenario", scenario.args
+    given = scenario.scope.expressions.first
+    assert_equal :Given, given.symbol
+    assert_equal "teh shiznit", given.args
+    assert_instance_of Proc, given.proc
+    assert_nil given.scope
+  end
+
+  def test_opt_in_parsing
+    assert_instance_of NoMethodError, @@opt_in_parsing_error
+    assert_match "blech", @@opt_in_parsing_error.message
+  end
+
+  def test_opt_out_parsing
+    begin
+      flunk if @@opt_out_parsing_fail
+    rescue
+      assert_instance_of NoMethodError, @@opt_out_parsing_error
+      assert_match "blech", @@opt_out_parsing_error.message
+    end
+  end
+end

data/yourdsl.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "yourdsl"
+
+Gem::Specification.new do |s|
+  s.name        = "yourdsl"
+  s.version     = YourDSL::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Evan Light", "Ryan Allen"]
+  s.email       = ["evan@tripledogdare.net", "ryan@ryanface.com"]
+  s.homepage    = "http://rubygems.org/gems/yourdsl"
+  s.summary     = %q{~1/2 of a compiler: a partial lexer and nested DSL language implementation}
+  s.description = %q{Records an internal DSL for playback as an AST within Ruby}
+
+  s.rubyforge_project = "yourdsl"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: yourdsl
+version: !ruby/object:Gem::Version
+  version: 0.7.0
+  prerelease: 
+platform: ruby
+authors:
+- Evan Light
+- Ryan Allen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-08-08 00:00:00.000000000Z
+dependencies: []
+description: Records an internal DSL for playback as an AST within Ruby
+email:
+- evan@tripledogdare.net
+- ryan@ryanface.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- example/feature.rb
+- lib/yourdsl.rb
+- test/yourdsl_test.rb
+- yourdsl.gemspec
+homepage: http://rubygems.org/gems/yourdsl
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: yourdsl
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: ! '~1/2 of a compiler: a partial lexer and nested DSL language implementation'
+test_files:
+- test/yourdsl_test.rb