tribeca_cms 0.1.1

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 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/patches.rb

@@ -0,0 +1,106 @@
+# encoding: utf-8
+
+require 'mongoid'
+
+module Mongoid#:nodoc:
+
+  module Document #:nodoc:
+    def as_json(options = {})
+      attrs = super(options)
+      attrs["id"] = attrs["_id"]
+      attrs
+    end
+  end
+
+  module Fields #:nodoc:
+    module Internal #:nodoc:
+      class RawArray < Mongoid::Fields::Internal::Array
+        def resizable?; false; end
+      end
+    end
+
+    class RawArray < ::Array; end
+  end
+
+  class Criteria
+    def to_liquid
+      Locomotive::Liquid::Drops::ProxyCollection.new(self)
+    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 Validations #:nodoc:
+
+    class ExclusionValidator < ActiveModel::Validations::ExclusionValidator
+      include Localizable
+    end
+
+    class UniquenessValidator < ActiveModel::EachValidator
+
+      def to_validate_with_localization(document, attribute, value)
+        field = document.fields[attribute.to_s]
+        if field.try(:localized?)
+          # no need of the translations, just the current value
+          value = document.send(attribute.to_sym)
+        end
+        to_validate_without_localization(document, attribute, value)
+      end
+
+      alias_method_chain :to_validate, :localization
+
+    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,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,212 @@
+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
+
+      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)
+      run_callbacks :set_attributes do
+        return unless values
+
+        _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|
+          value     = self.send(meth.to_sym)
+          _options  = self.property_options[meth]
+
+          if _options[:if].blank? || self.instance_eval(&_options[:if])
+            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))
+      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