browsercms-artirix 4.0.0.rc1.art4

data/app/inputs/template_editor_input.rb

@@ -0,0 +1,24 @@
+class TemplateEditorInput < SimpleForm::Inputs::TextInput
+
+  include Cms::FormBuilder::DefaultInput
+
+  def label(_wrapper_options = nil)
+    super if render_template_input?
+  end
+
+  def input(_wrapper_options = nil)
+    if render_template_input?
+      options[:default] = object.class.default_template
+      options[:default_handler] = "erb" unless options[:default_handler]
+      view = @builder.select "#{attribute_name}_handler", ActionView::Template.template_handler_extensions, selected: options[:default_handler]
+      view << '<br />'.html_safe
+      extract_default
+      view << @builder.text_area(attribute_name, input_html_options).html_safe
+    end
+  end
+
+  private
+  def render_template_input?
+    object.class.render_inline
+  end
+end

data/app/inputs/text_editor_input.rb

@@ -0,0 +1,19 @@
+class TextEditorInput < SimpleForm::Inputs::TextInput
+
+  def input(_wrapper_options)
+    tag_id = "#{object_name}_#{attribute_name}"
+    s = template.select_tag(:dhtml_selector,
+                                  template.options_for_select([["Rich Text", ""],["Simple Text", "disabled"]],
+                                  template.cookies[:editorEnabled] == 'true' ? "" : "disabled"),
+                                  :class => "#{object_name}_#{attribute_name}_dhtml_selector",
+                                  :tabindex => '-1',
+                                  :onchange => "toggleEditor('#{tag_id}', this)".html_safe)
+    s += template.content_tag(:div, super, class: 'editor')
+
+  end
+
+  # Mark textarea with class for WYSIWYG editor.
+  def input_html_classes
+    super.push('editor')
+  end
+end

data/app/models/cms/abstract_file_block.rb

@@ -0,0 +1,50 @@
+module Cms
+  class AbstractFileBlock < ActiveRecord::Base
+    self.table_name = "cms_file_blocks"
+
+    def self.with_parent_id(parent_id)
+      if parent_id == 'all'
+        where(true) # Empty scope for chaining
+      else
+        self.includes({:attachments => :section_node})
+            .references(:section_node)
+            .where(["#{"cms_section_nodes"}.ancestry = ?",  Section.find(parent_id).ancestry_path])
+
+      end
+    end
+
+    validates_presence_of :name
+
+    # Return the parent section for this block.
+    # @return [Cms::Section]
+    def parent
+      file.parent
+    end
+
+    # Exists here so FileBrowser can polymorphically call file_size on Page, Images, Files, etc.
+    def file_size
+      file.size.round_bytes
+    end
+
+    def path
+      file.url
+    end
+
+    def self.publishable?
+      true
+    end
+
+    def set_attachment_path
+      if @attachment_file_path && @attachment_file_path != attachment.file_path
+        attachment.file_path = @attachment_file_path
+      end
+    end
+
+    def set_attachment_section
+      if @attachment_section_id && @attachment_section_id != attachment.section
+        attachment.section_id = @attachment_section_id
+      end
+    end
+
+  end
+end

data/app/models/cms/attachment.rb

