locomotivecms_mounter 1.0.0.alpha1

data/lib/locomotive/mounter/models/content_entry.rb

@@ -0,0 +1,290 @@
+module Locomotive
+  module Mounter
+    module Models
+
+      class ContentEntry < Base
+
+        ## fields ##
+        field :_slug,               localized: true
+        field :_position,           default: 0
+        field :_visible,            default: true
+        field :seo_title,           localized: true
+        field :meta_keywords,       localized: true
+        field :meta_description,    localized: true
+
+        field :content_type,        association: true
+
+        attr_accessor :dynamic_attributes, :main_locale, :errors
+
+        alias :_permalink :_slug
+        alias :_permalink= :_slug=
+
+        ## callbacks ##
+        set_callback :initialize, :after, :set_slug
+        set_callback :initialize, :after, :set_default_main_locale
+
+        ## methods ##
+
+        # Return the internal label used to identify a content entry
+        # in a YAML file for instance. It is based on the first field
+        # of the related content type.
+        #
+        # @return [ String ] The internal label
+        #
+        def _label
+          name = self.content_type.label_field_name
+          self.dynamic_getter(name)
+        end
+
+        # Process a minimal validation by checking if the required fields
+        # are filled in or not.
+        #
+        # @return [ Boolean ] False if one of the required fields is missing.
+        #
+        def valid?
+          self.errors = []
+          self.content_type.fields.each do |field|
+            if field.required
+              if self.dynamic_getter(field.name).blank?
+                self.errors << field.name
+              end
+            end
+          end
+          self.errors.blank?
+        end
+
+        # Return the list of the fields defined in the content type
+        # for which there is a value assigned.
+        #
+        # @return [ Array ] The list of fields
+        #
+        def dynamic_fields
+          self.dynamic_attributes.keys.map do |name|
+            self.content_type.find_field(name)
+          end
+        end
+
+        # Loop over the list of dynamic fields defined in
+        # the content type for which there is a value assigned.
+        #
+        # @example: each_dynamic_field { |field, value| .... }
+        #
+        def each_dynamic_field(&block)
+          return unless block_given?
+
+          self.dynamic_fields.each do |field|
+            value = self.localized_dynamic_attribute_value(field)
+
+            # value = (self.dynamic_attributes || {})[field.name.to_sym]
+            # value = value.try(:[], Locomotive::Mounter.locale) unless field.is_relationship? || !field.localized
+
+            block.call(field, value)
+          end
+        end
+
+        # Determine if field passed in parameter is one of the dynamic fields.
+        #
+        # @param [ String/Symbol ] name Name of the dynamic field
+        #
+        # @return [ Boolean ] True if it is a dynamic field
+        #
+        def is_dynamic_field?(name)
+          name = name.to_s.gsub(/\=$/, '').to_sym
+          !self.content_type.find_field(name).nil?
+        end
+
+        # Return the value of a dynamic field and cast it depending
+        # on the type of the field (string, date, belongs_to, ...etc).
+        #
+        # @param [ String/Symbol ] name Name of the dynamic field
+        #
+        # @return [ Object ] The casted value (String, Date, ContentEntry, ...etc)
+        #
+        def dynamic_getter(name)
+          field = self.content_type.find_field(name)
+
+          value = self.localized_dynamic_attribute_value(field)
+
+          case field.type
+          when :string, :text, :select, :boolean, :category
+            value
+          when :date
+            value.is_a?(String) ? Date.parse(value) : value
+          when :file
+            { 'url' => value }
+          when :belongs_to
+            field.klass.find_entry(value)
+          when :has_many
+            field.klass.find_entries_by(field.inverse_of, [self._label, self._permalink])
+          when :many_to_many
+            field.klass.find_entries_among(value)
+          end
+        end
+
+        # Set the value of a dynamic field. If the value is a hash,
+        # it assumes that it represents the translations.
+        #
+        # @param [ String/Symbol ] name Name of the dynamic field
+        # @param [ Object ] value Value to set
+        #
+        def dynamic_setter(name, value)
+          self.dynamic_attributes ||= {}
+          self.dynamic_attributes[name.to_sym] ||= {}
+
+          field = self.content_type.find_field(name)
+
+          if value.is_a?(Hash) # already localized
+            value.keys.each { |locale| self.add_locale(locale) }
+            self.dynamic_attributes[name.to_sym].merge!(value.symbolize_keys)
+          else
+            if field.is_relationship? || !field.localized
+              self.dynamic_attributes[name.to_sym] = value
+            else
+              self.add_locale(Locomotive::Mounter.locale)
+              self.dynamic_attributes[name.to_sym][Locomotive::Mounter.locale] = value
+            end
+          end
+        end
+
+        # The magic of dynamic fields happens within this method.
+        # It calls the getter/setter of a dynamic field if it is one of them.
+        def method_missing(name, *args, &block)
+          if self.is_dynamic_field?(name)
+            if name.to_s.ends_with?('=')
+              name = name.to_s.gsub(/\=$/, '').to_sym
+              self.dynamic_setter(name, args.first)
+            else
+              self.dynamic_getter(name)
+            end
+          else
+            super
+          end
+        end
+
+        # Returns a hash with the label_field value as the key and the other fields as the value
+        #
+        # @param [ Boolean ] nested True to have a hash of hash (whose key is the label)
+        #
+        # @return [ Hash ] A simple hash (nested to false) or a hash of hash
+        #
+        def to_hash(nested = true)
+          # no need of _position and _visible (unless it's false)
+          hash = super.delete_if { |k, v| k == '_position' || (k == '_visible' && v == true) }
+
+          # also no need of the content type
+          hash.delete('content_type')
+
+          # dynamic attributes
+          hash.merge!(self.dynamic_attributes.deep_stringify_keys)
+
+          # no need of the translation of the field name in the current locale
+          label_field = self.content_type.label_field
+
+          if label_field.localized && !hash[label_field.name].empty?
+            hash[label_field.name].delete(Locomotive::Mounter.locale.to_s)
+
+            hash.delete(label_field.name) if hash[label_field.name].empty?
+          end
+
+          nested ? { self._label => hash } : hash
+        end
+
+        # Return the main default params used for the API, meaning all except
+        # the dynamic fields which have to be defined outside the model.
+        #
+        # @return [ Hash ] The params
+        #
+        def to_params
+          self.filter_attributes %w(_slug _position _visible seo_title meta_keywords meta_description)
+        end
+
+        def to_s
+          "#{self.content_type.slug} / #{self._slug}"
+        end
+
+        protected
+
+        # Sets the slug of the instance by using the value of the highlighted field
+        # (if available). If a sibling content instance has the same permalink then a
+        # unique one will be generated.
+        # It applies that to every translated version of the content entry.
+        def set_slug
+          self.translated_in.each do |locale|
+            Locomotive::Mounter.with_locale(locale) do
+              self._slug = self._label.dup if self._label.present?
+
+              if self._slug.blank?
+                self._slug = self.content_type.send(:label_to_slug)
+              end
+
+              self._slug.permalink!
+
+              self._slug = self.next_unique_slug if self.slug_already_taken?
+            end
+          end
+        end
+
+        # Once the entry has been initialized, we keep track of the current locale
+        #
+        def set_default_main_locale
+          self.main_locale = Locomotive::Mounter.locale
+        end
+
+        # Return the next available unique slug as a string
+        #
+        # @return [ String] An unique permalink (or slug)
+        #
+        def next_unique_slug
+          slug        = self._slug.gsub(/-\d*$/, '')
+          next_number = 0
+
+          self.content_type.entries.each do |entry|
+            if entry._permalink =~ /^#{slug}-?(\d*)$/i
+              next_number = $1.to_i if $1.to_i > next_number
+            end
+          end
+
+          [slug, next_number + 1].join('-')
+        end
+
+        def slug_already_taken?
+          entry = self.content_type.find_entry(self._slug)
+          entry.try(:_slug) == self._slug
+        end
+
+        # Return the value of a dynamic attribute specified by its
+        # corresponding content field.
+        # If that attribute is localized and in the current locale
+        # its value is nil, it returns the value in the main locale.
+        #
+        # @param [ Object ] The content field
+        #
+        # @return [ Object ] The value
+        #
+        def localized_dynamic_attribute_value(field)
+          value = (self.dynamic_attributes || {})[field.name.to_sym]
+
+          # puts "[#{field.name.inspect}] #{value.inspect} / #{field.localized.inspect} / #{value.is_a?(Hash).inspect}"
+
+          if !field.is_relationship? && field.localized && value.is_a?(Hash)
+            # get the localized value for the current locale
+            _value = value[Locomotive::Mounter.locale]
+
+            # puts "[#{field.name}] _value = #{value.inspect} / current #{Locomotive::Mounter.locale.inspect} / main #{self.main_locale.inspect}"
+
+            # no value for the current locale, give a try to the main one
+            if _value.nil? && Locomotive::Mounter.locale != self.main_locale
+              _value = value[self.main_locale]
+            end
+
+            value = _value
+          end
+
+          value #.tap { |v| puts "[#{field.name}] returning #{v.inspect}" }
+        end
+
+      end
+
+    end
+  end
+end

