locomotivecms 3.0.0.pre.alpha.3 → 3.0.0.pre.beta.1

data/app/services/locomotive/page_parsing_service.rb

@@ -8,22 +8,51 @@ module Locomotive
 
     def find_or_create_editable_elements(page)
       benchmark "Parse page #{page._id} find_or_create_editable_elements" do
-        parsed = { extends: {}, blocks: {}, elements: [] }
+        parsed = { extends: {}, blocks: {}, super_blocks: {}, elements: [] }
 
-        subscribe(parsed)
+        subscribe(parsed) do
+          parse(page)
 
-        parse(page)
+          persist_editable_elements(page, parsed).tap do |elements|
+            remove_useless_editable_elements(page, elements)
+          end
+        end
+      end
+    end
 
-        persist_editable_elements(page, parsed)
+    # Each element of the elements parameter is a couple: Page, EditableElement
+    def group_and_sort_editable_elements(elements)
+      elements.group_by { |(_, el)| el.block }.tap do |groups|
+        groups.each do |_, list|
+          list.sort! { |(_, a), (_, b)| (b.priority || 0) <=> (a.priority || 0) }
+        end
       end
     end
 
+    def blocks_from_grouped_editable_elements(groups)
+      groups.map do |block, elements|
+        next if elements.empty?
+
+        element = elements.first.last
+
+        { name: block, label: element.block_label, priority: element.block_priority }
+      end.sort { |a, b| b[:priority] <=> a[:priority] }
+    end
+
     private
 
-    def subscribe(parsed)
-      subscribe_to_extends(parsed[:extends])
-      subscribe_to_blocks(parsed[:blocks])
-      subscribe_to_editable_elements(parsed[:elements])
+    def subscribe(parsed, &block)
+      subscribers = [
+        subscribe_to_extends(parsed[:extends]),
+        subscribe_to_blocks(parsed[:blocks], parsed[:super_blocks]),
+        subscribe_to_editable_elements(parsed[:elements])
+      ]
+
+      yield.tap do
+        subscribers.each do |subscriber|
+          ActiveSupport::Notifications.unsubscribe(subscriber)
+        end
+      end
     end
 
     def subscribe_to_extends(extends)
@@ -33,11 +62,13 @@ module Locomotive
       end
     end
 
-    def subscribe_to_blocks(blocks)
+    def subscribe_to_blocks(blocks, super_blocks)
       ActiveSupport::Notifications.subscribe('steam.parse.inherited_block') do |name, start, finish, id, payload|
         page_id, block_name, found_super = payload[:page]._id, payload[:name], payload[:found_super]
-        blocks[page_id] ||= {}
-        blocks[page_id][block_name] = found_super
+        super_blocks[page_id] ||= {}
+        super_blocks[page_id][block_name] = found_super
+
+        blocks[block_name] ||= payload.slice(:short_name, :priority)
       end
     end
 
@@ -50,14 +81,14 @@ module Locomotive
 
     def parse(page)
       entity = repository.build(page.attributes.dup)
-      decorated_page = Locomotive::Steam::Decorators::TemplateDecorator.new(entity, self.locale)
+      decorated_page = Locomotive::Steam::Decorators::TemplateDecorator.new(entity, self.locale, self.site.default_locale)
 
       parser = services.liquid_parser
       parser.parse(decorated_page)
     end
 
     def persist_editable_elements(page, parsed)
-      modified_pages = [] # group modifications by page
+      modified_pages, pages = [], { page._id => page } # group modifications by page
 
       elements = parsed[:elements].map do |couple|
         _page, attributes = couple
@@ -65,10 +96,12 @@ module Locomotive
         next if !persist_editable_element?(page, parsed, _page, attributes)
 
         # Note: _page is a Steam entity but we need a Mongoid document to save the elements
-        _page = attributes[:fixed] ? Locomotive::Page.find(_page._id) : page
+        _page = attributes[:fixed] ? find_page(_page._id, pages) : page
+
+        element = add_or_modify_editable_element(_page, attributes)
+        couple[0], couple[1] = _page, element # we get now a Mongoid document instead of a Steam entity
 
