locomotivecms-solid 0.2.2

data/spec/solid/element_examples.rb

@@ -0,0 +1,67 @@
+require 'solid'
+
+shared_examples "a Solid element" do
+
+  describe '.tag_name' do
+
+    it 'should register tag to Liquid with given name' do
+      Liquid::Template.should_receive(:register_tag).with('dummy', described_class)
+      described_class.tag_name 'dummy'
+    end
+
+    it 'should return previously given name' do
+      Liquid::Template.stub(:register_tag)
+      described_class.tag_name 'dummy'
+      described_class.tag_name.should be == 'dummy'
+    end
+
+  end
+
+  describe '.context_attribute' do
+
+    let(:element) do
+      described_class.context_attribute :current_user
+      Solid::Arguments.stub(:parse).with('ARGUMENTS_STRING')
+      element = described_class.new('name', 'ARGUMENTS_STRING', ['{% endname %}'])
+    end
+
+    it 'should define a custom accessor to the rendered context' do
+      element.stub(:current_context => {'current_user' => 'me'})
+      element.current_user.should be == 'me'
+    end
+
+    it 'should raise a Solid::ContextError if called outside render' do
+      expect{
+        element.current_user
+      }.to raise_error(Solid::ContextError)
+    end
+
+  end
+
+  describe '#arguments' do
+
+    it 'should instanciate a Solid::Arguments with his arguments_string' do
+      Solid::Arguments.should_receive(:parse).with('ARGUMENTS_STRING')
+      described_class.new('name', 'ARGUMENTS_STRING', ['{% endname %}'])
+    end
+
+    it 'should store his Solid:Arguments instance' do
+      element = described_class.new('name', '1', ['{% endname %}'])
+      element.arguments.should be_a(Solid::Arguments)
+    end
+
+  end
+
+  describe '#display' do
+
+    it 'should force developper to define it in child class' do
+      Solid::Arguments.stub(:parse).with('ARGUMENTS_STRING')
+      element = described_class.new('name', 'ARGUMENTS_STRING', ['{% endname %}'])
+      expect{
+        element.display
+      }.to raise_error(NotImplementedError)
+    end
+
+  end
+
+end

data/spec/solid/liquid_extensions/assign_tag_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Solid::LiquidExtensions::AssignTag do
+  it_should_behave_like 'a tag highjacker'
+
+  context 'when Liquid::Assign is replaced' do
+
+    before :each do
+      described_class.load!
+    end
+
+    after :each do
+      described_class.unload!
+    end
+
+    it 'should allow complex expression inside an assign tag' do
+      template = Solid::Template.parse(%(
+        {% assign included = foo.include?('bar') %}
+        {{ included }}
+      ))
+      output = template.render('foo' => ' bar ').strip
+      output.should be == 'true'
+    end
+
+  end
+
+end

data/spec/solid/liquid_extensions/for_tag_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+# FIXME: disabled for now
+
+# describe Solid::LiquidExtensions::ForTag do
+#   it_should_behave_like 'a tag highjacker'
+
+#   context 'when Liquid::For is replaced' do
+
+#     before :each do
+#       described_class.load!
+#     end
+
+#     after :each do
+#       described_class.unload!
+#     end
+
+#     it 'should allow complex expression inside a for tag' do
+#       template = Solid::Template.parse(%(
+#         {% for foo in foos.concat(foos.reverse).flatten %}
+#           {{ foo }}
+#         {% endfor %}
+#       ))
+#       output = template.render('foos' => [1, 2, 3]).gsub(/[^\d]/, '')
+#       output.should be == '123321'
+#     end
+
+#     it 'should still provide the "forloop" object' do
+#       template = Solid::Template.parse(%(
+#         {% for foo in foos %}{{ forloop.first }},{{ forloop.index0 }}/{{ forloop.length }},{{ forloop.last }}|{% endfor %}
+#       ))
+#       output = template.render('foos' => [1, 2, 3]).strip
+#       output.should be == "true,0/3,false|false,1/3,false|false,2/3,true|"
+#     end
+
+#     it 'should consider all non iterable objects as empty arrays' do
+#       template = Solid::Template.parse(%(
+#         {% for foo in foos %}
+#           {{ foo }}
+#         {% endfor %}
+#       ))
+#       output = template.render('foos' => nil).strip
+#       output.should be == ''
+#     end
+
+#   end
+
+# end

