slices 1.0.0

data/app/models/attachment.rb

@@ -0,0 +1,11 @@
+class Attachment
+  include Mongoid::Document
+
+  belongs_to :asset
+
+  def as_json *args
+    attributes.as_json.merge asset: asset.as_json
+  end
+
+end
+

data/app/models/layout.rb

@@ -0,0 +1,44 @@
+class Layout
+  def self.all
+    files.map do |layout|
+      layout = layout.split('/').last.gsub(file_extension, '')
+      [layout.titleize, layout]
+    end
+  end
+
+  def self.files
+    files = []
+    SlicesController.view_paths.each do |resolver|
+      next if ignore_layout?(resolver.to_path)
+      query = File.join(resolver, 'layouts', "*#{file_extension}")
+      files.concat(Dir.glob(query))
+    end
+    files.reject do |file|
+      file.include?('admin.html.erb')
+    end.uniq.sort
+  end
+
+  def self.file_extension
+    '.html.erb'
+  end
+
+  def self.ignore_layout?(layout)
+    layout.include?(Slices.gem_path) && Rails.root.to_s != Slices.gem_path
+  end
+
+  def initialize(name)
+    @name = name
+  end
+
+  def path
+    self.class.files.select do |path|
+      path.split('/').last == @name + self.class.file_extension
+    end.first
+  end
+
+  def containers
+    parser = Slices::ContainerParser.new(path)
+    parser.parse
+  end
+
+end

data/app/models/page.rb

