tribeca_cms 0.1.1

data/app/controllers/locomotive/translations_controller.rb

@@ -0,0 +1,32 @@
+module Locomotive
+  class TranslationsController < BaseController
+
+    sections :settings, :translations
+
+    load_and_authorize_resource through: :current_site
+
+    respond_to :json, :only => [:create, :update]
+
+    def index
+    end
+
+    def new
+      respond_with @translation
+    end
+
+    def create
+      @translation = current_site.translations.create(params[:translation])
+      respond_with @translation, location: translations_path
+    end
+
+    def edit
+      respond_with @translation
+    end
+
+    def update
+      @translation = current_site.translations.find(params[:id])
+      @translation.update_attributes(params[:translation])
+      respond_with @translation, location: translations_path
+    end
+  end
+end

data/app/helpers/locomotive/accounts_helper.rb

@@ -0,0 +1,13 @@
+module Locomotive
+  module AccountsHelper
+
+    def admin_on?(site = current_site)
+      site.memberships.detect { |m| m.admin? && m.account == current_locomotive_account }
+    end
+
+    def options_for_account
+      current_site.accounts.collect { |a| ["#{a.name} <#{a.email}>", a.id.to_s] }
+    end
+
+  end
+end

data/app/helpers/locomotive/base_helper.rb

