locomotivecms_solid 0.2.1

data/spec/solid/arguments_spec.rb

@@ -0,0 +1,310 @@
+require 'spec_helper'
+
+describe Solid::Arguments do
+
+  class DummyDrop < Liquid::Drop
+
+    def before_method(name)
+      "dummy #{name}"
+    end
+
+  end
+
+  def parse(string, context={})
+    Solid::Arguments.parse(string).interpolate(Liquid::Context.new(context))
+  end
+
+  context 'with no arguments' do
+
+    it "parses as an empty array" do
+      parse('').should be == []
+    end
+
+  end
+
+  context 'with a single argument' do
+
+    context 'of type string' do
+
+      it 'can parse an empty string' do
+        parse("''").should be == ['']
+      end
+
+      it 'can parse a constant' do
+        parse("FooBar", {'FooBar' => 42}).should be == [42]
+      end
+
+      it 'can parse a simple string (between simple quotes)' do
+        parse("'foobar'").should be == ['foobar']
+      end
+
+      it 'can parse a simple string (between double quotes)' do
+        parse('"foobar"').should be == ['foobar']
+      end
+
+      it 'should not consider this string as a context var' do
+        parse('"foobar"', {'foobar' => 'plop'}).should_not == ['plop']
+      end
+
+      it 'should not be disturbed by a string containing a comma' do
+        parse(%{"foo,bar", 'egg,spam'}).should be == ['foo,bar', 'egg,spam']
+      end
+
+      it 'should not be disturbed by a string containing a simple quote' do
+        parse('"foo\'bar"').should be == ["foo'bar"]
+      end
+
+      it 'should not be disturbed by a string containing a double quote' do
+        parse("'foo\"bar'").should be == ['foo"bar']
+      end
+
+      pending('not yet implemented') do
+        it 'should work for a string containing interpolation' do
+          parse('"1#{foo}3"', {'foo' => 2}).should be == ['123']
+        end
+      end
+
+    end
+
+    context 'of type integer' do
+
+      it 'should work' do
+        parse('42').should be == [42]
+      end
+
+    end
+
+    context 'of type float' do
+
+      it 'should work' do
+        parse('4.2').should be == [4.2]
+      end
+
+    end
+
+    context 'of type boolean' do
+
+      it 'should work with `true`' do
+        parse('true').should be == [true]
+      end
+
+      it 'should work with `false`' do
+        parse('false').should be == [false]
+      end
+
+    end
+
+    context 'of type Regexp' do
+
+      it 'should work for simple cases' do
+        parse('/bb|[^b]{2}/').should be == [/bb|[^b]{2}/]
+      end
+
+      it 'should work for a regexp containing interpolation' do
+        pending('not yet implemented')
+        parse('/#{mystring}|[^b]{2}/', {'mystring' => 'bb'}).should be == [/bb|[^b]{2}/]
+      end
+
+    end
+
+    context 'of type Range' do
+
+      it 'should work for integer ranges' do
+        parse('1..10').should be == [1..10]
+      end
+
+      it 'should work for integer exclusive ranges' do
+        parse('1...10').should be == [1...10]
+      end
+
+      it 'should work for float ranges' do
+        parse('1.0..10.0').should be == [1.0..10.0]
+      end
+
+      it 'should work with context variables' do
+        parse('a..b', {'a' => 1, 'b' => 10}).should be == [1..10]
+      end
+
+    end
+
+    context 'binary operators' do
+
+      it 'should permit additions' do
+        parse('1 + 2').should be == [3]
+      end
+
+      it 'should permit multiplications' do
+        parse('2 * 3').should be == [6]
+      end
+
+      it 'should permit to use builtins boolean operators' do
+        parse('true && false').should be == [false]
+        parse('false || true').should be == [true]
+      end
+
+    end
+
+    context 'unary operators' do
+
+      it 'should allow to use "!"' do
+        parse('!true').should be == [false]
+        parse('!false').should be == [true]
+      end
+
+    end
+
+    context 'of type "context var"' do
+
+      it 'should work' do
+        parse('myvar', {'myvar' => 'myvalue'}).should be == ['myvalue']
+      end
+
+      it 'can call methods without arguments' do
+        parse('myvar.length', {'myvar' => ' myvalue '}).should be == [9]
+      end
+
+      it 'can call methods without arguments on immediate values' do
+        parse('"foobar".length').should be == [6]
+      end
+
+      it 'can call methods without arguments but parentheses on immediate values' do
+        parse('"foobar".length()').should be == [6]
+      end
+
+      it 'can call a method with arguments' do
+        parse('myvar.split(",", 2)', {'myvar' => 'foo,bar'}).should be == [%w(foo bar)]
+      end
+
+      it 'can call a method with context var arguments' do
+        parse('myvar.split(myseparator, 2)', {'myvar' => 'foo,bar', 'myseparator' => ','}).should be == [%w(foo bar)]
+      end
+
+      it 'can evaluate context var deeply unclosed in collections' do
+        parse('[{1 => [{2 => myvar}]}]', {'myvar' => 'myvalue'}).first.should be == [{1 => [{2 => 'myvalue'}]}]
+      end
+
+      it 'can call methods chain without arguments' do
+        parse('myvar.strip.length', {'myvar' => ' myvalue '}).should be == [7]
+      end
+
+      it 'can call predicate methods' do
+        parse('myvar.empty?', {'myvar' => ' myvalue '}).should be == [false]
+      end
+
+      it 'can get a hash value' do
+        parse('myvar.mykey', {'myvar' => {'mykey' => 'myvalue'}}).should be == ['myvalue']
+      end
+
+      it 'can fallback on Liquid::Drop#before_method' do
+        parse('myvar.mymethod', {'myvar' => DummyDrop.new}).should be == ['dummy mymethod']
+      end
+
+      it 'should manage errors'
+
+    end
+
+    context 'of type hash' do
+
+      it 'should be able to parse unclosed hashes' do
+        parse('permissions: ""').should be == [{permissions: ''}]
+      end
+
+    end
+
+    context 'of type "named parameter"' do
+
+      it 'should be able to parse a string' do
+        parse('foo:"bar"').should be == [{:foo => 'bar'}]
+      end
+
+      it 'should be able to parse an int' do
+        parse('foo:42').should be == [{:foo => 42}]
+      end
+
+      it 'should be able to parse a context var' do
+        parse('foo:bar', {'bar' => 'baz'}).should be == [{:foo => 'baz'}]
+      end
+
+      it "should not be disturbed by a comma into a named string" do
+        parse('foo:"bar,baz"').should be == [{:foo => 'bar,baz'}]
+      end
+
+      it "should support a mix of types" do
+        parse('foo:"bar",bar:42, baz:true, egg:spam', {'spam' => 'egg'}).should be == [{
+          foo: 'bar',
+          bar: 42,
+          baz: true,
+          egg: 'egg',
+        }]
+      end
+
+    end
+
+  end
+
+  context 'security !!!' do
+
+    it 'should not allow to call unsecure methods' do
+      parse('42.send("`", "echo foo")').should be == [nil]
+    end
+
+    it 'should not allow to call unsecure methods' do
+      parse('42.__send__("`", "echo foo")').should be == [nil]
+    end
+
+    it "should raise a Solid::SyntaxError on unknown constructs" do
+      expect {
+        parse('{}[]')
+      }.to raise_error(Solid::SyntaxError)
+    end
+
+    it "should use #to_liquid" do
+      drop = Object.new
+      def drop.to_liquid
+        'liquid'
+      end
+      parse('drop', 'drop' => drop).should be == ['liquid']
+    end
+
+    it "should use #context= if available" do
+      drop = Object.new
+      class << drop
+        def to_liquid
+          self
+        end
+        def to_s
+          @alias
+        end
+        def context=(context)
+          @alias = context['alias']
+        end
+      end
+      parse('drop.to_s', 'drop' => drop, 'alias' => 'liquid').should be == ['liquid']
+    end
+
+  end
+
+  context 'with useless round brackets' do
+
+    it 'should still work' do
+      parse('(42)').should be == [42]
+      parse('(((((((42)))))))').should be == [42]
+    end
+
+  end
+
+  context 'with multiple arguments' do
+
+    it 'should return 3 arguments and an option hash' do
+      args = parse('1, "2", myvar, myopt:false', {'myvar' => 4.2})
+      args.should be == [1, '2', 4.2, {:myopt => false}]
+    end
+
+    it 'should be tolerant about whitespace around commas and colons' do
+      args = parse("    1\t, '2'  ,myvar, myopt: false", {'myvar' => 4.2})
+      args.should be == [1, '2', 4.2, {:myopt => false}]
+    end
+
+  end
+
+end

