spina 0.6.11

data/app/models/spina/layout_part.rb

@@ -0,0 +1,38 @@
+module Spina
+  class LayoutPart < ActiveRecord::Base
+    include ApplicationHelper
+
+    belongs_to :account
+    belongs_to :layout_partable, polymorphic: true
+
+    accepts_nested_attributes_for :layout_partable, allow_destroy: true
+    attr_accessor :position
+
+    validates_presence_of :name, :layout_partable_type, :title
+    validates_uniqueness_of :name, scope: :account_id
+
+    scope :sorted, -> { order(:position) }
+
+    def to_s
+      name
+    end
+
+    def position(theme)
+      layout_parts = theme.config.layout_template[:layout_parts]
+      layout_parts.index { |layout_part| layout_part == self.name }.to_i
+    end
+
+    def content
+      self.layout_partable.try(:content) || self.layout_partable
+    end
+
+    def layout_partable_attributes=(attributes)
+      if self.layout_partable.present?
+        self.layout_partable.update_attributes(attributes)
+      else
+        self.layout_partable = self.layout_partable_type.constantize.create(attributes)
+      end
+    end
+
+  end
+end

data/app/models/spina/line.rb

@@ -0,0 +1,6 @@
+module Spina
+  class Line < ActiveRecord::Base
+    has_many :page_parts, as: :page_partable
+    has_many :layout_parts, as: :layout_partable
+  end
+end

data/app/models/spina/page.rb

@@ -0,0 +1,125 @@
+module Spina
+  class Page < ActiveRecord::Base
+    extend FriendlyId
+    
+    has_ancestry orphan_strategy: :adopt # i.e. added to the parent of deleted node
+
+    friendly_id :slug_candidates, use: [:slugged, :finders]
+
+    has_many :page_parts, dependent: :destroy
+
+    before_validation :ensure_title
+    before_save :set_materialized_path
+    before_save :ancestry_is_nil
+    after_save :save_children
+
+    accepts_nested_attributes_for :page_parts, allow_destroy: true
+    validates_presence_of :title
+
+    scope :sorted, -> { order('position') }
+    scope :custom_pages, -> { where(deletable: false) }
+    scope :live, -> { where(draft: false, active: true) }
+    scope :in_menu, -> { where(show_in_menu: true) }
+    scope :active, -> { where(active: true) }
+
+    def slug_candidates
+      [
+        :title, 
+        [:title, :id]
+      ]
+    end
+
+    def should_generate_new_friendly_id?
+      title_changed?
+    end
+
+    def to_s
+      name
+    end
+
+    def custom_page?
+      !deletable
+    end
+
+    def set_materialized_path
+      self.materialized_path = generate_materialized_path
+    end
+
+    def save_children
+      self.children.each { |child| child.save }
+    end
+
+    def menu_title
+      read_attribute(:menu_title).blank? ? title : read_attribute(:menu_title)
+    end
+
+    def seo_title
+      read_attribute(:seo_title).blank? ? title : read_attribute(:seo_title)
+    end
+
+    def page_part(page_part)
+      page_part = page_parts.where(name: page_part[:name]).first || page_parts.build(page_part)
+      page_part.page_partable = page_part.page_partable_type.constantize.new unless page_part.page_partable.present?
+      page_part
+    end
+
+    def has_content?(page_part)
+      content(page_part).present?
+    end
+
+    def content(page_part)
+      page_part = page_parts.where(name: page_part).first
+      page_part.try(:content)
+    end
+
+    def live?
+      !draft? && active?
+    end
+
+    def previous_sibling
+      self.siblings.where('position < ?', self.position).sorted.last
+    end
+
+    def next_sibling
+      self.siblings.where('position > ?', self.position).sorted.first
+    end
+
+    def deactivate!
+      self.active = false
+      self.save
+    end
+
+    def activate!
+      self.active = true
+      self.save
+    end
+
+    private
+
+    def generate_materialized_path
+      if self.name == 'homepage'
+        "/"
+      else
+        case self.depth
+        when 0
+          "/#{slug}"
+        when 1
+          "/#{self.parent.slug}/#{slug}"
+        when 2
+          "/#{self.parent.parent.try(:slug)}/#{self.parent.slug}/#{slug}"
+        end
+      end
+    end
+
+    def ancestry_is_nil
+      if self.ancestry && self.ancestry.empty?
+        self.ancestry = nil
+      end
+    end
+
+    def ensure_title
+      self.title = self.name.capitalize if self.title.blank? && self.name.present?
+    end
+
+  end
+end

