locomotive_cms 2.0.0.rc12 → 2.0.0

data/lib/locomotive/mongoid.rb

@@ -1,3 +1,4 @@
+require 'locomotive/mongoid/presenter'
+require 'locomotive/mongoid/liquid'
 require 'locomotive/mongoid/document'
-require 'locomotive/mongoid/model_extensions'
 require 'locomotive/mongoid/patches'

data/lib/locomotive/mongoid/document.rb

@@ -1,5 +1,4 @@
 module Locomotive
-
   module Mongoid
 
     module Document
@@ -9,10 +8,12 @@ module Locomotive
       included do
         include ::Mongoid::Document
         include ::Mongoid::Timestamps
+
+        include Locomotive::Mongoid::Presenter
+        include Locomotive::Mongoid::Liquid
       end
 
     end
 
   end
-
 end

data/lib/locomotive/mongoid/liquid.rb

@@ -0,0 +1,39 @@
+module Locomotive
+  module Mongoid
+
+    module Liquid
+
+      extend ActiveSupport::Concern
+
+      included do
+        # keeps track of the liquid drop class
+        class << self; attr_writer :drop_class  end
+      end
+
+      # Get the liquid drop corresponding to the current document
+      #
+      # @return [ Object ] The liquid drop
+      #
+      def to_liquid
+        return nil unless self.class.drop_class
+        self.class.drop_class.new(self)
+      end
+
+      module ClassMethods
+
+        # Return the memoized liquid drop class if it exists.
+        #
+        # @return [ Class ] The liquid drop class
+        #
+        def drop_class
+          return @drop_class if @drop_class
+          _name       = "Locomotive::Liquid::Drops::#{name.demodulize}"
+          @drop_class = _name.constantize rescue nil
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/mongoid/presenter.rb

@@ -0,0 +1,73 @@
+module Locomotive
+  module Mongoid
+
+    module Presenter
+
+      extend ActiveSupport::Concern
+
+      included do
+        # keep a link to the original as_json method from Mongoid
+        alias :as_json_from_mongoid :as_json
+
+        # keeps track of the presenter class
+        class << self; attr_writer :presenter_class end
+      end
+
+      # Get the presenter corresponding to the current document
+      #
+      # @return [ Object ] The presenter
+      #
+      def to_presenter(options = {})
+        return nil unless self.class.presenter_class
+        self.class.presenter_class.new(self, options)
+      end
+
+      # Set the attributes of the document by using
+      # the corresponding presenter.
+      #
+      # @param [ Hash ] attributes The document attributes
+      #
+      def from_presenter(attributes = {})
+        self.to_presenter.attributes = attributes
+      end
+
+      def as_json(options = {})
+        if presenter = self.to_presenter(options)
+          presenter.as_json
+        else
+          self.as_json_from_mongoid(options)
+        end
+      end
+
+      module ClassMethods
+
+        # Return the memoized presenter class if it exists.
+        #
+        # @return [ Class ] The presenter class
+        #
+        def presenter_class
+          return @presenter_class if @presenter_class
+          _name             = "Locomotive::#{name.demodulize}Presenter"
+          @presenter_class  = _name.constantize rescue nil
+        end
+
+        # Initialize an instance of the document by passing
+        # attributes calculated by the associated presenter.
+        #
+        # @param [ Hash ] attributes The document attributes
+        #
+        # @return [ Object ] A new document instance filled with the parameters
+        #
+        def from_presenter(attributes)
+          new.tap do |document|
+            presenter = document.to_presenter
+            presenter.attributes = attributes
+          end
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/presentable.rb

