locomotive_cms 1.0.0.beta.2 → 2.0.0.rc1

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

@@ -0,0 +1,86 @@
+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 domains=(array)
+            array = [] if array.blank?; super(array)
+          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,79 @@
+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
+
+    def as_json(options = {})
+      Locomotive::MembershipPresenter.new(self, options).as_json
+    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

data/app/models/locomotive/page.rb

@@ -0,0 +1,124 @@
+module Locomotive
+  class Page
+
+    include Locomotive::Mongoid::Document
+
+    ## Extensions ##
+    include Extensions::Page::Tree
+    include Extensions::Page::EditableElements
+    include Extensions::Page::Parse
+    include Extensions::Page::Render
+    include Extensions::Page::Templatized
+    include Extensions::Page::Redirect
+    include Extensions::Page::Listed
+    include Extensions::Shared::Seo
+
+    ## fields ##
+    field :title,               :localize => true
+    field :slug,                :localize => true
+    field :fullpath,            :localize => true
+    field :handle
+    field :raw_template,        :localize => true
+    field :locales,             :type => Array
+    field :published,           :type => Boolean, :default => false
+    field :cache_strategy,      :default => 'none'
+
+    ## associations ##
+    belongs_to :site, :class_name => 'Locomotive::Site'
+
+    ## indexes ##
+    index :site_id
+    index :parent_id
+    index [[:fullpath, Mongo::ASCENDING], [:site_id, Mongo::ASCENDING]]
+
+    ## callbacks ##
+    after_initialize    :set_default_raw_template
+    before_validation   :normalize_slug
+    before_save         :build_fullpath
+    before_save         :record_current_locale
+    before_destroy      :do_not_remove_index_and_404_pages
+
+    ## validations ##
+    validates_presence_of     :site, :title, :slug
+    validates_uniqueness_of   :slug, :scope => [:site_id, :parent_id]
+    validates_uniqueness_of   :handle, :allow_blank => true
+    validates_exclusion_of    :slug, :in => Locomotive.config.reserved_slugs, :if => Proc.new { |p| p.depth <= 1 }
+
+    ## named scopes ##
+    scope :latest_updated,      :order_by => [[:updated_at, :desc]], :limit => Locomotive.config.ui.latest_entries_nb
+    scope :root,                :where => { :slug => 'index', :depth => 0 }
+    scope :not_found,           :where => { :slug => '404', :depth => 0 }
+    scope :published,           :where => { :published => true }
+    scope :fullpath,            lambda { |fullpath| { :where => { :fullpath => fullpath } } }
+    scope :handle,              lambda { |handle| { :where => { :handle => handle } } }
+    scope :minimal_attributes,  :only => %w(title slug fullpath position depth published templatized redirect listed parent_id created_at updated_at)
+
+    ## methods ##
+
+    def index?
+      self.slug == 'index' && self.depth.to_i == 0
+    end
+
+    def not_found?
+      self.slug == '404' && self.depth.to_i == 0
+    end
+
+    def index_or_not_found?
+      self.index? || self.not_found?
+    end
+
+    def with_cache?
+      self.cache_strategy != 'none'
+    end
+
+    def to_liquid
+      Locomotive::Liquid::Drops::Page.new(self)
+    end
+
+    def to_presenter
+      Locomotive::PagePresenter.new(self)
+    end
+
+    def as_json(options = {})
+      self.to_presenter.as_json
+    end
+
+    protected
+
+    def do_not_remove_index_and_404_pages
+      return if self.site.nil? || self.site.destroyed?
+
+      if self.index? || self.not_found?
+        self.errors[:base] << ::I18n.t('errors.messages.protected_page')
+      end
+
+      self.errors.empty?
+    end
+
+    def normalize_slug
+      self.slug = self.title.clone if self.slug.blank? && self.title.present?
+      self.slug.permalink! if self.slug.present?
+    end
+
+    def set_default_raw_template
+      self.raw_template ||= ::I18n.t('attributes.defaults.pages.other.body')
+    end
+
+    def build_fullpath
+      if self.index? || self.not_found?
+        self.fullpath = self.slug
+      else
+        slugs = self.ancestors_and_self.map(&:slug)
+        slugs.shift unless slugs.size == 1
+        self.fullpath = File.join slugs.compact
+      end
+    end
+
+    def record_current_locale
+      self.locales ||= []
+      self.locales << ::Mongoid::Fields::I18n.locale
+      self.locales.uniq!
+    end
+
+  end
+end

data/app/models/locomotive/site.rb