@@ -0,0 +1,214 @@
+class Page
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  include MongoSearch::Searchable
+
+  include Slices::Tree
+  include Slices::HasSlices
+  include Slices::HasAttachments::PageInstanceMethods
+
+  field :name
+  field :role  # only relevant for virtual pages
+  field :active, type: Boolean, default: false
+  field :layout, type: String, default: 'default'
+  field :meta_description
+  field :title
+  field :has_content, type: Boolean, default: false
+
+  index :_keywords, background: true
+
+  has_slices :slices
+  has_and_belongs_to_many :assets
+
+  text_search_in :introduction, :extended, :name
+
+  scope :entries, all
+
+  def self.available_layouts
+    Layout.all.map do |human_name, machine_name|
+      { human_name: human_name, machine_name: machine_name }
+    end
+  end
+
+  scope :virtual, where(:role.ne => nil).asc(:name)
+  validates_presence_of :name
+
+  before_save :update_has_content
+  before_destroy :destroy_children
+  after_save :cache_virtual_page
+
+  class NotFound < RuntimeError; end
+
+  CACHED_VIRTUAL_PAGES = {
+    'not_found' => '404',
+    'error' => '500'
+  }
+
+  def self.role_for_status(status)
+    if CACHED_VIRTUAL_PAGES.has_value?(status)
+      CACHED_VIRTUAL_PAGES.detect { |k, v| v == status }[0]
+    else
+      nil
+    end
+  end
+
+  # Virtual pages don't live in the and are not associated with a
+  # specific URL. Instead, they can be rendered at any path, depending
+  # on the circumstances (e.g. when a page isn't found, or when an error
+  # occurs). Consequently they aren't created with a :parent attribute.
+  def self.make(attributes = {})
+    attributes = attributes.symbolize_keys
+    parent = parent_from_attributes(attributes)
+    attributes[:path] ||= path_from_attributes(attributes, parent)
+
+    new(attributes).tap do |page|
+      yield(page) if block_given?
+      page.parent = parent unless attributes.include?(:role)
+      if parent.present?
+        page.position = parent.children.count
+        page.layout = parent.layout if page.entry?
+      end
+      page.save
+    end
+  end
+
+  def self.find_by_id(id)
+    find(id)
+  rescue BSON::InvalidObjectId, Mongoid::Errors::DocumentNotFound
+    nil
+  end
+
+  def self.find_by_id!(id)
+    find_by_id(id) || (raise NotFound)
+  end
+
+  def self.find_virtual(role)
+    first(conditions: { role: role })
+  end
+
+  def cacheable_virtual_page?
+    CACHED_VIRTUAL_PAGES.has_key?(role)
+  end
+
+  def cache_virtual_page
+    if cacheable_virtual_page? && (! Rails.env.test?)
+      fork do
+        script = File.join(Slices.gem_path, 'script', 'request-local-page')
+        rails = File.join(Rails.root, 'script', 'rails')
+        path = "/#{CACHED_VIRTUAL_PAGES[role]}.html"
+        FileUtils.rm_f(File.join(Rails.root, 'public', path))
+        exec(rails, 'runner', '-e', Rails.env, script, path)
+      end
+    end
+  end
+
+  def virtual?
+    role.present?
+  end
+
+  def entry?
+    false
+  end
+
+  def set_page?
+    kind_of?(SetPage)
+  end
+
+  def sets
+    slices.select { |slice| slice.kind_of?(SetSlice) }
+  end
+
+  def set_slice(kind)
+    slice_class = Object.const_get("#{kind.to_s}SetSlice".camelize)
+    slices.detect { |slice| slice.kind_of?(slice_class) }
+  end
+
+  def template
+    "pages/show"
+  end
+
+  def update_attributes(attributes)
+    attributes = attributes.symbolize_keys
+
+    unless home?
+      if attributes.has_key?(:name) || attributes.has_key?(:permalink)
+        new_path = self.class.path_from_attributes(attributes, parent)
+        attributes[:path] = new_path if new_path != path
+      end
+      if attributes.has_key?(:path) && attributes[:path].blank?
+        attributes.delete(:path)
+      end
+    end
+
+    super
+    if valid?
+      update_path_for_children if attributes.has_key?(:path)
+    end
+  end
+
+  def as_json(options = {})
+    options ||= {}
+
+    hash = attributes.symbolize_keys.except(:_id, :_type, :_keywords, :set_slices, :site_id).merge(
+      id:        id,
+      permalink: permalink,
+      slices:    ordered_slices_for(options[:slice_embed]).map {|slice| slice.as_json },
+      available_layouts: available_layouts
+    )
+
+    keys = options[:only]
+    keys ? hash.slice(keys) : hash
+  end
+
+  # Added in merge or page & content
+  def set_keywords
+    super
+    slices.each do |slice|
+      self._keywords += MongoSearch::KeywordsExtractor.extract(slice.search_text)
+    end
+    self._keywords.uniq!
+  end
+
+  def available_layouts
+    self.class.available_layouts
+  end
+
+  # End of added
+
+  def description
+    ActiveSupport::Deprecation::warn "Page#description is now meta_description. If you are upgrading, run 'rake slices:migrate:meta_description' to update."
+    meta_description
+  end
+
+  def description=(value)
+    ActiveSupport::Deprecation::warn "Page#description is now meta_description.  If you are upgrading, run 'rake slices:migrate:meta_description' to update."
+    self.meta_description = value
+  end
+
+  private
+    def self.parent_from_attributes(attributes)
+      if attributes.has_key?(:parent_path)
+        Page.find_by_path(attributes.delete(:parent_path))
+      elsif attributes.has_key?(:parent_id)
+        Page.find_by_id(attributes.delete(:parent_id))
+      else
+        attributes.delete(:parent)
+      end
+    end
+
+    def self.page_exists?(path)
+      Page.find_by_path(path)
+    rescue NotFound
+      false
+    end
+
+    def update_has_content
+      self.has_content = slices.any?
+      true # must be true otherwise save will fail
+    end
+
+    def destroy_children
+      children.each { |child| child.destroy }
+    end
+
+end

data/app/models/placeholder_slice.rb

@@ -0,0 +1,8 @@
+class PlaceholderSlice < Slice
+  restricted_slice
+
+  def render
+    renderer.render_container(self.container, current_page.ordered_slices)
+  end
+end
+

data/app/models/set_page.rb

@@ -0,0 +1,12 @@
+class SetPage < Page
+
+  has_slices :set_slices
+
+  def entry_types
+    sets.map { |set| set.entry_type }
+  end
+
+  def entries(type)
+    children.criteria.where(_type: type.to_s.classify)
+  end
+end

data/app/models/set_slice.rb

