temple 0.9.1 → 0.10.3

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: temple
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.10.3
 platform: ruby
 authors:
 - Magnus Holm
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-10-25 00:00:00.000000000 Z
+date: 2023-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tilt
@@ -96,6 +96,7 @@ files:
 - lib/temple/filters/code_merger.rb
 - lib/temple/filters/control_flow.rb
 - lib/temple/filters/dynamic_inliner.rb
+- lib/temple/filters/dynamic_merger.rb
 - lib/temple/filters/encoding.rb
 - lib/temple/filters/eraser.rb
 - lib/temple/filters/escapable.rb
@@ -133,31 +134,6 @@ files:
 - lib/temple/templates/tilt.rb
 - lib/temple/utils.rb
 - lib/temple/version.rb
-- spec/engine_spec.rb
-- spec/erb_spec.rb
-- spec/filter_spec.rb
-- spec/filters/code_merger_spec.rb
-- spec/filters/control_flow_spec.rb
-- spec/filters/dynamic_inliner_spec.rb
-- spec/filters/eraser_spec.rb
-- spec/filters/escapable_spec.rb
-- spec/filters/multi_flattener_spec.rb
-- spec/filters/static_analyzer_spec.rb
-- spec/filters/static_merger_spec.rb
-- spec/filters/string_splitter_spec.rb
-- spec/generator_spec.rb
-- spec/grammar_spec.rb
-- spec/html/attribute_merger_spec.rb
-- spec/html/attribute_remover_spec.rb
-- spec/html/attribute_sorter_spec.rb
-- spec/html/fast_spec.rb
-- spec/html/pretty_spec.rb
-- spec/map_spec.rb
-- spec/mixins/dispatcher_spec.rb
-- spec/mixins/grammar_dsl_spec.rb
-- spec/spec_helper.rb
-- spec/static_analyzer_spec.rb
-- spec/utils_spec.rb
 - temple.gemspec
 homepage: https://github.com/judofyr/temple
 licenses:
@@ -178,7 +154,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.10
 signing_key: 
 specification_version: 4
 summary: Template compilation framework in Ruby

data/spec/engine_spec.rb

