locomotive_cms 2.0.0.rc12 → 2.0.0

data/app/models/locomotive/translation.rb

@@ -0,0 +1,35 @@
+class Locomotive::Translation
+
+  include Locomotive::Mongoid::Document
+
+  ## fields ##
+  field :key
+  field :values, type: Hash, default: {}
+
+  ## associations ##
+  belongs_to :site, class_name: 'Locomotive::Site'
+
+  ## validations ##
+  validates_uniqueness_of :key, scope: :site_id
+  validates_presence_of 	:site, :key
+
+  ## scopes ##
+  scope :ordered, :order_by => [[:key, :asc]]
+
+  ## callbacks ##
+	before_validation :underscore_key
+
+	## methods ##
+
+	protected
+
+	# Make sure the translation key is underscored
+	# since it is the unique way to use it in a liquid template.
+	#
+	def underscore_key
+		if self.key
+			self.key = self.key.permalink.underscore
+		end
+	end
+
+end

data/app/presenters/locomotive/account_presenter.rb

@@ -1,11 +1,19 @@
 module Locomotive
   class AccountPresenter < BasePresenter
 
-    delegate :name, :email, :locale, :to => :source
+    ## properties ##
+    properties  :name, :email, :locale
+    property    :admin, only_getter: true
 
-    def included_methods
-      super + %w(name email locale)
+    with_options only_setter: true do |presenter|
+      presenter.properties :password, :password_confirmation
+    end
+
+    ## other getters / setters ##
+
+    def admin
+      self.__source.admin?
     end
 
   end
-end
+end

data/app/presenters/locomotive/base_presenter.rb

@@ -1,46 +1,148 @@
 class Locomotive::BasePresenter
 
+  include Locomotive::Presentable
+
   include ActionView::Helpers::SanitizeHelper
   extend  ActionView::Helpers::SanitizeHelper::ClassMethods
   include ActionView::Helpers::TextHelper
   include ActionView::Helpers::NumberHelper
 
-  attr_reader :source, :options, :ability, :depth
+  ## default properties ##
+  with_options allow_nil: true do |presenter|
+    presenter.properties    :id, :_id
+  end
+  properties  :created_at, :updated_at, type: 'Date', only_getter: true
 
-  delegate :created_at, :updated_at, :to => :source
+  ## utility accessors ##
+  attr_reader :__ability, :__depth
 
-  def initialize(object, options = {})
-    @source   = object
-    @options  = options || {}
-    @depth    = options[:depth] || 0
-    @ability  = options[:ability]
+  # Set the ability object to check if we can or not
+  # get a property.
+  #
+  def after_initialize
+    @__depth    = self.__options[:depth] || 0
+    @__ability  = self.__options[:ability]
 
-    if @options[:current_account] && @options[:current_site]
-      @ability = Locomotive::Ability.new @options[:current_account], @options[:current_site]
+    if self.__options[:current_account] && self.__options[:current_site]
+      @__ability = Locomotive::Ability.new self.__options[:current_account], self.__options[:current_site]
     end
   end
 
-  def id
-    self.source.persisted? || self.source.embedded? ? self.source._id.to_s : nil
+  # Get the id of the source only if it has been persisted
+  # or if it's an embedded document.
+  #
+  # @return [ String ] The id of the source, nil if not persisted or not embedded.
+  #
+  def _id
+    self.__source.persisted? || self.__source.embedded? ? self.__source._id.to_s : nil
   end
 
-  alias :_id :id
+  alias :id :_id
 
+  # Check if there is an ability object used for permissions.
+  #
+  # @return [ Boolean ] True if defined, false otherwise
+  #
   def ability?
