express_templates 0.3.0 → 0.3.1

data/test/expander_test.rb

@@ -84,11 +84,12 @@ class ExpanderTest < ActiveSupport::TestCase
         foo
       end
     end
-    assert_equal %q("#{helper do
+    assert_equal %q(%Q(#{helper do
         foo
-      end}"), result.first.compile
+      end})), Interpolator.transform(result.first.compile)
   end
 
+  # NOTE: This probably should be deleted as {{helper}} is preferred
   test "non-interpolated string children containing string interpolations will interpolate in context" do
     source = 'p %q(some text #{helper})'
     result = ExpressTemplates::Expander.new(nil).expand(source)

data/test/interpolator_test.rb

@@ -0,0 +1,80 @@
+require 'test_helper'
+require 'express_templates/interpolator'
+require 'parslet/convenience'
+
+class InterpolatorTest < ActiveSupport::TestCase
+
+  def parse(s)
+    parser = ExpressTemplates::Interpolator.new
+    parsed = parser.parse_with_debug(s)
+    pp parsed if ENV['DEBUG'].eql?('true')
+    parsed
+  end
+
+  def transform(s)
+    trans = ExpressTemplates::Transformer.new
+    trans.apply(parse(s)).flatten.join
+  end
+
+  test "simplest expression parses" do
+    tree = parse("{{something}}")
+    expected = [{:interpolation=>{:expression=>[{:text=>"something"}]}}]
+    assert_equal expected, tree
+  end
+
+  test "simple expression with surrounding text parses" do
+    tree = parse('whatever {{something}} something else')
+    expected = [{:text=>"whatever "},
+                {:interpolation=>{:expression=>[{:text=>"something"}]}},
+                {:text=>" something else"}]
+    assert_equal expected, tree
+  end
+
+  test "nested without outer text parses" do
+    tree = parse('{{some {{thing}} foo}}')
+    expected = [{:interpolation=>
+                {:expression=>
+                  [{:text=>"some "},
+                   {:interpolation=>{:expression=>[{:text=>"thing"}]}},
+                   {:text=>" foo"}]}}]
+    assert_equal expected, tree
+  end
+
+  test "nested with outer text parses" do
+    tree = parse('a lot of {{something {{good}}}}')
+    expected = [{:text=>"a lot of "},
+                {:interpolation=>
+                  {:expression=>
+                    [{:text=>"something "},
+                     {:interpolation=>{:expression=>[{:text=>"good"}]}}]}}]
+    assert_equal expected, tree
+  end
+
+  test 'nested with multiple nested expressions parses' do
+    tree = parse(%q(%Q({{foo("{{xyz}}", "{{zyx}}", bar: "baz")}})))
+    expected = [{:text=>"%Q("},
+                {:interpolation=>
+                  {:expression=>
+                    [{:text=>"foo(\""},
+                     {:interpolation=>{:expression=>[{:text=>"xyz"}]}},
+                     {:text=>"\", \""},
+                     {:interpolation=>{:expression=>[{:text=>"zyx"}]}},
+                     {:text=>"\", bar: \"baz\")"}]}},
+                {:text=>")"}]
+    assert_equal expected, tree
+  end
+
+
+  test '"{{something}}" transforms to "#{something}"' do
+    assert_equal '#{something}', transform("{{something}}")
+  end
+
+  test '"{{some {{thing}} foo}}" transforms to "#{some #{thing} foo}"' do
+    assert_equal '#{some #{thing} foo}', transform("{{some {{thing}} foo}}")
+  end
+
+  test %('a lot of {{something "{{good}}"}}' transforms) do
+    assert_equal 'a lot of #{something "#{good}"}', transform('a lot of {{something "{{good}}"}}')
+  end
+
+end

data/test/markup/tag_test.rb

@@ -78,11 +78,13 @@ class TagTest < ActiveSupport::TestCase
   end
 
   test "double bracketed option values are substituted for evaluation in context" do
-    assert_equal '"<bare should_eval_in_context=\"#{foo}\" />"', bare_tag(should_eval_in_context: "{{foo}}").compile
+    assert_equal '"<bare should_eval_in_context=\"#{foo}\" />"',
+                  Interpolator.transform(bare_tag(should_eval_in_context: "{{foo}}").compile)
   end
 
   test "double bracketed child values are substituted for evaluation in context" do
-    assert_equal '"<bare>"+"#{foo}"+"</bare>"', bare_tag("{{foo}}").compile
+    assert_equal '"<bare>"+"#{foo}"+"</bare>"',
+                  Interpolator.transform(bare_tag("{{foo}}").compile)
   end
 
   test "data option value hashes are converted to data attributes similar to haml" do

data/test/markup/wrapper_test.rb

@@ -5,38 +5,38 @@ class WrapperTest < ActiveSupport::TestCase
   Wrapper = ExpressTemplates::Markup::Wrapper
 
   test "name compiles to just name" do
-    assert_equal '"#{foo}"', Wrapper.new('foo').compile
+    assert_equal '%Q(#{foo})', Interpolator.transform(Wrapper.new('foo').compile)
   end
 
   test "simple args are preserved" do
     wrapper =  Wrapper.new('foo', "xyzzy", 'bar', "baz", 1, false, 3)
-    assert_equal '"#{foo("xyzzy", "bar", "baz", 1, false, 3)}"', wrapper.compile
+    assert_equal '%Q(#{foo("xyzzy", "bar", "baz", 1, false, 3)})', Interpolator.transform(wrapper.compile)
   end
 
   test "args are preserved" do
     wrapper =  Wrapper.new('foo', "xyzzy", bar: "baz")
