parspec 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    Y2RjNGMzNzc3MDhmMDU5OGJjMTQyOGIyNWJjNjNmODc5NmY0ZGVmMQ==
+  data.tar.gz: !binary |-
+    ZjJmOTAzZDM3OGMyNmYxMDkyZGNlODFiMjllNGFhZTVlYjEyYzY0Nw==
+SHA512:
+  metadata.gz: !binary |-
+    NTViMWMxNTJmYmRhMjljZDZkNGEzZjc1OTlhNmVmOTA2ODYwNWU2Y2I4N2My
+    ZjdmMDA1NWZhODQ1ZDM0YWNmMTkwODg2MGNiMjYyODNhNTlmY2ZhZmRlNzlj
+    ZjU4MGNhOTY1ODcyMDEyNzRlN2E5MmM0NjA2NWE4Y2E5YjNiNGQ=
+  data.tar.gz: !binary |-
+    MjBhMThmMWNiNjY4NzcxMmEyNGIxMzM3ODhlZDFhMmU1ZjIzZjE4ODlmYjE3
+    YTYxOGY4Y2MxN2MwNzA2ZTEyNzJjMmEyZTllMTQzYWRmYjY4ODUzMDdlM2E0
+    MjU0ODEyMWM5ZTRhZDkwMTIxYWFhNGFkMzBjMTZkZjgyYmVjNzI=

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

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

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in parspec.gemspec
+gemspec
+
+group :test, :development do
+  gem 'guard-rspec'
+  gem 'wdm', '>= 0.1.0' if RbConfig::CONFIG['target_os'] =~ /mswin|mingw|cygwin/i
+end

data/Guardfile