-    self.ability.present?
+    self.__ability.present?
+  end
+
+  # Shortcut to the site taken from the source.
+  #
+  # @return [ Object ] The site or nil if not found
+  #
+  def site
+    self.__source.try(:site)
+  end
+
+  # Shortcut to the errors of the source
+  #
+  # @return [ Hash ] The errors or an empty hash if no errors
+  #
+  def errors
+    self.__source.errors.messages.to_hash.stringify_keys
+  end
+
+  # Tell if we have to include errors or not
+  #
+  # @return [ Boolean ] True if the source has errors.
+  #
+  def include_errors?
+    !!self.__options[:include_errors]
+  end
+
+  # Tell if the presenter is aimed to be used in a html view
+  #
+  # @return [ Boolean ] True if used in a HTML view
+  #
+  def html_view?
+    !!self.__options[:html_view]
+  end
+
+  # Mimic format used by to_json
+  #
+  # @param [ String ] text The string representing the time
+  #
+  # @return [ Time ] The time or nil if the input is nil or empty
+  #
+  def formatted_time(text)
+    return nil if text.blank?
+    format = '%Y-%m-%dT%H:%M:%S%Z'
+    ::Time.strptime(text, format)
   end
 
-  def included_methods
-    %w(id _id created_at updated_at)
+  # Return the set of setters with their options.
+  #
+  # @param [ Hash ] options Some options: with_ids (add id and _id)
+  #
+  # @return [ Hash ] The setters
+  #
+  def self.setters_to_hash(options = {})
+    options = { without_ids: true }.merge(options)
+
+    {}.tap do |hash|
+      self.setters.each do |name|
+        next if %w(id _id).include?(name.to_s) && options[:without_ids]
+        hash[name] = self.getters_or_setters_to_hash(name)
+      end
+    end
   end
 
-  def as_json(methods = nil)
-    methods ||= self.included_methods
+  # Return the set of getters with their options.
+  #
+  # @return [ Hash ] The getters
+  #
+  def self.getters_to_hash
     {}.tap do |hash|
-      methods.each do |meth|
-        hash[meth] = self.send(meth.to_sym) rescue nil
+      self.getters.each do |name|
+        next if %w(_id screated_at updated_at).include?(name)
+        hash[name] = self.getters_or_setters_to_hash(name)
+      end
+
+      %w(created_at updated_at).each do |name|
+        hash[name] = self.getters_or_setters_to_hash(name)
       end
     end
   end
 
-end
+  def self.getters_or_setters_to_hash(name)
+    options   = self.property_options[name] || {}
+
+    attributes = {
+      type:         options[:type] || 'String',
+      required:     options[:required].nil? ? true : options[:required],
+      alias_of:     self.alias_of(name),
+      description:  options[:description]
+    }
+
+    if options[:presenter]
+      attributes[:collection_of] = {
+        name:   options[:presenter].to_s.demodulize.gsub(/Presenter$/, '').underscore,
+        params: options[:presenter].setters_to_hash
+      }
+    end
+
+    attributes
+  end
+
+end

data/app/presenters/locomotive/content_asset_presenter.rb

@@ -1,36 +1,47 @@
 module Locomotive
   class ContentAssetPresenter < BasePresenter
 
-    delegate :content_type, :width, :height, :vignette_url, :to => :source
+    ## properties ##
+
+    properties :content_type, :width, :height
+
+    with_options only_getter: true do |presenter|
+      presenter.properties :filename, :full_filename, :short_name, :extname, :raw_size
+      presenter.properties :vignette_url, :url, :content_type_text
+    end
+
+    property :source, only_setter: true
+
+    ## custom getters / setters ##
 
     def full_filename
-      self.source.source_filename
+      self.__source.source_filename
     end
 
     def filename
-      truncate(self.source.source_filename, :length => 22)
+      truncate(self.__source.source_filename, length: 22)
     end
 
     def short_name
-      truncate(self.source.name, :length => 15)
+      truncate(self.__source.name, length: 15)
     end
 
     def extname
-      truncate(self.source.extname, :length => 3)
+      truncate(self.__source.extname, length: 3)
     end
 
     def content_type_text