-    assert_equal '"#{foo("xyzzy", bar: "baz")}"', wrapper.compile
+    assert_equal '%Q(#{foo("xyzzy", bar: "baz")})', Interpolator.transform(wrapper.compile)
   end
 
   test "something returning nil when wrapped and compiled, evals to an empty string" do
-    assert_equal '', eval(Wrapper.new('nil').compile)
+    assert_equal '', eval(Interpolator.transform(Wrapper.new('nil').compile))
   end
 
   test "double-braced args are evaluated in context" do
     wrapper = Wrapper.new('foo', "{{xyz}}", "{{zyx}}", bar: "baz")
-    assert_equal '"#{foo(xyz, zyx, bar: "baz")}"', wrapper.compile
+    assert_equal '%Q(#{foo(xyz, zyx, bar: "baz")})', Interpolator.transform(wrapper.compile)
   end
 
   test "initializer block is preserved in compile" do
     wrapper = Wrapper.new('foo') { whatever }
-    assert_equal '"#{foo { whatever }}"', wrapper.compile
+    assert_equal '%Q(#{foo { whatever }})', Interpolator.transform(wrapper.compile)
     wrapper = Wrapper.new('foo', 'bar') { whatever }
-    assert_equal '"#{foo("bar") { whatever }}"', wrapper.compile
+    assert_equal '%Q(#{foo("bar") { whatever }})', Interpolator.transform(wrapper.compile)
   end
 
   test "lambda option values are evaluated in context" do
     wrapper = Wrapper.new('foo', bar: -> { something })
-    assert_equal '"#{foo(bar: (-> { something }).call)}"', wrapper.compile
+    assert_equal '%Q(#{foo(bar: (-> { something }).call)})', Interpolator.transform(wrapper.compile)
   end
 
 end

data/test/performance_test.rb

@@ -71,23 +71,23 @@ HAML
     return end_time - start_time
   end
 
-  test "performance is okay" do
-    duration = time(100) { ExpressTemplates.render(self, "#{GARA_EXAMPLE}") }
-    assert_operator 1.0, :>, duration
-  end
+  # test "performance is okay" do
+  #   duration = time(100) { ExpressTemplates.render(self, "#{GARA_EXAMPLE}") }
+  #   assert_operator 1.0, :>, duration
+  # end
 
-  test "performance no more than 3.5x slower than erubis" do
-    eruby = Erubis::Eruby.new
-    duration_erb = time(100) { eval(eruby.convert(ERB_EXAMPLE)) }
-    duration_express_templates = time(100) { ExpressTemplates.render(self, "#{GARA_EXAMPLE}") }
-    assert_operator 4.0, :>, (duration_express_templates/duration_erb)
-  end
+  # test "performance no more than 3.5x slower than erubis" do
+  #   eruby = Erubis::Eruby.new
+  #   duration_erb = time(100) { eval(eruby.convert(ERB_EXAMPLE)) }
+  #   duration_express_templates = time(100) { ExpressTemplates.render(self, "#{GARA_EXAMPLE}") }
+  #   assert_operator 4.0, :>, (duration_express_templates/duration_erb)
+  # end
 
-  test "performance better than haml" do
-    duration_haml = time(100) { Haml::Engine.new(HAML_EXAMPLE).render(self) }
-    duration_express_templates = time(100) { ExpressTemplates.render(self, "#{GARA_EXAMPLE}") }
-    assert_operator 0.5, :>, (duration_express_templates/duration_haml)
-  end
+  # test "performance better than haml" do
+  #   duration_haml = time(100) { Haml::Engine.new(HAML_EXAMPLE).render(self) }
+  #   duration_express_templates = time(100) { ExpressTemplates.render(self, "#{GARA_EXAMPLE}") }
+  #   assert_operator 0.5, :>, (duration_express_templates/duration_haml)
+  # end
 
 end
 

data/test/test_helper.rb

@@ -19,6 +19,7 @@ end
 ECB = ExpressTemplates::Components::Base
 ETC = ExpressTemplates::Components
 ET = ExpressTemplates
+Interpolator = ExpressTemplates::Interpolator
 
 Tag = ExpressTemplates::Markup::Tag
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: express_templates
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Steven Talcott Smith
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-05 00:00:00.000000000 Z
+date: 2014-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -160,6 +174,7 @@ files:
 - lib/express_templates/components/unless_block.rb
 - lib/express_templates/expander.rb
 - lib/express_templates/indenter.rb
+- lib/express_templates/interpolator.rb
 - lib/express_templates/macro.rb
 - lib/express_templates/markup.rb
 - lib/express_templates/markup/html_tag.rb
@@ -242,6 +257,7 @@ files:
 - test/fixtures/a_big_page2.html
 - test/handler_test.rb
 - test/indenter_test.rb
+- test/interpolator_test.rb
 - test/markup/tag_test.rb
 - test/markup/wrapper_test.rb
 - test/markup/yielder_test.rb
@@ -344,6 +360,7 @@ test_files:
 - test/fixtures/a_big_page2.html
 - test/handler_test.rb
 - test/indenter_test.rb
+- test/interpolator_test.rb
 - test/markup/tag_test.rb
 - test/markup/wrapper_test.rb
 - test/markup/yielder_test.rb