@@ -0,0 +1,57 @@
+class SetSlice < Slice
+  include Mongoid::Document
+
+  DEFAULT_SORT_FIELD = :created_at
+  DEFAULT_SORT_DIRECTION = :desc
+
+  field :per_page, type: Integer, default: 5
+  field :sort_field, type: String, default: DEFAULT_SORT_FIELD
+  field :sort_direction, type: String, default: DEFAULT_SORT_DIRECTION
+
+  def prepare(params)
+    @page_num = params[:page] || 1
+  end
+
+  def addable_entries?
+    true
+  end
+
+  def editable_entries?
+    true
+  end
+
+  def entry_type
+    self.class.name.sub('SetSlice', '').underscore.to_sym
+  end
+
+  def entries
+    sorted selected_by_type normal_or_set_page.children
+  end
+
+  def page_entries(params = {})
+    entries.paginate(paginate_options(params))
+  end
+
+  def paginate_options(params)
+    params.reverse_merge(page: @page_num, per_page: per_page)
+  end
+
+  def sort_field
+    read_attribute(:sort_field) || DEFAULT_SORT_FIELD
+  end
+
+  def sort_direction
+    read_attribute(:sort_direction) || DEFAULT_SORT_DIRECTION
+  end
+
+
+  private
+
+  def sorted entries
+    entries.send sort_direction, sort_field
+  end
+
+  def selected_by_type entries
+    entries.where _type: entry_type.to_s.classify
+  end
+end

data/app/models/site_map.rb

@@ -0,0 +1,24 @@
+class SiteMap
+
+  def self.rebuild(tree)
+    set_children_for(tree.first['id'], tree.first['children'])
+  end
+
+  def permalink
+    '{root}'
+  end
+
+  private
+
+  def self.set_children_for(parent_id, data)
+    parent = Page.find(parent_id)
+    data.each_with_index do |child_data, i|
+      child = Page.find(child_data['id'])
+      child.position = i
+      child.parent = parent
+      child.path = child.generate_path
+      child.save!
+      set_children_for(child_data['id'], child_data['children']) if child_data['children']
+    end
+  end
+end

data/app/models/slice.rb

@@ -0,0 +1,80 @@
+class Slice
+  include Mongoid::Document
+  include Slices::PositionHelper
+
+  field :container
+  field :position, type: Integer, default: 999
+
+  class_attribute :restricted
+  embedded_in :normal_page, class_name: 'Page', inverse_of: :slices
+  embedded_in :set_page, inverse_of: :set_slices
+
+  attr_accessor :renderer, :current_page
+  alias :page :current_page
+
+  def self.restricted_slice
+    self.restricted = true
+  end
+
+  def self.restricted?
+    self.restricted == true
+  end
+
+  def setup(options)
+    self.renderer = options[:renderer]
+    self.current_page = options[:current_page]
+  end
+
+  def prepare(params)
+  end
+
+  def render
+    renderer.render_to_string(template_path, locals: {
+      slice: self
+    })
+  end
+
+  def normal_or_set_page
+    normal_page || set_page
+  end
+
+  def template_path
+    template = (type =~ /_(set|show)$/) ? $1 : 'show'
+    File.join type.sub(/_show$/, '_set'), 'views', template
+  end
+
+  def type
+    _type.to_s.underscore.gsub(/_slice$/, '')
+  end
+
+  def reference
+    [_type, id].join(':')
+  end
+
+  def client_id?
+    attributes.include?('client_id')
+  end
+
+  def id_or_client_id
+    client_id? ? client_id : id
+  end
+
+  def to_delete?
+    attributes.include?('_deleted')
+  end
+
+  def as_json(*args)
+    attributes.symbolize_keys.except(:_id, :_type).tap do |result|
+      result.merge!(id: id, type: type)
+      result.merge!(client_id: client_id) if client_id? && new_record?
+    end
+  end
+
+  def search_text
+    text_fields = fields.values.select do |field|
+      (field.type == String) && (field.name !~ /^container$|_id$/)
+    end
+    text_fields.map { |field| self[field.name.to_sym] }.join(" ")
+  end
+end
+