porthos 3.0.0.beta

data/app/models/datum_templates/datum_collection_template.rb

@@ -0,0 +1,15 @@
+class DatumCollectionTemplate < DatumTemplate
+  key :allow_texts, Boolean, :default => lambda { false }
+  key :allow_links, Boolean
+  key :allowed_asset_filetypes, Array, :default => lambda { [] }
+  key :allowed_page_template_ids, Array, :typecast => 'ObjectId', :default => lambda { [] }
+  key :content_templates_ids, Array, :typecast => 'ObjectId', :default => lambda { [] }
+
+  many :content_templates, :in => :content_templates_ids
+
+  before_validation do
+    self.allowed_asset_filetypes = allowed_asset_filetypes.compact.reject { |i| i.blank? }
+    self.allowed_page_template_ids = allowed_page_template_ids.compact.reject { |i| i.blank? }
+    self.content_templates_ids = content_templates_ids.compact.reject { |i| i.blank? }
+  end
+end

data/app/models/datum_templates/field_set_template.rb

@@ -0,0 +1,5 @@
+class FieldSetTemplate < DatumTemplate
+  key :template_name, String
+  key :content_template_id, ObjectId
+  belongs_to :content_template
+end

data/app/models/datum_templates/field_template.rb

@@ -0,0 +1,6 @@
+class FieldTemplate < DatumTemplate
+  key :input_type, String
+
+  cattr_reader :input_types
+  @@input_types = ['string', 'date', 'boolean']
+end

data/app/models/datum_templates/link_field_template.rb

@@ -0,0 +1,2 @@
+class LinkFieldTemplate < DatumTemplate
+end

data/app/models/datum_templates/page_association_template.rb

@@ -0,0 +1,4 @@
+class PageAssociationTemplate < DatumTemplate
+  key :page_template_ids, Array, typecast: 'ObjectId'
+  many :page_templates
+end

data/app/models/datum_templates/string_field_template.rb

@@ -0,0 +1,4 @@
+class StringFieldTemplate < FieldTemplate
+  key :multiline, Boolean, :default => lambda { false }
+  key :allow_rich_text, Boolean, :default => lambda { false }
+end

data/app/models/file_template.rb