data/app/models/spina/page_part.rb

@@ -0,0 +1,38 @@
+module Spina
+  class PagePart < ActiveRecord::Base
+    include ApplicationHelper
+
+    belongs_to :page
+    belongs_to :page_partable, polymorphic: true
+
+    accepts_nested_attributes_for :page_partable, allow_destroy: true
+    attr_accessor :position
+
+    validates_presence_of :name, :page_partable_type, :title
+    validates_uniqueness_of :name, scope: :page_id
+
+    scope :sorted, -> { order(:position) }
+
+    def to_s
+      name
+    end
+
+    def position(theme)
+      page_parts = theme.config.view_templates[self.page.try(:view_template) || "show"][:page_parts]
+      page_parts.index { |page_part| page_part == self.name }.to_i
+    end
+
+    def content
+      self.page_partable.try(:content) || self.page_partable
+    end
+
+    def page_partable_attributes=(attributes)
+      if self.page_partable.present?
+        self.page_partable.assign_attributes(attributes)
+      else
+        self.page_partable = self.page_partable_type.constantize.new(attributes)
+      end
+    end
+
+  end
+end

data/app/models/spina/photo.rb

@@ -0,0 +1,23 @@
+module Spina
+  class Photo < ActiveRecord::Base
+    mount_uploader :file, PhotoUploader
+
+    has_many :page_parts, as: :page_partable
+    has_many :photo_collections_photos
+    has_many :photo_collections, through: :photo_collections_photos
+
+    scope :sorted, -> { order('created_at DESC') }
+    scope :sorted_by_photo_collection, -> { order('position') }
+
+    validates_presence_of :file
+
+    def name
+      file.file.filename
+    end
+
+    def content
+      self
+    end
+    
+  end
+end

data/app/models/spina/photo_collection.rb

@@ -0,0 +1,30 @@
+module Spina
+  class PhotoCollection < ActiveRecord::Base
+    
+    has_one :page_part, as: :page_partable
+    has_many :photo_collections_photos, autosave: true
+    has_many :photos, through: :photo_collections_photos
+
+    attr_reader :photo_tokens, :photo_positions
+    accepts_nested_attributes_for :photos, allow_destroy: true
+
+    def photo_tokens=(ids)
+      self.photo_ids = ids.split(",")
+    end
+
+    def photo_positions=(positions)
+      positions = positions.split(",")
+      self.photo_collections_photos.each do |photo|
+        photo.position = positions.index(photo.photo.try(:id).try(:to_s))
+      end
+      logger.info self.photo_collections_photos.inspect
+    end
+
+    alias_method :old_update_attributes, :update_attributes
+    def update_attributes(attributes)
+      self.photos.clear if attributes.reject{|key,value| key == "id" }.blank?
+      old_update_attributes(attributes)
+    end
+
+  end
+end

data/app/models/spina/photo_collections_photo.rb

@@ -0,0 +1,6 @@
+module Spina
+  class PhotoCollectionsPhoto < ActiveRecord::Base
+    belongs_to :photo
+    belongs_to :photo_collection
+  end
+end

data/app/models/spina/spina.rb

@@ -0,0 +1,7 @@
+module Spina
+  module Spina
+    def self.table_name_prefix
+      'spina_'
+    end
+  end
+end

data/app/models/spina/text.rb

@@ -0,0 +1,6 @@
+module Spina
+  class Text < ActiveRecord::Base
+    has_many :page_parts, as: :page_partable
+    has_many :layout_parts, as: :layout_partable
+  end
+end

data/app/models/spina/user.rb

@@ -0,0 +1,31 @@
+module Spina
+  class User < ActiveRecord::Base
+    has_secure_password
+
+    validates_presence_of :name, :email
+    validates_presence_of :password, on: :create
+    validate :uniqueness_of_email
+    validates :email, format: { with:/\A[^@]+@[^@]+\z/, message: 'is geen geldig emailadres' }
+
+    def admin?
+      admin
+    end
+
+    def to_s
+      name
+    end
+
+    def update_last_logged_in!
+      self.last_logged_in = Time.now
+      self.save!
+    end
+
+    private
+
+    def uniqueness_of_email
+      if email_changed? && User.where(email: email).exists?
+        errors.add(:email, I18n.t('errors.messages.taken'))
+      end
+    end
+  end
+end

data/app/presenters/spina/pages/menu_presenter.rb

