antelope 0.2.0 → 0.2.2

data/spec/antelope/ace/compiler_spec.rb

@@ -1,60 +1,60 @@
-describe Ace::Compiler do
-  let :file do
-    <<-DOC
-    %{
-      test
-    %}
-
-    %require "#{VERSION}"
-    %language "ruby"
-
-    %terminal NUMBER
-    %terminal SEMICOLON ";"
-    %terminal ADD "+"
-    %terminal LPAREN "("
-    %terminal RPAREN ")"
-
-    %%
-
-    s: e
-    e: t ADD e
-    t: NUMBER | LPAREN e RPAREN
-
-    %%
-
-    hello
-    DOC
-  end
-
-  let :tokens do
-    Ace::Scanner.scan(file)
-  end
-
-  let :compiler do
-    Ace::Compiler.new(tokens)
-  end
-
-  subject do
-    compiler.compile
-    compiler
-  end
-
-  its(:body) { should =~ /test/  }
-  its(:body) { should =~ /hello/ }
-  its(:options) { should have_key :type }
-
-  it "should have the proper terminals" do
-    expect(subject.options[:terminals].map(&:first)).to eq [:NUMBER,
-      :SEMICOLON, :ADD, :LPAREN, :RPAREN]
-  end
-
-  context "with an unmatched version" do
-    let :file do "%require \"0.0.0\"\n%%\n%%\n" end
-
-    it "should raise an error" do
-      expect {
-        subject
-      }.to raise_error(Ace::IncompatibleVersionError)
-    end
-  end
-end
+describe Ace::Compiler do
+  let :file do
+    <<-DOC
+    %{
+      test
+    %}
+
+    %require "#{VERSION}"
+    %language "ruby"
+
+    %terminal NUMBER
+    %terminal SEMICOLON ";"
+    %terminal ADD "+"
+    %terminal LPAREN "("
+    %terminal RPAREN ")"
+
+    %%
+
+    s: e
+    e: t ADD e
+    t: NUMBER | LPAREN e RPAREN
+
+    %%
+
+    hello
+    DOC
+  end
+
+  let :tokens do
+    Ace::Scanner.scan(file)
+  end
+
+  let :compiler do
+    Ace::Compiler.new(tokens)
+  end
+
+  subject do
+    compiler.compile
+    compiler
+  end
+
+  its(:body) { should =~ /test/  }
+  its(:body) { should =~ /hello/ }
+  its(:options) { should have_key :type }
+
+  it "should have the proper terminals" do
+    expect(subject.options[:terminals].map(&:first)).to eq [:NUMBER,
+      :SEMICOLON, :ADD, :LPAREN, :RPAREN]
+  end
+
+  context "with an unmatched version" do
+    let :file do "%require \"0.0.0\"\n%%\n%%\n" end
+
+    it "should raise an error" do
+      expect {
+        subject
+      }.to raise_error(Ace::IncompatibleVersionError)
+    end
+  end
+end

data/spec/antelope/ace/scanner_spec.rb

@@ -1,27 +1,27 @@
-describe Ace::Scanner do
-
-  it "properly scans" do
-    expect(scan("%test \"a\" hi\n%%\nt: d { { } }\n%%\nhi\n")).to eq [
-      [:directive, "test", ["a", "hi"]],
-      [:second],
-      [:label, "t", nil],
-      [:part, "d", nil],
-      [:block, "{ { } }"],
-      [:third],
-      [:copy, "\nhi\n"]
-    ]
-  end
-
-  it "throws an error" do
-    expect {
-      scan("% %% %% ")
-    }.to raise_error(Ace::SyntaxError)
-  end
-
-  def scan(source)
-    Timeout.timeout(5) do
-      Ace::Scanner.scan(source)
-    end
-  end
-
-end
+describe Ace::Scanner do
+
+  it "properly scans" do
+    expect(scan("%test \"a\" hi\n%%\nt: d { { } }\n%%\nhi\n")).to eq [
+      [:directive, "test", ["a", "hi"]],
+      [:second],
+      [:label, "t", nil],
+      [:part, "d", nil],
+      [:block, "{ { } }"],
+      [:third],
+      [:copy, "\nhi\n"]
+    ]
+  end
+
+  it "throws an error" do
+    expect {
+      scan("% %% %% ")
+    }.to raise_error(Ace::SyntaxError)
+  end
+
+  def scan(source)
+    Timeout.timeout(5) do
+      Ace::Scanner.scan(source)
+    end
+  end
+
+end