@@ -0,0 +1,182 @@
+module Locomotive
+  module BaseHelper
+
+    def title(title = nil)
+      if title.nil?
+        @content_for_title
+      else
+        @content_for_title = title
+        ''
+      end
+    end
+
+    def inputs_folded?(resource)
+      resource.persisted? && resource.errors.empty?
+    end
+
+    # Like link_to but instead of passing a label, we
+    # pass the name of an Font Awesome icon.
+    # If the name is a Symbol, we append "icon-" to the
+    # dasherized version of the name.
+    #
+    # @param [ String / Symbol ] name The class name or a symbol
+    # @param [ Array ] *args
+    #
+    # @return [ String ] The HTML <a> tag
+    #
+    def link_to_icon(name, *args, &block)
+      name = name.is_a?(Symbol) ? "icon-#{name.to_s.dasherize}" : name
+      icon = content_tag(:i, '', :class => name)
+      link_to(icon, *args, &block).html_safe
+    end
+
+    # Execute the code only once during the request time. It avoids duplicated
+    # dom elements in the rendered rails page.
+    #
+    # @param [ String / Symbol ] label Unique identifier of the block
+    #
+    def required_once(label, &block)
+      symbol = :"@block_#{label.to_s.underscore}"
+
+      if instance_variable_get(symbol).blank?
+        yield
+        instance_variable_set(symbol, true)
+      end
+    end
+
+    def submenu_entry(name, url, options = {}, &block)
+      default_options = { :i18n => true, :css => name.dasherize.downcase }
+      default_options.merge!(options)
+
+      css = "#{'on' if name == sections(:sub)} #{options[:css]}"
+
+      label_link = default_options[:i18n] ? t("locomotive.shared.menu.#{name}") : name
+      if block_given?
+        popup = content_tag(:div, capture(&block), :class => 'popup', :style => 'display: none')
+        text  = content_tag(:span, preserve(label_link) + content_tag(:i, '', :class => 'icon-caret-down'))
+        link  = link_to(text + content_tag(:em), url, :class => css)
+        content_tag(:li, link + popup, :class => 'hoverable')
+      else
+        content_tag(:li, link_to(content_tag(:span, label_link), url, :class => css))
+      end
+    end
+
+    def local_action_button(text, url, options = {})
+      text = text.is_a?(Symbol) ? t(".#{text}") : text
+
+      icon = options.delete(:icon) || :exclamation_sign
+      icon = icon.is_a?(Symbol) ? "icon-#{icon.to_s.dasherize}" : icon
+
+      link_to(url, options) do
+        content_tag(:i, '', :class => icon) + text
+      end
+    end
+
+    def locale_picker_link
+      if current_site.locales.size > 1 && localized?
+        content_tag :div, render('locomotive/shared/locale_picker_link'), :class => 'action'
+      else
+        nil
+      end
+    end
+
+    def flash_message
+      if not flash.empty?
+        first_key = flash.keys.first
+        content_tag :div, flash[first_key],
+          :id => "flash-#{first_key}",
+          :class => 'application-message'
+      else
+        ''
+      end
+    end
+
+    def backbone_view_class_name
+      action = case controller.action_name
+      when 'create' then 'New'
+      when 'update' then 'Edit'
+      else
+        controller.action_name
+      end.camelize
+
+      "Locomotive.Views.#{controller.controller_name.camelize}.#{action}View"
+    end
+
+    def backbone_view_data
+      content_for?(:backbone_view_data) ? content_for(:backbone_view_data) : ''
+    end
+
+    # Display the image of the flag representing the locale.
+    #
+    # @param [ String / Symbol ] locale The locale (fr, en, ...etc)
+    # @param [ String ] size The width x height (by default, 24x24)
+    #
+    # @return [ String ] The HTML image tag with the path to the matching flag.
+    #
+    def flag_tag(locale, size = '24x24')
+      image_tag("locomotive/icons/flags/#{locale}.png", :class => 'flag', :size => size)
+    end
+
+    def nocoffee_tag
+      link_to 'noCoffee', 'http://www.nocoffee.fr', :id => 'nocoffee'
+    end
+
+    # sites
+
+    def application_domain
+      domain = Locomotive.config.domain
+      domain += ":#{request.port}" if request.port != 80
+      domain
+    end
+
+    def manage_subdomain_or_domains?
+      Locomotive.config.manage_subdomain? || Locomotive.config.manage_domains?
+    end
+
+    def manage_subdomain?
+      Locomotive.config.manage_subdomain?
+    end
+
+    def manage_domains?
+      Locomotive.config.manage_domains?
+    end
+
+    def multi_sites?
+      Locomotive.config.multi_sites?
+    end
+
+    def public_page_url(page, options = {})
+      if content = options.delete(:content)
+        File.join(current_site_public_url, page.fullpath.gsub('content_type_template', ''), content._slug)
+      else
+        File.join(current_site_public_url, page.fullpath)
+      end
+    end
+
+    # memberships
+
+    def options_for_membership_roles(options = {})
+      list = (unless options[:skip_admin]
+        Locomotive::Ability::ROLES.map { |r| [t("locomotive.memberships.roles.#{r}"), r] }
+      else
+        (Locomotive::Ability::ROLES - ['admin']).map { |r| [t("locomotive.memberships.roles.#{r}"), r] }
+      end)
+
+      options_for_select(list)
+    end
+
+    # locales
+
+    # For a localized site, tell if the current content locale does not match
+    # the default locale of the site. It is used by the page / snippet forms
+    # to determine if we have to display the warning message letting the
+    # designer know that the template is only editable in the default locale.
+    #
+    # @return [ Boolean ] True if it matches the condition above.
+    #
+    def not_the_default_current_locale?
+      current_site.localized? && current_content_locale.to_s != current_site.default_locale.to_s
+    end
+
+  end
+end

data/app/helpers/locomotive/content_entries_helper.rb

@@ -0,0 +1,15 @@
+module Locomotive
+  module ContentEntriesHelper
+
+    def options_for_belongs_to_custom_field(class_name)
+      content_type = Locomotive::ContentType.class_name_to_content_type(class_name, current_site)
+
+      if content_type
+        content_type.ordered_entries.map { |entry| [entry_label(content_type, entry), entry._id] }
+      else
+        [] # unknown content type
+      end
+    end
+
+  end
+end

data/app/helpers/locomotive/content_types_helper.rb

