locomotivecms 3.0.0.pre.beta.1 → 3.0.0.rc1

data/lib/locomotive/steam/services/api_entry_submission_service.rb

@@ -4,8 +4,11 @@ module Locomotive
     class APIEntrySubmissionService < Struct.new(:site, :locale)
 
       def submit(slug, attributes = {})
-        load_content_type(slug)
-        create_entry(attributes)
+        if load_content_type(slug)
+          create_entry(attributes)
+        else
+          nil
+        end
       end
 
       def to_json(entry)
@@ -15,7 +18,7 @@ module Locomotive
       private
 
       def load_content_type(slug)
-        @content_type = site.content_types.where(slug: slug).first
+        @content_type = site.content_types.where(slug: slug, public_submission_enabled: true).first
       end
 
       def create_entry(attributes)

data/lib/locomotive/steam/services/liquid_parser_with_cache_service.rb

@@ -0,0 +1,74 @@
+module Locomotive
+  module Steam
+
+    class LiquidParserWithCacheService < LiquidParserService
+
+      UNMARSHALABLE_OPTIONS = %i(parser page parent_finder snippet_finder).freeze
+
+      attr_accessor_initialize :current_site, :parent_finder, :snippet_finder, :locale
+
+      def parse(page)
+        return super unless current_site.cache_enabled
+
+        read_template_from_cache(page) || write_template_in_cache(page, super)
+      end
+
+      def cache_key(page)
+        "#{Locomotive::VERSION}/site/#{current_site._id}/template/#{current_site.template_version.to_i}/page/#{page._id}/#{locale}"
+      end
+
+      private
+
+      def read_template_from_cache(page)
+        if marshaled = Rails.cache.read(cache_key(page))
+          Marshal.load(marshaled)
+        end
+      end
+
+      def write_template_in_cache(page, template)
+        begin
+          Rails.cache.write(cache_key(page), marshal(template))
+        rescue Exception => e
+          Rails.logger.warn "Could not marshal #{cache_key(page)}, error: #{e.message}"
+        end
+
+        template
+      end
+
+      def marshal(template)
+        _template = template.dup
+
+        # get rid of options in any tags/blocks of the document
+        # because options can not be marshaled
+        remove_unmarshalable_options(_template)
+
+        clean_template!(_template.root)
+
+        Marshal.dump(_template)
+      end
+
+      def clean_template!(node)
+        remove_unmarshalable_options(node)
+
+        # special case
+        clean_template!(node.descendant) if node.respond_to?(:descendant) && node.descendant
+
+        if node.respond_to?(:nodelist) && node.nodelist
+          node.nodelist.each do |_node|
+            clean_template!(_node)
+          end
+        end
+      end
+
+      def remove_unmarshalable_options(node)
+        options = node.instance_variable_get(:@options)
+
+        return if options.blank?
+
+        options.delete_if { |name, _| UNMARSHALABLE_OPTIONS.include?(name) }
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/steam_adaptor.rb

@@ -26,17 +26,23 @@ Locomotive::Steam.configure do |config|
 
   require_relative 'steam/middlewares/missing_translations'
   require_relative 'steam/middlewares/page_editing'
+  require_relative 'steam/middlewares/cache'
 
+  config.middleware.insert_after Locomotive::Steam::Middlewares::Page, Locomotive::Steam::Middlewares::Cache
   config.middleware.insert_after Locomotive::Steam::Middlewares::Page, Locomotive::Steam::Middlewares::PageEditing
   config.middleware.insert_after Locomotive::Steam::Middlewares::Page, Locomotive::Steam::Middlewares::MissingTranslations
 
   require_relative 'steam/services/api_entry_submission_service'
+  require_relative 'steam/services/liquid_parser_with_cache_service'
 
   # let the Rails engine handle the "no site" error
   config.render_404_if_no_site = false
 
   config.services_hook = -> (services) {
-    services.entry_submission = Locomotive::Steam::APIEntrySubmissionService.new(services.current_site, services.locale) if services.request
+    if services.request
+      services.entry_submission = Locomotive::Steam::APIEntrySubmissionService.new(services.current_site, services.locale)
+      services.defer(:liquid_parser) { Locomotive::Steam::LiquidParserWithCacheService.new(services.current_site, services.parent_finder, services.snippet_finder, services.locale) }
+    end
   }
 end
 

