temple 0.9.1 → 0.10.3

data/spec/map_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-describe Temple::ImmutableMap do
-  it 'has read accessor' do
-    hash = Temple::ImmutableMap.new({a: 1},{b: 2, a: 3})
-    expect(hash[:a]).to eq(1)
-    expect(hash[:b]).to eq(2)
-  end
-
-  it 'has include?' do
-    hash = Temple::ImmutableMap.new({a: 1},{b: 2, a: 3})
-    expect(hash).to include(:a)
-    expect(hash).to include(:b)
-    expect(hash).not_to include(:c)
-  end
-
-  it 'has values' do
-    expect(Temple::ImmutableMap.new({a: 1},{b: 2, a: 3}).values.sort).to eq([1,2])
-  end
-
-  it 'has keys' do
-    expect(Temple::ImmutableMap.new({a: 1},{b: 2, a: 3}).keys).to eq([:a,:b])
-  end
-
-  it 'has to_a' do
-    expect(Temple::ImmutableMap.new({a: 1},{b: 2, a: 3}).to_a).to eq([[:a, 1], [:b, 2]])
-  end
-end
-
-describe Temple::MutableMap do
-  it 'has write accessor' do
-    parent = {a: 1}
-    hash = Temple::MutableMap.new(parent)
-    expect(hash[:a]).to eq(1)
-    hash[:a] = 2
-    expect(hash[:a]).to eq(2)
-    expect(parent[:a]).to eq(1)
-  end
-end

data/spec/mixins/dispatcher_spec.rb

@@ -1,70 +0,0 @@
-require 'spec_helper'
-
-class FilterWithDispatcherMixin
-  include Temple::Mixins::Dispatcher
-
-  def on_test(arg)
-    [:on_test, arg]
-  end
-
-  def on_test_check(arg)
-    [:on_check, arg]
-  end
-
-  def on_second_test(arg)
-    [:on_second_test, arg]
-  end
-
-  def on_a_b(*arg)
-    [:on_ab, *arg]
-  end
-
-  def on_a_b_test(arg)
-    [:on_ab_test, arg]
-  end
-
-  def on_a_b_c_d_test(arg)
-    [:on_abcd_test, arg]
-  end
-end
-
-class FilterWithDispatcherMixinAndOn < FilterWithDispatcherMixin
-  def on(*args)
-    [:on_zero, *args]
-  end
-end
-
-describe Temple::Mixins::Dispatcher do
-  before do
-    @filter = FilterWithDispatcherMixin.new
-  end
-
-  it 'should return unhandled expressions' do
-    expect(@filter.call([:unhandled])).to eq([:unhandled])
-  end
-
-  it 'should dispatch first level' do
-    expect(@filter.call([:test, 42])).to eq([:on_test, 42])
-  end
-
-  it 'should dispatch second level' do
-    expect(@filter.call([:second, :test, 42])).to eq([:on_second_test, 42])
-  end
-
-  it 'should dispatch second level if prefixed' do
-    expect(@filter.call([:test, :check, 42])).to eq([:on_check, 42])
-  end
-
-  it 'should dispatch parent level' do
-    expect(@filter.call([:a, 42])).to eq [:a, 42]
-    expect(@filter.call([:a, :b, 42])).to eq [:on_ab, 42]
-    expect(@filter.call([:a, :b, :test, 42])).to eq [:on_ab_test, 42]
-    expect(@filter.call([:a, :b, :c, 42])).to eq [:on_ab, :c, 42]
-    expect(@filter.call([:a, :b, :c, :d, 42])).to eq [:on_ab, :c, :d, 42]
-    expect(@filter.call([:a, :b, :c, :d, :test, 42])).to eq [:on_abcd_test, 42]
-  end
-
-  it 'should dispatch zero level' do
-    expect(FilterWithDispatcherMixinAndOn.new.call([:foo,42])).to eq [:on_zero, :foo, 42]
-  end
-end

data/spec/mixins/grammar_dsl_spec.rb

@@ -1,86 +0,0 @@
-require 'spec_helper'
-
-module BasicGrammar
-  extend Temple::Mixins::GrammarDSL
-
-  Expression <<
-    Symbol |
-    Answer |
-    [:zero_or_more, 'Expression*'] |
-    [:one_or_more,  'Expression+'] |
-    [:zero_or_one,  'Expression?'] |
-    [:bool, Bool] |
-    nil
-
-  Bool <<
-    true | false
-
-  Answer <<
-    Value(42)
-
-end
-
-module ExtendedGrammar
-  extend BasicGrammar
-
-  Expression << [:extended, Expression]
-end
-
-describe Temple::Mixins::GrammarDSL do
-  it 'should support class types' do
-    expect(BasicGrammar).to be_match(:symbol)
-    expect(BasicGrammar).not_to be_match([:symbol])
-    expect(BasicGrammar).not_to be_match('string')
-    expect(BasicGrammar).not_to be_match(['string'])
-  end
-
-  it 'should support value types' do
-    expect(BasicGrammar).to be_match(42)
-    expect(BasicGrammar).not_to be_match(43)
-  end
-
-  it 'should support nesting' do
-    expect(BasicGrammar).to be_match([:zero_or_more, [:zero_or_more]])
-  end
-
-  it 'should support *' do
-    expect(BasicGrammar).to be_match([:zero_or_more])
-    expect(BasicGrammar).to be_match([:zero_or_more, nil, 42])
-  end
-
-  it 'should support +' do
-    expect(BasicGrammar).not_to be_match([:one_or_more])
-    expect(BasicGrammar).to be_match(    [:one_or_more, 42])
-    expect(BasicGrammar).to be_match(    [:one_or_more, 42, nil])
-  end
-
-  it 'should support ?' do
-    expect(BasicGrammar).not_to be_match([:zero_or_one, nil, 42])
-    expect(BasicGrammar).to be_match(    [:zero_or_one])
-    expect(BasicGrammar).to be_match(    [:zero_or_one, 42])
-  end
-
-  it 'should support extended grammars' do
-    expect(ExtendedGrammar).to be_match([:extended, [:extended, 42]])
-    expect(BasicGrammar).not_to be_match([:zero_or_more, [:extended, nil]])
-    expect(BasicGrammar).not_to be_match([:extended, [:extended, 42]])
-  end
-
-  it 'should have validate!' do
-    grammar_validate BasicGrammar,
-                     [:zero_or_more, [:zero_or_more, [:unknown]]],
-                     "BasicGrammar::Expression did not match\n[:unknown]\n"
-
-    grammar_validate BasicGrammar,
-                     [:zero_or_more, [:one_or_more]],
-                     "BasicGrammar::Expression did not match\n[:one_or_more]\n"
-
-    grammar_validate BasicGrammar,
-                     [:zero_or_more, 123, [:unknown]],
-                     "BasicGrammar::Expression did not match\n123\n"
-
-    grammar_validate BasicGrammar,
-                     [:bool, 123],
-                     "BasicGrammar::Bool did not match\n123\n"
-  end
-end

data/spec/spec_helper.rb

@@ -1,29 +0,0 @@
-require 'temple'
-
-module TestHelper
-  def with_html_safe
-    require 'temple/html/safe'
-    String.send(:define_method, :html_safe?) { false }
-    String.send(:define_method, :html_safe) { Temple::HTML::SafeString.new(self) }
-    yield
-  ensure
-    String.send(:undef_method, :html_safe?) if String.method_defined?(:html_safe?)
-    String.send(:undef_method, :html_safe) if String.method_defined?(:html_safe)
-  end
-
-  def grammar_validate(grammar, exp, message)
-    expect { grammar.validate!(exp) }.to raise_error(Temple::InvalidExpression, message)
-  end
-
-  def erb(src, options = {})
-    Temple::ERB::Template.new(options) { src }.render
-  end
-
-  def erubi(src, options = {})
-    Tilt::ErubiTemplate.new(options) { src }.render
-  end
-end
-
-RSpec.configure do |config|
-  config.include TestHelper
-end

data/spec/static_analyzer_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-describe Temple::StaticAnalyzer do
-  describe '.available?' do
-    it 'should return true if its dependency is available' do
-      expect(Temple::StaticAnalyzer.available?).to eq(defined?(Ripper) && Ripper.respond_to?(:lex))
-    end
-  end
-
-  if Temple::StaticAnalyzer.available?
-    describe '.static?' do
-      it 'should return true if given Ruby expression is static' do
-        ['true', 'false', '"hello world"', "[1, { 2 => 3 }]", "[\n1,\n]"].each do |exp|
-          expect(Temple::StaticAnalyzer.static?(exp)).to eq(true)
-        end
-      end
-
-      it 'should return false if given Ruby expression is dynamic' do
-        ['1 + 2', 'variable', 'method_call(a)', 'CONSTANT'].each do |exp|
-          expect(Temple::StaticAnalyzer.static?(exp)).to eq(false)
-        end
-      end
-    end
-
-    describe '.syntax_error?' do
-      it 'should return false if given Ruby expression is valid' do
-        ['Foo.bar.baz { |c| c.d! }', '{ foo: bar }'].each do |exp|
-          expect(Temple::StaticAnalyzer.syntax_error?(exp)).to eq(false)
-        end
-      end
-
-      it 'should return true if given Ruby expression is invalid' do
-        ['Foo.bar.baz { |c| c.d! ', ' foo: bar '].each do |exp|
-          expect(Temple::StaticAnalyzer.syntax_error?(exp)).to eq(true)
-        end
-      end
-    end
-  end
-end

data/spec/utils_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-class UniqueTest
-  include Temple::Utils
-end
-
-describe Temple::Utils do
-  it 'has empty_exp?' do
-    expect(Temple::Utils.empty_exp?([:multi])).to eq(true)
-    expect(Temple::Utils.empty_exp?([:multi, [:multi]])).to eq(true)
-    expect(Temple::Utils.empty_exp?([:multi, [:multi, [:newline]], [:newline]])).to eq(true)
-    expect(Temple::Utils.empty_exp?([:multi])).to eq(true)
-    expect(Temple::Utils.empty_exp?([:multi, [:multi, [:static, 'text']]])).to eq(false)
-    expect(Temple::Utils.empty_exp?([:multi, [:newline], [:multi, [:dynamic, 'text']]])).to eq(false)
-  end
-
-  it 'has unique_name' do
-    u = UniqueTest.new
-    expect(u.unique_name).to eq('_uniquetest1')
-    expect(u.unique_name).to eq('_uniquetest2')
-    expect(UniqueTest.new.unique_name).to eq('_uniquetest1')
-  end
-
-  it 'has escape_html' do
-    expect(Temple::Utils.escape_html('<')).to eq('&lt;')
-  end
-
-  it 'should escape unsafe html strings' do
-    with_html_safe do
-      expect(Temple::Utils.escape_html_safe('<')).to eq('&lt;')
-    end
-  end
-
-  it 'should not escape safe html strings' do
-    with_html_safe do
-      expect(Temple::Utils.escape_html_safe('<'.html_safe)).to eq('<')
-    end
-  end
-end