data/lib/locomotive/mounter/models/content_field.rb

@@ -0,0 +1,128 @@
+module Locomotive
+  module Mounter
+    module Models
+
+      class ContentField < Base
+
+        ## fields ##
+        field :label
+        field :name
+        field :type,      default: :string
+        field :hint
+        field :position,  default: 0
+        field :required,  default: false
+        field :localized, default: false
+
+        # text
+        field :text_formatting
+
+        # select
+        field :select_options, type: :array, class_name: 'Locomotive::Mounter::Models::ContentSelectOption'
+
+        # relationships: belongs_to, has_many, many_to_many
+        field :class_name
+        field :inverse_of
+        field :order_by
+        field :ui_enabled
+
+        alias :target :class_name
+        alias :target= :class_name=
+
+        ## callbacks ##
+        set_callback :initialize, :after, :prepare_attributes
+
+        ## other accessors ##
+        attr_accessor :_destroy
+
+        ## methods ##
+
+        def prepare_attributes
+          self.label ||= self.name.try(:humanize)
+          self.type = self.type.to_sym
+          self.sanitize
+        end
+
+        # Tell if it describes a relationship (belongs_to, many_to_many, has_many) or not.
+        #
+        # @return [ Boolean ] True if describing a relationship
+        #
+        def is_relationship?
+          %w(belongs_to has_many many_to_many).include?(self.type.to_s)
+        end
+
+        # Return the content type matching the class_name / target attribute
+        #
+        # @return [ Object ] The matching Content Type
+        #
+        def klass
+          (@klass ||= self.mounting_point.content_types[self.class_name]).tap do |klass|
+            if klass.nil?
+              raise UnknownContentTypeException.new("unknow content type #{self.class_name}")
+            end
+          end
+        end
+
+        # Find a select option by its name IN the current locale.
+        #
+        # @param [ String / Symbol] name_or_id Name or Id of the option
+        #
+        # @return [ Object ] The select option or nil if not found
+        #
+        def find_select_option(name_or_id)
+          return nil if self.select_options.blank?
+          self.select_options.detect { |option| option.name.to_s == name_or_id.to_s || option._id == name_or_id }
+        end
+
+        # Instead of returning a simple hash, it returns a hash with name as the key and
+        # the remaining attributes as the value.
+        #
+        # @return [ Hash ] A hash of hash
+        #
+        def to_hash
+          hash = super.delete_if { |k, v| %w(name position).include?(k) }
+          { self.name => hash }
+        end
+
+        # Return the params used for the API.
+        #
+        # @return [ Hash ] The params
+        #
+        def to_params
+          params = self.filter_attributes %w(label name type hint position required localized)
+
+          # we set the _id / _destroy attributes for embedded documents
+          params[:_id]      = self._id if self.persisted?
+          params[:_destroy] = self._destroy if self._destroy
+
+          case self.type
+          when :text
+            params[:text_formatting] = self.text_formatting
+          when :select
+            params[:raw_select_options] = self.select_options.map(&:to_params)
+          when :belongs_to
+            params[:class_name] = self.class_name
+          when :has_many, :many_to_many
+            %w(class_name inverse_of order_by ui_enabled).each do |name|
+              params[name.to_sym] = self.send(name.to_sym)
+            end
+          end
+
+          params
+        end
+
+        protected
+
+        # Clean up useless properties depending on its type
+        def sanitize
+          # ui_enabled only for the belongs_to, has_many and many_to_many types
+          self.ui_enabled = nil unless self.is_relationship?
+
+          # text_formatting only for the text type
+          self.text_formatting = nil unless self.type == :text
+        end
+
+      end
+
+    end
+  end
+end

