locomotivecms_steam 1.5.0.rc0 → 1.5.0.rc1

data/spec/unit/adapters/filesystem/sanitizers/section_spec.rb

@@ -6,60 +6,86 @@ require_relative '../../../../../lib/locomotive/steam/errors.rb'
 
 describe Locomotive::Steam::Adapters::Filesystem::Sanitizers::Section do
 
-  let(:template_path) { 'spec/fixtures/default/app/views/sections/header.liquid' }
-  let(:entity)    { instance_double('SectionEntity', template_path: template_path) }
-  let(:site)    { instance_double('Site', _id: 1) }
-  let(:scope)   { instance_double('Scope', site: site) }
-  let(:sanitizer) { described_class.new }
-
-  before(:each) do
-    sanitizer.setup(scope);
-  end
+  let(:entity)        { instance_double('SectionEntity', definition: definition) }
+  let(:site)          { instance_double('Site', _id: 1) }
+  let(:scope)         { instance_double('Scope', site: site) }
+  let(:sanitizer)     { described_class.new }
+
+  before(:each) { sanitizer.setup(scope) }
 
   describe '#apply_to_entity' do
+
+    before { expect(entity).to receive(:[]=).with(:site_id, 1) }
+
     subject { sanitizer.apply_to_entity(entity) }
 
-    describe 'with correct json' do
-
-      it 'sanitize entity' do
-        expect(entity).to receive(:definition=).with(hash_including({ 'name' => 'header' }))
-        expect(entity).to receive(:template=).with((<<-LIQUID
-<h1> {{ section.settings.brand }} </h1>
-<ul>
-  {% for block in section.blocks %}
-    <li>
-      <a href="{{ block.settings.url }}" target="{% if block.settings.new_tab %}_blank{% endif %}">
-        {{ block.settings.label }}
-      </a>
-    </li>
-  {% endfor %}
-</ul>
-LIQUID
-        ).gsub /^$\n/, '')
-        expect(entity).to receive(:[]=).with(:site_id, 1)
-        subject
+    describe 'aliases' do
+
+      let(:definition) { load_section_definition('carousel', :yaml) }
+
+      it 'allows to alias presets' do
+        expect(subject.definition).to match(hash_including({ 'presets' => [{ 'name' => 'Carousel', 'category' => 'Content', 'settings' => { 'brand' => 'Acme' }, 'blocks' => [] }] }))
       end
+
     end
-    describe 'errors' do
-      before(:each) do
-        allow(entity).to receive(:[]=)
-      end
 
-      describe 'in json header' do
-        let(:template_path) { 'spec/fixtures/errors/section_bad_json_header.liquid' }
+    describe 'fill_presets / set_default_values' do
+
+      context 'global content (global section)' do
+
+        let(:definition) { load_section_definition('footer') }
 
-        it 'should throw an error' do
-          expect { subject }.to raise_error(Locomotive::Steam::ParsingRenderingError)
+        it 'allows to alias default' do
+          expect(subject.definition).to match(hash_including({ 'default' =>
+            { 'settings' => { 'brand' => 'MY COMPANY', 'copyright' => '(c) NoCoffee' }, 'blocks' => [
+              { 'type' => 'link', 'settings' => { 'label' => 'Link #1', 'url' => 'https://www.nocoffee.fr', 'new_tab' => true } },
+              { 'type' => 'link', 'settings' => { 'label' => 'Link #2', 'url' => 'https://www.nocoffee.fr', 'new_tab' => true } },
+              { 'type' => 'link', 'settings' => { 'label' => 'Link', 'url' => 'https://www.locomotivecms.com', 'new_tab' => true } }
+            ]}
+          }))
         end
+
       end
 
-      describe 'json content' do
-        let(:template_path) { 'spec/fixtures/errors/section_bad_json_content.liquid' }
+      context 'default (global) used also for dropzone_presets (DRY)' do
+
+        let(:definition) { load_section_definition('header') }
 