@@ -0,0 +1,72 @@
+module Locomotive
+  module ContentTypesHelper
+
+    # Iterates over the content types with the following rules
+    # - content types are ordered by the updated_at date (DESC)
+    # - each content type has its own submenu if saved recently
+    # - if there are more than ui.max_content_types content types, the extra ones go under "..."
+    # - if a content type is selected and it is part of the extra content types, then
+    #   it will be moved to the first position in the displayed list (with its own submenu)
+    #
+    # @param [ Block ] block The statements responsible to display the menu item from a content type or a list of content types
+    #
+    def each_content_type(&block)
+      visible, others = [], []
+
+      current_site.content_types.ordered.only(:site_id, :name, :slug, :label_field_name).each_with_index do |content_type, index|
+        next if !content_type.persisted?
+
+        if index >= Locomotive.config.ui[:max_content_types]
+          if self.is_content_type_selected(content_type)
+            others << visible.delete_at(Locomotive.config.ui[:max_content_types] - 1) # swap content types
+            visible.insert(0, content_type)
+          else
+            others << content_type # fills the "..." menu
+          end
+          next
+        end
+
+        visible << content_type
+
+      end.each do |content_type|
+        # make sure to have a fresh copy of the content types because for now we don't have the full content types (ie: content_types.only(...))
+        ::Mongoid::IdentityMap.remove(content_type)
+      end
+
+      if visible.size > 0
+        visible.map { |c| yield(c) }
+        yield(others) if others.size > 0
+      end
+    end
+
+    def is_content_type_selected(content_type)
+      @content_type && content_type.slug == @content_type.slug
+    end
+
+    # Renders the label of a content type entry. If no raw_item_template filled in the content type,
+    # it just calls the _label method of the entry (based on the label_field_id). Otherwise, it
+    # parses and renders the liquid template.
+    #
+    # @param [ ContentType ] content_type The content type for better performance
+    # @param [ ContentEntry] entry The entry we want to display the label
+    #
+    # @return [ String ] The label of the content type entry
+    #
+    def entry_label(content_type, entry)
+      if content_type.raw_item_template.blank?
+        entry._label # default one
+      else
+        assigns = { 'site' => current_site, 'entry' => entry }
+
+        registers = {
+          :controller     => self,
+          :site           => current_site,
+          :current_locomotive_account  => current_locomotive_account
+        }
+
+        preserve(content_type.item_template.render(::Liquid::Context.new({}, assigns, registers)))
+      end
+    end
+
+  end
+end

data/app/helpers/locomotive/custom_fields_helper.rb

@@ -0,0 +1,70 @@
+module Locomotive
+  module CustomFieldsHelper
+
+    def options_for_custom_field_type
+      %w(string text select boolean date file belongs_to has_many many_to_many).map do |type|
+        [t("custom_fields.type.#{type}"), type]
+      end
+    end
+
+    def options_for_label_field(content_type)
+      content_type.ordered_entries_custom_fields.find_all do |field|
+        %w(string date).include?(field.type)
+      end.map do |field|
+        [field.label, field._id]
+      end
+    end
+
+    def options_for_group_by_field(content_type)
+      content_type.ordered_entries_custom_fields.find_all do |field|
+        %w(select belongs_to).include?(field.type)
+      end.map do |field|
+        [field.label, field._id]
+      end
+    end
+
+    def options_for_order_by(content_type)
+      options = %w{created_at updated_at _position}.map do |type|
+        [t("locomotive.content_types.form.order_by.#{type.gsub(/^_/, '')}"), type]
+      end
+      options + options_for_label_field(content_type)
+    end
+
+    def options_for_order_direction
+      %w(asc desc).map do |direction|
+        [t("locomotive.content_types.form.order_direction.#{direction}"), direction]
+      end
+    end
+
+    def options_for_text_formatting
+      %w(none html).map do |option|
+        [t("locomotive.custom_fields.text_formatting.#{option}"), option]
+      end
+    end
+
+    def options_for_content_type
+      current_site.content_types.map do |c|
+        [c.name, c.entries_class_name]
+      end.compact
+    end
+
+    def options_for_content_type_inverse_of
+      {}.tap do |hash|
+        current_site.content_types.where(:'entries_custom_fields.type'.in => %w(belongs_to many_to_many)).each do |content_type|
+          content_type.entries_custom_fields.each do |field|
+            if %w(belongs_to many_to_many).include?(field.type)
+              type = field.type == 'belongs_to' ? 'has_many' : field.type
+              hash[type] ||= []
+              hash[type] << {
+                :label      => field.label,
+                :name       => field.name,
+                :class_name => content_type.entries_class_name
+              }
+            end
+          end
+        end
+      end
+    end
+
+  end
+end