@@ -0,0 +1,14 @@
+# -*- ruby -*-
+
+format = 'doc' # 'doc' for more verbose, 'progress' for less
+tags   = %w[ ] #
+
+guard 'rspec',
+      cmd: "bundle exec rspec --format #{format} #{tags.map{|tag| "--tag #{tag}"}.join(' ')}",
+      all_after_pass: false do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})             { |m| "spec/#{m[1]}_spec.rb" }
+  watch('lib/parspec.rb')               { 'spec' }
+  watch('spec/spec_helper.rb')          { 'spec' }
+  watch(/spec\/support\/(.+)\.rb/)      { 'spec' }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Marcel Otto
+
+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,238 @@
+# Parspec
+
+A [gUnit](https://theantlrguy.atlassian.net/wiki/display/ANTLR3/gUnit+-+Grammar+Unit+Testing)-like specification language for [Parslet](http://kschiess.github.io/parslet/) parsers and transformers, which translates to [RSpec](http://rspec.info/).
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'parspec', group: :test
+```
+
+And then execute:
+
+    $ bundle
+
+Or install with gem:
+
+    $ gem install parspec
+
+
+## Specification language
+
+### Example
+
+The following example shows parts of the [TOML spec](https://github.com/zerowidth/toml-parslet/blob/master/spec/toml/parser_spec.rb) translated to Parspec:
+
+    parser TOML::Parser
+    
+    value:
+        "120381" OK
+        "0181" FAIL
+        "3.14159" OK
+        ".1" FAIL
+        "true" OK
+        "truefalse" FAIL
+        "1979-05-27T07:32:00Z" OK
+        "1979l05-27 07:32:00" FAIL
+        "\"hello world\"" OK
+        "\"hello\nworld\"" FAIL
+        "\"hello/world\"" FAIL
+    
+        "1234"                 -> ":integer => '1234'"
+        "-0.123"               -> ":float   => '-0.123'"
+        "true"                 -> ":boolean => 'true'"
+        "1979-05-27T07:32:00Z" -> ":datetime => '1979-05-27T07:32:00Z'"
+        "\"hello world\""      -> ":string => 'hello world'"
+        "\"hello\nworld\""     -> ":string => \"hello\nworld\""
+    
+    array:
+        "[]" OK
+        "[1]" OK
+        "[0.1, -0.1, 3.14159]" OK
+        "[ true, false, true, true ]" OK
+        "[1979-05-27T07:32:00Z]" OK  # [2013-02-24T17:26:21Z]
+        "[\n1\n,\n2\n]" OK
+        "[\n\n\t1  , 2,     3\\t,4\n]" OK
+        "[1, 2, \"three\"]" FAIL
+        "[1,2,]" OK
+        "[1,2\n,\\t]" OK
+    
+         "[1,2]"     -> ":array => [ {:integer => '1'}, {:integer => '2'}]"
+         "[]"        -> ":array => '[]'"
+         "[ [1,2] ]"
+            -> ":array => [
+                  {:array => [ {:integer => '1'}, {:integer => '2'}]}
+               ]"
+    
+    key:
+         "foobar" OK
+         "lolwhat.noWAY" OK
+         "no white\\tspace" FAIL
+         "noequal=thing" FAIL
+    
+    assignment:
+          "key=3.14" OK
+          "key = 10" OK
+          "key = true" OK
+          "key = \"value\"" OK
+          "#comment=1" FAIL
+          "thing = 1" -> ":key => 'thing', :value => {:integer => '1'}"
+
+
+### Description
+
+#### Header
+
+A Parspec specification starts with a definition of the subject:
+
+    <type> <instantiation expression>
+
+There are two types of specifications: `parser` and `transformer`. A parser specification describes a `Parslet::Parser`, a transformer specification describes a `Parslet::Transform`. Syntactically these types of specifications are equal, but the generated RSpec descriptions will differ.
+
+The instantiation expression is used to create a RSpec test subject. It usually consists of a constant for a `Parslet::Parser` or `Parslet::Transform` class, according to the type of specification, but can be any valid Ruby expression, which responds to `new` with a `Parslet::Parser` or `Parslet::Tranform` instance.
+
+
+#### Rule examples
+
+After the definition, a series of examples for the grammar rules follows. Rules start with a rule name followed by a colon.
+
+There are two types of examples: simple validations and mapping examples.
+
+
+##### Validations
+
+A validation is a string in double-quotes followed either by the keyword `OK` or `FAIL`, according to the expected outcome of parsing the given string under the given rule. Currently, it is supported in parser specifications only.
+
+For example, the following validation:
+
+    some_rule:
+      "some input" OK
+      "another input" FAIL
+
+will translate to this RSpec description:
+
+```ruby
+context 'some_rule parsing' do
+  subject { parser.some_rule }
+
+  it { should parse 'some input' }
+  it { should_not parse 'another input' }
+end
+```
+
+
+##### Mapping examples
+
+Mapping examples describe the input-output-behaviour of a rule. Syntactically they consist of two strings separated by `->`. Since the semantics of parser and transformer specifications differ, let's discuss them separately, starting with the parser case:
+
+While the input string on the left side is simply some sample text as in a validity example, the output string on the right must contain a valid Ruby expression, which should evaluate to the expected outcome of the respective rule parsing.
+
+For example, the following mapping:
+
+    some_rule:
+      "some input"    -> "42"
+      "another input" -> "{ foo: 'bar' }"
+
+will be translated to the following RSpec parser specification:
+
+```ruby
+context 'some_rule parsing' do
+  subject { parser.some_rule }
+
+  it "should parse 'some input' to 42" do
+    expect(subject.parse('some input')).to eq 42
+  end
+
+  it "should parse 'another input' to { foo: 'bar' }" do
+    expect(subject.parse('another input')).to eq { foo: 'bar' }
+  end
+end
+```
+
+In the case of a transformer specification, both sides must contain Ruby expressions.
+
+
+#### Shared examples
+
+The examples of a rule can be reused inside other rules with the `include` keyword:
+
+    some_rule:
+      "some input"    -> "42"
+      "another input" -> "{ foo: 'bar' }"
+
+    another_rule:
+      include some_rule
+
+
+#### String escaping
+
+Parspec strings in general support the following escape sequences: `\t`, `\n`, `\r`, `\"`, `\\`. 
+  
+
+#### Comments
+
+One-line comments are supported in the `#`-style.
+
+
+## Usage
+
+### Command-line interface
+
+Parspec comes with a command-line interface through the `parspec` command.
+
+For a full description of the available parameters, run:
+
+    $ parspec --help
+    Usage: parspec [options] PARSPEC_FILE
+        -h, --help                       Display this information
+        -v, --version                    Print version information
+        -s, --stdout                     Print the translation to stdout only
+        -o, --out OUTPUT_FILE            Path where translated RSpec file should be stored
+        -b, --beside-input               Put the output file into the same directory as the input
+        -e, --header HEADER              A block of code to be put in front of the translation
+            --no-debug-parse             Don't print the whole Parslet ascii_tree on errors
+
+Unless specified otherwise, the default header is:
+
+```ruby
+# coding: utf-8
+require 'spec_helper'
+require 'parslet/convenience'
+require 'parslet/rig/rspec'
+```
+
+
+### `load_parspec` 
+
+You can use the command-line interface to integrate Parspec in your testing tool chain, e.g. via Rake or Guard. 
+
+But you can also load your Parspec spec from a normal Ruby file in your spec directory with the `load_parspec` command:   
+
+```ruby
+require 'spec_helper'
+require 'parspec'
+require 'my_parser'
+
+load_parspec __FILE__
+```
+
+If the `load_parspec` command gets a filename with the extension `.rb`, it looks for a file with the same name, but the extension `.parspec`. For example, if the former Ruby file would be at `spec/my_parser/my_parser_spec.rb`, the `load_parspec` command would try to load a Parspec spec from a file `spec/my_parser/my_parser_spec.parspec`.
+
+
+Note: This feature is currently implemented via `eval`, till I find a way to include specs from other RSpec files or another alternative. If you have any advice, please share it in issue #1.
+
+
+## Contributing
+
+1. Fork it ( https://github.com/marcelotto/parspec/fork )
+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 a new Pull Request
+
+## Author
+
+- Marcel Otto

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler/gem_tasks'
+

data/bin/parspec

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'parspec'
+Parspec::CLI.run

data/examples/parspec_spec.parspec

@@ -0,0 +1,14 @@
+parser Parspec::Parser
+
+string:
+    "\"test\"" OK
+    "\"test
+     on multiple lines\"" OK
+    "test" FAIL
+
+    "\"test\"" -> "string: 'test'"
+# TODO:   "\"\\\"test\\\"\"" -> "string: '\"test\"'"
+
+validity_example:
+    "\"test\" OK" OK
+    "\"test\" FAIL" OK

data/examples/toml_spec.parspec

@@ -0,0 +1,66 @@
+parser TOML::Parser
+
+value:
+    "1" OK
+    "-123" OK
+    "120381" OK
+    "181" OK
+    "0181" FAIL
+    "0.1" OK
+    "3.14159" OK
+    "-0.00001" OK
+    ".1" FAIL
+    "true" OK
+    "false" OK
+    "truefalse" FAIL
+    "1979-05-27T07:32:00Z" OK
+    "2013-02-24T17:26:21Z" OK
+    "1979l05-27 07:32:00" FAIL
+    "\"\"" OK
+    "\"hello world\"" OK
+    "\"no way, jos\\u00E9\"" OK
+    "\"hello\nworld\"" FAIL
+    "\"hello/world\"" FAIL
+    "\"\\u001F\"" OK
+
+    "1234"                 -> ":integer => '1234'"
+    "-0.123"               -> ":float   => '-0.123'"
+    "true"                 -> ":boolean => 'true'"
+    "1979-05-27T07:32:00Z" -> ":datetime => '1979-05-27T07:32:00Z'"
+    "\"hello world\""      -> ":string => 'hello world'"
+    "\"hello\nworld\""    -> ":string => \"hello\nworld\""
+
+array:
+    "[]" OK
+    "[1]" OK
+    "[1, 2, 3, 4, 5]" OK
+    "[0.1, -0.1, 3.14159]" OK
+    "[ true, false, true, true ]" OK
+    "[1979-05-27T07:32:00Z]" OK  # [2013-02-24T17:26:21Z]
+    "[\n1\n,\n2\n]" OK
+    "[\n\n\t1  , 2,     3\\t,4\n]" OK
+    "[1, 2, \"three\"]" FAIL
+    "[1,2,]" OK
+    "[1,2\n,\\t]" OK
+
+     "[1,2]"     -> ":array => [ {:integer => '1'}, {:integer => '2'}]"
+     "[]"        -> ":array => '[]'"
+     "[ [1,2] ]"
+        -> ":array => [
+              {:array => [ {:integer => '1'}, {:integer => '2'}]}
+           ]"
+
+key:
+     "foobar" OK
+     "lolwhat.noWAY" OK
+     "no white\\tspace" FAIL
+     "noequal=thing" FAIL
+
+assignment:
+      "key=3.14" OK
+      "key = 10" OK
+      "key = 10.10" OK
+      "key = true" OK
+      "key = \"value\"" OK
+      "#comment=1" FAIL
+      "thing = 1" -> ":key => 'thing', :value => {:integer => '1'}"

data/lib/parspec/cli.rb

@@ -0,0 +1,110 @@
+# coding: utf-8
+require 'singleton'
+require 'optparse'
+require 'pathname'
+
+module Parspec
+  class Cli
+    include Singleton
+
+    def run(options = {})
+      @options = options
+      parse_command_line!
+      init_output_dir
+      puts "Translating #@input #{@print_only ? ' ': "to #@output " }..."
+      translation = header + Parspec.translate(@input, @options)
+      if @print_only
+        puts translation
+        exit
+      end
+      File.open(@output, 'w') { |file| file.write(translation) }
+      self
+    end
+
+    def header
+      @header || <<HEADER
+# coding: utf-8
+require 'spec_helper'
+require 'parslet/convenience'
+require 'parslet/rig/rspec'
+
+HEADER
+    end
+
+    private
+
+    def parse_command_line!
+      optparse = OptionParser.new do |opts|
+        opts.banner = 'Usage: parspec [options] PARSPEC_FILE'
+
+        opts.on('-h', '--help', 'Display this information') do
+          puts opts
+          exit
+        end
+
+        opts.on('-v', '--version', 'Print version information') do
+          puts "Parspec #{VERSION}"
+          exit
+        end
+
+        opts.on('-s', '--stdout', 'Print the translation to stdout only') do
+          @print_only = true
+        end
+
+        opts.on('-o', '--out OUTPUT_FILE', 'Path where translated RSpec file should be stored') do |file|
+          @output = file
+        end
+
+        opts.on('-b', '--beside-input', 'Put the output file into the same directory as the input') do
+          @beside_input = true
+        end
+
+        opts.on('-e', '--header HEADER', 'A block of code to be put in front of the translation') do |header|
+          @header = header
+        end
+
+        opts.on('--no-debug-parse', "Don't print the whole Parslet ascii_tree on errors") do
+          @options[:no_debug_parse] = true
+        end
+
+      end
+
+      optparse.parse!
+      if not input = ARGV.shift
+        puts 'Error: no input file given'
+        puts optparse
+        exit(1)
+      end
+      if not File.exist?(input)
+        puts "Error: couldn't find input file #{input}"
+        exit(1)
+      end
+      @input = input
+    end
+
+    def init_output_dir
+      default_dir = File.dirname(@input)
+      default_basename = File.basename(@input, File.extname(@input)) + '.rb'
+
+      # no output defined
+      @output = if not @output
+        File.join (@beside_input ? default_dir : '.'), default_basename
+      # only path given
+      elsif Dir.exist?(@output) or @output.end_with?(File::SEPARATOR) or
+          (File::ALT_SEPARATOR and @output.end_with?(File::ALT_SEPARATOR))
+        warn('Ignoring -b, since directory specified') if @beside_input
+        File.join @output, default_basename
+      # directory and name given
+      elsif File.dirname(@output) != '.'
+        warn('Ignoring -b, since directory specified') if @beside_input
+        @output
+      # only name given
+      else
+        File.join (@beside_input ? default_dir : '.'), @output
+      end
+    end
+
+  end
+
+  CLI = Cli.instance
+end

data/lib/parspec/parser.rb

@@ -0,0 +1,76 @@
+module Parspec
+  class Parser < Parslet::Parser
+    rule(:eof)      { any.absent? }
+    rule(:space)    { match[' \t'].repeat(1) }
+    rule(:newline)  { match['\n'] }
+    rule(:newlines) { newline.repeat(1) | eof }
+    rule(:comment)  { str('#') >> match_till(:newlines).maybe >> (newline | eof) }
+    rule(:ws)       { (space | newline | comment).repeat(1) }
+    rule(:ws?)      { ws.maybe }
+
+    rule(:special)         { match['"\\\\'] }
+    rule(:escaped_special) { str("\\") >> match['tnr"\\\\'] }
+    rule(:string) do
+      str('"') >>
+        ((escaped_special | special.absent? >> any).repeat).as(:string) >>
+      str('"') >> ws?
+    end
+
+    rule(:rule_name) do
+      match['A-Za-z_'] >> match['\w'].repeat >> match['!?'].maybe
+    end
+
+    rule(:validity) { (stri('OK') | stri('FAIL')).as(:status) >> ws? }
+    rule(:validity_example) { string.as(:input) >> validity.as(:validity) }
+
+    rule(:mapping_example) do
+      string.as(:input) >> ws? >> str('->') >> ws? >> string.as(:output)
+    end
+
+    rule(:include_example) do
+      str('include') >> space >> rule_name.as(:include_rule)
+    end
+
+    rule(:description_example) do
+      (validity_example | mapping_example | include_example) >> ws?
+    end
+    rule(:description_examples) { description_example.repeat }
+
+    rule(:rule_description) do
+      rule_name.as(:rule_name) >> str(':') >> ws? >>
+      description_examples.as(:examples)
+    end
+    rule(:rule_descriptions) { rule_description.repeat }
+
+    rule(:spec_header) do
+      (str('parser') | str('transformer')).as(:type) >> space >>
+      match_till { newline | comment }.as(:subject_class) >> ws?
+    end
+
+    rule(:spec) do
+      ws? >> (spec_header.as(:header) >> rule_descriptions.as(:rules) | eof)
+    end
+
+    root :spec
+
+  private
+
+    def match_till(ending = nil)
+      case ending
+        when String then (str(ending).absent? >> any).repeat(1)
+        when Symbol then (send(ending).absent? >> any).repeat(1)
+        when nil
+          raise ParserError, 'expected a block' unless block_given?
+          (yield.absent? >> any).repeat(1)
+      end
+    end
+
+    def stri(str)
+      key_chars = str.split(//)
+      key_chars
+        .collect! { |char| match["#{char.upcase}#{char.downcase}"] }
+        .reduce(:>>)
+    end
+
+  end
+end

data/lib/parspec/parser_spec_transform.rb

@@ -0,0 +1,50 @@
+module Parspec
+  class ParserSpecTransform < Parslet::Transform
+
+    class << self
+      attr_accessor :no_debug_parse
+    end
+
+    rule(input: simple(:input), validity: simple(:valid)) do <<RSPEC_TEMPLATE
+    it { should#{ valid ? '' : '_not' } parse '#{input.gsub("'", "\\''")}' }
+RSPEC_TEMPLATE
+    end
+
+    rule(input: simple(:input), output: simple(:output)) do <<RSPEC_TEMPLATE
+    it "should parse '#{input.gsub('"', '\\"')}' to #{output.gsub('"', '\\"')}" do
+      expect(subject.#{ParserSpecTransform.no_debug_parse ? 'parse' : 'parse_with_debug'}('#{input.gsub("'", "\\''")}')).to eq #{output}
+    end
+RSPEC_TEMPLATE
+    end
+
+    rule(include_rule: simple(:rule_name)) do <<RSPEC_TEMPLATE
+    it_behaves_like 'every #{rule_name} parsing'
+RSPEC_TEMPLATE
+    end
+
+    rule(rule_name: simple(:rule_name), examples: sequence(:examples)) do <<RSPEC_TEMPLATE
+  shared_examples 'every #{rule_name} parsing' do
+
+#{examples.join("\n")}
+  end
+
+  context '#{rule_name} parsing' do
+    subject { parser.#{rule_name} }
+
+    it_behaves_like 'every #{rule_name} parsing'
+  end
+RSPEC_TEMPLATE
+    end
+
+    rule(header: {type: simple(:type), subject_class: simple(:subject_class)},
+         rules: sequence(:rules)) do <<RSPEC_TEMPLATE
+describe #{subject_class} do
+  let(:parser) { #{subject_class}.new }
+
+#{rules.join("\n")}
+end
+RSPEC_TEMPLATE
+    end
+
+  end
+end

data/lib/parspec/shared_transform.rb

@@ -0,0 +1,18 @@
+module Parspec
+  class SharedTransform < Parslet::Transform
+
+    rule(status: simple(:status)) { status.to_s.upcase == 'OK' }
+    rule(string: sequence(:empty)) { '' }
+    rule(string: simple(:string)) do
+      string.to_s.gsub(
+          /\\[tnr"\/\\]/,
+          "\\t" => "\t",
+          "\\n" => "\n",
+          "\\r" => "\r",
+          '\\"' => '"',
+          "\\\\" => "\\"
+      )
+    end
+
+  end
+end

data/lib/parspec/transformer_spec_transform.rb

@@ -0,0 +1,43 @@
+module Parspec
+  class TransformerSpecTransform < Parslet::Transform
+
+    rule(input: simple(:input), validity: simple(:valid)) do
+      raise NotImplementedError
+    end
+
+    rule(input: simple(:input), output: simple(:output)) do <<RSPEC_TEMPLATE
+    it "should parse '#{input.gsub('"', '\\"')}' to #{output.gsub('"', '\\"')}" do
+      expect(transformer.apply(#{input})).to eq #{output}
+    end
+RSPEC_TEMPLATE
+    end
+
+    rule(include_rule: simple(:rule_name)) do <<RSPEC_TEMPLATE
+    it_behaves_like 'every #{rule_name} transformation'
+RSPEC_TEMPLATE
+    end
+
+    rule(rule_name: simple(:rule_name), examples: sequence(:examples)) do <<RSPEC_TEMPLATE
+  shared_examples 'every #{rule_name} transformation' do
+
+#{examples.join("\n")}
+  end
+
+  context '#{rule_name} tranformation' do
+    it_behaves_like 'every #{rule_name} transformation'
+  end
+RSPEC_TEMPLATE
+    end
+
+    rule(header: {type: simple(:type), subject_class: simple(:subject_class)},
+         rules: sequence(:rules)) do <<RSPEC_TEMPLATE
+describe #{subject_class} do
+  let(:transformer) { #{subject_class}.new }
+
+#{rules.join("\n")}
+end
+RSPEC_TEMPLATE
+    end
+
+  end
+end

data/lib/parspec/version.rb

@@ -0,0 +1,3 @@
+module Parspec
+  VERSION = '0.0.1'
+end

data/lib/parspec.rb

@@ -0,0 +1,79 @@
+# coding: utf-8
+require 'parslet'
+require 'parspec/version'
+require 'parspec/parser'
+require 'parspec/shared_transform'
+require 'parspec/parser_spec_transform'
+require 'parspec/transformer_spec_transform'
+require 'parspec/cli'
+
+module Parspec
+
+  Error          = Class.new StandardError
+  ParseError     = Class.new Error
+  TransformError = Class.new Error
+
+  def self.translate(file_or_str, options = {})
+    if File.exist?(file_or_str)
+      translate_file(file_or_str, options)
+    else
+      translate_string(file_or_str, options)
+    end
+  end
+
+  def self.translate_file(filename, options = {})
+    translate_string(File.read(filename), options)
+  end
+
+  def self.translate_string(str, options = {})
+    ParserSpecTransform.no_debug_parse = options[:no_debug_parse]
+    tree = Parser.new.parse(str)
+    tree = SharedTransform.new.apply(tree)
+    translation = Parslet::Transform.new do
+      spec = ->(type) {
+        { header: {type: type, subject_class: simple(:subject_class) },
+          rules: subtree(:rules) } }
+      rule(spec['parser'])      { ParserSpecTransform.new.apply(tree) }
+      rule(spec['transformer']) { TransformerSpecTransform.new.apply(tree) }
+    end.apply(tree)
+    raise Error, "unexpected translation: #{translation}" unless translation.is_a? String
+    translation
+  rescue Parslet::ParseFailed => e
+    deepest = deepest_cause e.cause
+    line, column = deepest.source.line_and_column(deepest.pos)
+    raise ParseError, "unexpected input at line #{line} column #{column}"
+  end
+
+  # Internal: helper for finding the deepest cause for a parse error
+  def self.deepest_cause(cause)
+    if cause.children.any?
+      deepest_cause(cause.children.first)
+    else
+      cause
+    end
+  end
+
+end
+
+def load_parspec(file, options = {})
+  parspec_file = case File.extname(file)
+    when '.rb' then file.sub(/rb$/, 'parspec')
+    when ''    then "#{file}.parspec"
+  end
+
+  if not File.exists?(parspec_file)
+    # TODO: try to find the file in the load_path
+    raise LoadError, "cannot load such file -- #{parspec_file}"
+  end
+
+  require 'parslet/convenience'
+  require 'parslet/rig/rspec'
+
+  parspec = Parspec.translate_file(parspec_file, options)
+  # TODO: These are not detected as examples by RSpec ...
+  #tmp_file = Tempfile.new([File.basename(parspec_file), '.rb'])
+  #tmp_file.write(parspec)
+  #require tmp_file.path
+  # only as a fallback or if options[:force_eval]
+  eval(parspec)
+end

data/parspec.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'parspec/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'parspec'
+  spec.version       = Parspec::VERSION
+  spec.authors       = ['Marcel Otto']
+  spec.email         = ['marcelotto.de@gmail.com']
+  spec.summary       = %q{Testing of Parslet grammars and transformations}
+  spec.description   = %q{A specification language for Parslet grammars and transformers, which gets translated to RSpec.}
+  spec.homepage      = 'http://github.com/marcelotto/parspec'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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 'parslet'
+  spec.add_dependency 'rspec', '~> 3.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+end

data/spec/parspec/parser_spec.rb

@@ -0,0 +1,324 @@
+require 'spec_helper'
+require 'parslet/rig/rspec'
+
+describe Parspec::Parser do
+  let(:parser) { Parspec::Parser.new }
+
+  context 'string parsing' do
+    let(:string_parser) { parser.string }
+    subject { string_parser }
+    it { should parse('"test"')}
+    it { should parse("\"test\n on multiple lines\"")}
+
+    it { should_not parse('test')}
+
+    it 'should interpret the empty string correctly' do
+      expect(string_parser.parse('""')).to eq string: [] # TODO: should be ''
+    end
+
+    it 'should preserve escaped double-quotes' do
+      expect(string_parser.parse('"\\"test\\""')).to eq string: '\\"test\\"'
+    end
+
+    it 'should preserve escape-sequences' do
+      expect(string_parser.parse('"\\n"')).to eq string: '\n'
+    end
+
+    it 'should preserve special characters' do
+      expect(string_parser.parse("\"test with:\n\tspecial characters\n\tesp. \\\", \\\\\""))
+        .to eq string: "test with:\n\tspecial characters\n\tesp. \\\", \\\\"
+    end
+  end
+
+  context 'validity example parsing' do
+    let(:validity_example_parser) { parser.validity_example }
+    subject { validity_example_parser }
+    it { should parse('"test" OK') }
+    it { should parse('"test" ok') }
+    it { should parse('"test" FAIL') }
+    it { should parse('"test" Fail') }
+    it { should parse("\"test\n on multiple lines\" OK") }
+
+    it { should_not parse('"test"') }
+    it { should_not parse('"test" OTHER') }
+    it { should_not parse('"test" -> OTHER') }
+
+    it 'should be parsed to {input: {string: "example"}, validity: {status: "OK"}}, when validity is OK' do
+      expect(validity_example_parser.parse('"test" OK'))
+        .to eq input: { string: 'test' }, validity: {status: 'OK'}
+      expect(validity_example_parser.parse('"test" OK    '))
+      .to eq input: { string: 'test' }, validity: {status: 'OK'}
+    end
+
+    it 'should be parsed to {input: {string: "example"}, validity: {status: "FAIL"}}, when validity is FAIL' do
+      expect(validity_example_parser.parse('"test" FAIL'))
+        .to eq input: { string: 'test' }, validity: {status: 'FAIL'}
+    end
+   end
+
+  context 'mapping example parsing' do
+    let(:mapping_example_parser) { parser.mapping_example }
+    subject { mapping_example_parser }
+    it { should parse('"test" -> ":foo => :bar"') }
+    it { should parse('"test" -> "{ foo: 42, bar: \'baz\'} "') }
+    it { should parse("\"test\n on multiple lines\" -> \"{\n\tfoo: 42,\tbar: 'baz'\n}\"") }
+
+    it { should_not parse('"test"') }
+    it { should_not parse('"test" OK') }
+    it { should_not parse('"test" -> OK') }
+
+    it 'should be parsed to {input: {string: "example"}, output: {string: "example"}}' do
+      expect(mapping_example_parser.parse('"test" -> ":foo => :bar"'))
+        .to eq input: { string: 'test' }, output: { string: ':foo => :bar' }
+      expect(mapping_example_parser.parse('"test" -> "{ foo: 42, bar: \'baz\'} "'))
+        .to eq input: { string: 'test' }, output: { string: "{ foo: 42, bar: 'baz'} " }
+      expect(mapping_example_parser.parse("\"test\n on multiple lines\" -> \"{\n\tfoo: 42,\tbar: 'baz'\n}\""))
+        .to eq input: { string: "test\n on multiple lines" }, output: { string: "{\n\tfoo: 42,\tbar: 'baz'\n}" }
+    end
+  end
+
+  context 'rule name parsing' do
+    let(:rule_name_parser) { parser.rule_name }
+    subject { rule_name_parser }
+    it { should parse 'a_rule_name' }
+    it { should parse 'rule1' }
+    it { should parse '_rule2' }
+    it { should parse 'a_rule_name?' }
+    it { should parse 'a_rule_name!' }
+    it { should_not parse '0a' }
+  end
+
+  context 'rule description parsing' do
+    let(:rule_description_parser) { parser.rule_description }
+    subject { rule_description_parser }
+
+    it { should parse "a_rule_name:\n" }
+    it { should parse "a_rule_name:\n\"test\" OK" }
+    it { should parse <<PARSPEC_RULE_DESCRIPTION
+a_rule_name:
+"test" -> "foo: :bar"
+PARSPEC_RULE_DESCRIPTION
+    }
+
+    it { should parse <<PARSPEC_RULE_DESCRIPTION
+a_rule_name:
+"test" OK
+"test" -> "foo: :bar"
+PARSPEC_RULE_DESCRIPTION
+    }
+
+    it { should parse <<PARSPEC_RULE_DESCRIPTION
+a_rule_name:
+  "test" OK
+  "test" -> "foo: :bar"
+PARSPEC_RULE_DESCRIPTION
+    }
+
+    it { should parse <<PARSPEC_RULE_DESCRIPTION
+a_rule_name:
+
+  "test" OK
+
+  "test" -> "foo: :bar"
+
+
+PARSPEC_RULE_DESCRIPTION
+    }
+
+    it { should parse <<PARSPEC_RULE_DESCRIPTION
+a_rule_name:
+  "test"
+    -> "foo: :bar"
+  "test" ->
+      "foo: :bar"
+
+  "test"
+    ->
+    "foo: :bar"
+PARSPEC_RULE_DESCRIPTION
+    }
+
+    it { should parse <<PARSPEC_RULE_DESCRIPTION
+a_rule_name:
+#  "test" OK
+PARSPEC_RULE_DESCRIPTION
+    }
+
+    it { should parse <<PARSPEC_RULE_DESCRIPTION
+a_rule_name:
+  "test" OK
+#  "test" -> "foo: :bar"
+PARSPEC_RULE_DESCRIPTION
+    }
+
+    it { should parse <<PARSPEC_RULE_DESCRIPTION
+a_rule_name: # this a comment
+  "test" OK
+PARSPEC_RULE_DESCRIPTION
+    }
+
+    it { should parse <<PARSPEC_RULE_DESCRIPTION
+a_rule_name:
+  "test" OK             # this is a comment
+PARSPEC_RULE_DESCRIPTION
+    }
+
+
+    it { should parse <<PARSPEC_RULE_DESCRIPTION
+a_rule_name: # comment #1
+
+# comment #2
+
+# comment #3
+
+  "test" OK  # comment #4
+
+# comment #5
+
+
+  "test" -> "foo: :bar" # comment #6
+# comment #7
+
+PARSPEC_RULE_DESCRIPTION
+    }
+
+    it 'should parse a rule without examples to {rule_name: "name", examples: []}' do
+      expect(rule_description_parser.parse("a_rule_name:\n#some comment\n\n"))
+        .to eq rule_name: 'a_rule_name', examples: []
+    end
+
+    it 'should be parsed to {rule_name: "name", examples: [...]}' do
+      tree = {
+          rule_name: 'a_rule_name',
+          examples: [
+            {input: {string: 'test'}, validity: {status: 'OK' }},
+            {input: {string: 'test'}, output: {string: 'foo: :bar'}}
+          ]
+      }
+
+      expect(rule_description_parser.parse(<<PARSPEC_RULE_DESCRIPTION
+a_rule_name:
+"test" OK
+"test" -> "foo: :bar"
+PARSPEC_RULE_DESCRIPTION
+      )).to eq tree
+
+      expect(rule_description_parser.parse(<<PARSPEC_RULE_DESCRIPTION
+a_rule_name:
+
+  "test" OK
+
+  "test" -> "foo: :bar"
+
+
+PARSPEC_RULE_DESCRIPTION
+       )).to eq tree
+
+      expect(rule_description_parser.parse(<<PARSPEC_RULE_DESCRIPTION
+a_rule_name: # comment #1
+
+# comment #2
+
+# comment #3
+
+  "test" OK  # comment #4
+
+# comment #5
+
+
+  "test" -> "foo: :bar" # comment #6
+# comment #7
+
+PARSPEC_RULE_DESCRIPTION
+             )).to eq tree
+    end
+
+  end
+
+  context 'spec parsing' do
+    it { should parse '' }
+    it { should parse ' ' }
+    it { should parse "\n" }
+    it { should parse "\n# comment only\n" }
+    it { should parse 'parser Some::Parser' }
+    it { should parse ' parser Some::Parser' }
+
+    it { should parse <<PARSPEC
+parser Some::Parser
+
+rule1:
+  "test" OK
+  "test" -> "foo: :bar"
+
+rule2:
+  "foo" OK
+  "foo" -> ":bar => :foo"
+PARSPEC
+    }
+
+    it { should parse <<PARSPEC
+parser Some::Parser # a comment
+
+rule1:
+  "test" OK
+  "test" -> "foo: :bar"
+PARSPEC
+    }
+
+    it { should parse <<PARSPEC
+ parser Some::Parser
+# a comment
+rule1:
+  "test" OK
+  "test" -> "foo: :bar"
+PARSPEC
+    }
+
+    it { should parse <<PARSPEC
+# a comment
+parser Some::Parser
+
+ # a comment
+
+rule1:
+  "test" OK
+  "test" -> "foo: :bar"
+PARSPEC
+    }
+
+    it 'should be parsed to {spec_name: "name", rules: [...]}' do
+      tree = {
+          header: {
+              subject_class: 'Some::Parser',
+              type: 'parser'
+          },
+          rules: [
+            { rule_name: 'rule1',
+              examples: [
+                  {input: {string: 'test'}, validity: {status: 'OK' }},
+                  {input: {string: 'test'}, output: {string: 'foo: :bar'}}
+              ] },
+            { rule_name: 'rule2',
+              examples: [
+                  {input: {string: 'foo'}, output: {string: ':bar => :foo'}}
+              ] }
+          ]
+      }
+
+      expect(parser.parse(<<PARSPEC
+parser Some::Parser
+
+rule1:
+  "test" OK
+  "test" -> "foo: :bar"
+
+rule2:
+  "foo" -> ":bar => :foo"
+PARSPEC
+
+             )).to eq tree
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'bundler/setup'
+Bundler.require(:test)
+
+require 'parspec'
+
+SPEC_DIR = File.dirname(__FILE__)
+Dir[File.join(SPEC_DIR, 'support/**/*.rb')].each {|f| require f }
+
+RSpec.configure do |config|
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: parspec
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Marcel Otto
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  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: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: A specification language for Parslet grammars and transformers, which
+  gets translated to RSpec.
+email:
+- marcelotto.de@gmail.com
+executables:
+- parspec
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/parspec
+- examples/parspec_spec.parspec
+- examples/toml_spec.parspec
+- lib/parspec.rb
+- lib/parspec/cli.rb
+- lib/parspec/parser.rb
+- lib/parspec/parser_spec_transform.rb
+- lib/parspec/shared_transform.rb
+- lib/parspec/transformer_spec_transform.rb
+- lib/parspec/version.rb
+- parspec.gemspec
+- spec/parspec/parser_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/marcelotto/parspec
+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.1.9
+signing_key: 
+specification_version: 4
+summary: Testing of Parslet grammars and transformations
+test_files:
+- spec/parspec/parser_spec.rb
+- spec/spec_helper.rb
+has_rdoc: