locomotivecms 3.0.0.pre.alpha

data/lib/locomotive/haml.rb

@@ -0,0 +1 @@
+# patches for haml here

data/lib/locomotive/kaminari.rb

@@ -0,0 +1,36 @@
+# require 'kaminari'
+
+# module Kaminari
+
+#   class PaginatableArray < Array
+#     def to_liquid(options = {})
+#       {
+#         collection:       to_a,
+#         current_page:     current_page,
+#         previous_page:    first_page? ? nil : current_page - 1,
+#         next_page:        last_page? ? nil : current_page + 1,
+#         total_entries:    total_count,
+#         total_pages:      num_pages,
+#         per_page:         limit_value
+#       }
+#     end
+#   end
+
+#   module PageScopeMethods
+
+#    def to_liquid(options = {})
+#      {
+#        collection:       to_a,
+#        current_page:     current_page,
+#        previous_page:    first_page? ? nil : current_page - 1,
+#        total_entries:    total_count,
+#        per_page:         limit_value
+#      }.tap do |hash|
+#        # note: very important to avoid extra and useless mongodb requests
+#        hash[:total_pages] = (hash[:total_entries].to_f / limit_value).ceil
+#        hash[:next_page]   = current_page >= hash[:total_pages] ? nil : current_page + 1
+#      end
+#    end
+
+#   end
+# end

data/lib/locomotive/logger.rb

@@ -0,0 +1,11 @@
+module Locomotive
+  module Logger
+
+    def self.method_missing(meth, message, &block)
+      if Locomotive.config.enable_logs == true
+        Rails.logger.send(meth, "[LocomotiveCMS] #{message}")
+      end
+    end
+
+  end
+end

data/lib/locomotive/middlewares.rb

@@ -0,0 +1,2 @@
+require 'locomotive/middlewares/permalink'
+require 'locomotive/middlewares/site'

data/lib/locomotive/middlewares/permalink.rb

@@ -0,0 +1,22 @@
+module Locomotive
+  module Middlewares
+    class Permalink
+
+      def initialize(app, opts = {})
+        @app = app
+      end
+
+      def call(env)
+        if env['PATH_INFO'] =~ /^#{Locomotive.mounted_on}\/_permalink.json/
+          request     = Rack::Request.new(env)
+          underscore  = request.params['underscore'] == '1'
+          value       = request.params['string'].try(:permalink, underscore)
+
+          [200, {}, [{ value: value }.to_json]]
+        else
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/locomotive/middlewares/site.rb

@@ -0,0 +1,58 @@
+module Locomotive
+  module Middlewares
+    class Site
+
+      def initialize(app, opts = {})
+        @app = app
+      end
+
+      def call(env)
+        env['locomotive.site'] = env['steam.site'] = fetch_site(env)
+        @app.call(env)
+      end
+
+      def fetch_site(env)
+        request = Rack::Request.new(env)
+        handle  = site_handle(request)
+
+        return nil if handle == 'api'
+
+        Locomotive.log "[fetch site] host = #{request.host} / site_handle = #{handle.inspect}"
+
+        if handle
+          # The site is not rendered from a domain but from the back-office
+          # we need to get:
+          # - the path of "mouting point" (basically: locomotive/:handle/preview)
+          # - the real path of the page
+          #
+          # FIXME: move that in a different middleware
+          mounted_on = "#{Locomotive.mounted_on}/#{handle}/preview"
+
+          env['locomotive.mounted_on']  = env['steam.mounted_on'] = mounted_on
+          env['locomotive.path']        = request.path_info.gsub(mounted_on, '')
+
+          Locomotive::Site.where(handle: handle).first
+        else
+          env['locomotive.path'] = request.path_info
+
+          Locomotive::Site.match_domain(request.host).first
+        end
+      end
+
+      def site_handle(request)
+        if handle = request.env['HTTP_X_LOCOMOTIVE_SITE_HANDLE']
+          return handle
+        elsif request.path_info =~ site_handle_regexp
+          return $1 if !Locomotive.config.reserved_site_handles.include?($1)
+        end
+
+        nil
+      end
+
+      def site_handle_regexp
+        @regexp ||= /#{Locomotive.mounted_on}\/([^\/]+)/o
+      end
+
+    end
+  end
+end

data/lib/locomotive/mongoid.rb

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

data/lib/locomotive/mongoid/document.rb

@@ -0,0 +1,19 @@
+module Locomotive
+  module Mongoid
+
+    module Document
+
+      extend ActiveSupport::Concern
+
+      included do
+        include ::Mongoid::Document
+        include ::Mongoid::Timestamps
+        include ::Mongoid::Attributes::Dynamic
+
+        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/patches.rb