data/lib/locomotive/mounter/models/content_select_option.rb

@@ -0,0 +1,29 @@
+module Locomotive
+  module Mounter
+    module Models
+
+      class ContentSelectOption < Base
+
+        ## fields ##
+        field :name,      localized: true
+        field :position,  default: 0
+
+        ## methods ##
+
+        # Return the params used for the API.
+        #
+        # @param [ Hash ] options For now, none
+        #
+        # @return [ Hash ] The params
+        #
+        def to_params(options = nil)
+          { name: self.name_translations, position: self.position }.tap do |params|
+            params[:id] = self._id if self.persisted?
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/locomotive/mounter/models/content_type.rb

@@ -0,0 +1,217 @@
+module Locomotive
+  module Mounter
+    module Models
+
+      class ContentType < Base
+
+        ## fields ##
+        field :name
+        field :description
+        field :slug
+        field :label_field_name
+        field :group_by
+        field :order_by
+        field :order_direction
+        field :public_submission_enabled
+        field :public_submission_accounts
+        field :raw_item_template
+
+        field :fields, type: :array, class_name: 'Locomotive::Mounter::Models::ContentField'
+
+        field :entries, association: true
+
+        ## callbacks ##
+        set_callback :initialize, :after, :sanitize
+        set_callback :initialize, :after, :assign_mounting_point_to_fields
+
+        ## other accessors ##
+        attr_accessor :klass_name, :group_by_field_id
+
+        ## aliases ##
+        alias_method :group_by_field_name, :group_by
+        alias_method :group_by_field_name=, :group_by=
+
+        ## methods ##
+
+        # Return the label field (by the default the first field)
+        #
+        # @return [ Object ] The label field
+        #
+        def label_field
+          self.find_field(self.label_field_name) || self.fields.first
+        end
+
+        # Return the group_by field
+        #
+        # @return [ Object ] The group_by field
+        #
+        def group_by_field
+          self.fields.find_field(self.group_by_field_name)
+        end
+
+        # Build a content entry and add it to the list of entries of the content type.
+        # The content type will be referenced into the newly built entry .
+        #
+        # @param [ Hash ] attributes Attributes of the new content entry
+        #
+        # @return [ Object ] The newly built content entry
+        #
+        def build_entry(attributes)
+          ContentEntry.new(content_type: self).tap do |entry|
+            # do not forget that we are manipulating dynamic fields
+            attributes.each do |k, v|
+              begin
+                entry.send(:"#{k}=", v)
+              rescue NoMethodError => e
+                Mounter.logger.error e.backtrace
+                raise FieldDoesNotExistException.new("The '#{self.slug}' content type does not have a field named '#{k}'.")
+              end
+            end
+
+            # force the slug to be defined from its label and in all the locales
+            entry.send :set_slug
+
+            (self.entries ||= []) << entry
+          end
+        end
+
+        # Tell if the content type owns a field which defines
+        # a relationship to another content type.
+        #
+        # @return [ Boolean ] True if a relationship field exists
+        #
+        def with_relationships?
+          self.fields.any? { |field| field.is_relationship? }
+        end
+
+        # Return the list of fields which do not describe
+        # a relationship.
+        #
+        # @return [ Array ] The list of fields.
+        #
+        def non_relationship_fields
+          self.fields.select { |field| !field.is_relationship? }
+        end
+
+        # Find a field by its name (string or symbol) or its id (API)
+        #
+        # @param [ String / Symbol] name_or_id Name or Id of the field
+        #
+        # @return [ Object ] The field if it exists or nil
+        #
+        def find_field(name_or_id)
+          self.fields.detect { |field| field.name.to_s == name_or_id.to_s || field._id == name_or_id }
+        end
+
+        # Find a content entry by its ids (ie: _permalink or _label)
+        #
+        # @param [ String ] id A permalink or a label
+        #
+        # @return [ Object ] The content entry if it exists or nil
+        #
+        def find_entry(id)
+          (self.entries || []).detect { |entry| [entry._permalink, entry._label].include?(id) }
+        end
+
+        # Find all the entries whose their _permalink or _label is among the ids
+        # passed in parameter.
+        #
+        # @param [ Array ] ids List of permalinks or labels
+        #
+        # @return [ Array ] List of content entries or [] if none
+        #
+        def find_entries_among(ids)
+          (self.entries || []).find_all { |entry| [*ids].any? { |v| [entry._permalink, entry._label].include?(v) } }
+        end
+
+        # Find all the entries by a field and its value.
+        #
+        # @param [ String ] name Name of the field
+        # @param [ String / Array ] value The different value of the field to test
+        #
+        # @return [ Array ] List of content entries or [] if none
+        #
+        def find_entries_by(name, value)
+          (self.entries || []).find_all { |entry| [*value].include?(entry.send(name.to_sym)) }
+        end
+
+        # Return the params used for the API.
+        # The options parameter can be used to get all the fields even
+        # the ones describing a relationship with another content type.
+        #
+        # @param [ Hash ] options Default values: { all_fields: false }
+        #
+        # @return [ Hash ] The params
+        #
+        def to_params(options = nil)
+          options = { all_fields: false }.merge(options || {})
+
+          params = self.filter_attributes %w(name slug description label_field_name group_by_field_name order_by order_by_direction public_submission_enabled raw_item_template)
+
+          # order by
+          params[:order_by] = '_position' if self.order_by == 'manually'
+
+          # fields
+          _fields = options[:all_fields] ? self.fields : self.non_relationship_fields
+          params[:entries_custom_fields] = _fields.map(&:to_params)
+
+          params
+        end
+
+        def to_s
+          self.name
+        end
+
+        protected
+
+        # Give an unique slug based on a label and within the scope of the content type.
+        #
+        # @param [ String ] label The label. If nil, we take the singularized version of the content type slug.
+        #
+        # @return [ String ] An unique slug
+        #
+        def label_to_slug(label = nil)
+          label ||= self.slug.singularize
+          base, index = label.parameterize('-'), 1
+          unique_slug = base
+
+          while self.find_entry(unique_slug)
+            unique_slug = "#{base}-#{index}"
+            index += 1
+          end
+
+          unique_slug
+        end
+
+        # Method used to clean up the content and its fields.
+        # Besides, it also sets the values defined by other attributes.
+        def sanitize
+          # if no label_field_name provided, take the first field
+          unless self.label_field_name
+            self.label_field_name = (self.fields || []).first.try(:name)
+          end
+
+          # define group_by_field from group_by_field_id
+          if self.group_by_field_id
+            self.group_by_field_name = self.find_field(self.group_by_field_id)
+          end
+
+          # public_submission_accounts means public_submission_enabled set to true
+          self.public_submission_enabled = true if self.public_submission_accounts.is_a?(Array)
+        end
+
+        # Each field should have a reference to the mounting point
+        #
+        def assign_mounting_point_to_fields
+          return if self.fields.blank?
+
+          self.fields.each do |field|
+            field.mounting_point = self.mounting_point
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/locomotive/mounter/models/editable_element.rb

@@ -0,0 +1,27 @@
+module Locomotive
+  module Mounter
+    module Models
+
+      class EditableElement < Base
+
+        ## fields ##
+        field :content, localized: true
+
+        ## other accessors
+        attr_accessor :block, :slug
+
+        ## methods ##
+
+        def to_params
+          { block: self.block, slug: self.slug, content: self.content }
+        end
+
+        def to_yaml
+          { "#{block}/#{slug}" => content }
+        end
+
+      end
+
+    end
+  end
+end