wlang 0.10.2 → 2.0.0.beta

data/spec/unit/compiler/test_grammar.rb

@@ -0,0 +1,207 @@
+require 'spec_helper'
+module WLang
+  describe Grammar do
+
+    let(:grammar){ WLang::Grammar }
+
+    context "parsing" do
+
+      subject{
+        if defined?(trailing)
+          grammar.parse(text, :root => rule, :consume => false)
+        else
+          grammar.parse(text, :root => rule)
+        end
+      }
+      after { subject.should eq(text) }
+
+      describe 'the fn_start rule' do
+        let(:rule){ :fn_start }
+        let(:text){ "{"       }
+        it{ should_not be_nil }
+      end
+
+      describe 'the fn_stop rule' do
+        let(:rule){ :fn_stop  }
+        let(:text){ "}"       }
+        it{ should_not be_nil }
+      end
+
+      describe 'the symbols rule' do
+        let(:rule){ :symbols }
+        WLang::SYMBOLS.each do |sym|
+          describe 'on #{sym}' do
+            let(:text){ sym }
+            it{ should_not be_nil }
+          end
+        end
+        describe 'on "<<+"' do
+          let(:text){ "<<+"     }
+          it{ should_not be_nil }
+        end
+        describe 'on joined symbols' do
+          let(:text){ WLang::SYMBOLS.join }
+          it{ should_not be_nil }
+        end
+      end
+
+      describe 'the stop char rule' do
+        let(:rule){ :stop_char  }
+        describe 'on {' do
+          let(:text){ '{'         }
+          it{ should_not be_nil   }
+        end
+        describe 'on }' do
+          let(:text){ '}'         }
+          it{ should_not be_nil   }
+        end
+        describe 'on ${' do
+          let(:text){ '${'        }
+          it{ should_not be_nil   }
+        end
+        describe 'on <<+{' do
+          let(:text){ '<<+{'      }
+          it{ should_not be_nil   }
+        end
+      end
+
+      describe 'the block rule' do
+        let(:rule){ :block      }
+        let(:text){ '{ hello }' }
+        it{ should_not be_nil   }
+      end
+
+      describe 'the wlang rule' do
+        let(:rule){ :wlang      }
+        describe 'on a single wlang block' do
+          let(:text){ '${who}'    }
+          it{ should_not be_nil   }
+        end
+        describe 'on a wlang with two blocks' do
+          let(:text){ '${who}{,}' }
+          it{ should_not be_nil   }
+        end
+      end
+
+      describe 'the static rule' do
+        let(:rule){ :static       }
+        describe 'on pure static text' do
+          let(:text){ 'Hello world' }
+          it{ should_not be_nil     }
+        end
+        describe 'with trailing chars' do
+          let(:text){ 'Hello '       }
+          let(:trailing){ "${who}"   }
+          it{ should_not be_nil      }
+        end
+      end
+
+      describe 'the non_static rule on a block' do
+        describe 'on a block' do
+          let(:rule){ :non_static   }
+          let(:text){ '{ hello }'   }
+          it{ should_not be_nil     }
+        end
+        describe 'on a wlang' do
+          let(:rule){ :non_static   }
+          let(:text){ '${who}'      }
+          it{ should_not be_nil     }
+        end
+      end
+
+      describe 'the strconcat rule' do
+        let(:rule){ :strconcat        }
+        let(:text){ 'Hello ${who}' }
+        it{ should_not be_nil      }
+      end
+
+      describe "the template rule" do
+        let(:rule){ :template }
+        describe 'on an empty template' do
+          let(:text){ "" }
+          it{ should_not be_nil }
+        end
+        describe 'on a static template' do
+          let(:text){ "Hello world" }
+          it{ should_not be_nil }
+        end
+        describe 'on a block' do
+          let(:text){ "{ world }" }
+          it{ should_not be_nil }
+        end
+        describe 'on a wlang' do
+          let(:text){ "${who}" }
+          it{ should_not be_nil }
+        end
+        describe 'on a high-order wlang' do
+          let(:text){ "${${who}}" }
+          it{ should_not be_nil }
+        end
+        describe 'on a mix' do
+          let(:text){ "Hello ${who}!" }
+          it{ should_not be_nil }
+        end
+      end
+
+    end
+
+    context "value" do
+
+      subject{ grammar.parse(text, :root => rule).value }
+
+      describe 'the static rule' do
+        let(:rule){ :static }
+        let(:text){ "Hello world!" }
+        it{ should eq([:static, text]) }
+      end
+
+      describe 'the block rule' do
+        let(:rule){ :block }
+        let(:text){ "{ world }" }
+        it{ should eq([:static, text]) }
+      end
+
+      describe 'the wlang rule' do
+        let(:rule){ :wlang }
+        let(:text){ "${who}" }
+        it{ should eq([:wlang, '$', [:fn, [:static, "who"]] ]) }
+      end
+
+      describe 'the strconcat rule' do
+        let(:rule){ :strconcat }
+        describe "when a single match" do
+          let(:text){ "Hello world" }
+          it{ should eq([:static, text]) }
+        end
+        describe "with multiple matches" do
+          let(:text){ "Hello ${who}!" }
+          specify{
+            expected = \
+              [:strconcat,
+                [:static, "Hello "],
+                [:wlang, '$', [:fn, [:static, "who"]]],
+                [:static, "!"]]
+            subject.should eq(expected)
+          }
+        end
+      end
+
+      describe 'the template rule' do
+        let(:rule){ :template       }
+        let(:text){ "Hello ${who}!" }
+        specify{
+          expected = \
+            [:template,
+              [:fn,
+                [:strconcat,
+                  [:static, "Hello "],
+                  [:wlang, '$', [:fn, [:static, "who"]]],
+                  [:static, "!"]]]]
+          subject.should eq(expected)
+        }
+      end
+
+    end
+
+  end
+end