data/lib/locomotive/version.rb

@@ -2,5 +2,5 @@
 # MAJOR.MINOR.PATCH format.
 # 1.0.0-alpha < 1.0.0-alpha.1 < 1.0.0-alpha.beta < 1.0.0-beta < 1.0.0-beta.2 < 1.0.0-beta.11 < 1.0.0-rc.1 < 1.0.0
 module Locomotive #:nodoc
-  VERSION = '3.0.0-beta.1'
+  VERSION = '3.0.0.rc1'
 end

data/lib/tasks/development.rake

@@ -31,10 +31,14 @@ namespace :development do
     site.memberships.build account: account, role: 'admin'
     site.save!
 
+    puts "\"LocomotiveCMS\" created: #{site._id}"
+
     site = Locomotive::Site.create! name: "Sample site", handle: "sample", domains: ["sample.example.com"]
     site.memberships.build account: account, role: 'admin'
     site.save!
 
+    puts "\"Sample site\" created: #{site._id}"
+
     puts "Now you have a www.example.com site"
     puts "and a sample.example.com site as well. (add them to your /etc/hosts)"
     puts "You can login with admin@locomotivecms.com and \"locomotive\" password."

data/lib/tasks/locomotive.rake

@@ -31,6 +31,20 @@ namespace :locomotive do
     task v3: :environment do
       puts '...'
 
+      # subdomain to handle
+      Locomotive::Site.all.each_by(10) do |site|
+        if subdomain = site.attributes['subdomain']
+          site.set handle: subdomain
+        end
+      end
+      puts '[x] set the handle attribute for all the sites'
+
+      # number_of_entries by content type
+      Locomotive::ContentType.all.each_by(10) do |content_type|
+        content_type.set number_of_entries: content_type.entries.count
+      end
+      puts '[x] set the number of entries by content type'
+
       # content asset checksums
       Locomotive::ContentAsset.all.each do |asset|
         asset.send(:calculate_checksum)

data/spec/lib/locomotive/steam/services/api_entry_submission_service_spec.rb

@@ -4,7 +4,8 @@ describe Locomotive::Steam::APIEntrySubmissionService do
 
   let(:site)          { create(:site) }
   let(:locale)        { :en }
-  let!(:content_type) { create('message content type', site: site).reload }
+  let(:enabled)       { true }
+  let!(:content_type) { create('message content type', site: site, public_submission_enabled: enabled).reload }
   let(:service)       { described_class.new(site, locale) }
 
   describe '#submit' do
@@ -20,6 +21,14 @@ describe Locomotive::Steam::APIEntrySubmissionService do
       expect(subject.message).to eq 'Hello'
     end
 
+    context 'no public submission allowed' do
+
+      let(:enabled) { false }
+
+      it { expect(subject).to eq nil }
+
+    end
+
   end #
 
   describe '#to_json' do