@@ -0,0 +1,82 @@
+module Locomotive
+  class Site
+
+    include Locomotive::Mongoid::Document
+
+    ## Extensions ##
+    extend  Extensions::Site::SubdomainDomains
+    extend  Extensions::Site::FirstInstallation
+    include Extensions::Shared::Seo
+    include Extensions::Site::Locales
+
+    ## fields ##
+    field :name
+    field :robots_txt
+
+    ## associations ##
+    references_many :pages,           :class_name => 'Locomotive::Page',          :validate => false
+    references_many :snippets,        :class_name => 'Locomotive::Snippet',       :dependent => :destroy, :validate => false
+    references_many :theme_assets,    :class_name => 'Locomotive::ThemeAsset',    :dependent => :destroy, :validate => false
+    references_many :content_assets,  :class_name => 'Locomotive::ContentAsset',  :dependent => :destroy, :validate => false
+    references_many :content_types,   :class_name => 'Locomotive::ContentType',   :dependent => :destroy, :validate => false
+    embeds_many     :memberships,     :class_name => 'Locomotive::Membership'
+
+    ## validations ##
+    validates_presence_of :name
+
+    ## callbacks ##
+    after_create    :create_default_pages!
+    after_destroy   :destroy_pages
+
+    ## behaviours ##
+    enable_subdomain_n_domains_if_multi_sites
+    accepts_nested_attributes_for :memberships, :allow_destroy => true
+
+    ## methods ##
+
+    def all_pages_in_once
+      Page.quick_tree(self)
+    end
+
+    def accounts
+      Account.criteria.in(:_id => self.memberships.map(&:account_id))
+    end
+
+    def admin_memberships
+      self.memberships.find_all { |m| m.admin? }
+    end
+
+    def to_liquid
+      Locomotive::Liquid::Drops::Site.new(self)
+    end
+
+    def as_json(options = {})
+      Locomotive::SitePresenter.new(self, options).as_json
+    end
+
+    protected
+
+    # FIXME: Currently there is no t/translate method on the I18n module
+    # Extensions::Site::I18n which is breaking the testing. The
+    # namespaced ::I18n should be changed to just I18n when the t()
+    # method is available
+    def create_default_pages!
+      ::Mongoid::Fields::I18n.with_locale(self.default_locale) do
+        %w{index 404}.each do |slug|
+          self.pages.create({
+            :slug         => slug,
+            :title        => ::I18n.t("attributes.defaults.pages.#{slug}.title"),
+            :raw_template => ::I18n.t("attributes.defaults.pages.#{slug}.body"),
+            :published    => true
+          })
+        end
+      end
+    end
+
+    def destroy_pages
+      # pages is a tree so we just need to delete the root (as well as the page not found page)
+      self.pages.root.first.try(:destroy) && self.pages.not_found.first.try(:destroy)
+    end
+
+  end
+end

data/app/models/locomotive/snippet.rb

@@ -0,0 +1,76 @@
+module Locomotive
+  class Snippet
+
+    include Locomotive::Mongoid::Document
+
+    ## fields ##
+    field :name
+    field :slug
+    field :template, :localize => true
+
+    ## associations ##
+    referenced_in :site, :class_name => 'Locomotive::Site'
+
+    ## callbacks ##
+    before_validation :normalize_slug
+    after_save        :update_templates
+    after_destroy     :update_templates
+
+    ## validations ##
+    validates_presence_of   :site, :name, :slug, :template
+    validates_uniqueness_of :slug, :scope => :site_id
+
+    ## behaviours ##
+    attr_protected  :id
+    attr_accessible :name, :slug, :template
+
+    ## methods ##
+
+    def to_presenter
+      Locomotive::SnippetPresenter.new(self)
+    end
+
+    def as_json(options = {})
+      self.to_presenter.as_json
+    end
+
+    protected
+
+    def normalize_slug
+      self.slug = self.name.clone if self.slug.blank? && self.name.present?
+      self.slug.permalink! if self.slug.present?
+    end
+
+    def update_templates
+      return unless (self.site rescue false) # not run if the site is being destroyed
+
+      pages = self.site.pages.any_in(:snippet_dependencies => [self.slug]).to_a
+
+      pages.each do |page|
+        self._change_snippet_inside_template(page.template.root)
+
+        page.send(:_serialize_template)
+
+        Page.without_callback(:save, :after, :update_template_descendants) do
+          page.save(:validate => false)
+        end
+      end
+    end
+
+    def _change_snippet_inside_template(node)
+      case node
+      when Locomotive::Liquid::Tags::Snippet
+        node.refresh(self) if node.slug == self.slug
+      when Locomotive::Liquid::Tags::InheritedBlock
+        _change_snippet_inside_template(node.parent) if node.parent
+      end
+      # Walk the children of this entry if they're available.
+      if node.respond_to?(:nodelist)
+        (node.nodelist || []).each do |child|
+          self._change_snippet_inside_template(child)
+        end
+      end
+    end
+
+  end
+end