cardboard_cms 0.1.4

data/app/inputs/date_picker_input.rb

@@ -0,0 +1,10 @@
+class DatePickerInput < SimpleForm::Inputs::StringInput
+  def input
+    input_html_options[:class] |= ["datepicker"]
+    input_html_options[:type] = "text"
+    super
+  end
+
+end
+
+

data/app/inputs/date_time_input.rb

@@ -0,0 +1,7 @@
+class DateTimeInput < SimpleForm::Inputs::DateTimeInput
+  def input
+    # added for http://silviomoreto.github.io/bootstrap-select/
+    input_html_options["data-width"] = "auto"
+    super
+  end
+end

data/app/inputs/image_input.rb

@@ -0,0 +1,3 @@
+class ImageInput < SimpleForm::Inputs::FileInput
+  #image is a file input, just makes code cleaner
+end

data/app/inputs/rich_text_input.rb

@@ -0,0 +1,6 @@
+class RichTextInput < SimpleForm::Inputs::TextInput
+  def input
+    input_html_options[:class] += [:wysihtml5] 
+    @builder.text_area(attribute_name, input_html_options)
+  end
+end

data/app/models/cardboard/field.rb

@@ -0,0 +1,67 @@
+module Cardboard
+  class Field < ActiveRecord::Base
+    attr_accessor :seeding, :default
+    alias_attribute :value, :value_uid
+
+    belongs_to :object_with_field, :polymorphic => true, :inverse_of => :fields
+
+    #gem
+    include RankedModel
+    ranks :position, :with_same => [:object_with_field_id, :object_with_field_type], :class_name => 'Cardboard::Field'
+
+    #validations
+    validates :identifier, :type, presence:true
+    validates :identifier, uniqueness: {:case_sensitive => false, :scope => [:object_with_field_id, :object_with_field_type]}, 
+                          :format => { :with => /\A[a-z\_0-9]+\z/,
+                          :message => "Only downcase letters, numbers and underscores are allowed" }
+
+    default_scope {rank(:position)}
+
+    class << self
+      # Allow "type" to be passed in nested forms
+      def new_with_cast(*attributes, &block)
+        if (h = attributes.first).is_a?(Hash) && !h.nil? && (type = h.delete(:type) || h.delete('type')) && type.present? && (klass = type.constantize) != self
+          raise "Field type #{type} does not inherit from Cardboard::Field"  unless klass <= self
+          return klass.new(*attributes, &block)
+        end
+        new_without_cast(*attributes, &block)
+      end
+      alias_method_chain :new, :cast
+    end
+
+    # overwritten setter
+    def type=(val)
+      return super if val =~ /^Cardboard::Field::/ || val.nil?
+      @_type = val.to_s.downcase
+      self[:type] = "Cardboard::Field::#{@_type.camelize}"
+    end
+    def type
+      @_type ||= self[:type].demodulize.underscore
+    end
+
+    def default
+      #overwritten for each subclass
+    end
+    def default=(val) 
+      return unless self.value_uid.nil? && val.present?
+      if type == "image" || type == "file"
+        path = "app/assets/#{type.pluralize}/defaults/#{val}"
+        raise "File not found #{path}. Make sure to add your #{type} before seeding." unless ::File.exist?(Rails.root.join(path))
+        self.value_uid = path
+      else
+        self.value_uid = val 
+      end
+    end
+
+  private
+
+    def is_required
+      errors.add(:value, "is required") if required_field? && value_uid.blank?
+    end
+    
+    def required_field?
+      self.required? && !self.seeding
+    end
+
+  end
+end

data/app/models/cardboard/field/boolean.rb

@@ -0,0 +1,29 @@
+module Cardboard
+  class Field::Boolean < Field
+    before_validation :convert_to_boolean
+
+    validate :is_boolean
+    
+
+    def default
+      [true, false].sample
+    end
+
+    private
+
+    def is_boolean
+      errors.add(:value, "is not a valid boolean") if self.value.nil?
+    end
+
+    def convert_to_boolean
+      self.value = to_boolean(self.value_uid)
+      true # don't return a validation error on false
+    end
+
+    def to_boolean(val)
+      return true if val == true || !!(val =~ /(true|t|yes|y|1)$/i)
+      return false if val == false || val.blank? || !!(val =~ /(false|f|no|n|0)$/i)
+      return nil
+    end
+  end
+end

data/app/models/cardboard/field/date.rb

@@ -0,0 +1,24 @@
+module Cardboard
+  class Field::Date < Field
+    validate :is_required
+    validate :is_date
+
+    def value
+      Chronic.parse(value_uid)
+    end
+
+    def value=(val)
+      self.value_uid = val
+    end
+
+    def default
+      Time.now
+    end
+
+    private
+
+    def is_date
+      errors.add(:value, "not a recognized date format") if value_uid.present? && value.blank?
+    end
+  end
+end

data/app/models/cardboard/field/decimal.rb

@@ -0,0 +1,25 @@
+module Cardboard
+  class Field::Decimal < Field
+    validate :is_decimal
+    validate :is_required
+
+    def value=(val)
+      self.value_uid = val == "" ? nil : val #bug in rails? should work with allow_blank
+    end
+
+    def value
+      value_uid.to_f
+    end
+
+    def default
+      234.23
+    end
+
+    private
+
+    def is_decimal
+      errors.add(:value, "is not a number") if value_uid.present? && value_uid.to_s =~ /([^\d\.]|\.{2,})/
+    end
+
+  end
+end

data/app/models/cardboard/field/external_link.rb

@@ -0,0 +1,4 @@
+module Cardboard
+  class Field::ExternalLink < Field
+  end
+end

data/app/models/cardboard/field/file.rb

@@ -0,0 +1,19 @@
+module Cardboard
+  class Field::File < Field
+
+    dragonfly_accessor :value
+
+    validates_size_of :value, :maximum => 20.megabytes #20000.kilobytes #TODO: move size to gem settings
+    validate :is_required #for some reason this is different from image
+
+    def value
+      return nil unless value_uid
+      if value_uid =~ /^app\/assets\/files/
+        Dragonfly.app.fetch_file(value_uid)
+      else
+        Dragonfly.app.fetch(value_uid)
+      end
+    end
+
+  end
+end

data/app/models/cardboard/field/image.rb

@@ -0,0 +1,33 @@
+module Cardboard
+  class Field::Image < Field
+
+    dragonfly_accessor :value do 
+      after_assign  :resize_image 
+    end
+
+    validates_property :format, :of => :value, :in => ['jpeg', 'jpg', 'png', 'gif'], if: :value_uid?
+    validates_property :image?, :of => :value, :as => true, if: :value_uid?
+    validates :value, presence:true, :if => :required_field?
+
+    def value
+      return nil unless value_uid
+      if value_uid =~ /^app\/assets\/images/
+        Dragonfly.app.fetch_file(value_uid)
+      else
+        Dragonfly.app.fetch(value_uid)
+      end
+    end
+
+    def default
+      # Dragonfly.app.generate(:plasma, [400, 800].sample, 600) 
+      Dragonfly.app.generate(:plain, [400, 800].sample, 600, :color => '#CCCCCC')
+    end
+
+  private
+
+    def resize_image
+      self.value.process!(:resize, '1920x1080>') if value_uid? #max image size 
+    end
+
+  end
+end

data/app/models/cardboard/field/integer.rb

@@ -0,0 +1,26 @@
+module Cardboard
+  class Field::Integer < Field
+    validate :is_integer
+    validate :is_required
+
+
+    def value=(val)
+      self.value_uid = val == "" ? nil : val #bug in rails? should work with allow_blank
+    end
+
+    def value
+      self.value_uid.to_i
+    end
+
+    def default
+      12321454
+    end
+
+  private
+
+    def is_integer
+      errors.add(:value, "is not a number") if value_uid.present? && value_uid.to_s =~ /[^\d]/
+    end
+
+  end
+end

data/app/models/cardboard/field/resource_link.rb

@@ -0,0 +1,4 @@
+module Cardboard
+  class Field::ResourceLink < Field
+  end
+end

data/app/models/cardboard/field/rich_text.rb

@@ -0,0 +1,21 @@
+module Cardboard
+  class Field::RichText < Field
+    validate :is_required
+    before_save :sanitize_value
+
+    def value
+      self.value_uid.try(:html_safe)
+    end
+
+    def default
+      "<div><p><strong>Lorem Ipsum</strong> is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.</p></div>".html_safe
+    end
+
+    private
+    
+    def sanitize_value
+      return nil unless value_changed?
+      self.value = ActionController::Base.helpers.sanitize(self.value, :tags => %w(strong b i u em br p div span ul ol li a pre code blockquote h1 h2 h3), :attributes => %w(class style href src width height alt))
+    end
+  end
+end

data/app/models/cardboard/field/string.rb