@@ -0,0 +1,182 @@
+# encoding: utf-8
+
+require 'mongoid'
+
+class RawArray < ::Array
+  def resizable?; false; end
+end
+
+module BSON
+  class ObjectId
+    def to_json(*)
+      to_s.to_json
+    end
+    def as_json(*)
+      to_s.as_json
+    end
+  end
+end
+
+module Mongoid #:nodoc:
+
+  # FIXME: https://github.com/benedikt/mongoid-tree/issues/58
+  # We replace all the @_#{name} occurences by @_#{name}_ivar.
+  module Relations
+    module Accessors
+      def reset_relation_criteria(name)
+        if instance_variable_defined?("@_#{name}_ivar")
+          send(name).reset_unloaded
+        end
+      end
+      def set_relation(name, relation)
+        instance_variable_set("@_#{name}_ivar", relation)
+      end
+    end
+    def reload_relations
+      relations.each_pair do |name, meta|
+        if instance_variable_defined?("@_#{name}_ivar")
+          if _parent.nil? || instance_variable_get("@_#{name}_ivar") != _parent
+            remove_instance_variable("@_#{name}_ivar")
+          end
+        end
+      end
+    end
+  end
+  module Extensions
+    module Object
+      def ivar(name)
+        if instance_variable_defined?("@_#{name}_ivar")
+          return instance_variable_get("@_#{name}_ivar")
+        else
+          false
+        end
+      end
+      def remove_ivar(name)
+        if instance_variable_defined?("@_#{name}_ivar")
+          return remove_instance_variable("@_#{name}_ivar")
+        else
+          false
+        end
+      end
+    end
+  end
+
+  module Document #:nodoc:
+    def as_json(options = {})
+      attrs = super(options)
+      attrs['id'] = attrs['_id']
+      attrs
+    end
+  end
+
+  class Criteria
+    def without_sorting
+      clone.tap { |crit| crit.options.delete(:sort) }
+    end
+
+    # http://code.dblock.org/paging-and-iterating-over-large-mongo-collections
+    def each_by(by, &block)
+      idx = total = 0
+      set_limit = options[:limit]
+      while ((results = ordered_clone.limit(by).skip(idx)) && results.any?)
+        results.each do |result|
+          return self if set_limit and set_limit >= total
+          total += 1
+          yield result
+        end
+        idx += by
+      end
+      self
+    end
+
+    # Optimized version of the max aggregate method.
+    # It works efficiently only if the field is part of a MongoDB index.
+    # more here: http://stackoverflow.com/questions/4762980/getting-the-highest-value-of-a-column-in-mongodb
+    def indexed_max(field)
+      _criteria = criteria.order_by(field.to_sym.desc).only(field.to_sym)
+      selector  = _criteria.send(:selector_with_type_selection)
+      fields    = _criteria.options[:fields]
+      sort      = _criteria.options[:sort]
+
+      document = collection.find(selector).select(fields).sort(sort).limit(1).first
+      document ? document[field.to_s].to_i : nil
+    end
+
+    def to_liquid
+      Locomotive::Liquid::Drops::ProxyCollection.new(self)
+    end
+
+    private
+
+    def ordered_clone
+      options[:sort] ? clone : clone.asc(:_id)
+    end
+  end
+
+  module Findable
+    def indexed_max(field)
+      with_default_scope.indexed_max(field)
+    end
+  end
+
+  module Criterion
+    class Selector < Hash
+      # for some reason, the store method behaves differently than the []= one, causing regression bugs (query not localized)
+      alias :store :[]=
+    end
+  end
+
+  # without callback feature
+  # module Callbacks #:nodoc:
+  #   module ClassMethods #:nodoc:
+  #     def without_callback(*args, &block)
+  #       skip_callback(*args)
+  #       yield
+  #       set_callback(*args)
+  #     end
+  #   end
+  # end
+
+  # make the validators work with localized field
+  module Validatable #:nodoc:
+
+    class ExclusionValidator < ActiveModel::Validations::ExclusionValidator
+      include Localizable
+    end
+
+    module ClassMethods
+      def validates_exclusion_of(*args)
+        validates_with(ExclusionValidator, _merge_attributes(args))
+      end
+    end
+
+    module LocalizedEachValidator
+
+      # Performs validation on the supplied record. By default this will call
+      # +validates_each+ to determine validity therefore subclasses should
+      # override +validates_each+ with validation logic.
+      def validate(record)
+        attributes.each do |attribute|
+          field = record.fields[attribute.to_s]
+
+          # make sure that we use the localized value and not the translations when we test the allow_nil and allow_blank options
+          value = field.try(:localized?) ? record.send(attribute.to_sym) : record.read_attribute_for_validation(attribute)
+
+          next if (value.nil? && options[:allow_nil]) || (value.blank? && options[:allow_blank])
+
+          # use the translations of the localized field for the next part
+          value = record.read_attribute_for_validation(attribute) if field.try(:localized?)
+
+          validate_each(record, attribute, value)
+        end
+      end
+
+    end
+
+    [FormatValidator, LengthValidator, PresenceValidator, UniquenessValidator, ExclusionValidator].each do |klass|
+      klass.send(:include, LocalizedEachValidator)
+    end
+
+  end
+
+end

data/lib/locomotive/mongoid/presenter.rb

@@ -0,0 +1,76 @@
+# 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
+#       #
+#       # @return [ Object ] The document
+#       #
+#       def from_presenter(attributes = {})
+#         self.to_presenter.attributes = attributes
+#         self
+#       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