data/spec/solid/block_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+class DummyBlock < Solid::Block
+
+  def display(condition)
+    if condition
+      yield
+    else
+      'not_yielded'
+    end
+  end
+
+end
+
+describe Solid::Block do
+
+  it_behaves_like "a Solid element"
+
+  describe '#display' do
+
+    let(:tokens) { ["dummy", "{% enddummy %}", "outside"] }
+
+    subject{ DummyBlock.new('dummy', 'condition', tokens) }
+
+    it 'yielding should render the block content' do
+      subject.render(Liquid::Context.new('condition' => true)).should be == 'dummy'
+    end
+
+    it 'should only render until the {% endblock %} tag' do
+      subject.render(Liquid::Context.new('condition' => true)).should_not include('outside')
+    end
+
+    it 'should not render its content if it do not yield' do
+      subject.render(Liquid::Context.new('condition' => false)).should_not include('dummy')
+    end
+
+  end
+
+end

data/spec/solid/conditional_block_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+class IfPresent < Solid::ConditionalBlock
+
+  def display(string)
+    yield(!string.strip.empty?)
+  end
+
+end
+
+describe Solid::ConditionalBlock do
+
+  it_behaves_like "a Solid element"
+
+  describe '#display' do
+
+    let(:tokens) { ["present", "{% else %}", "blank", "{% endifpresent %}"] }
+
+    subject{ IfPresent.new('ifpresent', 'mystring', tokens) }
+
+    it 'yielding true should render the main block' do
+      context = Liquid::Context.new('mystring' => 'blah')
+      subject.render(context).should be == 'present'
+    end
+
+    it 'yielding false should render the `else` block' do
+      context = Liquid::Context.new('mystring' => '')
+      subject.render(context).should be == 'blank'
+    end
+
+    it 'yielding false without a `else` block does not render anything' do
+      context = Liquid::Context.new('mystring' => '')
+      subject = IfPresent.new('ifpresent', 'mystring', ['present', '{% endifpresent %}'])
+      subject.render(context).should be_nil
+    end
+
+  end
+
+end