data/spec/solid/liquid_extensions/if_tag_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Solid::LiquidExtensions::IfTag do
+  it_should_behave_like 'a tag highjacker'
+
+  context 'when Liquid::If is replaced' do
+
+    before :each do
+      described_class.load!
+    end
+
+    after :each do
+      described_class.unload!
+    end
+
+    it 'should allow complex expression inside an if tag' do
+      template = Solid::Template.parse(%(
+        {% if foo.include?('bar') %}
+          Hello !
+        {% endif %}
+      ))
+      output = template.render('foo' => ' bar ').strip
+      output.should be == 'Hello !'
+    end
+
+    it 'should render nothing if the predicate return false' do
+      template = Solid::Template.parse(%(
+        {% if foo.include?('bar') %}
+          Hello !
+        {% endif %}
+      ))
+      output = template.render('foo' => ' plop ').strip
+      output.should be == ''
+    end
+
+    it 'should still accept an else tag' do
+      template = Solid::Template.parse(%(
+        {% if foo.include?('bar') %}
+          Hello !
+        {% else %}
+          Failed
+        {% endif %}
+      ))
+      output = template.render('foo' => ' spam ').strip
+      output.should be == 'Failed'
+    end
+
+    it 'should still accept some elsif tags' do
+      template = Solid::Template.parse(%(
+        {% if foo.include?('bar') %}
+          Hello !
+        {% elsif foo.include?('spam') %}
+          World !
+        {% else %}
+          Failed
+        {% endif %}
+      ))
+      output = template.render('foo' => ' spam ').strip
+      output.should be == 'World !'
+    end
+
+  end
+
+end

data/spec/solid/liquid_extensions/unless_tag_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Solid::LiquidExtensions::UnlessTag do
+  it_should_behave_like 'a tag highjacker'
+
+  context 'when Liquid::Unless is replaced' do
+
+    before :each do
+      described_class.load!
+    end
+
+    after :each do
+      described_class.unload!
+    end
+
+    it 'should allow complex expression inside an unless tag' do
+      template = Solid::Template.parse(%(
+        {% unless foo.include?('bar') %}
+          Hello !
+        {% endunless %}
+      ))
+      output = template.render('foo' => ' spam ').strip
+      output.should be == 'Hello !'
+    end
+
+    it 'should still accept an else tag' do
+      template = Solid::Template.parse(%(
+        {% unless foo.include?('bar') %}
+          Hello !
+        {% else %}
+          Failed
+        {% endunless %}
+      ))
+      output = template.render('foo' => ' bar ').strip
+      output.should be == 'Failed'
+    end
+
+    it 'should still accept some elsif tags' do
+      template = Solid::Template.parse(%(
+        {% unless foo.include?('spam') %}
+          Hello !
+        {% elsif foo.include?('spam') %}
+          World !
+        {% else %}
+          Failed
+        {% endunless %}
+      ))
+      output = template.render('foo' => ' spam ').strip
+      output.should be == 'World !'
+    end
+
+  end
+
+end

data/spec/solid/liquid_extensions/variable_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Solid::LiquidExtensions::Variable do
+  it_should_behave_like 'a class highjacker'
+
+  context 'real world example' do
+
+    before :each do
+      described_class.load!
+    end
+
+    after :each do
+      described_class.unload!
+    end
+
+    let(:template) { template = Solid::Template.parse('{{ foo.include?("bar") | upcase }}') }
+
+    it 'should allow method call with arguments in variables brackets' do
+      template.render('foo' => 'egg bar spam').should be == 'TRUE'
+      template.render('foo' => '').should be == 'FALSE'
+    end
+
+  end
+
+end