data/spec/antelope/constructor_spec.rb

@@ -1,136 +1,133 @@
-describe Generation::Constructor do
-  let(:grammar)  { double("grammar") }
-  let(:terminal) { token(:TERMINAL)  }
-  let(:epsilon)  { token(:epsilon) }
-
-  subject { described_class.new(grammar) }
-
-  context "#nullable?" do
-    context "when given an epsilon token" do
-      it "returns true" do
-        expect(subject.nullable?(epsilon)).to be true
-      end
-    end
-
-    context "when given a terminal" do
-      it "returns false" do
-        expect(subject.nullable?(terminal)).to be false
-      end
-    end
-
-    context "when given an array" do
-      context "with one of the elements not nullable" do
-        it "returns false" do
-          expect(subject.nullable?([terminal, epsilon])).to be false
-        end
-      end
-
-      context "with all of the elements nullable" do
-        it "returns true" do
-          expect(subject.nullable?([epsilon, epsilon])).to be true
-        end
-      end
-    end
-
-    context "when given a nonterminal" do
-      let(:grammar) { with_recognizer }
-
-      context "with no nullable productions" do
-        let(:nonterminal) { Ace::Token::Nonterminal.new(:l) }
-
-        it "returns false" do
-          expect(subject.nullable?(nonterminal)).to be false
-        end
-      end
-
-      context "with a nullable production" do
-        let(:nonterminal) { Ace::Token::Nonterminal.new(:e) }
-
-        it "returns true" do
-          expect(subject.nullable?(nonterminal)).to be true
-        end
-      end
-    end
-
-    context "when given a bad argument" do
-      it "raises an error" do
-        expect { subject.nullable?(nil) }.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  context "#first" do
-    context "when given an epsilon token" do
-      it "generates an empty set" do
-        expect(subject.first(epsilon)).to eq Set.new
-      end
-    end
-
-    context "when given a terminal" do
-      it "generates a set" do
-        expect(subject.first(terminal)).to eq [terminal].to_set
-      end
-    end
-
-    context "when given an array" do
-      let(:terminal2) { token(:terminal, :TERMINAL2) }
-
-      it "generates a set" do
-        expect(subject.first([epsilon, terminal])).
-          to eq [terminal].to_set
-        expect(subject.first([terminal, terminal2])).
-          to eq [terminal].to_set
-      end
-    end
-
-    context "when given a nonterminal" do
-      let(:grammar) { with_recognizer }
-      let(:nonterminal) { token(:nonterminal, :e) }
-
-      before do
-        p grammar.terminals
-      end
-      it "generates a set" do
-        expect(subject.first(nonterminal)).
-          to eq [token(:terminal, :IDENT), token(:terminal, :STAR, "*")].to_set
-      end
-    end
-
-    context "when given a bad argument" do
-      it "raises an error" do
-        expect { subject.first(nil) }.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  context "#follow" do
-    context "when given a bad argument" do
-      it "raises an error" do
-        expect { subject.follow(nil) }.to raise_error(ArgumentError)
-      end
-    end
-
-    context "when given a nonterminal" do
-      let(:grammar) { with_recognizer }
-      let(:nonterminal) { token(:nonterminal, :l) }
-
-      before do
-        subject.productions.merge grammar.productions.values.flatten
-      end
-
-      it "generates a set" do
-        expect(subject.follow(nonterminal)).to eq [
-          token(:terminal, :EQUALS, "="),
-          token(:terminal, :"$end")
-        ].to_set
-      end
-    end
-  end
-
-
-
-  def token(type, name = nil, value = nil, ttype = nil, id = nil)
-    type = Ace::Token.const_get(type.to_s.capitalize)
-    type.new(name, ttype, id, value)
-  end
-end
+describe Generation::Constructor do
+  let(:grammar)  { double("grammar") }
+  let(:terminal) { token(:TERMINAL)  }
+  let(:epsilon)  { token(:epsilon) }
+
+  subject { described_class.new(grammar) }
+
+  context "#nullable?" do
+    context "when given an epsilon token" do
+      it "returns true" do
+        expect(subject.nullable?(epsilon)).to be true
+      end
+    end
+
+    context "when given a terminal" do
+      it "returns false" do
+        expect(subject.nullable?(terminal)).to be false
+      end
+    end
+
+    context "when given an array" do
+      context "with one of the elements not nullable" do
+        it "returns false" do
+          expect(subject.nullable?([terminal, epsilon])).to be false
+        end
+      end
+
+      context "with all of the elements nullable" do
+        it "returns true" do
+          expect(subject.nullable?([epsilon, epsilon])).to be true
+        end
+      end
+    end
+
+    context "when given a nonterminal" do
+      let(:grammar) { with_recognizer }
+
+      context "with no nullable productions" do
+        let(:nonterminal) { Ace::Token::Nonterminal.new(:l) }
+
+        it "returns false" do
+          expect(subject.nullable?(nonterminal)).to be false
+        end
+      end
+
+      context "with a nullable production" do
+        let(:nonterminal) { Ace::Token::Nonterminal.new(:e) }
+
+        it "returns true" do
+          expect(subject.nullable?(nonterminal)).to be true
+        end
+      end
+    end
+
+    context "when given a bad argument" do
+      it "raises an error" do
+        expect { subject.nullable?(nil) }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  context "#first" do
+    context "when given an epsilon token" do
+      it "generates an empty set" do
+        expect(subject.first(epsilon)).to eq Set.new
+      end
+    end
+
+    context "when given a terminal" do
+      it "generates a set" do
+        expect(subject.first(terminal)).to eq [terminal].to_set
+      end
+    end
+
+    context "when given an array" do
+      let(:terminal2) { token(:terminal, :TERMINAL2) }
+
+      it "generates a set" do
+        expect(subject.first([epsilon, terminal])).
+          to eq [terminal].to_set
+        expect(subject.first([terminal, terminal2])).
+          to eq [terminal].to_set
+      end
+    end
+
+    context "when given a nonterminal" do
+      let(:grammar) { with_recognizer }
+      let(:nonterminal) { token(:nonterminal, :e) }
+
+      it "generates a set" do
+        expect(subject.first(nonterminal)).
+          to eq [token(:terminal, :IDENT), token(:terminal, :STAR, "*")].to_set
+      end
+    end
+
+    context "when given a bad argument" do
+      it "raises an error" do
+        expect { subject.first(nil) }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  context "#follow" do
+    context "when given a bad argument" do
+      it "raises an error" do
+        expect { subject.follow(nil) }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "when given a nonterminal" do
+      let(:grammar) { with_recognizer }
+      let(:nonterminal) { token(:nonterminal, :l) }
+
+      before do
+        subject.productions.merge grammar.productions.values.flatten
+      end
+
+      it "generates a set" do
+        expect(subject.follow(nonterminal)).to eq [
+          token(:terminal, :EQUALS, "="),
+          token(:terminal, :"$end")
+        ].to_set
+      end
+    end
+  end
+
+
+
+  def token(type, name = nil, value = nil, ttype = nil, id = nil)
+    type = Ace::Token.const_get(type.to_s.capitalize)
+    type.new(name, ttype, id, value)
+  end
+end

