tribeca_cms 0.1.1

data/app/models/locomotive/extensions/page/tree.rb

@@ -0,0 +1,133 @@
+module Locomotive
+  module Extensions
+    module Page
+      module Tree
+
+        extend ActiveSupport::Concern
+
+        included do
+          include ::Mongoid::Tree
+          include ::Mongoid::Tree::Ordering
+
+          ## fields ##
+          field :depth, :type => Integer, :default => 0
+
+          ## callbacks ##
+          before_save     :persist_depth
+          before_destroy  :delete_descendants
+
+          ## indexes ##
+          index :position
+          index [[:depth, Mongo::ASCENDING], [:position, Mongo::ASCENDING]]
+
+          alias_method_chain :rearrange, :identity_map
+          alias_method_chain :rearrange_children, :identity_map
+          alias_method_chain :siblings_and_self, :scoping
+        end
+
+        module ClassMethods
+
+          # Returns the tree of pages from the site with the most minimal amount of queries.
+          # This method should only be used for read-only purpose since
+          # the mongodb returns the minimal set of required attributes to build
+          # the tree.
+          #
+          # @param [ Locomotive::Site ] site The site owning the pages
+          #
+          # @return [ Array ] The first array of pages (depth = 0)
+          #
+          def quick_tree(site, minimal_attributes = true)
+            pages = (minimal_attributes ? site.pages.unscoped.minimal_attributes : site.pages.unscoped).order_by([:depth.asc, :position.asc]).to_a
+
+            tmp = []
+
+            while !pages.empty?
+              tmp << _quick_tree(pages.delete_at(0), pages)
+            end
+
+            tmp
+          end
+
+          #:nodoc:
+          def _quick_tree(current_page, pages)
+            i, children = 0, []
+
+            while !pages.empty?
+              page = pages[i]
+
+              break if page.nil?
+
+              if page.parent_id == current_page.id
+                page = pages.delete_at(i)
+
+                children << _quick_tree(page, pages)
+              else
+                i += 1
+              end
+            end
+
+            current_page.instance_eval do
+              def children=(list); @children = list; end
+              def children; @children || []; end
+            end
+
+            current_page.children = children
+
+            current_page
+          end
+
+        end
+
+        # Returns the children of this node but with the minimal set of required attributes
+        #
+        # @return [ Array ] The children pages ordered by their position
+        #
+        def children_with_minimal_attributes(attrs = [])
+          self.children.minimal_attributes(attrs)
+        end
+
+        # Assigns the new position of each child of this node.
+        #
+        # @param [ Array ] ids The ordered list of page ids (string)
+        #
+        def sort_children!(ids)
+          cached_children = self.children.to_a
+          ids.each_with_index do |id, position|
+            child = cached_children.detect { |p| p._id == BSON::ObjectId(id) }
+            child.position = position
+            child.save
+          end
+        end
+
+        ##
+        # Returns this document's siblings and itself, all scoped by the site
+        #
+        # @return [Mongoid::Criteria] Mongoid criteria to retrieve the document's siblings and itself
+        def siblings_and_self_with_scoping
+          base_class.where(:parent_id => self.parent_id, :site_id => self.site_id)
+        end
+
+        def depth
+          self.parent_ids.count
+        end
+
+        protected
+
+        def rearrange_with_identity_map
+          ::Mongoid::IdentityMap.clear
+          rearrange_without_identity_map
+        end
+
+        def rearrange_children_with_identity_map
+          self.children.reset
+          rearrange_children_without_identity_map
+        end
+
+        def persist_depth
+          self.depth = self.parent_ids.count
+        end
+
+      end
+    end
+  end
+end

data/app/models/locomotive/extensions/shared/seo.rb

@@ -0,0 +1,16 @@
+module Locomotive
+  module Extensions
+    module Shared
+      module Seo
+        extend ActiveSupport::Concern
+
+        included do
+          field :seo_title,         :type => String, :localize => true
+          field :meta_keywords,     :type => String, :localize => true
+          field :meta_description,  :type => String, :localize => true
+        end
+
+      end # Seo
+    end # Shared
+  end # Extensions
+end # Locomotive

data/app/models/locomotive/extensions/site/first_installation.rb

@@ -0,0 +1,20 @@
+module Locomotive
+  module Extensions
+    module Site
+      module FirstInstallation
+
+        # only called during the installation workflow, just after the admin account has been created
+        def create_first_one(attributes)
+          site = self.new(attributes)
+
+          site.memberships.build :account => Account.first, :role => 'admin'
+
+          site.save
+
+          site
+        end
+
+      end
+    end
+  end
+end