data/spec/solid/model_drop_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'active_support/core_ext'
+require 'ostruct'
+Rails = OpenStruct.new(env: OpenStruct.new(test?: true))
+require 'solid/model_drop'
+
+describe Solid::ModelDrop do
+  describe "array methods" do
+
+    it "work on a drop" do
+      drop = described_class.new([1, 2, 3])
+      drop.reverse.should be == [3, 2, 1]
+    end
+
+    it "go through #each" do
+      klass = Class.new(described_class) do
+        def each
+          super.select(&:odd?)
+        end
+      end
+      drop = klass.new([1, 2, 3])
+      drop.reverse.should be == [3, 1]
+    end
+
+  end
+end

data/spec/solid/parser/ripper_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+ripper_support = true
+begin
+  require 'ripper'
+rescue LoadError
+  ripper_support = false
+end
+
+describe Solid::Parser::Ripper do
+
+  it_should_behave_like 'a solid parser'
+
+end if ripper_support

data/spec/solid/parser/ruby_parser_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Solid::Parser::RubyParser do
+
+  it_should_behave_like 'a solid parser'
+
+end

data/spec/solid/tag_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+class DummyTag < Solid::Tag
+
+  def display(*args)
+    args.inspect
+  end
+
+end
+
+describe Solid::Tag do
+
+  it_behaves_like "a Solid element"
+
+  subject{ DummyTag.new('dummy', '1, "foo", myvar, myopts: false', 'token') }
+
+  it 'should works' do
+    subject.render('myvar' => 'bar').should be == '[1, "foo", "bar", {:myopts=>false}]'
+  end
+
+  it 'should send all parsed arguments do #display' do
+    subject.should_receive(:display).with(1, 'foo', 'bar', :myopts => false).and_return('result')
+    subject.render('myvar' => 'bar').should be == 'result'
+  end
+
+end

data/spec/solid/template_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Solid::Template do
+
+  let(:liquid) { %{first_string{% comment %}
+      {% if foo %}ifcontent{% endif %}
+      {% if foo %}ifsecondcontent{% endif %}
+    {% endcomment %}
+    {% unless foo %}unlesscontent{% endunless %}
+    
+  } }
+
+  let(:template) { Solid::Template.parse(liquid) }
+
+  specify { subject.should be_an(Enumerable) }
+
+  describe '#each' do
+
+    let(:yielded_nodes) do
+      [].tap do |nodes|
+        template.each{ |node| nodes << node }
+      end
+     end
+
+     let(:yielded_classes) { yielded_nodes.map(&:class) }
+
+    it 'should yield parent nodes before child nodes' do
+      yielded_classes.index(Liquid::Comment).should be < yielded_classes.index(Liquid::If)
+    end
+
+    it 'should yield first sibling first (No ! really ? ...)' do
+      yielded_classes.index(Liquid::Comment).should be < yielded_classes.index(Liquid::Unless)
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'rspec'
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'solid'))
+
+RSpec.configure do |c|
+  c.mock_with :rspec
+end
+
+Dir[File.join(File.dirname(__FILE__), '/**/*_examples.rb'), File.join(File.dirname(__FILE__), '/**/*_matchers.rb')].each{ |f| require f }

data/spec/support/class_highjacker_examples.rb

@@ -0,0 +1,33 @@
+shared_examples "a class highjacker" do
+
+  context 'class highjacking' do
+
+    let(:highjacked_class_name) { "Liquid::#{described_class.demodulized_name}" }
+
+    def highjacked_class
+      highjacked_class_name.split('::').inject(Object) { |klass, const_name| klass.const_get(const_name) }
+    end
+
+    after :each do
+      described_class.unload!
+    end
+
+    let!(:original_class_id) { highjacked_class.object_id }
+
+    it 'should be able to replace original class' do
+      expect{
+        described_class.load!
+      }.to change{ highjacked_class.object_id }.from(original_class_id).to(described_class.object_id)
+    end
+
+    it 'should be able to restore original class' do
+      described_class.load!
+      expect{
+        described_class.unload!
+      }.to change{ highjacked_class.object_id }.from(described_class.object_id).to(original_class_id)
+    end
+
+  end
+
+
+end