@@ -0,0 +1,216 @@
+module Locomotive
+  module Presentable
+
+    extend ActiveSupport::Concern
+
+    included do
+
+      # callbacks enabled
+      include ActiveSupport::Callbacks
+      define_callbacks :set_attributes
+
+      # keep tracks of the getters and setters
+      class << self; attr_accessor :getters, :setters, :property_options end
+
+      # __source is a reference to the main object (__ is for variable protection)
+      attr_reader :__source, :__options
+
+    end
+
+    # Initializer
+    def initialize(object, options = {})
+      @__source   = object
+      @__options  = options || {}
+
+      self.after_initialize
+    end
+
+    # Method called just after a presenter has been
+    # initialized. This method can be overridden.
+    #
+    def after_initialize
+      # do nothing
+    end
+
+    # Set the attributes of the presenter. Only call the methods
+    # which the presenter can handle.
+    #
+    # @param [ Hash ] value The attributes
+    #
+    def attributes=(values)
+      return unless values
+
+      @_attributes = values # memoize them for the callbacks
+
+      run_callbacks :set_attributes do
+        _values = values.stringify_keys
+
+        self.setters.each do |name|
+          if _values.has_key?(name)
+            _options = self.property_options[name] || {}
+
+            if _options[:if].blank? || self.instance_eval(&_options[:if])
+              self.send(:"#{name}=", _values[name])
+            end
+          end
+        end
+      end
+    end
+
+    # Build the hash of the values of all the properties.
+    #
+    # @param [ Array ] methods (Optional) List of methods instead of using the default getters
+    #
+    # @return [ Hash ] The "attributes" of the object
+    #
+    def as_json(methods = nil)
+      methods ||= self.getters
+      {}.tap do |hash|
+        methods.each do |meth|
+          _options = self.property_options[meth]
+
+          if _options[:if].blank? || self.instance_eval(&_options[:if])
+            value = self.send(meth.to_sym)
+
+            if !value.nil? || (_options && !!_options[:allow_nil])
+              hash[meth] = value
+            end
+          end
+        end
+      end
+    end
+
+    # Return the list of getters.
+    #
+    # @return [ List ] Array of method names
+    #
+    def getters
+      self.class.getters || []
+    end
+
+    # Return the list of setters.
+    #
+    # @return [ List ] Array of method names
+    #
+    def setters
+      self.class.setters || []
+    end
+
+    def property_options
+      self.class.property_options || {}
+    end
+
+    module ClassMethods
+
+      # Override inherited in order to copy the parent list
+      # of getters, setters and property options.
+      #
+      # @param [ Class ] subclass The subclass inheriting from the current class
+      #
+      def inherited(subclass)
+        subclass.getters = getters.clone if getters
+        subclass.setters = setters.clone if setters
+        subclass.property_options = property_options.clone if property_options
+
+        super
+      end
+
+      # Add multiple properties all in once.
+      # If th last property name is a hash, then it will be
+      # used as the options for all the other properties.
+      #
+      # @param [ Array ] args List of property names
+      #
+      def properties(*names)
+        options = names.last.is_a?(Hash) ? names.pop : {}
+
+        names.each do |name|
+          property(name, options)
+        end
+      end
+
+      # Add a property to the current instance. It creates getter/setter methods
+      # related to that property. By default, the getter and setter are bound
+      # to the source object.
+      #
+      # @param [ String ] name The name of the property
+      # @param [ Hash ] options The options related to the property.
+      #
+      def property(name, options = {})
+        aliases     = [*options[:alias]]
+        collection  = options[:collection] == true
+
+        (@property_options ||= {})[name.to_s] = options
+
+        unless options[:only_setter] == true
+          define_getter(name, collection)
+        end
+
+        unless options[:only_getter] == true
+          define_setter(name, aliases)
+        end
+      end
+
+      # Add a collection to the current instance. It creates getter/setter
+      # mapped to the collection of the source object.
+      #
+      # @param [ String ] name The name of the collection
+      # @param [ Hash ] options The options related to the collection (:alias)
+      #
+      def collection(name, options = {})
+        property(name, options.merge(collection: true, type: 'Array'))
+      end
+
+      def define_getter(name, collection = false)
+        (@getters ||= []) << name.to_s
+
+        class_eval <<-EOV
+          def #{name}
+            if #{collection.to_s}
+              list = self.__source.send(:#{name})
+              list ? list.map(&:as_json) : []
+            else
+              self.__source.send(:#{name})
+            end
+          end
+        EOV
+      end
+
+      def define_setter(name, aliases = [])
+        (@setters ||= []) << name.to_s
+        @setters += aliases.map(&:to_s)
+
+        class_eval <<-EOV
+          def #{name}=(value)
+            self.__source.send(:#{name}=, value)
+          end
+        EOV
+
+        aliases.each do |_name|
+          class_eval <<-EOV
+            def #{_name}=(value)
+              self.#{name} = value
+            end
+          EOV
+        end
+      end
+
+      # Get the name of the property for which
+      # the property passed in parameter is an alias.
+      #
+      # @param [ String ] alias_name Name of the alias
+      #
+      # @return [ String ] The original property
+      #
+      def alias_of(alias_name)
+        self.setters.find do |name|
+          list = [*(self.property_options[name] || {})[:alias]] || []
+          list.include?(alias_name.to_sym)
+        end
+      end
+
+
+    end # ClassMethods
+
+  end # Presentable
+end # Locomotive

data/lib/locomotive/render.rb

@@ -5,31 +5,51 @@ module Locomotive
 
     protected
 
-    # Render a Locomotive page from the request fullpath and the current site.
-    # If the page corresponds to a redirect, then a 301 redirection is made.
+    # Render a Locomotive page from the the current site and both the params[:page] / params[:page_path]
+    # attributes OR the request fullpath if those params are not present.
+    # If the page corresponds to a redirect, then a 301 or 302 redirection is made.
+    # If the page is templatized, the target content entry is retrieved and attached to the
+    # Liquid context.
     #
-    def render_locomotive_page
+    # @param [ String ] path The path can be forced (optional)
+    # @param [ Hash ] assigns The liquid context passed to the page can be enhanced by assigns coming from the controller for instance.
+    #
+    def render_locomotive_page(path = nil, assigns = {})
       if request.fullpath =~ /^\/#{Locomotive.mounted_on}\//
-        render :template => '/locomotive/errors/404', :layout => '/locomotive/layouts/not_logged_in', :status => :not_found
+        render template: '/locomotive/errors/404', layout: '/locomotive/layouts/not_logged_in', status: :not_found
       else
-        @page = locomotive_page
+        @page ||= self.locomotive_page(path)
 
-        redirect_to(@page.redirect_url, :status => 301) and return if @page.present? && @page.redirect?
+        if @page.present? && @page.redirect?
+          self.redirect_to_locomotive_page and return
+        end
 
         render_no_page_error and return if @page.nil?
 
-        output = @page.render(locomotive_context)
+        output = @page.render(self.locomotive_context(assigns))
 
         self.prepare_and_set_response(output)
       end
     end
 
+    # Redirect to the url given by the redirect_url field of the
+    # Locomotive page. If we are in the editing mode, the "_edit" prefix
+    # will be added as well.
+    #
+    def redirect_to_locomotive_page
+      redirect_url = @page.redirect_url
+
+      redirect_url = "#{redirect_url}/_edit" if self.editing_page?
+
+      redirect_to(redirect_url, status: @page.redirect_type)
+    end
+
     # Render the page which tells that no page exists.
     # This case should not happen since all the sites contains
     # the "Page Not Found" page.
     #
     def render_no_page_error
-      render :template => '/locomotive/errors/no_page', :layout => false
+      render template: 'locomotive/errors/no_page', layout: false, status: 404
     end
 
     # Prepare and set the response object for the Locomotive page retrieved
@@ -46,7 +66,7 @@ module Locomotive
       response.headers['Editable']      = 'true' unless self.editing_page? || current_locomotive_account.nil?
 
       if @page.with_cache?
-        fresh_when :etag => @page, :last_modified => @page.updated_at.utc, :public => true
+        fresh_when etag: @page, last_modified: @page.updated_at.utc, public: true
 
         if @page.cache_strategy != 'simple' # varnish
           response.headers['Editable']      = ''
@@ -54,7 +74,7 @@ module Locomotive
         end
       end
 
-      render :text => output, :layout => false, :status => page_status unless performed?
+      render text: output, layout: false, status: page_status unless performed?
     end
 
     # Tell if the current Locomotive page is being edited.
@@ -76,19 +96,25 @@ module Locomotive
 
     # Get the Locomotive page matching the request and scoped by the current Locomotive site
     #
+    # @param [ String ] path An optional path overriding the default default behaviour to get a page
+    #
     # @return [ Object ] The Locomotive::Page
     #
-    def locomotive_page
-      current_site.fetch_page self.locomotive_page_path, current_locomotive_account.present?
+    def locomotive_page(path = nil)
+      # TODO: params[:path] is more consistent
+      path ||= (params[:path] || params[:page_path] || request.fullpath).clone
+
+      path = self.sanitize_locomotive_page_path(path)
+
+      current_site.fetch_page path, current_locomotive_account.present?
     end
 
-    # Build the path that can be understood by Locomotive in order to retrieve
+    # Clean the path that can be understood by Locomotive in order to retrieve
     # the matching Locomotive page (see the locomotive_page method)
     #
     # @return [ String ] The path to the Locomotive page
     #
-    def locomotive_page_path
-      path = (params[:path] || params[:page_path] || request.fullpath).clone # TODO: params[:path] is more consistent
+    def sanitize_locomotive_page_path(path)
       path = path.split('?').first # take everything before the query string or the lookup fails
       path.gsub!(/\.[a-zA-Z][a-zA-Z0-9]{2,}$/, '') # remove the page extension
       path.gsub!(/^\//, '') # remove the leading slash
@@ -101,16 +127,22 @@ module Locomotive
     # Build the Liquid context used to render the Locomotive page. It
     # stores both assigns and registers.
     #
-    # @return [ Object ] A Liquid::Context object.
+    # @param [ Hash ] other_assigns Assigns coming for instance from the controler (optional)
+    #
+    # @return [ Object ] A new instance of the Liquid::Context class.
     #
-    def locomotive_context
+    def locomotive_context(other_assigns = {})
       assigns = self.locomotive_default_assigns
 
+      # proxy drops
       assigns.merge!(Locomotive.config.context_assign_extensions)
 
-      assigns.merge!(flash.to_hash.stringify_keys) # data from public submissions
+      # process data from the session
+      assigns.merge!(self.locomotive_flash_assigns)
 
-      if @page.templatized? # add instance from content type
+      assigns.merge!(other_assigns)
+
+      if defined?(@page) && @page.templatized? # add instance from content type
         content_entry = @page.content_entry.to_liquid
         ['content_entry', 'entry', @page.target_entry_name].each do |key|
           assigns[key] = content_entry
@@ -121,6 +153,26 @@ module Locomotive
       ::Liquid::Context.new({}, assigns, self.locomotive_default_registers, false)
     end
 
+    # Get the assigns from the flash object (session). For instance, once
+    # a new content entry has been submitted, the new instance is available
+    # after redirecting the user to the success locomotive page.
+    #
+    # @return [ Hash ] The sanitized assigns from the flash object
+    #
+    def locomotive_flash_assigns
+      assigns = flash.to_hash.stringify_keys
+
+      if entry_id = assigns.delete('submitted_entry_id')
+        entry = Locomotive::ContentEntry.find(entry_id) rescue nil
+
+        if entry
+          assigns[entry.content_type.slug.singularize] = entry.to_liquid
+        end
+      end
+
+      assigns
+    end
+
     # Return the default Liquid assigns used inside the Locomotive Liquid context
     #
     # @return [ Hash ] The default liquid assigns object
@@ -151,11 +203,11 @@ module Locomotive
     #
     def locomotive_default_registers
       {
-        :controller     => self,
-        :site           => current_site,
-        :page           => @page,
-        :inline_editor  => self.editing_page?,
-        :current_locomotive_account => current_locomotive_account
+        controller:     self,
+        site:           current_site,
+        page:           @page,
+        inline_editor:  self.editing_page?,
+        current_locomotive_account: current_locomotive_account
       }
     end