data/app/models/locomotive/extensions/site/locales.rb

@@ -0,0 +1,112 @@
+module Locomotive
+  module Extensions
+    module Site
+      module Locales
+
+        extend ActiveSupport::Concern
+
+        included do
+
+          ## fields ##
+          field :locales, :type => 'RawArray', :default => []
+
+          ## validations ##
+          validate :can_not_remove_default_locale
+
+          ## callbacks ##
+          after_validation  :add_default_locale
+          before_update     :verify_localized_default_pages_integrity
+
+        end
+
+        # Tell if the site serves other locales than the default one.
+        #
+        # @return [ Boolean ] True if the number of locales is greater than 1
+        #
+        def localized?
+          self.locales.size > 1
+        end
+
+        # Returns the fullpath of a page in the context of the current locale (I18n.locale)
+        # or the one passed in parameter. It also depends on the default site locale.
+        #
+        # Ex:
+        #   For a site with its default site locale to 'en'
+        #   # context 1: i18n.locale is 'en'
+        #   contact_us.fullpath <= 'contact_us'
+        #
+        #   # context 2: i18n.locale is 'fr'
+        #   contact_us.fullpath <= 'fr/nous_contacter'
+        #
+        # @params [ Page ] page The page we want the localized fullpath
+        # @params [ String ] locale The optional locale in place of the current one
+        #
+        # @returns [ String ] The localized fullpath according to the current locale
+        #
+        def localized_page_fullpath(page, locale = nil)
+          return nil if page.fullpath_translations.blank?
+
+          locale = (locale || I18n.locale).to_s
+          fullpath = page.fullpath_translations[locale] || page.fullpath_translations[self.default_locale]
+
+          if locale == self.default_locale.to_s # no need to specify the locale
+            page.index? ? '' : fullpath
+          elsif page.index? # avoid /en/index or /fr/index, prefer /en or /fr instead
+            locale
+          else
+            File.join(locale, fullpath)
+          end
+        end
+
+        def locales=(array)
+          array = [] if array.blank?; super(array)
+        end
+
+        def default_locale
+          self.locales.first || Locomotive.config.site_locales.first
+        end
+
+        def default_locale_was
+          self.locales_was.first || Locomotive.config.site_locales.first
+        end
+
+        def locale_fallbacks(locale)
+          [locale.to_s] + (locales - [locale.to_s])
+        end
+
+        protected
+
+        def add_default_locale
+          self.locales = [Locomotive.config.site_locales.first] if self.locales.blank?
+        end
+
+        def can_not_remove_default_locale
+          if self.persisted? && !self.locales.include?(self.default_locale_was)
+            self.errors.add :locales, I18n.t(:default_locale_removed, :scope => [:errors, :messages, :site])
+          end
+        end
+
+        def verify_localized_default_pages_integrity
+          if self.persisted? && self.locales_changed?
+            self.pages.where(:"slug.#{self.default_locale_was}".in => %w(index 404), :depth => 0).each do |page|
+              modifications = { 'title' => {}, 'slug' => {}, 'fullpath' => {}, 'locales' => self.locales }
+
+              self.locales.each do |locale|
+                slug  = page.attributes['slug'][self.default_locale_was]
+                title = page.attributes['title'][locale] || ::I18n.t("attributes.defaults.pages.#{slug}.title", :locale => locale)
+
+                modifications['slug'][locale]     = slug
+                modifications['fullpath'][locale] = slug
+                modifications['title'][locale]    = title
+              end
+
+              page.collection.update({ :_id => page._id }, { '$set' => modifications })
+            end
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/app/models/locomotive/extensions/site/subdomain_domains.rb