-      value = self.source.content_type.to_s == 'other' ? self.extname : self.source.content_type
+      value = self.__source.content_type.to_s == 'other' ? self.extname : self.__source.content_type
       value.blank? ? '?' : value
     end
 
-    def url
-      self.source.source.url
+    def raw_size
+      self.__source.size
     end
 
-    def included_methods
-      super + %w(full_filename filename short_name extname content_type content_type_text url vignette_url width height)
+    def url
+      self.__source.source.url
     end
 
   end
-end
+end

data/app/presenters/locomotive/content_entry_presenter.rb

@@ -1,60 +1,175 @@
 module Locomotive
   class ContentEntryPresenter < BasePresenter
 
-    delegate  :_label, :_slug, :_position, :translated_in, :seo_title,
-              :meta_keywords, :meta_description, :select_custom_fields,
-              :file_custom_fields, :has_many_custom_fields, :many_to_many_custom_fields, :to => :source
+    ## properties ##
 
-    # Lists of all the attributes editable thru the html form for instance
-    #
-    # @returns [ List ] a list of attributes (string)
-    #
-    def safe_attributes
-      self.source.custom_fields_safe_attributes + %w(_slug seo_title meta_keywords meta_description _destroy)
+    properties  :_label, only_getter: true
+
+    property    :_slug
+
+    property    :_position, required: false
+
+    properties  :seo_title, :meta_keywords, :meta_description, required: false
+
+    with_options only_getter: true do |presenter|
+      presenter.properties  :content_type_slug, :translated_in
+
+      presenter.property    :errors, if: Proc.new { include_errors? }
     end
 
-    def filtered_custom_fields_methods
-      self.source.custom_fields_methods do |rule|
-        if self.source.is_a_custom_field_many_relationship?(rule['name'])
-          # avoid circular dependencies, it should accept only one deep level
-          self.depth == 0
-        else
-          true
-        end
-      end
+    with_options only_getter: true, if: Proc.new { html_view? } do |presenter|
+      presenter.properties  :safe_attributes
+      presenter.properties  :select_custom_fields, :file_custom_fields, :has_many_custom_fields, :many_to_many_custom_fields
     end
 
+    ## callbacks ##
+
+    set_callback :set_attributes, :after, :set_dynamic_attributes
+
+    ## other getters / setters ##
+
     def errors
-      self.source.errors.to_hash.stringify_keys
+      super
     end
 
     def content_type_slug
-      self.source.content_type.slug
+      self.__source.content_type.slug
     end
 
-    def included_methods
-      default_list = %w(_label _slug _position content_type_slug select_custom_fields file_custom_fields has_many_custom_fields many_to_many_custom_fields translated_in safe_attributes)
-      default_list << 'errors' if !!self.options[:include_errors]
-      super + self.filtered_custom_fields_methods + default_list
+    def safe_attributes
+      self.__source.custom_fields_safe_setters + %w(_slug seo_title meta_keywords meta_description)
     end
 
-    def as_json(methods = nil)
-      methods ||= self.included_methods
+    ## other methods ##
+
+    def as_json_with_custom_fields
+      as_json_without_custom_fields.merge(self.custom_fields_to_hash)
+    end
+
+    alias_method_chain :as_json, :custom_fields
+
+    def as_json_for_html_view
+      self.__options[:html_view] = true
+      as_json_without_custom_fields.merge(self.custom_fields_to_hash)
+    end
+
+    protected
+
+    # Build the hash representing the values of all
+    # the custom fields of the content entry.
+    # It also includes the ones from relationships fields
+    #
+    # @return [ Hash ] key the name of the custom field and value from the source
+    #
+    def custom_fields_to_hash
+      base = self.__source.custom_fields_basic_attributes
+      base.merge!(self.many_relationships_to_hash)
+      base.merge!(self.belongs_to_to_hash)
+    end
+
+    # Build the hash storing for each *belongs_to* type field the target entry.
+    #
+    # @return [ Hash ] The hash whose name is the name of the belongs_to field
+    #
+    def belongs_to_to_hash
       {}.tap do |hash|