-        it 'should throw an error' do
-          expect { subject }.to raise_error(Locomotive::Steam::JsonParsingError)
+        it 'copies the default settings to any dropzone preset' do
+          expect(subject.definition).to match(hash_including({
+            'presets' => [
+              {
+                'name'      => 'Default header',
+                'category'  => 'Header',
+                'settings'  => { 'brand' => 'MY COMPANY' },
+                'blocks'    => [
+                  { 'type' => 'link', 'settings' => { 'label' => 'Link #1', 'url' => 'https://www.nocoffee.fr', 'new_tab' => true } },
+                  { 'type' => 'link', 'settings' => { 'label' => 'Link #2', 'url' => 'https://www.nocoffee.fr', 'new_tab' => true } },
+                  { 'type' => 'link', 'settings' => { 'label' => 'Link', 'url' => 'https://www.locomotivecms.com', 'new_tab' => true } }
+                ]
+              }
+            ]
+          }))
         end
+
       end
+
+    end
+
+  end
+
+  def load_section_definition(slug, format = :json)
+    filepath  = File.join(default_fixture_site_path, 'app', 'views', 'sections', "#{slug}.liquid")
+    content   = File.read(filepath)
+
+    case format
+    when :json
+      match = content.match(Locomotive::Steam::JSON_FRONTMATTER_REGEXP)
+      MultiJson.load(match[:json])
+    when :yaml
+      match = content.match(Locomotive::Steam::YAML_FRONTMATTER_REGEXP)
+      YAML.load(match[:yaml])
     end
   end
+
 end

data/spec/unit/adapters/filesystem/yaml_loaders/section_spec.rb

@@ -24,4 +24,29 @@ describe Locomotive::Steam::Adapters::Filesystem::YAMLLoaders::Section do
 
   end
 
+  describe '#load_file' do
+
+    subject { loader.send(:load_file, filepath) }
+
+    describe 'error in the json header' do
+
+      let(:filepath) { File.join(default_fixture_site_path, '..', 'errors', 'section_bad_json_header.liquid') }
+
+      it 'should throw an error' do
+        expect { subject }.to raise_error(Locomotive::Steam::TemplateError)
+      end
+
+    end
+
+    describe 'json content' do
+
+      let(:filepath) { File.join(default_fixture_site_path, '..', 'errors', 'section_bad_json_content.liquid') }
+
+      it 'should throw an error' do
+        expect { subject }.to raise_error(Locomotive::Steam::JsonParsingError)
+      end
+    end
+
+  end
+
 end

data/spec/unit/errors_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Locomotive::Steam::ParsingRenderingError do
+describe Locomotive::Steam::TemplateError do
 
   let(:message)   { 'Wrong syntax' }
   let(:file)      { 'template.liquid.haml' }

data/spec/unit/liquid/drops/content_entry_collection_spec.rb

@@ -85,7 +85,7 @@ describe Locomotive::Steam::Liquid::Drops::ContentEntryCollection do
       expect(services.repositories.content_type).to receive(:select_options).with(content_type, 'category').and_return([option_a, option_b])
     end
 
-    it { expect(drop.before_method(:category_options)).to eq ['a', 'b'] }
+    it { expect(drop.liquid_method_missing(:category_options)).to eq ['a', 'b'] }
 
   end
 
@@ -95,13 +95,13 @@ describe Locomotive::Steam::Liquid::Drops::ContentEntryCollection do
       expect(services.repositories.content_entry).to receive(:group_by_select_option).with('category').and_return([['a', [1, 2]]])
     end
 
-    it { expect(drop.before_method(:group_by_category)).to eq [['a', [1, 2]]] }
+    it { expect(drop.liquid_method_missing(:group_by_category)).to eq [['a', [1, 2]]] }
 
   end
 
   describe 'unknown method' do
 
-    it { expect(drop.before_method(:foo)).to eq nil }
+    it { expect(drop.liquid_method_missing(:foo)).to eq nil }
 
   end
 

data/spec/unit/liquid/drops/content_entry_spec.rb

@@ -24,10 +24,10 @@ describe Locomotive::Steam::Liquid::Drops::ContentEntry do
     expect(subject.updated_at).to eq 1
   end
 