data/spec/solid/default_security_rules_spec.rb

@@ -0,0 +1,180 @@
+require 'spec_helper'
+require 'active_support/core_ext'
+
+describe Solid, 'default security rules' do
+
+  shared_examples_for 'a ruby object' do
+    it_should_safely_respond_to :nil?, :==, :!=, :!, :!~, :blank?, :present?, :in?, :to_json
+    it_should_not_safely_respond_to :const_get, :const_set,
+      :instance_variable_get, :instance_variable_set, :instance_variable_defined?,
+      :send, :__send__, :public_send,
+      :__id__, :object_id,
+      :class, :singleton_class, :trust, :taint, :untaint, :untrust,
+      :clone, :dup, :initialize_dup, :initialize_clone, :freeze,
+      :methods, :singleton_methods, :protected_methods, :private_methods,
+      :method, :public_method, :define_singleton_method, :extend,
+      :eval, :instance_eval, :instance_exec, :exec, :`, :system, :test,
+      :global_variables, :local_variables,
+      :gets, :readline, :readlines, :sleep,
+      :at_exit!, :exit, :fork, :spawn, :trap, :exit!, :syscall
+  end
+
+  shared_examples_for 'a ruby module' do
+    it_should_behave_like 'a ruby object'
+    it_should_not_safely_respond_to :ancestors
+  end
+
+  shared_examples_for 'a ruby class' do
+    it_should_behave_like 'a ruby module'
+    it_should_not_safely_respond_to :new, :allocate, :superclass
+  end
+
+  shared_examples_for 'a boolean' do
+    it_should_behave_like 'a ruby object'
+    it_should_safely_respond_to :false?, :true?
+  end
+
+  shared_examples_for 'an enumerable' do
+    it_should_safely_respond_to :sort, :length, :size
+  end
+
+  shared_examples_for 'a comparable' do
+    it_should_safely_respond_to :<, :<=, :==, :>, :>=, :between?
+  end
+
+  shared_examples_for 'a numeric' do
+    it_should_behave_like 'a ruby object', 'a comparable'
+    it_should_safely_respond_to :%, :*, :**, :+, :-, :-@, :/, :<=>, :===, :to_s, :abs,
+      :second, :seconds, :minute, :minutes, :hour, :hours, :day, :days, :week, :weeks,
+      :bytes, :kilobytes, :megabytes, :gigabytes, :terabytes, :petabytes, :exabytes
+  end
+
+  shared_examples_for 'an integer' do
+    it_should_behave_like 'a numeric'
+    it_should_safely_respond_to :div, :divmod, :even?, :odd?, :to_f,
+      :month, :months, :year, :years
+  end
+
+  describe 'nil' do
+    subject { nil }
+
+    it_should_behave_like 'a ruby object'
+  end
+
+  describe true do
+    subject { true }
+
+    it_should_behave_like 'a ruby object'
+  end
+
+  describe false do
+    subject { false }
+
+    it_should_behave_like 'a ruby object'
+  end
+
+  describe 'Basic object instance' do
+    let(:basic_class) { Class.new(Object) }
+    subject { basic_class.new }
+
+    it_should_behave_like 'a ruby object'
+  end
+
+  describe 'Array instances' do
+    subject { [] }
+
+    it_should_behave_like 'a ruby object', 'an enumerable'
+    it_should_safely_respond_to :[], :[]=, :first, :last, :join, :reverse, :uniq, :include?, :empty?,
+      :to_sentence, :in_groups_of, :in_groups
+  end
+
+  describe 'Array class' do
+    subject { Array }
+
+    it_should_behave_like 'a ruby class'
+    it_should_safely_respond_to :wrap
+  end
+
+  describe 'Hash instances' do
+    subject { {} }
+
+    it_should_behave_like 'a ruby object', 'an enumerable'
+    it_should_safely_respond_to :[], :[]=, :has_key?, :has_value?, :empty?, :except, :slice
+  end
+
+  describe 'Range instances' do
+    subject { 1..10 }
+
+    it_should_behave_like 'a ruby object', 'an enumerable'
+    it_should_safely_respond_to :first, :last, :begin, :end, :max, :min, :cover?, :include?, :member?
+  end
+
+  describe 'Regexp instances' do
+    subject { /bb|[^b]{2}/ }
+
+    it_should_behave_like 'a ruby object'
+    it_should_safely_respond_to :==, :===, :=~, :match
+  end
+
+  describe 'Bignum instances' do
+    subject { 2 ** 123 }
+
+    it { should be_a Bignum }
+    it_should_behave_like 'an integer'
+  end
+
+  describe 'Fixnum instances' do
+    subject { 4 }
+
+    it_should_behave_like 'an integer'
+    it_should_safely_respond_to :multiple_of?
+  end
+
+  describe 'Float instances' do
+    subject { 4.2 }
+
+    it_should_behave_like 'a numeric'
+  end
+
+  describe 'Time class' do
+    subject { Time }
+
+    it_should_behave_like 'a ruby class'
+    it_should_safely_respond_to :at, :now
+  end
+
+  describe 'Time instances' do
+    subject { Time.now }
+
+    it_should_safely_respond_to :to_i, :to_f, :<=>,
+      :localtime, :gmtime, :utc, :getlocal, :getgm, :getutc,
+      :ctime, :asctime, :to_s, :inspect, :to_a, :+, :-, :round,
+      :sec, :min, :hour, :mday, :day, :mon, :month, :year, :wday, :yday,
+      :isdst, :dst?, :zone, :gmtoff, :gmt_offset, :utc_offset, :utc?, :gmt?,
+      :sunday?, :monday?, :tuesday?, :wednesday?, :thursday?, :friday?, :saturday?,
+      :tv_sec, :tv_usec, :usec, :tv_nsec, :nsec, :subsec, :strftime,
+      :to_time, :to_date, :to_datetime
+  end
+
+  describe 'String instances' do
+    subject { 'string' }
+
+    it_should_behave_like 'a ruby object', 'a comparable', 'an enumerable'
+    it_should_safely_respond_to :gsub, :strip, :chop, :chomp, :start_with?, :end_with?,
+      :[], :length, :size, :empty?, :=~, :split, :upcase, :downcase, :capitalize, :squeeze, :tr,
+      :exclude?, :truncate
+  end
+
+  describe 'Module instances' do
+    subject { Module.new }
+
+    it_should_behave_like 'a ruby module'
+  end
+
+  describe 'Class instances' do
+    subject { Class.new }
+
+    it_should_behave_like 'a ruby class'
+  end
+
+end

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