data/spec/unit/compiler/test_parser.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+module WLang
+  describe Parser do
+
+    def parse(input)
+      WLang::Parser.new.call(input)
+    end
+
+    let(:expected) {
+      [:template,
+        [:fn,
+          [:strconcat,
+            [:static, "Hello "],
+            [:wlang,  "$",
+              [:fn,
+                [:static, "who"]]],
+            [:static, "!"]]]]
+    }
+
+    it 'should parse "Hello ${world}!" as expected' do
+      parse(hello_tpl).should eq(expected)
+    end
+
+    it 'should support high-order wlang' do
+      expected = \
+      [:template,
+        [:fn,
+          [:wlang,  "$",
+            [:fn,
+              [:wlang, "$",
+                [:fn,
+                  [:static, "who"]]]]]]]
+      parse("${${who}}").should eq(expected)
+    end
+
+    it 'should support mutli-block functions' do
+      expected = \
+      [:template,
+        [:fn,
+          [:wlang,  "$",
+            [:fn, [:static, "first" ]],
+            [:fn, [:static, "second"]]]]]
+      parse("${first}{second}").should eq(expected)
+    end
+
+    it 'is idempotent' do
+      parse(parse(hello_tpl)).should eq(expected)
+    end
+
+    it 'supports a path-like object' do
+      parse(hello_path).should eq(expected)
+    end
+
+    it 'supports an IO object' do
+      hello_io{|io| parse(io)}.should eq(expected)
+    end
+
+    it 'recognizes objects that respond to :to_path' do
+      s = Struct.new(:to_path).new(hello_path)
+      parse(s).should eq(expected)
+    end
+
+    it 'recognizes objects that respond to :to_str' do
+      s = Struct.new(:to_str).new(hello_tpl)
+      parse(s).should eq(expected)
+    end
+
+  end
+end

data/spec/unit/compiler/test_proc_call_removal.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module WLang
+  class Compiler
+    describe ProcCallRemoval do
+
+      def optimize(source)
+        ProcCallRemoval.new.call(source)
+      end
+
+      it 'optimizes :fn' do
+        source   = [:fn, [:static, "Hello world"]]
+        expected = [:arg, "Hello world"]
+        optimize(source).should eq(expected)
+      end
+
+      it 'recurses on :wlang' do
+        source   = [:wlang, '$', [:fn, [:static, "Hello world"]]]
+        expected = [:wlang, '$', [:arg, "Hello world"]]
+        optimize(source).should eq(expected)
+      end
+
+    end # describe ToRubyCode
+  end # class Compiler
+end # module WLang