data/spec/antelope/template_spec.rb

@@ -1,49 +1,50 @@
-describe Template do
-
-  let(:content) { "hello {{ world }} test" }
-
-  subject { Template.new(content) }
-
-  it "generates ruby code" do
-    expect(subject.parse).to eq %Q(_out ||= ""\n_out << "hello "\nworld\n_out << " test"\n_out\n)
-  end
-
-  context "when the tag is on its own line" do
-
-    let :content do
-<<-TEST
-hello
-{{= something }}
-world
-
-{{ thing }}
-a
-
-TEST
-    end
-
-    it "removes surrounding whitespace" do
-      expect(subject.parse).to eq <<-TEST
-_out ||= ""
-_out << "hello"
-_out << begin
-  something
-end.to_s
-_out << "\\nworld\\n"
-thing
-_out << "\\na\\n\\n"
-_out
-TEST
-    end
-
-    it "runs in ruby" do
-      object = Object.new
-      result = nil
-      def object.something; "-" end
-      def object.thing; end
-
-      expect { result = object.instance_eval(subject.parse) }.to_not raise_error
-      expect(result).to eq "hello-\nworld\n\na\n\n"
-    end
-  end
-end
+describe Template do
+
+  let(:content) { "hello {{ world }} test" }
+
+  subject { Template.new(content) }
+
+  it "generates ruby code" do
+    expect(subject.parse).to eq %Q(# encoding: utf-8\n_out ||= ""\n_out << "hello "\n world\n_out << " test"\n_out\n)
+  end
+
+  context "when the tag is on its own line" do
+
+    let :content do
+<<-TEST
+hello
+{{= something }}
+world
+
+{{ thing }}
+a
+
+TEST
+    end
+
+    it "removes surrounding whitespace" do
+      expect(subject.parse).to eq <<-TEST
+# encoding: utf-8
+_out ||= ""
+_out << "hello"
+_out << begin
+  something
+end.to_s
+_out << "\\nworld\\n"
+ thing
+_out << "\\na\\n\\n"
+_out
+TEST
+    end
+
+    it "runs in ruby" do
+      object = Object.new
+      result = nil
+      def object.something; "-" end
+      def object.thing; end
+
+      expect { result = object.instance_eval(subject.parse) }.to_not raise_error
+      expect(result).to eq "hello-\nworld\n\na\n\n"
+    end
+  end
+end

data/spec/fixtures/simple.ace

@@ -1,22 +1,22 @@
-%language <ruby>
-
-%terminal IDENT
-%terminal STAR "*"
-%terminal EQUALS "="
-
-%%
-
-e: l EQUALS r
- | r
- | nothing
-
-l: IDENT
- | STAR r
-
-r: l
-
-%%
-
-class SimpleParser
-  %{write}
-end
+%language <ruby>
+
+%terminal IDENT
+%terminal STAR "*"
+%terminal EQUALS "="
+
+%%
+
+e: l EQUALS r
+ | r
+ | nothing
+
+l: IDENT
+ | STAR r
+
+r: l
+
+%%
+
+class SimpleParser
+  %{write}
+end

data/spec/spec_helper.rb

@@ -1,39 +1,39 @@
-require "rubygems"
-require "bundler/setup"
-Bundler.setup
-
-require "timeout"
-require "benchmark"
-require "simplecov"
-require "coveralls"
-
-SimpleCov.formatter = Coveralls::SimpleCov::Formatter
-SimpleCov.start do
-  add_filter 'spec'
-
-end
-
-require "rspec/its"
-require "antelope"
-
-include Antelope
-
-Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each { |f| require f }
-
-# This file was generated by the `rspec --init` command. Conventionally, all
-# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
-# Require this file using `require "spec_helper"` to ensure that it is only
-# loaded once.
-#
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
-RSpec.configure do |config|
-  config.run_all_when_everything_filtered = true
-
-  # 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'
-  config.include BenchmarkHelper
-  config.include GrammarHelper
-end
+require "rubygems"
+require "bundler/setup"
+Bundler.setup
+
+require "timeout"
+require "benchmark"
+require "simplecov"
+require "coveralls"
+
+SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+SimpleCov.start do
+  add_filter 'spec'
+
+end
+
+require "rspec/its"
+require "antelope"
+
+include Antelope
+
+Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each { |f| require f }
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+
+  # 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'
+  config.include BenchmarkHelper
+  config.include GrammarHelper
+end

data/spec/support/benchmark_helper.rb

@@ -1,5 +1,5 @@
-module BenchmarkHelper
-  def benchmark
-    Benchmark.realtime(&Proc.new)
-  end
-end
+module BenchmarkHelper
+  def benchmark
+    Benchmark.realtime(&Proc.new)
+  end
+end