-  describe '#before_method (dynamic attributes)' do
+  describe '#liquid_method_missing (dynamic attributes)' do
 
     describe 'simple ones' do
-      it { expect(subject.before_method(:title)).to eq 'Hello world' }
+      it { expect(subject.liquid_method_missing(:title)).to eq 'Hello world' }
     end
 
     describe 'relationship field' do
@@ -38,7 +38,7 @@ describe Locomotive::Steam::Liquid::Drops::ContentEntry do
 
       before { allow(authors).to receive(:dup).and_return(authors) }
 
-      it { expect(subject.before_method(:authors).first).to eq 'john' }
+      it { expect(subject.liquid_method_missing(:authors).first).to eq 'john' }
 
     end
 
@@ -93,7 +93,7 @@ describe Locomotive::Steam::Liquid::Drops::ContentEntry do
     let(:entry) { instance_double('Article', content_type: type, localized_attributes: { title: true }, title: { en: 'Hello world', fr: 'Bonjour monde' }) }
     let(:drop)  { described_class.new(entry).tap { |d| d.context = context } }
 
-    subject { drop.before_method(:title) }
+    subject { drop.liquid_method_missing(:title) }
 
     it { is_expected.to eq 'Hello world' }
 

data/spec/unit/liquid/drops/content_types_spec.rb

@@ -10,7 +10,7 @@ describe Locomotive::Steam::Liquid::Drops::ContentTypes do
     allow(services.repositories.content_type).to receive(:by_slug).with('articles').and_return(true)
   end
 
-  it { expect(drop.before_method('articles')).not_to eq nil }
+  it { expect(drop.liquid_method_missing('articles')).not_to eq nil }
 
   context 'content type not found' do
 
@@ -18,7 +18,7 @@ describe Locomotive::Steam::Liquid::Drops::ContentTypes do
       allow(services.repositories.content_type).to receive(:by_slug).with('articles').and_return(nil)
     end
 
-    it { expect(drop.before_method('articles')).to eq nil }
+    it { expect(drop.liquid_method_missing('articles')).to eq nil }
 
   end
 

data/spec/unit/liquid/drops/metafields_spec.rb

@@ -10,7 +10,7 @@ describe Locomotive::Steam::Liquid::Drops::Metafields do
 
   describe 'fields' do
 
-    let(:namespace) { drop.before_method(:my_namespace).tap { |d| d.context = context } }
+    let(:namespace) { drop.liquid_method_missing(:my_namespace).tap { |d| d.context = context } }
 
     it 'gives the number of the fields' do
       expect(namespace.size).to eq 4
@@ -28,7 +28,7 @@ describe Locomotive::Steam::Liquid::Drops::Metafields do
 
     context 'unknown namespace' do
 
-      subject { drop.before_method(:unknown_namespace) }
+      subject { drop.liquid_method_missing(:unknown_namespace) }
 
       it { is_expected.to eq nil }
 
@@ -36,11 +36,11 @@ describe Locomotive::Steam::Liquid::Drops::Metafields do
 
     context 'existing namespace' do
 
-      let(:namespace) { drop.before_method(:my_namespace).tap { |d| d.context = context } }
+      let(:namespace) { drop.liquid_method_missing(:my_namespace).tap { |d| d.context = context } }
 
       context 'unknown field' do
 
-        subject { namespace.before_method(:unknown_field) }
+        subject { namespace.liquid_method_missing(:unknown_field) }
 
         it { is_expected.to eq nil }
 
@@ -51,7 +51,7 @@ describe Locomotive::Steam::Liquid::Drops::Metafields do
         let(:boolean) { true }
         let(:metafields) { { 'my_namespace' => { 'visible' => { 'default' => boolean } } } }
 
-        subject { namespace.before_method(:visible) }
+        subject { namespace.liquid_method_missing(:visible) }
 
         it { is_expected.to eq true }
 
@@ -81,7 +81,7 @@ describe Locomotive::Steam::Liquid::Drops::Metafields do
 
         context 'the value exists' do
 