data/spec/unit/compiler/test_static_merger.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+module WLang
+  class Compiler
+    describe StaticMerger do
+
+      def optimize(source)
+        StaticMerger.new.call(source)
+      end
+
+      let(:trailing){[
+        [:strconcat, [:static, "{"], [:static, "Hello world"], [:static, "}"]],
+        [:strconcat, [:static, "{Hello world}"]]
+      ]}
+
+      it 'optimize result of trailing blocks' do
+        optimize(trailing.first).should eq(trailing.last)
+      end
+
+      [:template, :modulo, :wlang, :fn].each do |kind|
+
+        it "recurses on :#{kind}" do
+          optimize([kind, trailing.first]).should eq([kind, trailing.last])
+        end
+
+      end
+
+    end # describe StaticMerger
+  end # class Compiler
+end # module WLang

data/spec/unit/compiler/test_strconcat_flattener.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+module WLang
+  class Compiler
+    describe StrconcatFlattener do
+
+      def optimize(source)
+        StrconcatFlattener.new.call(source)
+      end
+
+      it 'cleans singleton' do
+        source   = [:strconcat, [:static, "Hello World!"]]
+        expected = [:static, "Hello World!"]
+        optimize(source).should eq(expected)
+      end
+
+      it 'does nothing on single :strconcat' do
+        source   = [:strconcat, [:static, "Hello "], [:static, "World"]]
+        expected = [:strconcat, [:static, "Hello "], [:static, "World"]]
+        optimize(source).should eq(expected)
+      end
+
+      it 'flattens :strconcat' do
+        source   = [:strconcat, [:strconcat, [:static, "Hello "], [:static, "World"]], [:static, "!"]]
+        expected = [:strconcat, [:static, "Hello "], [:static, "World"], [:static, "!"]]
+        optimize(source).should eq(expected)
+      end
+
+    end # describe StrconcatFlattener
+  end # class Compiler
+end # module WLang

data/spec/unit/compiler/test_to_ruby_abstraction.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+module WLang
+  class Compiler
+    describe ToRubyAbstraction do
+
+      def optimize(source)
+        ToRubyAbstraction.new.call(source)
+      end
+
+      let(:hello){[
+        [:static, "Hello world"],
+        [:static, "Hello world"]
+      ]}
+      let(:strconcat){[
+        [:strconcat, [:static, "Hello "], [:static, "world"]],
+        [:multi,     [:static, "Hello "], [:static, "world"]]
+      ]}
+
+      it 'let [:static, ...] unchanged' do
+        optimize(hello.first).should eq(hello.last)
+      end
+
+      it 'transforms :strconcat to :multi' do
+        optimize(strconcat.first).should eq(strconcat.last)
+      end
+
+      it 'recurses on :strconcat' do
+        source   = [:strconcat, strconcat.first]
+        expected = [:multi,     strconcat.last]
+        optimize(source).should eq(expected)
+      end
+
+      it 'transforms :fn to :proc' do
+        source   = [:fn, hello.first]
+        expected = [:proc, hello.last]
+        optimize(source).should eq(expected)
+      end
+
+      it 'recurses on :fn' do
+        source   = [:fn, strconcat.first]
+        expected = [:proc, strconcat.last]
+        optimize(source).should eq(expected)
+      end
+
+      it "recurses on :template" do
+        source   = [:template, strconcat.first]
+        expected = [:template, strconcat.last]
+        optimize(source).should eq(expected)
+      end
+
+      it 'transforms :wlang to :dispatch' do
+        source   = [:wlang, '$', [:fn, strconcat.first]]
+        expected = [:dispatch, :_tag_36, [:proc, strconcat.last]]
+        optimize(source).should eq(expected)
+      end
+
+    end # describe ToRubyAbstraction
+  end # class Compiler
+end # module WLang

data/spec/unit/compiler/test_to_ruby_code.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module WLang
+  class Compiler
+    describe ToRubyCode do
+
+      def generate(source)
+        ToRubyCode.new.call(source)
+      end
+
+      it 'compiles [:proc, ...]' do
+        source   = [:proc, [:static, "Hello world"]]
+        expected = %q{Proc.new{|d1,b1| b1 << ("Hello world") }}
+        generate(source).should eq(expected)
+      end
+
+      it 'compiles [:dispatch, ...]' do
+        source   = [:dispatch, :_tag_36, [:proc, [:static, "Hello world"]]]
+        expected = %q{d0._tag_36(b0, Proc.new{|d1,b1| b1 << ("Hello world") })}
+        generate(source).should eq(expected)
+      end
+
+    end # describe ToRubyCode
+  end # class Compiler
+end # module WLang