@@ -0,0 +1,82 @@
+# require 'active_support/core_ext/string'
+require 'active_support/configurable'
+require 'action_view/helpers/tag_helper'
+require 'action_view/helpers/url_helper'
+
+module Spina
+  module Pages
+    class MenuPresenter
+      include ActionView::Helpers::TagHelper
+      include ActionView::Helpers::UrlHelper
+      include ActiveSupport::Configurable
+
+      config_accessor :list_tag, :list_wrapper, :list_item_tag, :list_item_css, :selected_css, :current_css, :first_css, :last_css
+      
+      self.list_tag = :ul
+      self.list_item_tag = :li
+      self.list_item_css = nil
+      self.list_wrapper = false
+      self.selected_css = :selected
+      self.current_css = :current
+      self.first_css = :first
+      self.last_css = :last
+
+      attr_accessor :context, :collection, :current_menu_item
+      delegate :output_buffer, :output_buffer=, to: :context
+
+      def initialize(collection, context, current_menu_item=nil)
+        @collection = collection
+        @context = context
+        @current_menu_item = current_menu_item
+        @selected_menu_items = [@current_menu_item] + @current_menu_item.try(:ancestors)
+      end
+
+      def to_html
+        render_list_wrapper(collection) if collection.present?
+      end
+
+      private
+
+      def render_list_wrapper(menu_items)
+        if menu_items.any?
+          if list_wrapper
+            content_tag(:div) do
+              render_menu_items(menu_items)
+            end
+          else
+            render_menu_items(menu_items)
+          end
+        end
+      end
+
+      def render_menu_items(menu_items)
+        content_tag(list_tag) do
+          menu_items.each_with_index.inject(ActiveSupport::SafeBuffer.new) do |buffer, (item, index)|
+            buffer << render_menu_item(item, index, menu_items.length)
+          end
+        end
+      end
+
+      def render_menu_item(menu_item, index, menu_items_length)
+        content_tag(list_item_tag, class: menu_item_css(menu_item[0], index, menu_items_length)) do
+          buffer = ActiveSupport::SafeBuffer.new
+          buffer << link_to(menu_item[0].menu_title, "#{menu_item[0].materialized_path}")
+          buffer << render_list_wrapper(menu_item[1]) 
+          buffer
+        end
+      end
+
+      def menu_item_css(menu_item, index, menu_items_length)
+        css = []
+        css << list_item_css
+        css << selected_css if (@selected_menu_items.present? && @selected_menu_items.include?(menu_item) )
+        css << current_css if @current_menu_item == menu_item
+        css << first_css if index == 0
+        css << last_css if index + 1 == menu_items_length
+
+        css.reject(&:blank?).presence
+      end
+
+    end
+  end
+end

data/app/uploaders/spina/file_uploader.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+module Spina
+  class FileUploader < CarrierWave::Uploader::Base
+
+    # Include RMagick or MiniMagick support:
+    # include CarrierWave::RMagick
+    # include CarrierWave::MiniMagick
+
+    # Include the Sprockets helpers for Rails 3.1+ asset pipeline compatibility:
+    # include Sprockets::Helpers::RailsHelper
+    # include Sprockets::Helpers::IsolatedHelper
+
+    # Choose what kind of storage to use for this uploader:
+    storage :file
+    # storage :fog
+
+    # Override the directory where uploaded files will be stored.
+    # This is a sensible default for uploaders that are meant to be mounted:
+    def store_dir
+      "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
+    end
+
+    # Provide a default URL as a default if there hasn't been a file uploaded:
+    # def default_url
+    #   # For Rails 3.1+ asset pipeline compatibility:
+    #   # asset_path("fallback/" + [version_name, "default.png"].compact.join('_'))
+    #
+    #   "/images/fallback/" + [version_name, "default.png"].compact.join('_')
+    # end
+
+    # Process files as they are uploaded:
+    # process :scale => [200, 300]
+    #
+    # def scale(width, height)
+    #   # do something
+    # end
+
+    # Create different versions of your uploaded files:
+    # version :thumb do
+    #   process :scale => [50, 50]
+    # end
+
+    # Add a white list of extensions which are allowed to be uploaded.
+    # For images you might use something like this:
+    # def extension_white_list
+    #   %w(jpg jpeg gif png)
+    # end
+
+    # Override the filename of the uploaded files:
+    # Avoid using model.id or version_name here, see uploader/store.rb for details.
+    # def filename
+    #   "something.jpg" if original_filename
+    # end
+
+  end
+end