-          subject { namespace.before_method(:analytics_id) }
+          subject { namespace.liquid_method_missing(:analytics_id) }
 
           it { is_expected.to eq '42' }
 
@@ -96,7 +96,7 @@ describe Locomotive::Steam::Liquid::Drops::Metafields do
 
         context "the value doesn't exist" do
 
-          subject { namespace.before_method(:country) }
+          subject { namespace.liquid_method_missing(:country) }
 
           it { is_expected.to eq nil }
 
@@ -106,7 +106,7 @@ describe Locomotive::Steam::Liquid::Drops::Metafields do
 
       context 'localized field' do
 
-        subject { namespace.before_method(:street) }
+        subject { namespace.liquid_method_missing(:street) }
 
         it { is_expected.to eq '7 Albert Camus Alley' }
 

data/spec/unit/liquid/drops/params_spec.rb

@@ -5,9 +5,9 @@ describe Locomotive::Steam::Liquid::Drops::Params do
   let(:params)    { { 'foo' => '42' } }
   let(:drop)      { described_class.new(params) }
 
-  it { expect(drop.before_method('bar').to_s).to eq '' }
+  it { expect(drop.liquid_method_missing('bar').to_s).to eq '' }
 
-  it { expect(drop.before_method('foo').to_s).to eq '42' }
+  it { expect(drop.liquid_method_missing('foo').to_s).to eq '42' }
 
   describe 'prevent XSS attack' do
 
@@ -15,11 +15,11 @@ describe Locomotive::Steam::Liquid::Drops::Params do
 
       let(:params) { { 'foo' => 'Hello<script>alert(document.cookie)</script>' } }
 
-      it { expect(drop.before_method('foo').to_s).to eq 'Hello&lt;script&gt;alert(document.cookie)&lt;/script&gt;' }
+      it { expect(drop.liquid_method_missing('foo').to_s).to eq 'Hello&lt;script&gt;alert(document.cookie)&lt;/script&gt;' }
 
       context 'security is disabled' do
 
-        it { expect(drop.before_method('foo').html_safe).to eq 'Hello<script>alert(document.cookie)</script>' }
+        it { expect(drop.liquid_method_missing('foo').html_safe).to eq 'Hello<script>alert(document.cookie)</script>' }
 
       end
 
@@ -29,7 +29,7 @@ describe Locomotive::Steam::Liquid::Drops::Params do
 
       let(:params) { { 'foo' => "'+alert(document.cookie)+'" } }
 
-      it { expect(drop.before_method('foo').to_s).to eq '&#39;+alert(document.cookie)+&#39;' }
+      it { expect(drop.liquid_method_missing('foo').to_s).to eq '&#39;+alert(document.cookie)+&#39;' }
 
     end
 

data/spec/unit/liquid/drops/section_content_proxy_spec.rb

@@ -13,13 +13,40 @@ describe Locomotive::Steam::Liquid::Drops::SectionContentProxy do
     let(:settings)  { [{ 'id' => 'title', 'type' => 'text' }] }
     let(:content)   { { 'title' => %(Click <a href="//locomotive/_locomotive-link/aaaa">here</a>) } }
 
-    subject { drop.before_method(:title) }
+    subject { drop.liquid_method_missing(:title) }
 
     it 'calls the url_finder_service to transform encoded links to existing urls' do
       expect(url_finder_service).to receive(:decode_urls_for).with(%(Click <a href="//locomotive/_locomotive-link/aaaa">here</a>)).and_return('done')
       is_expected.to eq 'done'
     end
 
+    context 'the text is nil' do
+
+      let(:content) { { 'title' => nil } }
+      it { is_expected.to eq nil }
+
+    end
+
+  end
+
+  describe 'integer type setting' do
+
+    let(:settings)  { [{ 'id' => 'number', 'type' => 'integer' }] }
+    let(:content)   { { 'number' => '42' } }
+
+    subject { drop.liquid_method_missing(:number) }
+
+    it 'converts the number into an integer' do
+      is_expected.to eq 42
+    end
+
+    context 'the number is nil' do
+
+      let(:content) { { 'number' => nil } }
+      it { is_expected.to eq nil }
+
+    end
+
   end
 
   describe 'url type setting' do