data/app/helpers/locomotive/installation_helper.rb

@@ -0,0 +1,9 @@
+module Locomotive
+  module InstallationHelper
+
+    def next_installation_step_link(step = 1, label = nil)
+      link_to(content_tag(:span, label || t('admin.installation.common.next')), installation_step_url(step), :class => 'button')
+    end
+
+  end
+end

data/app/helpers/locomotive/pages_helper.rb

@@ -0,0 +1,95 @@
+module Locomotive
+  module PagesHelper
+
+    def css_for_page(page)
+      %w(index not_found templatized redirect unpublished).inject([]) do |memo, state|
+        memo << state.dasherize if page.send(:"#{state}?")
+        memo
+      end.join(' ')
+    end
+
+    def page_toggler(page)
+      icon_class = cookies["folder-#{page._id}"] != 'none' ? 'icon-caret-down' : 'icon-caret-right'
+      content_tag :i, '',
+        :class  => "#{icon_class} toggler",
+        :data   => {
+          :open   => 'icon-caret-down',
+          :closed => 'icon-caret-right'
+        }
+    end
+
+    def parent_pages_options
+      roots = current_site.pages.roots.where(:slug.ne => '404').and(:_id.ne => @page.id)
+
+      [].tap do |list|
+        roots.each do |page|
+          list = add_children_to_options(page, list)
+        end
+      end
+    end
+
+    def add_children_to_options(page, list)
+      return list if page.parent_ids.include?(@page.id) || page == @page
+
+      offset = '- ' * (page.depth || 0) * 2
+
+      list << ["#{offset}#{page.title}", page.id]
+      page.children.each { |child| add_children_to_options(child, list) }
+      list
+    end
+
+    def options_for_target_klass_name
+      base_models = current_site.content_types.map do |type|
+        [type.name.humanize, type.klass_with_custom_fields(:entries)]
+      end
+      base_models + Locomotive.config.models_for_templatization.map { |name| [name.underscore.humanize, name] }
+    end
+
+    def options_for_page_cache_strategy
+      [
+        [t('.cache_strategy.none'), 'none'],
+        [t('.cache_strategy.simple'), 'simple'],
+        [t('.cache_strategy.hour'), 1.hour.to_s],
+        [t('.cache_strategy.day'), 1.day.to_s],
+        [t('.cache_strategy.week'), 1.week.to_s],
+        [t('.cache_strategy.month'), 1.month.to_s]
+      ]
+    end
+
+    def options_for_page_response_type
+      [
+        ['HTML', 'text/html'],
+        ['RSS', 'application/rss+xml'],
+        ['XML', 'text/xml'],
+        ['JSON', 'application/json']
+      ]
+    end
+
+    def options_for_page_redirect_type
+      [
+        [t('.redirect_type.permanent'), 301],
+        [t('.redirect_type.temporary'), 302]
+      ]
+    end
+
+    def page_response_type_to_string(page)
+      options_for_page_response_type.detect { |t| t.last == page.response_type }.try(:first) || '&mdash;'
+    end
+
+    # Give the path to the template of the page for the main locale ONLY IF
+    # the user does not already edit the page in the main locale.
+    #
+    # @param [ Object ] page The page
+    #
+    # @return [ String ] The path or nil if the main locale is enabled
+    #
+    def page_main_template_path(page)
+      if not_the_default_current_locale?
+        page_path(page, :content_locale => current_site.default_locale, :format => :json)
+      else
+        nil
+      end
+    end
+
+  end
+end