@@ -0,0 +1,91 @@
+module Locomotive
+  module Extensions
+    module Site
+      module SubdomainDomains
+
+        def enable_subdomain_n_domains_if_multi_sites
+          # puts "multi_sites? #{Locomotive.config.multi_sites?} / manage_domains? #{Locomotive.config.manage_domains?} / heroku? #{Locomotive.heroku?} / bushido? #{Locomotive.bushido?}"
+
+          if Locomotive.config.multi_sites? || Locomotive.config.manage_domains?
+
+            ## fields ##
+            field :subdomain
+            field :domains, :type => Array, :default => []
+
+            ## indexes
+            index :domains
+
+            ## validations ##
+            validates_presence_of     :subdomain
+            validates_uniqueness_of   :subdomain
+            validates_exclusion_of    :subdomain, :in => Locomotive.config.reserved_subdomains
+            validates_format_of       :subdomain, :with => Locomotive::Regexps::SUBDOMAIN, :allow_blank => true
+            validate                  :domains_must_be_valid_and_unique
+
+            ## callbacks ##
+            before_save :add_subdomain_to_domains
+
+            ## named scopes ##
+            scope :match_domain, lambda { |domain| { :any_in => { :domains => [*domain] } } }
+            scope :match_domain_with_exclusion_of, lambda { |domain, site|
+              { :any_in => { :domains => [*domain] }, :where => { :_id.ne => site.id } }
+            }
+
+            send :include, InstanceMethods
+          end
+        end
+
+        module InstanceMethods
+
+          def subdomain=(subdomain)
+            super(subdomain.try(:downcase))
+          end
+
+          def domains=(array)
+            array.reject!(&:blank?)
+            array = [] if array.blank?; super(array.map(&:downcase))
+          end
+
+          def add_subdomain_to_domains
+            self.domains ||= []
+            (self.domains << self.full_subdomain).uniq!
+          end
+
+          def domains_without_subdomain
+            (self.domains || []) - [self.full_subdomain_was] - [self.full_subdomain]
+          end
+
+          def domains_with_subdomain
+            ((self.domains || []) + [self.full_subdomain]).uniq
+          end
+
+          def full_subdomain
+            "#{self.subdomain}.#{Locomotive.config.domain}"
+          end
+
+          def full_subdomain_was
+            "#{self.subdomain_was}.#{Locomotive.config.domain}"
+          end
+
+          protected
+
+          def domains_must_be_valid_and_unique
+            return if self.domains.empty?
+
+            self.domains_without_subdomain.each do |domain|
+              if self.class.match_domain_with_exclusion_of(domain, self).any?
+                self.errors.add(:domains, :domain_taken, :value => domain)
+              end
+
+              if not domain =~ Locomotive::Regexps::DOMAIN
+                self.errors.add(:domains, :invalid_domain, :value => domain)
+              end
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/app/models/locomotive/membership.rb

@@ -0,0 +1,75 @@
+module Locomotive
+  class Membership
+
+    include Locomotive::Mongoid::Document
+
+    ## fields ##
+    field :role, :default => 'author'
+
+    ## associations ##
+    referenced_in :account, :class_name => 'Locomotive::Account', :validate => false
+    embedded_in   :site,    :class_name => 'Locomotive::Site',    :inverse_of => :memberships
+
+    ## validations ##
+    validates_presence_of :account
+    validate              :can_change_role, :if => :role_changed?
+
+    ## callbacks ##
+    before_save :define_role
+
+    ## methods ##
+
+    Ability::ROLES.each do |_role|
+      define_method("#{_role}?") do
+        self.role == _role
+      end
+    end
+
+    def email; @email; end
+
+    def email=(email)
+      @email = email
+      self.account = Locomotive::Account.where(:email => email).first
+    end
+
+    def process!
+      if @email.blank?
+        self.errors.add_on_blank(:email)
+        :error
+      elsif self.account.blank?
+        :create_account
+      elsif self.site.memberships.any? { |m| m.account_id == self.account_id && m._id != self._id }
+        self.errors.add(:base, 'Already created')
+        :already_created
+      else
+        self.save
+        :save_it
+      end
+    end
+
+    def ability
+      @ability ||= Ability.new(self.account, self.site)
+    end
+
+    protected
+
+    def define_role
+      self.role = Ability::ROLES.include?(role.downcase) ? role.downcase : Ability::ROLES.first
+    end
+
+    # Users should not be able to set the role of another user to be higher than
+    # their own. A designer for example should not be able to set another user to
+    # be an administrator
+    def can_change_role
+      current_site       = Thread.current[:site]
+      current_membership = current_site.memberships.where(:account_id => Thread.current[:account].id).first if current_site.present?
+
+      if current_membership.present?
+        # The role cannot be set higher than the current one (we use the index in
+        # the roles array to check role presidence)
+        errors.add(:role, :invalid) if Ability::ROLES.index(role) < Ability::ROLES.index(current_membership.role)
+      end
+    end
+
+  end
+end