@@ -28,29 +55,43 @@ describe Locomotive::Steam::Liquid::Drops::SectionContentProxy do
     let(:content)   { { 'link' => { 'type' => 'page', 'value' => 42, 'new_window' => true } } }
     let(:page)      { instance_double('Page') }
 
-    before do
-      expect(url_finder_service).to receive(:url_for).with({ 'type' => 'page', 'value' => 42, 'new_window' => true }).and_return(['/foo/bar', true])
-    end
+    context 'the link is not nil' do
+
+      before do
+        expect(url_finder_service).to receive(:url_for).with({ 'type' => 'page', 'value' => 42, 'new_window' => true }).and_return(['/foo/bar', true])
+      end
 
-    subject { drop.before_method(:link).to_s }
+      subject { drop.liquid_method_missing(:link).to_s }
 
-    it 'returns the url to the page' do
-      is_expected.to eq '/foo/bar'
-    end
+      it 'returns the url to the page' do
+        is_expected.to eq '/foo/bar'
+      end
 
-    context 'it knows if the link has to be opened in a new window or not' do
+      context 'it knows if the link has to be opened in a new window or not' do
 
-      subject { drop.before_method(:link).new_window }
+        subject { drop.liquid_method_missing(:link).new_window }
 
-      it { is_expected.to eq true }
+        it { is_expected.to eq true }
+
+      end
+
+      context 'it outputs the target="_blank" A attribute if new window is true' do
+
+        subject { drop.liquid_method_missing(:link).new_window_attribute }
+
+        it { is_expected.to eq('target="_blank"') }
+
+      end
 
     end
 
-    context 'it outputs the target="_blank" A attribute if new window is true' do
+    context 'the link is nil' do
+
+      let(:content) { { 'link' => nil } }
 
-      subject { drop.before_method(:link).new_window_attribute }
+      subject { drop.liquid_method_missing(:link) }
 
-      it { is_expected.to eq('target="_blank"') }
+      it { is_expected.to eq nil }
 
     end
 
@@ -62,13 +103,13 @@ describe Locomotive::Steam::Liquid::Drops::SectionContentProxy do
     let(:value)       { nil }
     let(:content)     { { 'image' => value } }
     let(:page)        { instance_double('Page') }
-    let(:image_drop)  { drop.before_method(:image) }
+    let(:image_drop)  { drop.liquid_method_missing(:image) }
 
     subject { image_drop.to_s }
 
-    it { is_expected.to eq('') }
+    it { is_expected.to eq '' }
 
-    context 'the content is a string' do
+    context 'the image is a string' do
 
       let(:value) { 'banner.jpg' }
 
@@ -76,7 +117,7 @@ describe Locomotive::Steam::Liquid::Drops::SectionContentProxy do
 
     end
 
-    context 'the content is a hash' do
+    context 'the image is a hash' do
 
       let(:value) { { source: 'awesome_banner.jpg', cropped: 'cropped_awesome_banner.jpg', width: 42, height: 30 } }
 
@@ -91,6 +132,16 @@ describe Locomotive::Steam::Liquid::Drops::SectionContentProxy do
 
     end
 
+    context 'the image is nil' do
+
+      let(:value) { nil }
+
+      subject { image_drop }
+
+      it { is_expected.to eq nil }
+
+    end
+
   end
 
 end

data/spec/unit/liquid/drops/section_spec.rb

@@ -15,7 +15,7 @@ describe Locomotive::Steam::Liquid::Drops::Section do
 
     before { expect(drop.settings).to receive(:url_finder).and_return(url_finder) }
 
-    subject { drop.settings.before_method(:title) }
+    subject { drop.settings.liquid_method_missing(:title) }
 
     it 'returns the value of the text setting' do
       is_expected.to eq 'Hello world'