@@ -0,0 +1,16 @@
+module Cardboard
+  class Field::String < Field
+    validate :is_required
+    before_validation :truncate_long_string # validates :value, :length => { :maximum => 255 }
+
+    def default
+      "Neque porro quisquam est qui dolorem ipsum quia dolor sit amet, consectetur"
+    end
+
+    private
+
+    def truncate_long_string
+      self.value = self.value[0..254] if value
+    end
+  end
+end

data/app/models/cardboard/field/text.rb

@@ -0,0 +1,15 @@
+module Cardboard
+  class Field::Text < Field
+    validate :is_required
+
+    def value
+      return nil unless self.value_uid 
+      self.value_uid.split(/\n/).map { |i| ERB::Util.html_escape(i) }.join("<br />").html_safe
+    end
+
+    def default
+      "What is Lorem Ipsum? Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum."
+    end
+
+  end
+end

data/app/models/cardboard/page.rb

@@ -0,0 +1,253 @@
+module Cardboard
+  class Page < ActiveRecord::Base
+    has_many :parts, class_name: "Cardboard::PagePart", :dependent => :destroy, :validate => true
+      
+    attr_accessor :parent_url, :is_root
+
+    accepts_nested_attributes_for :parts, allow_destroy: true, :reject_if => :all_blank
+    serialize :meta_seo, Hash
+    serialize :slugs_backup, Array
+
+    before_validation :default_values
+    before_save :update_slugs_backup
+
+    #gems
+    acts_as_url :title, :url_attribute => :slug, :scope =>  :path, only_when_blank: true
+
+    include RankedModel
+    ranks :position, :with_same => :path
+
+    #validations
+    validates :title, :path, presence:true
+    validates :slug, uniqueness: { :case_sensitive => false, :scope => :path }, presence: true
+    validates :identifier, uniqueness: {:case_sensitive => false}, :format => { :with => /\A[a-z\_0-9]+\z/,
+    :message => "Only downcase letters, numbers and underscores are allowed" }
+    #validate all seo keys are valid meta keys + title
+
+    # validates_associated :parts, on: :update #breaks seed, should work
+
+    #scopes
+    scope :preordered, -> {order("path ASC, position ASC, slug ASC")} #order("CASE slug WHEN '/' THEN 'slug, position' ELSE 'path, position, slug' END")
+
+    #class variables
+    after_commit do
+      Page.clear_arranged_pages
+    end
+
+    #overwritten setters/getters
+    def slug=(value)
+      # the user can overwrite the auto generated slug
+      self[:slug] = value.present? ? value.to_url : nil
+    end
+
+    def is_root=(val)
+      self.position_position = :first if val
+    end
+
+    def using_slug_backup?
+      @using_slug_backup || false
+    end
+
+    def using_slug_backup=(value)
+      @using_slug_backup = value
+    end
+
+    #class methods
+    def self.find_by_url(full_url)
+      return nil unless full_url
+      path, slug = self.path_and_slug(full_url)
+      page = self.where(path: path, slug: slug).first
+
+      if slug && page.nil?
+        #use arel instead of LIKE/ILIKE
+        page = self.where(path: path).where(self.arel_table[:slugs_backup].matches("% #{slug}\n%")).first
+        page.using_slug_backup = true if page
+      end
+
+      page
+    end
+
+    def self.root
+      # Homepage is the highest position in the root path
+      where(path: "/").rank(:position).first
+    end
+    def self.homepage; self.root; end
+
+    def root?
+      @root_id ||= Page.root.id
+      @root_id == self.id
+    end
+
+    #instance methods
+
+    # @page.get("slideshow.image1")
+    # @page.get("slideshow").first.image1
+    # @page.get("slideshow").each...
+
+    # slideshow = @page.get("slideshow")
+    # slideshow.field("image1")
+    # slideshow.each{|p| p.field("image")}
+    # slideshow.get("slide1")
+    def get(field)
+      f = field.split(".")
+      parent_part = self.parts.where(identifier: f.first).first
+      return nil unless parent_part
+
+      part = parent_part.try(:subparts)
+      if parent_part.repeatable? 
+        raise "Part is repeatable, expected each loop" unless f.size == 1 
+        part || []
+      else
+        return nil unless part
+        f.size == 1 ? part.first : part.first.attr(f.last)
+      end
+    end
+
+    # def page_hash
+    #   return {} if self.parts.blank?
+    #   self.parts.rank(:part_position).inject(ActiveSupport::OrderedHash.new) do |part_hash, part| 
+    #     part_hash[part.identifier] = if part.repeatable?
+    #       part.subparts.rank(:subpart_position).inject([]) do |sub_array, subpart|
+    #         sub_array << subpart.fields.rank(:position).inject(ActiveSupport::OrderedHash.new) do |fields_hash, field|
+    #           fields_hash[field.identifier] = subpart.attr(field.identifier)
+    #           fields_hash
+    #         end
+    #       end
+    #     else
+    #       get(part.identifier).fields.rank(:position).inject(ActiveSupport::OrderedHash.new) do |fields_hash, field|
+    #         fields_hash[field.identifier] = part.attr(field.identifier)
+    #         fields_hash
+    #       end
+    #     end
+    #     part_hash
+    #   end
+    # end
+
+    # SEO
+    # children inherit their parent's SEO settings (these can be overwritten)
+    def seo
+      @_seo ||= begin
+        seo = self.meta_seo
+        seo = self.parent.seo.merge(seo) if parent
+        seo = Page.root.seo.merge(seo) unless root?
+        seo
+      end
+    end
+    
+    def seo=(hash)
+      # to hash is important here for strong parameters
+      self.meta_seo = hash.to_hash
+      @_seo = nil
+    end
+    
+    def url
+      return "/" if slug.blank? #|| self.root?
+      "#{path}#{slug}/"
+    end
+
+    def split_path
+      # path.sub(/^\//,'').split("/") # "/path/" => ["path"]
+      path[1..-1].split("/")
+    end
+
+    def parent
+      @parent ||= Cardboard::Page.find_by_url(path)
+    end
+
+    # Get all other pages
+    def parent_url_options
+      # @parent_url_options ||= begin
+        Cardboard::Page.all.inject(["/"]) do |result, elm| 
+          result << elm.url unless elm.id == self.id
+          result
+        end.sort
+      # end
+    end
+
+    def parent_url
+      return "/" if parent.nil?
+      parent.url
+    end
+
+    def parent=(new_parent)
+      return nil if new_parent && !new_parent.is_a?(Cardboard::Page) 
+      self.path = new_parent ? new_parent.url : "/"
+    end
+
+    def parent_id=(new_parent_id)
+      self.parent = Cardboard::Page.where(identifier: new_parent_id).first
+    end
+
+    def parent_url=(new_parent_url)
+      self.parent = Cardboard::Page.find_by_url(new_parent_url)
+    end
+
+    def children
+      Cardboard::Page.where(path: url)
+    end
+
+    def siblings
+      Cardboard::Page.where("path = ? AND id != ?", path, id)
+    end
+
+    def depth
+      # root is depth 0
+      split_path.size
+    end
+
+    # Arrange array of nodes into a nested hash of the form 
+    # {node => children}, where children = {} if the node has no children
+    #
+    # Example:
+    # {#<Cardboard::Page => {
+    #    #<Cardboard::Page => {}
+    #    #<Cardboard::Page => {}
+    #    #<Cardboard::Page => {#<Cardboard::Page => {}}
+    # }}
+    def self.arrange(root_page = nil)
+      root_page ||= self.root
+      return unless root_page
+      # TODO: use root_page...
+
+      Rails.cache.fetch("arranged_pages") do
+        pages = self.preordered
+
+        pages.inject(ActiveSupport::OrderedHash.new) do |ordered_hash, page|
+          (["/"] + page.split_path).inject(ordered_hash) do |insertion_hash, subpath|
+            
+            insertion_hash.each do |parent, children|
+              insertion_hash = children if subpath == parent.slug
+            end
+            insertion_hash
+          end[page] = ActiveSupport::OrderedHash.new
+          ordered_hash
+        end
+      end
+    end 
+    def self.clear_arranged_pages
+      # clear cache when a page changes
+      Rails.cache.delete("arranged_pages")
+    end
+
+  # def to_param
+  #   "#{id}-#{slug}"
+  # end  
+
+  private
+    def self.path_and_slug(full_url)
+      *path, slug = full_url.sub(/^\//, '').split('/')
+      [path.blank? ? '/' : "/#{path.join('/')}/", slug]
+    end
+
+
+    def update_slugs_backup
+      return nil if !self.slug_changed? || self.slug_was.nil?
+      self.slugs_backup |= [self.slug_was] #Yes, that's a single pipe...
+    end
+
+    def default_values
+      self.path  ||= '/'
+      self.title ||= self.identifier.parameterize("_")
+    end
+  end
+end