@@ -0,0 +1,105 @@
+require 'enumerator'
+class FileTemplate
+  include Comparable
+
+  attr_reader :name,
+              :handle,
+              :path,
+              :full_path
+
+  def initialize(name)
+    @full_path = self.class.available_template_paths[name]
+    unless @full_path
+      raise "FileTemplate: #{name} is not a available template"
+    end
+    @path = @full_path.gsub(/(.*)app\/views\//,'')
+    @handle = name
+    @name = @handle.capitalize
+  end
+
+  def views
+    @views ||= self.class::Views.new(self)
+  end
+
+  def <=>(other)
+    self.handle <=> other.handle
+  end
+
+  def to_s
+    name
+  end
+
+  class << self
+
+    def all
+      @all ||= available_template_paths.any? ? available_template_paths.collect {|name, path| self.new(name) } : []
+    end
+
+    def available_template_paths
+      available_template_paths = {}
+      root_directories.each do |root_path|
+        if Dir.exists?(root_path)
+          Dir.entries(root_path).reject { |f| f[0...1] == "." }.collect do |template_path|
+            unless available_template_paths.has_key?(File.basename(template_path))
+              available_template_paths[template_path] = File.join(root_path, template_path)
+            end
+          end
+        end
+      end
+      available_template_paths
+    end
+
+    def default
+      self.new('default')
+    end
+
+    def find(template_handle)
+      self.all.detect { |template| template.handle == template_handle }
+    end
+
+    def root_path
+      raise "Needs to be implemented in subclass"
+    end
+
+    def root_directories
+      [File.join(Rails.root, 'app', 'views', root_path), File.join(Porthos.root, 'app', 'views', root_path)]
+    end
+
+  end
+
+  class Views
+    include Enumerable
+
+    def initialize(template)
+      @template = template
+      @views = Dir.entries(@template.full_path).reject { |f| f[0...1] == "." || File.basename(f, '.*') == 'template' }
+    end
+
+    def each
+      @views.each { |v| yield v }
+    end
+
+    def names
+      @names ||= self.collect { |v| v.split(/\./).first.gsub(/(^\_)/, '') }
+    end
+
+    def respond_to?(*args)
+      super(*args) || names.include?(args.first.to_s)
+    end
+
+    def method_missing_with_check_default(method, *args)
+      _method = method.to_s
+      if names.include?(_method)
+        File.join(@template.path, _method)
+      else
+        default_template = @template.class.default
+        if @template != default_template and default_template.views.respond_to?(method)
+          default_template.views.send(method, *args)
+        else
+          method_missing_without_check_default(method, *args)
+        end
+      end
+    end
+    alias_method_chain :method_missing, :check_default
+  end
+end

data/app/models/file_templates/field_set_file_template.rb

@@ -0,0 +1,7 @@
+class FieldSetFileTemplate < FileTemplate
+  class << self
+    def root_path
+      File.join('field_set_templates')
+    end
+  end
+end

data/app/models/file_templates/page_file_template.rb

@@ -0,0 +1,14 @@
+require 'yaml'
+class PageFileTemplate < FileTemplate
+
+  def initialize(*args)
+    super(*args)
+    require File.join(@full_path, "#{@handle}_renderer")
+  end
+
+  class << self
+    def root_path
+      File.join('pages', 'templates')
+    end
+  end
+end

data/app/models/image_asset.rb

@@ -0,0 +1,102 @@
+class ImageAsset < Asset
+  key :width, Integer
+  key :height, Integer
+  key :resizor_id, Integer
+  key :versions, Hash, :default => lambda { Hash.new }
+
+  tankit Porthos.config.tanking.index_name, :as => 'Asset' do
+    indexes :name
+    indexes :title
+    indexes :description
+    indexes :author
+    indexes :tag_names
+    indexes :hidden
+    indexes :reference_number
+  end
+
+  validates_presence_of :resizor_id,
+                        :on => :create,
+                        :message => I18n.t(:unable_to_store)
+
+  def remote_url
+    resizor_asset.url(:size => 'original', :format => extension)
+  end
+
+
+  def versions=(new_version)
+    super(versions.is_a?(Hash) ? versions.merge(new_version) : new_version)
+  end
+
+  def version_url(options = {})
+    options = extract_cropping_options(options) if options[:size].start_with?('c')
+    resizor_asset.url(options)
+  end
+
+  def landscape?
+    width > height
+  end
+
+  def portrait?
+    not landscape?
+  end
+
+  def height_for_width(new_width)
+    unless new_width >= self.width
+      (height.to_f * (new_width.to_f / self.width.to_f)).ceil
+    else
+      height
+    end
+  end
+
+  def width_for_height(new_height)
+    unless new_height >= self.height
+      (width.to_f * (new_height.to_f / self.height.to_f)).ceil
+    else
+      width
+    end
+  end
+
+protected
+
+  def store
+    resizor_asset.path = File.join(Dir.tmpdir, file.original_filename).tap do |_path|
+      file.respond_to?(:path) ? FileUtils.move(file.path, _path) : File.open(_path, 'wb') { |f| f.write(file.read) }
+    end
+    if resizor_asset.save_to_resizor
+      self.resizor_id = resizor_asset.id
+      self.width = resizor_asset.width
+      self.height = resizor_asset.height
+      File.unlink(resizor_asset.path)
+    end
+  end
+
+  def cleanup
+    resizor_asset.destroy
+  end
+
+  def resizor_asset
+    @resizor_asset ||= Resizor::ResizorAsset.new(:id => self.resizor_id)
+  end
+
+private
+
+  def extract_cropping_options(options)
+    options.tap do |opts|
+      size = opts[:size]
+      unless versions.has_key?(size)
+        add_version size
+      else
+        version = versions[size]
+        if version.keys.any?
+          opts[:cutout] = "#{version[:cutout_width]}x#{version[:cutout_height]}-#{version[:cutout_x]}x#{version[:cutout_y]}"
+        end
+      end
+    end
+  end
+
+  def add_version(size)
+    self.versions[size] = {}
+    set("versions.#{size}" => self.versions[size])
+  end
+
+end

data/app/models/item.rb

@@ -0,0 +1,115 @@
+class Item
+  include MongoMapper::Document
+  plugin MongoMapper::Plugins::IdentityMap
+  include Tanker
+
+  tankit Porthos.config.tanking.index_name do
+    indexes :title
+    indexes :uri
+    indexes :tag_names
+    indexes :data
+    indexes :note
+  end
+
+  key :created_by_id, ObjectId
+  key :updated_by_id, ObjectId
+
+  key :title, String
+  key :uri, String
+  key :handle, String
+  key :note
+
+  key :active, Boolean
+  key :restricted, Boolean
+
+  key :published_on, Time
+
+  timestamps!
+
+  taggable
+
+  belongs_to :created_by,
+             :class_name => 'User'
+
+  belongs_to :updated_by,
+             :class_name => 'User'
+
+  many :data, :order => 'position asc' do
+    def [](handle)
+      detect { |d| d.handle == handle }
+    end
+  end
+
+  validates_presence_of :title
+
+  before_validation { self.title.strip! if title }
+  before_create :set_created_by
+  before_save :set_updated_by
+  before_save :sort_data
+
+  after_save proc { |page| page.delay.update_tank_indexes }
+  after_destroy proc { |page| page.delay.delete_tank_indexes }
+
+  scope :by_class, lambda { |klass_name| where(type: klass_name) }
+
+  scope :order_by, lambda { |order_by| sort(order_by) }
+
+  scope :published, lambda { where(:published_on.lte => Time.now) }
+
+  scope :unpublished, lambda {
+    where(:$or => [{:published_on => nil}, {:published_on.gt => Time.now}])
+  }
+
+  scope :published_within, lambda { |from, to|
+    where(:published_on.gte => from, :published_on.lte => to)
+  }
+
+  scope :created_latest, sort(:created_at.desc)
+
+  scope :updated_latest, where(:updated_at.gt => :created_at).sort(:updated_at.desc)
+
+  scope :created_by, lambda { |user_id| where(:created_by_id => user_id) }
+
+  scope :updated_by, lambda { |user_id| where(:updated_by_id => user_id) }
+
+  class << self
+    def contributors
+      User.find(self.fields(:updated_by_id).distinct(:updated_by_id))
+    end
+  end
+
+  def published?
+    published_on.present? && published_on <= DateTime.now
+  end
+
+  def can_have_a_node?
+    false
+  end
+
+  def node
+    @node ||= Node.where(:resource_type => self.class.model_name, :resource_id => self.id).first
+  end
+
+  def node=(node_attributes)
+    node ? node.attributes.merge(node_attributes) : Node.new(node_attributes).first
+  end
+
+  def has_url?
+    published? and node.present?
+  end
+
+private
+
+  def sort_data
+    self.data.sort_by!(&:position)
+  end
+
+  def set_created_by
+    self.created_by = User.current
+  end
+
+  def set_updated_by
+    self.updated_by = User.current
+  end
+
+end

data/app/models/link.rb

@@ -0,0 +1,46 @@
+class Link
+  include MongoMapper::EmbeddedDocument
+
+  key :title, String
+  key :url, String
+  key :position, Integer
+
+  key :node_id, ObjectId
+  key :node_url, String
+  belongs_to :node
+
+  validates :title,
+            :presence => true
+
+  validates_presence_of :url,
+                        :unless => proc { |l| l.node_id.present? }
+
+  validates_presence_of :node_id,
+                        :unless => proc { |l| l.url.present? }
+
+  before_validation :cache_node_url
+  before_validation :move_to_list_bottom
+
+  def url
+    node_url || self[:url]
+  end
+
+private
+
+  def cache_node_url
+    if node
+      self.url = nil
+      self.node_url = "/#{node.url}"
+    else
+      self.node_url = nil
+    end
+  end
+
+  def move_to_list_bottom
+    if position.blank? && _parent_document
+      siblings = _parent_document.links.find_all { |l| l.position.present? && l.id != self.id }
+      self.position = siblings.any? ? siblings.sort_by(&:position).last.position + 1 : 1
+    end
+  end
+
+end

data/app/models/link_list.rb

@@ -0,0 +1,30 @@
+class LinkList
+  include MongoMapper::Document
+  key :title, String
+  key :handle, String
+
+  many :links
+
+  validates :title, presence: true
+  validates :handle, presence: true
+
+  before_validation :create_title
+  before_save :sort_links
+
+  class << self
+    def [](handle)
+      find_or_create_by_handle(handle)
+    end
+  end
+
+private
+
+  def create_title
+    self.title = handle.to_s.humanize unless title.present?
+  end
+
+  def sort_links
+    links.sort_by!(&:position)
+  end
+
+end