data/spec/unit/liquid/file_system_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::Liquid::FileSystem do
+
+  let(:section_finder) { instance_double('SectionFinder') }
+  let(:snippet_finder) { instance_double('SnippetFinder') }
+  let(:instance) { described_class.new(section_finder: section_finder, snippet_finder: snippet_finder) }
+
+  describe '#read_template_file' do
+
+    let(:template_path) { nil }
+
+    subject { instance.read_template_file(template_path) }
+
+    context 'unknown type' do
+
+      let(:template_path) { 'unknown_template' }
+
+      it { expect { subject }.to raise_error('Liquid error: This liquid context does not allow unknown_template.') }
+
+    end
+
+  end
+
+end

data/spec/unit/liquid/filters/array_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+describe 'Locomotive::Steam::Liquid::Filters::Array' do
+
+  include ::Liquid::StandardFilters
+  include Locomotive::Steam::Liquid::Filters::Base
+  include Locomotive::Steam::Liquid::Filters::Array
+
+  describe '#pop' do
+
+    let(:array) { ['a', 'b', 'c'] }
+
+    subject { pop(array) }
+
+    it { is_expected.to eq(['a', 'b']) }
+
+    context 'removing last n elements' do
+
+      subject { pop(array, 2) }
+
+      it { is_expected.to eq(['a']) }
+
+    end
+
+    context 'passing a non array input' do
+
+      let(:array) { 'Hello world' }
+      it { is_expected.to eq('Hello world') }
+
+    end
+
+  end
+
+  describe '#push' do
+
+    let(:array) { ['a', 'b', 'c'] }
+
+    subject { push(array, 'd') }
+
+    it { is_expected.to eq(['a', 'b', 'c', 'd']) }
+
+    context 'passing a non array input' do
+
+      let(:array) { 'Hello world' }
+      it { is_expected.to eq('Hello world') }
+
+    end
+
+  end
+
+  describe '#shift' do
+
+    let(:array) { ['a', 'b', 'c'] }
+
+    subject { shift(array) }
+
+    it { is_expected.to eq(['b', 'c']) }
+
+    context 'removing n first elements' do
+
+      subject { shift(array, 2) }
+
+      it { is_expected.to eq(['c']) }
+
+    end
+
+    context 'passing a non array input' do
+
+      let(:array) { 'Hello world' }
+      it { is_expected.to eq('Hello world') }
+
+    end
+
+  end
+
+  describe '#unshift' do
+
+    let(:array) { ['a', 'b', 'c'] }
+
+    subject { unshift(array, '1') }
+
+    it { is_expected.to eq(['1', 'a', 'b', 'c']) }
+
+    context 'adding n elements' do
+
+      subject { unshift(array, ['1', '2']) }
+
+      it { is_expected.to eq(['1', '2', 'a', 'b', 'c']) }
+
+    end
+
+    context 'passing a non array input' do
+
+      let(:array) { 'Hello world' }
+      it { is_expected.to eq('Hello world') }
+
+    end
+
+  end
+
+  describe '#in_groups_of' do
+
+    let(:array) { (1..10).to_a }
+
+    subject { in_groups_of(array, '3') }
+
+    it { is_expected.to eq([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, nil, nil]]) }
+
+    context 'passing fill_with argument: nil' do
+      subject { in_groups_of(array, '3', nil) }
+      it { is_expected.to eq([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, nil, nil]]) }
+    end
+
+    context 'passing fill_with argument: value' do
+      subject { in_groups_of(array, '3', 'foo') }
+      it { is_expected.to eq([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 'foo', 'foo']]) }
+    end
+
+    context 'passing fill_with argument: false' do
+      subject { in_groups_of(array, '3', false) }
+      it { is_expected.to eq([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]) }
+    end
+
+    context 'passing a non array input' do
+      let(:array) { 'Hello world' }
+      it { is_expected.to eq('Hello world') }
+    end
+
+    context 'passing a ContentEntryCollection input' do
+      let(:array) { Locomotive::Steam::Liquid::Drops::ContentEntryCollection.new('blog_posts') }
+
+      it 'groups entries' do
+        expect(array).to receive(:all).and_return((1..10).to_a)
+        is_expected.to eq([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, nil, nil]])
+      end
+    end
+
+  end
+
+end