data/spec/lib/locomotive/steam/services/liquid_parser_with_cache_service_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Locomotive::Steam::LiquidParserWithCacheService do
+
+  let(:cache)         { false }
+  let(:site)          { build(:site, cache_enabled: cache, template_version: DateTime.parse('2009/09/10 00:00:00')).to_steam }
+  let(:parent_finder) { nil}
+  let(:service)       { described_class.new(site, parent_finder, nil, 'en') }
+
+  describe '#cache_key' do
+
+    let(:page) { instance_double('ParsedPage', _id: '0001') }
+
+    subject { service.cache_key(page) }
+
+    it { expect(subject).to match %r{\A#{Locomotive::VERSION}/site\/[a-z0-9]+\/template\/1252540800\/page\/0001\/en\Z} }
+
+  end
+
+  describe '#parse' do
+
+    let(:parent)  { instance_double('ParsedPage', liquid_source: 'Hello {% block content %}!{% endblock %}') }
+    let(:page)    { instance_double('ParsedPage', _id: '0001', liquid_source: '{% extends parent %}{% block content %}world{{ block.super}}{% endblock %}') }
+    let(:parent_finder) { instance_double('ParentFinder', find: parent) }
+
+    subject { service.parse(page) }
+
+    it { expect(subject).not_to eq nil }
+    it { expect(subject.render).to eq 'Hello world!' }
+
+    it 'does not cache the template' do
+      service.parse(page) # warm up the cache
+      expect(service).to receive(:_parse)
+      subject
+    end
+
+    context 'cache enabled' do
+
+      before(:each) { Rails.cache.clear }
+
+      let(:cache) { true }
+
+      it 'does not parse the template twice' do
+        service.parse(page) # warm up the cache
+        expect(service).not_to receive(:_parse)
+        expect(subject.render).to eq 'Hello world!'
+      end
+
+    end
+
+  end
+
+end

data/spec/models/locomotive/concerns/content_entry/file_size_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Locomotive::Concerns::ContentEntry::FileSize do
+
+  let(:content_type)  { create_content_type }
+  let(:content_entry) { build_content_entry }
+
+  subject { content_entry._file_size }
+
+  context 'entry not persisted' do
+
+    it { expect(subject).to eq 0 }
+
+  end
+
+  context 'entry persisted' do
+
+    before { content_entry.save! }
+
+    it { expect(subject).to eq 1309 }
+
+  end
+
+  def create_content_type
+    allow_any_instance_of(Locomotive::Site).to receive(:create_default_pages!).and_return(true)
+    FactoryGirl.build(:content_type).tap do |content_type|
+      content_type.entries_custom_fields.build label: 'Title', type: 'string'
+      content_type.entries_custom_fields.build label: 'File 1', type: 'file'
+      content_type.entries_custom_fields.build label: 'File 2', type: 'file'
+      content_type.valid?
+      content_type.send(:set_label_field)
+      content_type.save!
+    end
+  end
+
+  def build_content_entry
+    content_type.entries.build(title: 'LocomotiveCMS', file_1: FixturedAsset.open('5k.png'), file_2: FixturedAsset.open('main.css'))
+  end
+
+end

data/spec/models/locomotive/concerns/page/layout_spec.rb

@@ -2,46 +2,84 @@ require 'spec_helper'
 
 describe Locomotive::Concerns::Page::Layout do
 
-  let(:site)          { FactoryGirl.build(:site) }
+  let(:site)          { build(:site) }
   let(:allow_layout)  { true }
-  let(:layout)        { Locomotive::Page.new(is_layout: true, fullpath: 'awesome-layout') }
-  let(:page)          { Locomotive::Page.new(layout: layout, allow_layout: allow_layout, site: site) }
+  let(:template)      { nil }
+  let(:layout)        { Locomotive::Page.new(_id: 42, is_layout: true, fullpath: 'awesome-layout') }
+  let(:page)          { Locomotive::Page.new(layout: layout, allow_layout: allow_layout, site: site, raw_template: template) }
 
-  describe 'allow_layout default value' do
+  describe '#find_layout' do
 
-    let(:page) { Locomotive::Page.new }
+    subject { page.find_layout; page.layout_id }
 
-    subject { page.allow_layout }
+    it { is_expected.to eq 42 }
 
-    describe 'true for a new page' do
+    context 'from the raw_template' do
 
-      it { is_expected.to eq true }
+      let(:page) { build(:page, raw_template: ' {% extends foo/bar %}  ', site: site) }
+
+      it 'looks for the layout based on the extends liquid tag' do
+        expect(page.site.pages).to receive(:fullpath).with('foo/bar').and_return([layout])
+        is_expected.to eq 42
+      end
+
+      it 'switches to the default locale' do
+        allow(page.site).to receive(:is_default_locale?).and_return(false)
+        expect(page.site).to receive(:with_default_locale).and_return(layout)
+        is_expected.to eq 42
+      end
 
     end
 
-    describe 'false for an existing page without the allow_layout attribute' do
+  end
 
-      let(:page) { p = Locomotive::Page.new(site: site); p.save(validate: false); p.unset(:allow_layout); Locomotive::Page.find(p._id) }
+  describe '#valid_allow_layout_consistency' do
+
+    before  { page.valid? }
+    subject { page.allow_layout? }
+
+    it { is_expected.to eq true }
+
+    context 'allow_layout was false at first' do
 
+      let(:allow_layout) { false }
       it { is_expected.to eq false }
 
+      context "the template doesn't include the extend liquid tag" do
+        let(:template) { '{% extends parent %}' }
+        it { is_expected.to eq false }
+      end
+    end
+
+    context 'the template includes the extend liquid tag' do
+      let(:template) { '{% extends parent %} Bla bla' }
+      it { is_expected.to eq true }
+    end
+
+    context 'the template includes the extend liquid tag but also blocks' do
+      let(:template) { '{% extends layouts/simple %} {% block content %}Hello world{% endblock %}' }
+      it { is_expected.to eq false }
     end
 
   end
 
-  describe 'use a layout' do
+  describe 'allow_layout default value' do
 
-    before { page.valid? }
+    let(:page) { Locomotive::Page.new }
 
-    subject { page.raw_template }
+    subject { page.allow_layout }
 
-    it { is_expected.to eq '{% extends "awesome-layout" %}' }
+    describe 'true for a new page' do
 
-    context 'but changing the layout is not allowed' do
+      it { is_expected.to eq true }
 
-      let(:allow_layout) { false }
+    end
+
+    describe 'false for an existing page without the allow_layout attribute' do
+
+      let(:page) { p = Locomotive::Page.new(site: site); p.save(validate: false); p.unset(:allow_layout); Locomotive::Page.find(p._id) }
 
-      it { is_expected.to eq "{% extends 'parent' %}" }
+      it { is_expected.to eq false }
 
     end
 
@@ -73,4 +111,71 @@ describe Locomotive::Concerns::Page::Layout do
 
   end
 
+  describe 'use a layout' do
+
+    subject { page.raw_template }
+
+    context 'on create' do
+
+      before { page.valid? }
+      it { is_expected.to eq '{% extends "awesome-layout" %}' }
+
+      context 'select the parent layout' do
+
+        let(:page) { build(:page, layout_id: 'parent', allow_layout: allow_layout, site: site, raw_template: nil) }
+        it { is_expected.to eq '{% extends parent %}' }
+
+      end
+
+      context 'no selected layout' do
+
+        let(:page) { build(:page, slug: 'new-page', allow_layout: allow_layout, site: site, raw_template: nil) }
+        it { is_expected.to eq '{% extends parent %}' }
+
+        context 'the page is the home page' do
+
+          let(:page) { build(:page, slug: 'index', site: site, layout_id: 'parent') }
+          it { is_expected.to eq '{% extends parent %}' }
+
+          it 'also adds an error to the layout attribute' do
+            expect(page.valid?).to eq false
+            expect(page.errors[:layout_id].first).to eq "The index page can't have its parent page as a layout"
+          end
+
+        end
+
+      end
+
+    end
+
+    context 'on update' do
+
+      let(:site)  { create(:site) }
+      let!(:page) { create(:page, slug: 'sub_page', allow_layout: allow_layout, raw_template: '{% extends parent %}') }
+
+      before { page.layout = layout; page.valid? }
+
+      subject { page.raw_template }
+
+      it { is_expected.to eq '{% extends "awesome-layout" %}' }
+
+      context 'no layout allowed' do
+
+        let(:allow_layout) { false }
+        it { is_expected.to eq '{% extends parent %}' }
+
+      end
+
+      context 'parent selected' do
+
+        before { page.layout_id = 'parent'; page.valid? }
+
+        it { is_expected.to eq '{% extends parent %}' }
+
+      end
+
+    end
+
+  end
+
 end