-        methods.each do |meth|
-          hash[meth]= (if self.source.custom_fields_methods.include?(meth.to_s)
-            if self.source.is_a_custom_field_many_relationship?(meth.to_s)
-              # go deeper
-              self.source.send(meth).ordered.map { |entry| entry.to_presenter(:depth => self.depth + 1) }
+        self.__source.belongs_to_custom_fields.each do |name, _|
+          if target = self.__source.send(name.to_sym)
+            if self.html_view?
+              hash["#{name}_id"] = target._id
             else
-              self.source.send(meth) rescue nil
+              hash[name.to_s]    = target._slug
+            end
+          end
+        end
+      end
+    end
+
+    # Build the hash storing for each *many* type field
+    # the list of entries.
+    #
+    # @return [ Hash ] The hash whose name is the name of the relationhip
+    #
+    def many_relationships_to_hash
+      {}.tap do |hash|
+        (self.__source.has_many_custom_fields + self.__source.many_to_many_custom_fields).each do |name, _|
+          if self.__depth == 0
+            list = self.__source.send(name.to_sym).ordered
+            hash[name.to_s] = list.map do |entry|
+              if self.html_view?
+                entry.to_presenter(depth: self.__depth + 1, html_view: true).as_json
+              else
+                entry._slug
+              end
             end
-          else
-            self.send(meth.to_sym) rescue nil
-          end)
+          end
+        end
+      end
+    end
+
+    # Set the values of the dynamic attributes for the
+    # content entry instance. This method is called automatically
+    # (callback) when the attributes= is called.
+    #
+    def set_dynamic_attributes
+      # process the basic types
+      self.__source.custom_fields_basic_attributes = @_attributes
+
+      # now the relationships
+      self.__source.relationship_custom_fields.each do |rule|
+        if rule['type'] == 'belongs_to'
+          self.set_belongs_to_attribute(rule['name'], rule['class_name'])
+        elsif rule['type'] == 'many_to_many'
+          self.set_many_to_many_attribute(rule['name'], rule['class_name'])
         end
       end
     end
 
+    def set_belongs_to_attribute(name, class_name)
+      id_or_slug  = @_attributes[name] || @_attributes["#{name}_id"]
+
+      return if id_or_slug.nil?
+
+      entry = self.fetch_content_entries(class_name, id_or_slug).first
+
+      if entry
+        self.__source.send(:"#{name}_id=", entry._id)
+
+        if position = @_attributes["#{name}_position"]
+          self.__source.send(:"#{name}_position=", position)
+        end
+      end
+    end
+
+    def set_many_to_many_attribute(name, class_name)
+      ids_or_slugs  = @_attributes[name] || @_attributes["#{name}_ids"]
+
+      return if ids_or_slugs.nil?
+
+      entries = self.fetch_content_entries(class_name, ids_or_slugs)
+
+      unless entries.empty?
+        entries = entries.sort do |a, b|
+          (ids_or_slugs.index(a._id.to_s) || ids_or_slugs.index(a._permalink)) <=>
+          (ids_or_slugs.index(b._id.to_s) || ids_or_slugs.index(b._permalink))
+        end # keep the original order
+
+        self.__source.send(:"#{name}=", entries.to_a)
+      end
+    end
+
+    # Return all the ids of the content entries matching the ids or the slugs
+    #
+    # @param [ Array ] ids_or_slugs Array of ids or slugs
+    #
+    # @return [ Array ] The matching entries
+    #
+    def fetch_content_entries(class_name, ids_or_slugs)
+      ids_or_slugs  = [*ids_or_slugs]
+      klass         = class_name.constantize
+
+      klass.any_of({ :_slug.in => ids_or_slugs }, { :_id.in => ids_or_slugs })
+    end
+
   end
-end
+end