-        element   = add_or_modify_editable_element(_page, attributes)
-        couple[1] = element # we get now a Mongoid document instead of a Steam entity
+        assign_block_information(element, parsed[:blocks])
 
         modified_pages << _page
 
@@ -82,13 +115,34 @@ module Locomotive
 
     def persist_editable_element?(page, parsed, _page, attributes)
       page_id, block_name = _page._id, attributes[:block]
-      descendant  = parsed[:extends][page_id]
-      found_super = parsed[:blocks][descendant].try(:[], block_name)
 
-      page._id == _page._id ||  # same page
-      block_name.blank?     ||  # an editable_element out of a block (impossible to remove it in pages extending this template)
-      found_super.nil?      ||  # block does not get overriden
-      found_super               # if block.super is present in the descendant page
+      if page._id == _page._id  # same page
+        true
+      elsif block_name.blank?   # an editable_element out of a block (impossible to remove it in pages extending this template)
+        true
+      else
+        block_visible?(_page._id, parsed, attributes)
+      end
+    end
+
+    def block_visible?(page_id, parsed, attributes)
+      block_name = attributes[:block]
+      descendant = parsed[:extends][page_id]
+
+      return true if descendant.nil?
+
+      # find if the descendant hides the block
+      if (blocks = parsed[:super_blocks][descendant]).blank?
+        # we can not know for sure, ask the descendant of the descendant
+        block_visible?(descendant, parsed, attributes)
+      else
+        found_super = blocks[block_name]
+        hidden = blocks.keys.any? { |name| block_name =~ /\A#{name}(\Z|\/)/ }
+        if found_super || !hidden
+          # again, we need to ask the descendant of the descendant
+          block_visible?(descendant, parsed, attributes)
+        end
+      end
     end
 
     def add_or_modify_editable_element(page, attributes)
@@ -97,7 +151,20 @@ module Locomotive
         element
       else
         klass = "Locomotive::#{attributes[:type].to_s.classify}".constantize
-        element = page.editable_elements.build(attributes, klass)
+        page.editable_elements.build(attributes, klass)
+      end
+    end
+
+    def remove_useless_editable_elements(page, elements)
+      if _elements = (elements.map { |p, _elements| p._id == page._id ? _elements : nil }.flatten.compact)
+        page.editable_elements.where(:_id.nin => _elements.map(&:_id)).destroy_all
+      end
+    end
+
+    def assign_block_information(element, blocks)
+      if element.block && (options = blocks[element.block])
+        element.block_name      = element.block.split('/').last if options[:short_name]
+        element.block_priority  = options[:priority]
       end
     end
 
@@ -112,6 +179,10 @@ module Locomotive
       services.repositories.page
     end
 
+    def find_page(id, in_memory)
+      in_memory[id] ||= Locomotive::Page.find(id)
+    end
+
     def logger
       Rails.logger
     end

data/app/services/locomotive/page_service.rb

@@ -2,6 +2,8 @@ module Locomotive
 
   class PageService < Struct.new(:site, :account)
 
+    include Locomotive::Concerns::ActivityService
+
     # Create a page from the attributes passed in parameter.
     # It sets the created_by column with the current account.
     #
@@ -12,7 +14,16 @@ module Locomotive
     def create(attributes)
       site.pages.build(attributes).tap do |page|
         page.created_by = account if account
-        page.save
+
+        if page.save
+          track_activity 'page.created', parameters: { title: page.title, _id: page._id }
+        end
+      end
+    end
+
+    def sort(page, children)
+      page.sort_children!(children).tap do
+        track_activity 'page.sorted', parameters: { title: page.title, _id: page._id }
       end
     end
 
@@ -27,8 +38,55 @@ module Locomotive
     def update(page, attributes)
       page.tap do
         page.attributes = attributes
-        page.updated_by = account
-        page.save
+        page.updated_by = account if account
+
+        if page.save
+          track_activity 'page.updated', parameters: { title: page.title, _id: page._id }
+        end
+      end
+    end
+
+    def destroy(page)
+      page.destroy.tap do
+        track_activity 'page.destroyed', parameters: { title: page.title }
+      end
+    end
+
+    # For all the pages of a site, use the slug property from
+    # the default locale for all the new locales passed as the first argument.
+    # Do not erase existing values in the new locales.
+    # This method is called when an user has changed the locales of a site.
+    #
+    def localize(locales, previous_default_locale)
+      parent_fullpaths  = {}
+      default_locale    = previous_default_locale || site.default_locale
+
+      site.pages.without_sorting.order_by(:depth.asc).each_by(50) do |page|
+        _localize(page, locales, default_locale, parent_fullpaths)
+
+        page.skip_callbacks_on_update = true
+        page.save if page.changed?
+      end
+    end
+
+    private
+
+    def _localize(page, locales, default_locale, parent_fullpaths)
+      slug = page.slug_translations[default_locale]
+
+      locales.each do |locale|
+        next if locale == default_locale
+
+        ::Mongoid::Fields::I18n.with_locale(locale) do
+          page.slug     ||= slug
+          page.fullpath ||= page.depth > 1 ? parent_fullpaths[page.parent_id][locale] + '/' + slug : slug
+
+          if page.depth == 0 && (slug == 'index' || slug == '404')
+            page.title ||= ::I18n.t("attributes.defaults.pages.#{slug}.title", locale: locale)
+          end
+
+          (parent_fullpaths[page._id] ||= {})[locale] = page.fullpath
+        end
       end
     end
 

data/app/services/locomotive/site_service.rb

@@ -1,6 +1,17 @@
 module Locomotive
   class SiteService < Struct.new(:account)
 
+    include Locomotive::Concerns::ActivityService
+    include Morphine
+
+    register :page_service do
+      Locomotive::PageService.new(nil, account)
+    end
+
+    register :content_entry_service do
+      Locomotive::ContentEntryService.new(nil, account)
+    end
+
     def list
       sorter = lambda do |site_a, site_b|
         site_a.name.downcase <=> site_b.name.downcase
@@ -21,7 +32,11 @@ module Locomotive
       Site.new(attributes).tap do |site|
         site.memberships.build account: account, role: 'admin'
 
-        raise_if_not_valid ? site.save! : site.save
+        success = raise_if_not_valid ? site.save! : site.save
+
+        ActiveSupport::Notifications.instrument 'locomotive.site.created', account: account, site: site
+
+        track_activity 'site.created', site: site, parameters: { name: site.name } if success
       end
     end
 
@@ -29,8 +44,35 @@ module Locomotive
       create(attributes, true)
     end
 
+    def update(site, attributes)
+      site.attributes = attributes
+
+      new_locales = site.locales_changed? ? site.locales - site.locales_was : nil
+      previous_default_locale = site.default_locale_was
+
+      site.save.tap do |success|
+        if success
+          localize_pages_and_content_entries(site, new_locales, previous_default_locale)
+        end
+      end
+    end
+
     private
 
+    def localize_pages_and_content_entries(site, new_locales, previous_default_locale)
+      return unless new_locales.present?
+
+      # localize all the existing pages
+      page_service.site = site
+      page_service.localize(new_locales, previous_default_locale)
+
+      # localize all the content entries of localized content types
+      site.localized_content_types.each do |content_type|
+        content_entry_service.content_type = content_type
+        content_entry_service.localize(new_locales, previous_default_locale)
+      end
+    end
+
     def unique_handle
       Bazaar.heroku do |value|
         Site.where(handle: value).exists?

data/app/services/locomotive/translation_service.rb

@@ -0,0 +1,51 @@
+module Locomotive
+
+  class TranslationService < Struct.new(:site, :account)
+
+    def all(options = {})
+      query       = site.translations.ordered
+      keywords    = prepare_keywords_statement(options[:q])
+      completion  = prepare_completion_statement(options[:filter_by])
+
+      # filtering
+      query = if completion then query.and(*keywords, *completion) else query.where(keywords) end
+
+      # pagination
+      query
+        .page(options[:page] || 1)
+        .per(options[:per_page] || Locomotive.config.ui[:per_page])
+    end
+
+    def update(translation, values)
+      translation.tap do
+        translation.values = values
+        translation.updated_by = account if account
+        translation.save
+      end
+    end
+
+    protected
+
+    def prepare_keywords_statement(keywords)
+      return {} if keywords.blank?
+
+      regexp = /.*#{keywords.split.map { |k| Regexp.escape(k) }.join('.*')}.*/i
+
+      [{ '$or' => [
+        { key: regexp },
+        *site.locales.map { |l| { "values.#{l}" => regexp  } }
+      ] }]
+    end
+
+    def prepare_completion_statement(filter_by)
+      case filter_by
+      when 'done'       then [{ completion: site.locales.size }]
+      when 'partially'  then [{ :completion.lt => site.locales.size }, { :completion.gt => 0 }]
+      when 'none'       then [{ completion: 0 }]
+      else {}
+      end
+    end
+
+  end
+
+end

data/app/uploaders/locomotive/picture_uploader.rb

@@ -13,5 +13,9 @@ module Locomotive
       self.file ? self.file.content_type : false
     end
 
+    def store_dir
+      self.build_store_dir('uploaded_assets', model.id)
+    end
+
   end
-end
+end

data/app/views/locomotive/content_assets/{_dropzone.html.haml → _dropzone.html.slim}

@@ -1,7 +1,8 @@
 .instructions
-  %i.fa.fa-cloud-upload
-  %br
+  i.fa.fa-cloud-upload
+  br
   = t('.instructions').html_safe
+  |  
   = link_to t('.browse'), '#', class: 'upload'
 
 = form_tag('', class: 'hide') do
@@ -10,4 +11,4 @@
 = link_to 'Refresh', request.fullpath, remote: remote, class: 'refresh hide'
 
 .progress.hide
-  .progress-bar{ role: 'progressbar', aria: { valuenow: 0, valuemin: 0, valuemax: '100' } }
+  .progress-bar role='progressbar' aria-valuenow='0' aria-valuemin='0' aria-valuemax='100'

data/app/views/locomotive/content_assets/{_list.html.haml → _list.html.slim}

@@ -1,8 +1,8 @@
 - if @content_assets.empty?
-  %br
+  br
 
   .alert.alert-warning
-    != t('.no_items')
+    == t('.no_items')
 
 - else
   - # Display the assets
@@ -10,27 +10,29 @@
     - @content_assets.each do |asset|
       .asset
         .top
+          h2= asset_filename(asset)
+          .size= human_asset_size(asset)
+
+        .body
           .small-thumbnail
             - if asset_with_thumbnail?(asset)
               = image_tag asset.alternative_vignette_url
             - else
-              .not-a-image{ class: asset.content_type }
-                %span= asset_text(asset)
-
-          %h2= asset_filename(asset)
+              div class="not-a-image #{asset.content_type}"
+                span= asset_text(asset)
 
         .actions
           - if enable_select
             = link_to t('.buttons.select'), asset.source.url, class: 'btn btn-primary btn-sm select', title: asset_filename(asset), data: { image: asset.image? }
-             
+            |  
 
           - if asset.image?
             = link_to t('.buttons.edit'), edit_content_asset_path(current_site, asset._id), class: 'btn btn-primary btn-sm edit'
 
-           
+          |   
 
           = link_to content_asset_path(current_site, asset, params.slice(:types, :query, :page, :per_page)), class: 'remove', method: :delete, data: { confirm: t('locomotive.messages.confirm'), return_url: request.original_url }, title: t('locomotive.buttons.delete'), remote: remote do
-            %i.fa.fa-trash-o
+            i.fa.fa-trash-o
 
   .text-center
     = paginate @content_assets, theme: 'twitter-bootstrap-3', pagination_class: 'pagination-sm', remote: remote