@@ -0,0 +1,267 @@
+module Cms
+  class Attachment < ActiveRecord::Base
+
+    MULTIPLE = 'multiple'
+
+    SANITIZATION_REGEXES = [[/\s/, '_'], [/[&+()]/, '-'], [/[=?!'"{}\[\]#<>%]/, '']]
+    #' this tic cleans up emacs ruby mode
+
+    self.table_name = :cms_attachments
+
+    cattr_accessor :definitions, :instance_writer => false
+    @@definitions = {}.with_indifferent_access
+    cattr_reader :configuration
+
+    before_validation :set_cardinality
+    before_save :set_section, :sanitized_file_path_and_name
+    before_create :setup_attachment
+
+    belongs_to :attachable, :polymorphic => true
+
+    extend DefaultAccessible
+
+    validates :attachment_name, :attachable_type, :presence => true
+
+    is_addressable
+    include Cms::Concerns::Addressable::DeprecatedPageAccessors
+
+    is_archivable; is_publishable; uses_soft_delete; is_userstamped; is_versioned
+
+    scope :named, lambda { |name|
+      {:conditions => {:attachment_name => name.to_s}}
+    }
+
+    scope :multiple, -> {where(:cardinality => MULTIPLE)}
+
+    FILE_BLOCKS = "Cms::AbstractFileBlock"
+    validates_presence_of :data_file_path, :if => Proc.new { |a| a.attachable_type == FILE_BLOCKS }
+    validates_uniqueness_of :data_file_path, :message =>"must be unique. (Another file, image or page is already using '%{value}').", :if => Proc.new { |a| a.attachable_type == FILE_BLOCKS }
+
+    class << self
+
+      def permitted_params
+        super + [:attachable_class, :data]
+      end
+      # Makes file paths more URL friendly
+      def sanitize_file_path(file_path)
+        SANITIZATION_REGEXES.inject(file_path.to_s) do |s, (regex, replace)|
+          s.gsub(regex, replace)
+        end
+      end
+
+      def definitions_for(klass, type)
+        definitions[klass].inject({}) { |d, (k, v)| d[k.capitalize] = v if v["type"] == type; d }
+      end
+
+      def configuration
+        @@configuration ||= Cms::Attachments.configuration
+      end
+
+      # Returns a Proc that can be used to dynamically determine styles based on the Cms::Attachment class
+      #
+      # Paperclip can handle a :styles parameter which responds to :call(Paperclip::Attachment)
+      def dynamically_return_styles
+        lambda do |paperclip_attachment|
+          cms_attachment = paperclip_attachment.instance
+
+          # Look up the style for the given block
+          if cms_attachment.has_assigned_content_type?
+            configuration_value(cms_attachment.content_block_class, cms_attachment.attachment_name, :styles)
+          else # New attachments that aren't associated with an Attaching type yet have no styles
+            {}
+          end
+        end
+      end
+
+      def find_live_by_file_path(path)
+        Attachment.published.not_archived.find_by_data_file_path path
+      end
+
+
+      def configure_paperclip
+        # @todo This might be better done using subclasses of Attachment for each document instance.
+        # We could use single table inheritance to avoid needing to do meta configurations.
+        has_attached_file :data,
+                          :url => configuration.url,
+                          :path => configuration.path,
+                          :styles => dynamically_return_styles,
+
+                          # Needed for versioning so that we keep all previous files.
+                          :preserve_files => true,
+
+                          #TODO: enable custom processors
+                          :processors => configuration.processors,
+                          :default_url => configuration.default_url,
+                          :default_style => configuration.default_style,
+                          :use_timestamp => configuration.use_timestamp,
+                          :whiny => configuration.whiny,
+                          :storage => rail_config(:storage),
+                          :s3_credentials => rail_config(:s3_credentials),
+                          :bucket => rail_config(:s3_bucket),
+                          :s3_host_name => rail_config(:s3_host_name),
+                          :s3_host_alias => rail_config(:s3_host_alias)
+
+      end
+
+      # Looks up a value from Rails config
+      def rail_config(key)
+        Rails.configuration.cms.attachments[key]
+      end
+
+      # Looks up the configuration value given:
+      # @param [Class] block_class The class of a block which has an attachment.
+      # @param [String] name_of_attachment The name of the attachment association (i.e. if was 'has_attachment :photos' then pass 'photo')
+      # @param [Symbol] key The key for the value to be fetched (i.e. :styles)
+      def configuration_value(block_class, name_of_attachment, key)
+        class_definitions = definitions[block_class]
+        if class_definitions == nil
+          raise "Couldn't find any definitions for '#{block_class}'. Available definitions are #{definitions.inspect}."
+        end
+        attachment_definition = class_definitions[name_of_attachment]
+        if attachment_definition == nil
+          raise "Verify that '#{block_class}' defines an attachment named ':#{name_of_attachment}'."
+        end
+        attachment_definition[key] || configuration.send(key)
+      end
+
+    end
+
+    def attachable_class
+      attachable_type
+    end
+
+    # @todo There isn't any good reason I know of why this needs to be a distinct field. Needed to add it to get it working for 4.0 though.
+    def attachable_class=(klass)
+      self.attachable_type = klass
+    end
+
+    def section=(section)
+      dirty! if self.section != section
+      super(section)
+    end
+
+    def config_value_for(key)
+      self.class.configuration_value(content_block_class, attachment_name, key)
+    end
+
+    def content_block_class
+      attachable.try(:class).try(:name) || attachable_type
+      #attachable_class || attachable.try(:class).try(:name) || attachable_type
+    end
+
+    def icon
+      {
+          :doc => %w[doc],
+          :gif => %w[gif jpg jpeg png tiff bmp],
+          :htm => %w[htm html],
+          :pdf => %w[pdf],
+          :ppt => %w[ppt],
+          :swf => %w[swf],
+          :txt => %w[txt],
+          :xls => %w[xls],
+          :xml => %w[xml],
+          :zip => %w[zip rar tar gz tgz]
+      }.each do |icon, extensions|
+        return icon if extensions.include?(data_file_extension)
+      end
+      :file
+    end
+
+    # For authorized users, return the path to get the specific version of the file associated with this attachment.
+    # Guests should always get 'data_file_path' which is the public version of the asset.
+    def attachment_version_path
+      "/cms/attachments/#{id}?version=#{version}"
+    end
+
+    def public?
+      section ? section.public? : false
+    end
+
+    def is_image?
+      %w[jpg gif png jpeg].include?(data_file_extension)
+    end
+
+    # Returns a Paperclip generated relative path to the file (with thumbnail sizing)
+    def url(style_name = configuration.default_style)
+      data.url(style_name)
+    end
+
+    # Returns the absolute file location of the underlying asset
+    def path(style_name = configuration.default_style)
+      data.path(style_name)
+    end
+
+    def original_filename
+      data_file_name
+    end
+
+    alias :file_name :original_filename
+
+    def size
+      data_file_size
+    end
+
+    def content_type
+      data_content_type
+    end
+
+    alias :file_type :content_type
+
+    # Returns the definitions for this particular attachment type.
+    # @return [Hash] Empty Hash if no definition have been defined for this attachment.
+    def config
+      content_defs = definitions[content_block_class] ? definitions[content_block_class] : {}
+      content_defs[attachment_name] ? content_defs[attachment_name] : {}
+    end
+
+    # Determines if this Attachment has access to configuration information yet. Until it is assigned to an Attaching object,
+    # it will lack style information.
+    def has_assigned_content_type?()
+      attachable_type && attachment_name
+    end
+
+    protected
+
+    private
+
+    def data_file_extension
+      data_file_name.split('.').last.downcase if data_file_name && data_file_name['.']
+    end
+
+    # Filter - Ensure that paths are going to URL friendly (and won't need encoding for special characters.')
+    def sanitized_file_path_and_name
+      if data_file_path
+        self.data_file_path = self.class.sanitize_file_path(data_file_path)
+        if !data_file_path.empty? && !data_file_path.starts_with?("/")
+          self.data_file_path = "/#{data_file_path}"
+        end
+      end
+
+      if data_file_name
+        self.data_file_name = self.class.sanitize_file_path(data_file_name)
+      end
+    end
+
+    def set_section
+      unless parent
+        self.parent = Section.root.first
+      end
+    end
+
+    def setup_attachment
+      data.instance_variable_set :@url, config_value_for(:url)
+      data.instance_variable_set :@path, config_value_for(:path)
+      data.instance_variable_set :@styles, config_value_for(:styles)
+      data.instance_variable_set :@normalized_styles, nil
+      data.send :post_process_styles
+    end
+
+    # Attachments should always be configured with a cardinality
+    def set_cardinality
+      unless cardinality
+        self.cardinality = config[:type].to_s
+      end
+
+    end
+  end
+end

data/app/models/cms/category.rb

@@ -0,0 +1,56 @@
+module Cms
+  class Category < ActiveRecord::Base
+    belongs_to :category_type, :class_name => 'Cms::CategoryType'
+    belongs_to :parent, :class_name => 'Cms::Category'
+    has_many :children, :class_name => 'Cms::Category', :foreign_key => "parent_id"
+    is_searchable
+    has_content_type :module => :categorization
+
+    extend DefaultAccessible
+    include Concerns::IgnoresPublishing
+
+    validates_presence_of :category_type_id, :name
+    validates_uniqueness_of :name, :scope => :category_type_id
+
+    class << self
+      def named(name)
+        where(["#{table_name}.name = ?", name])
+      end
+
+      def of_type(type_name)
+        where(["#{CategoryType.table_name}.name = ?", type_name])
+        .order("#{Category.table_name}.name")
+        .includes(:category_type)
+        .references(:category_type)
+      end
+    end
+    scope :top_level, -> { where(["#{Category.table_name}.parent_id is null"]) }
+    scope :list, -> { includes(:category_type) }
+
+    def ancestors
+      fn = lambda do |cat, parents|
+        if cat.parent_id
+          p = self.class.find(cat.parent)
+          fn.call(p, (parents << p))
+        else
+          parents.reverse
+        end
+      end
+      fn.call(self, [])
+    end
+
+    def path(sep=" > ")
+      (ancestors.map(&:name) + [name]).join(sep)
+    end
+
+    def category_type_name
+      category_type ? category_type.name : nil
+    end
+
+    def self.columns_for_index
+      [{:label => "Name", :method => :name, :order => "#{Category.table_name}.name"},
+       {:label => "Type", :method => :category_type_name, :order => "#{CategoryType.table_name}.name"},
+       {:label => "Updated On", :method => :updated_on_string, :order => "#{Category.table_name}.updated_at"}]
+    end
+  end
+end

data/app/models/cms/category_type.rb

@@ -0,0 +1,43 @@
+module Cms
+  class CategoryType < ActiveRecord::Base
+
+    has_many :categories, :class_name => 'Cms::Category'
+    validates_presence_of :name
+    validates_uniqueness_of :name
+    is_searchable
+    has_content_type :module => :categorization
+
+    include Concerns::IgnoresPublishing
+
+    def self.named(name)
+      where(name: name)
+    end
+
+    # Return a map when the key is category type id as a string
+    # and the value is an array of arrays, each entry having
+    # the first value as the category path and the second value
+    # being the category id as a string
+    def self.category_map
+      all.inject(Hash.new([])) do |map, ct|
+        map[ct.id.to_s] = ct.category_list.map { |c| [c.path, c.id.to_s] }
+        map
+      end
+    end
+
+    # This is used to get the full list of categories for this category type in the correct order.
+    def category_list(order="name")
+      list = []
+      fn = lambda do |cat|
+        list << cat
+        cat.children.order(order).each { |c| fn.call(c) }
+      end
+      categories.top_level.order(order).each { |cat| fn.call(cat) }
+      list
+    end
+
+    def cannot_be_deleted_message
+      categories.count.zero? ? nil : "This cannot be deleted because it is in use in #{categories.count} #{"category".pluralize_unless_one(categories.count)}"
+    end
+
+  end
+end

data/app/models/cms/connector.rb

@@ -0,0 +1,99 @@
+module Cms
+  class Connector < ActiveRecord::Base
+
+    belongs_to :page, :class_name => 'Cms::Page'
+    belongs_to :connectable, :polymorphic => true
+
+    extend DefaultAccessible
+    #attr_accessible :connectable, :page_version, :connectable_version, :container # Need to be explicit due to seed data loading
+
+    acts_as_list :scope => "#{Connector.table_name}.page_id = \#{page_id} and #{Cms::Connector.table_name}.page_version = \#{page_version} and #{Cms::Connector.table_name}.container = '\#{container}'"
+    alias :move_up :move_higher
+    alias :move_down :move_lower
+
+    class << self
+      def for_page_version(pv)
+        where(:page_version => pv)
+      end
+
+      def for_connectable_version(cv)
+        where(:connectable_version => cv)
+      end
+
+      def for_connectable(c)
+        where(:connectable_id => c.id, :connectable_type => c.class.base_class.name)
+      end
+
+      def in_container(container)
+        where(:container => container)
+      end
+
+      def at_position(position)
+        where(:position => position)
+      end
+
+      def like(connector)
+        where(:connectable_id => connector.connectable_id,
+              :connectable_type => connector.connectable_type,
+              :connectable_version => connector.connectable_version,
+              :container => connector.container,
+              :position => connector.position)
+      end
+    end
+
+    validates_presence_of :page_id, :page_version, :connectable_id, :connectable_type, :container
+
+    def current_connectable
+      if versioned?
+        connectable.as_of_version(connectable_version) if connectable
+      else
+        get_connectable
+      end
+    end
+
+    def connectable_with_deleted
+      c = if connectable_type.constantize.respond_to?(:find_with_deleted)
+            connectable_type.constantize.find_with_deleted(id: connectable_id)
+          else
+            connectable_type.constantize.find(connectable_id)
+          end
+      (c && c.class.versioned?) ? c.as_of_version(connectable_version) : c
+    end
+
+    def status
+      live? ? 'published' : 'draft'
+    end
+
+    def status_name
+      status.to_s.titleize
+    end
+
+    def live?
+      if publishable?
+        connectable.live?
+      else
+        true
+      end
+    end
+
+    def publishable?
+      connectable_type.constantize.publishable?
+    end
+
+    def versioned?
+      connectable_type.constantize.versioned?
+    end
+
+    # Determines if a connector should be copied when a page is updated/versioned, etc.
+    #
+    #
+    def should_be_copied?
+      if connectable && (!connectable.respond_to?(:draft) || !connectable.draft.deleted?)
+        return true
+      end
+
+
+      false
+    end
+  end
+end

data/app/models/cms/content.rb

@@ -0,0 +1,31 @@
+module Cms
+  # An API for interacting with the Content API of BrowserCMS.
+  module Content
+
+    # Find a single content item.
+    # example:
+    #   Cms::Content.find("html_block", 12) # Finds a Cms::HtmlBlock with an id of 12.
+    #
+    # @param [String] content_name The name of the content type to find.
+    # @param [Integer] id The id of the content.
+    # @return [ContentBlock] A single content block or page
+    def self.find(content_type, id)
+      if content_type == "page"
+        return Cms::Page.find(id)
+      end
+      type = ContentType.find_by_key(content_type)
+      type.model_class.find(id)
+    end
+
+    # Find the latest draft for a single content item.
+    # example:
+    #   Cms::Content.find("html_block", 12) # Finds a Cms::HtmlBlock with an id of 12.
+    #
+    # @param [String] content_name The name of the content type to find.
+    # @param [Integer] id The id of the content.
+    # @return [ContentBlock] A single content block or page
+    def self.find_draft(content_type, id)
+      find(content_type, id).as_of_draft_version
+    end
+  end
+end