@@ -1,189 +0,0 @@
-# -*- coding: utf-8 -*-
-require 'spec_helper'
-
-class Callable1
-  def call(exp)
-    exp
-  end
-end
-
-class Callable2
-  def call(exp)
-    exp
-  end
-end
-
-class MySpecialFilter
-  def initialize(opts = {})
-  end
-
-  def call(exp)
-    exp
-  end
-end
-
-class TestEngine < Temple::Engine
-  use(:Parser) do |input|
-    [:static, input]
-  end
-  use :MyFilter1, proc {|exp| exp }
-  use :MyFilter2, proc {|exp| exp }
-  use Temple::HTML::Pretty, pretty: true
-  filter :MultiFlattener
-  generator :ArrayBuffer
-  use(:BeforeBeforeLast) { MySpecialFilter }
-  use :BeforeLast, Callable1.new
-  use(:Last) { Callable2.new }
-end
-
-describe Temple::Engine do
-  it 'should build chain' do
-    expect(TestEngine.chain.size).to eq(9)
-
-    expect(TestEngine.chain[0].first).to eq(:Parser)
-    expect(TestEngine.chain[0].size).to eq(2)
-    expect(TestEngine.chain[0].last).to be_a(Proc)
-
-    expect(TestEngine.chain[1].first).to eq(:MyFilter1)
-    expect(TestEngine.chain[1].size).to eq(2)
-    expect(TestEngine.chain[1].last).to be_a(Proc)
-
-    expect(TestEngine.chain[2].first).to eq(:MyFilter2)
-    expect(TestEngine.chain[2].size).to eq(2)
-    expect(TestEngine.chain[2].last).to be_a(Proc)
-
-    expect(TestEngine.chain[3].first).to eq(:'Temple::HTML::Pretty')
-    expect(TestEngine.chain[3].size).to eq(2)
-    expect(TestEngine.chain[3].last).to be_a(Proc)
-
-    expect(TestEngine.chain[4].first).to eq(:MultiFlattener)
-    expect(TestEngine.chain[4].size).to eq(2)
-    expect(TestEngine.chain[4].last).to be_a(Proc)
-
-    expect(TestEngine.chain[5].first).to eq(:ArrayBuffer)
-    expect(TestEngine.chain[5].size).to eq(2)
-    expect(TestEngine.chain[5].last).to be_a(Proc)
-
-    expect(TestEngine.chain[6].first).to eq(:BeforeBeforeLast)
-    expect(TestEngine.chain[6].size).to eq(2)
-    expect(TestEngine.chain[6].last).to be_a(Proc)
-
-    expect(TestEngine.chain[7].first).to eq(:BeforeLast)
-    expect(TestEngine.chain[7].size).to eq(2)
-    expect(TestEngine.chain[7].last).to be_a(Proc)
-
-    expect(TestEngine.chain[8].first).to eq(:Last)
-    expect(TestEngine.chain[8].size).to eq(2)
-    expect(TestEngine.chain[8].last).to be_a(Proc)
-  end
-
-  it 'should instantiate chain' do
-    call_chain = TestEngine.new.send(:call_chain)
-    expect(call_chain[0]).to be_a(Method)
-    expect(call_chain[1]).to be_a(Method)
-    expect(call_chain[2]).to be_a(Method)
-    expect(call_chain[3]).to be_a(Temple::HTML::Pretty)
-    expect(call_chain[4]).to be_a(Temple::Filters::MultiFlattener)
-    expect(call_chain[5]).to be_a(Temple::Generators::ArrayBuffer)
-    expect(call_chain[6]).to be_a(MySpecialFilter)
-    expect(call_chain[7]).to be_a(Callable1)
-    expect(call_chain[8]).to be_a(Callable2)
-  end
-
-  it 'should have #append' do
-    engine = TestEngine.new
-    call_chain = engine.send(:call_chain)
-    expect(call_chain.size).to eq(9)
-
-    engine.append :MyFilter3 do |exp|
-      exp
-    end
-
-    expect(TestEngine.chain.size).to eq(9)
-    expect(engine.chain.size).to eq(10)
-    expect(engine.chain[9].first).to eq(:MyFilter3)
-    expect(engine.chain[9].size).to eq(2)
-    expect(engine.chain[9].last).to be_a(Proc)
-
-    call_chain = engine.send(:call_chain)
-    expect(call_chain.size).to eq(10)
-    expect(call_chain[9]).to be_a(Method)
-  end
-
-  it 'should have #prepend' do
-    engine = TestEngine.new
-    call_chain = engine.send(:call_chain)
-    expect(call_chain.size).to eq(9)
-
-    engine.prepend :MyFilter0 do |exp|
-      exp
-    end
-
-    expect(TestEngine.chain.size).to eq(9)
-    expect(engine.chain.size).to eq(10)
-    expect(engine.chain[0].first).to eq(:MyFilter0)
-    expect(engine.chain[0].size).to eq(2)
-    expect(engine.chain[0].last).to be_a(Proc)
-    expect(engine.chain[1].first).to eq(:Parser)
-
-    call_chain = engine.send(:call_chain)
-    expect(call_chain.size).to eq(10)
-    expect(call_chain[0]).to be_a(Method)
-  end
-
-  it 'should have #after' do
-    engine = TestEngine.new
-    engine.after :Parser, :MyFilter0 do |exp|
-      exp
-    end
-    expect(TestEngine.chain.size).to eq(9)
-    expect(engine.chain.size).to eq(10)
-    expect(engine.chain[0].first).to eq(:Parser)
-    expect(engine.chain[1].first).to eq(:MyFilter0)
-    expect(engine.chain[2].first).to eq(:MyFilter1)
-  end
-
-  it 'should have #before' do
-    engine = TestEngine.new
-    engine.before :MyFilter1, :MyFilter0 do |exp|
-      exp
-    end
-    expect(TestEngine.chain.size).to eq(9)
-    expect(engine.chain.size).to eq(10)
-    expect(engine.chain[0].first).to eq(:Parser)
-    expect(engine.chain[1].first).to eq(:MyFilter0)
-    expect(engine.chain[2].first).to eq(:MyFilter1)
-  end
-
-  it 'should have #remove' do
-    engine = TestEngine.new
-    engine.remove :MyFilter1
-    expect(TestEngine.chain.size).to eq(9)
-    expect(engine.chain.size).to eq(8)
-    expect(engine.chain[0].first).to eq(:Parser)
-    expect(engine.chain[1].first).to eq(:MyFilter2)
-
-    engine = TestEngine.new
-    engine.remove /Last/
-    expect(engine.chain.size).to eq(6)
-  end
-
-  it 'should have #replace' do
-    engine = TestEngine.new
-    engine.replace :Parser, :MyParser do |exp|
-      exp
-    end
-    expect(engine.chain.size).to eq(9)
-    expect(engine.chain[0].first).to eq(:MyParser)
-  end
-
-  it 'should work with inheritance' do
-    inherited_engine = Class.new(TestEngine)
-    expect(inherited_engine.chain.size).to eq(9)
-    inherited_engine.append :MyFilter3 do |exp|
-      exp
-    end
-    expect(inherited_engine.chain.size).to eq(10)
-    expect(TestEngine.chain.size).to eq(9)
-  end
-end

data/spec/erb_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-require 'tilt/erubi'
-
-describe Temple::ERB::Engine do
-  it 'should compile erb' do
-    src = %q{
-%% hi
-= hello
-<% 3.times do |n| %>
-* <%= n %>
-<% end %>
-}
-
-    expect(erb(src)).to eq(erubi(src))
-  end
-
-  it 'should recognize comments' do
-    src = %q{
-hello
-  <%# comment -- ignored -- useful in testing %>
-world}
-
-    expect(erb(src)).to eq(erubi(src))
-  end
-
-  it 'should recognize <%% and %%>' do
-    src = %q{
-<%%
-<% if true %>
-  %%>
-<% end %>
-}
-
-    expect(erb(src)).to eq("\n<%\n  %>\n")
-  end
-
-  it 'should escape automatically' do
-    src = '<%== "<" %>'
-    ans = '&lt;'
-    expect(erb(src)).to eq(ans)
-  end
-
-  it 'should support = to disable automatic escape' do
-    src = '<%= "<" %>'
-    ans = '<'
-    expect(erb(src)).to eq(ans)
-  end
-
-  it 'should support trim mode' do
-    src = %q{
-%% hi
-= hello
-<% 3.times do |n| %>
-* <%= n %>
-<% end %>
-}
-
-    expect(erb(src, trim: true)).to eq(erubi(src, trim: true))
-    expect(erb(src, trim: false)).to eq(erubi(src, trim: false))
-  end
-end

data/spec/filter_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-class SimpleFilter < Temple::Filter
-  define_options :key
-
-  def on_test(arg)
-    [:on_test, arg]
-  end
-end
-
-describe Temple::Filter do
-  it 'should support options' do
-    expect(Temple::Filter).to respond_to(:default_options)
-    expect(Temple::Filter).to respond_to(:set_default_options)
-    expect(Temple::Filter).to respond_to(:define_options)
-    expect(Temple::Filter.new.options).to be_a(Temple::ImmutableMap)
-    expect(SimpleFilter.new(key: 3).options[:key]).to eq(3)
-  end
-
-  it 'should implement call' do
-    expect(Temple::Filter.new.call([:exp])).to eq([:exp])
-  end
-
-  it 'should process expressions' do
-    filter = SimpleFilter.new
-    expect(filter.call([:unhandled])).to eq([:unhandled])
-    expect(filter.call([:test, 42])).to eq([:on_test, 42])
-  end
-end

data/spec/filters/code_merger_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-describe Temple::Filters::CodeMerger do
-  before do
-    @filter = Temple::Filters::CodeMerger.new
-  end
-
-  it 'should merge serveral codes' do
-    expect(@filter.call([:multi,
-      [:code, "a"],
-      [:code, "b"],
-      [:code, "c"]
-    ])).to eq [:code, "a; b; c"]
-  end
-
-  it 'should merge serveral codes around static' do
-    expect(@filter.call([:multi,
-      [:code, "a"],
-      [:code, "b"],
-      [:static, "123"],
-      [:code, "a"],
-      [:code, "b"]
-    ])).to eq [:multi,
-      [:code, "a; b"],
-      [:static, "123"],
-      [:code, "a; b"]
-    ]
-  end
-
-  it 'should merge serveral codes with newlines' do
-    expect(@filter.call([:multi,
-      [:code, "a"],
-      [:code, "b"],
-      [:newline],
-      [:code, "c"]
-    ])).to eq [:code, "a; b\nc"]
-  end
-end

data/spec/filters/control_flow_spec.rb

@@ -1,90 +0,0 @@
-require 'spec_helper'
-
-describe Temple::Filters::ControlFlow do
-  before do
-    @filter = Temple::Filters::ControlFlow.new
-  end
-
-  it 'should process blocks' do
-    expect(@filter.call([:block, 'loop do',
-      [:static, 'Hello']
-    ])).to eq [:multi,
-                     [:code, 'loop do'],
-                     [:static, 'Hello'],
-                     [:code, 'end']]
-  end
-
-  it 'should process if' do
-    expect(@filter.call([:if, 'condition',
-      [:static, 'Hello']
-    ])).to eq [:multi,
-      [:code, 'if condition'],
-      [:static, 'Hello'],
-      [:code, 'end']
-    ]
-  end
-
-  it 'should process if with else' do
-    expect(@filter.call([:if, 'condition',
-      [:static, 'True'],
-      [:static, 'False']
-    ])).to eq [:multi,
-      [:code, 'if condition'],
-      [:static, 'True'],
-      [:code, 'else'],
-      [:static, 'False'],
-      [:code, 'end']
-    ]
-  end
-
-  it 'should create elsif' do
-    expect(@filter.call([:if, 'condition1',
-      [:static, '1'],
-      [:if, 'condition2',
-       [:static, '2'],
-       [:static, '3']]
-    ])).to eq [:multi,
-      [:code, 'if condition1'],
-      [:static, '1'],
-      [:code, 'elsif condition2'],
-      [:static, '2'],
-      [:code, 'else'],
-      [:static, '3'],
-      [:code, 'end']
-    ]
-  end
-
-  it 'should process cond' do
-    expect(@filter.call([:cond,
-      ['cond1', [:exp1]],
-      ['cond2', [:exp2]],
-      [:else,   [:exp3]],
-    ])).to eq [:multi,
-      [:code, 'case'],
-      [:code, 'when cond1'],
-      [:exp1],
-      [:code, 'when cond2'],
-      [:exp2],
-      [:code, 'else'],
-      [:exp3],
-      [:code, 'end']
-    ]
-  end
-
-  it 'should process case' do
-    expect(@filter.call([:case, 'var',
-      ['Array',  [:exp1]],
-      ['String', [:exp2]],
-      [:else,    [:exp3]],
-    ])).to eq [:multi,
-      [:code, 'case (var)'],
-      [:code, 'when Array'],
-      [:exp1],
-      [:code, 'when String'],
-      [:exp2],
-      [:code, 'else'],
-      [:exp3],
-      [:code, 'end']
-    ]
-  end
-end

data/spec/filters/dynamic_inliner_spec.rb

@@ -1,95 +0,0 @@
-require 'spec_helper'
-
-describe Temple::Filters::DynamicInliner do
-  before do
-    @filter = Temple::Filters::DynamicInliner.new
-  end
-
-  it 'should compile several statics into dynamic' do
-    expect(@filter.call([:multi,
-      [:static, "Hello "],
-      [:static, "World\n "],
-      [:static, "Have a nice day"]
-    ])).to eq [:dynamic, '"Hello World\n Have a nice day"']
-  end
-
-  it 'should compile several dynamics into dynamic' do
-    expect(@filter.call([:multi,
-      [:dynamic, "@hello"],
-      [:dynamic, "@world"],
-      [:dynamic, "@yeah"]
-    ])).to eq [:dynamic, '"#{@hello}#{@world}#{@yeah}"']
-  end
-
-  it 'should compile static and dynamic into dynamic' do
-    expect(@filter.call([:multi,
-      [:static, "Hello"],
-      [:dynamic, "@world"],
-      [:dynamic, "@yeah"],
-      [:static, "Nice"]
-    ])).to eq [:dynamic, '"Hello#{@world}#{@yeah}Nice"']
-  end
-
-  it 'should merge statics and dynamics around a code' do
-    expect(@filter.call([:multi,
-      [:static, "Hello "],
-      [:dynamic, "@world"],
-      [:code, "Oh yeah"],
-      [:dynamic, "@yeah"],
-      [:static, "Once more"]
-    ])).to eq [:multi,
-      [:dynamic, '"Hello #{@world}"'],
-      [:code, "Oh yeah"],
-      [:dynamic, '"#{@yeah}Once more"']
-    ]
-  end
-
-  it 'should keep codes intact' do
-    expect(@filter.call([:multi, [:code, 'foo']])).to eq([:code, 'foo'])
-  end
-
-  it 'should keep single statics intact' do
-    expect(@filter.call([:multi, [:static, 'foo']])).to eq([:static, 'foo'])
-  end
-
-  it 'should keep single dynamic intact' do
-    expect(@filter.call([:multi, [:dynamic, 'foo']])).to eq([:dynamic, 'foo'])
-  end
-
-  it 'should inline inside multi' do
-    expect(@filter.call([:multi,
-      [:static, "Hello "],
-      [:dynamic, "@world"],
-      [:multi,
-        [:static, "Hello "],
-        [:dynamic, "@world"]],
-      [:static, "Hello "],
-      [:dynamic, "@world"]
-    ])).to eq [:multi,
-      [:dynamic, '"Hello #{@world}"'],
-      [:dynamic, '"Hello #{@world}"'],
-      [:dynamic, '"Hello #{@world}"']
-    ]
-  end
-
-  it 'should merge across newlines' do
-    exp = expect(@filter.call([:multi,
-      [:static, "Hello \n"],
-      [:newline],
-      [:dynamic, "@world"],
-      [:newline]
-    ])).to eq [:dynamic, ['"Hello \n"', '"#{@world}"', '""'].join("\\\n")]
-  end
-
-  it 'should compile static followed by newline' do
-    expect(@filter.call([:multi,
-      [:static, "Hello \n"],
-      [:newline],
-      [:code, "world"]
-    ])).to eq [:multi,
-      [:static, "Hello \n"],
-      [:newline],
-      [:code, "world"]
-    ]
-  end
-end

data/spec/filters/eraser_spec.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-
-describe Temple::Filters::Eraser do
-  it 'should respect keep' do
-    eraser = Temple::Filters::Eraser.new(keep: [:a])
-    expect(eraser.call([:multi,
-      [:a],
-      [:b],
-      [:c]
-    ])).to eq [:multi,
-      [:a],
-      [:multi],
-      [:multi]
-    ]
-  end
-
-  it 'should respect erase' do
-    eraser = Temple::Filters::Eraser.new(erase: [:a])
-    expect(eraser.call([:multi,
-      [:a],
-      [:b],
-      [:c]
-    ])).to eq [:multi,
-      [:multi],
-      [:b],
-      [:c]
-    ]
-  end
-
-  it 'should choose erase over keep' do
-    eraser = Temple::Filters::Eraser.new(keep: [:a, :b], erase: [:a])
-    expect(eraser.call([:multi,
-      [:a],
-      [:b],
-      [:c]
-    ])).to eq [:multi,
-      [:multi],
-      [:b],
-      [:multi]
-    ]
-  end
-
-  it 'should erase nested types' do
-    eraser = Temple::Filters::Eraser.new(erase: [[:a, :b]])
-    expect(eraser.call([:multi,
-      [:a, :a],
-      [:a, :b],
-      [:b]
-    ])).to eq [:multi,
-      [:a, :a],
-      [:multi],
-      [:b]
-    ]
-  end
-end

data/spec/filters/escapable_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-
-describe Temple::Filters::Escapable do
-  before do
-    @filter = Temple::Filters::Escapable.new
-  end
-
-  it 'should handle escape expressions' do
-    expect(@filter.call([:escape, true,
-                  [:multi,
-                   [:static, "a < b"],
-                   [:dynamic, "ruby_method"]]
-    ])).to eq [:multi,
-      [:static, "a &lt; b"],
-      [:dynamic, "::Temple::Utils.escape_html((ruby_method))"],
-    ]
-  end
-
-  it 'should keep codes intact' do
-    exp = [:multi, [:code, 'foo']]
-    expect(@filter.call(exp)).to eq(exp)
-  end
-
-  it 'should keep statics intact' do
-    exp = [:multi, [:static, '<']]
-    expect(@filter.call(exp)).to eq(exp)
-  end
-
-  it 'should keep dynamic intact' do
-    exp = [:multi, [:dynamic, 'foo']]
-    expect(@filter.call(exp)).to eq(exp)
-  end
-
-  it 'should have use_html_safe option' do
-    with_html_safe do
-      filter = Temple::Filters::Escapable.new(use_html_safe: true)
-      expect(filter.call([:escape, true,
-        [:static, Temple::HTML::SafeString.new("a < b")]
-      ])).to eq [:static, "a < b"]
-    end
-  end
-
-  it 'should support censoring' do
-    filter = Temple::Filters::Escapable.new(escape_code: '(%s).gsub("Temple sucks", "Temple rocks")')
-    expect(filter.call([:escape, true,
-      [:static, "~~ Temple sucks ~~"]
-    ])).to eq [:static, "~~ Temple rocks ~~"]
-  end
-end

data/spec/filters/multi_flattener_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-describe Temple::Filters::MultiFlattener do
-  before do
-    @filter = Temple::Filters::MultiFlattener.new
-  end
-
-  it 'should flatten nested multi expressions' do
-    expect(@filter.call([:multi,
-      [:static, "a"],
-      [:multi,
-       [:dynamic, "aa"],
-       [:multi,
-        [:static, "aaa"],
-        [:static, "aab"],
-       ],
-       [:dynamic, "ab"],
-      ],
-      [:static, "b"],
-    ])).to eq [:multi,
-      [:static, "a"],
-      [:dynamic, "aa"],
-      [:static, "aaa"],
-      [:static, "aab"],
-      [:dynamic, "ab"],
-      [:static, "b"],
-    ]
-  end
-
-  it 'should return first element' do
-    expect(@filter.call([:multi, [:code, 'foo']])).to eq([:code, 'foo'])
-  end
-end