browsercms 3.0.0

data/app/helpers/cms/form_builder.rb

@@ -0,0 +1,98 @@
+class Cms::FormBuilder < ActionView::Helpers::FormBuilder
+  
+  # These are the new fields we are adding
+  
+  # A JavaScript/CSS styled select
+  def drop_down(method, choices, options = {}, html_options = {})
+    @template.drop_down(@object_name, method, choices, objectify_options(options), add_tabindex!(@default_options.merge(html_options)))
+  end
+
+  def text_editor(method, options = {})
+    @template.send(
+      "text_editor",
+      @object_name,
+      method,
+      objectify_options(options))
+  end
+
+  def date_picker(method, options={})
+    text_field(method, {:size => 10, :class => "date_picker"}.merge(options))
+  end
+  
+  def tag_list(options={})
+    field_name = options.delete(:name) || :tag_list
+    text_field(field_name, {:size => 50, :class => "tag-list"}.merge(options))
+  end
+
+  # These are the higher-level fields, 
+  # that get wrapped in divs with labels, instructions, etc.
+  
+  %w[date_picker text_area text_field file_field].each do |f|
+    src = <<-end_src
+      def cms_#{f}(method, options={})
+        add_tabindex!(options)
+        set_default_value!(method, options)
+        cms_options = options.extract!(:label, :instructions)
+        render_cms_form_partial :#{f},
+          :object_name => @object_name, :method => method,
+          :options => options, :cms_options => cms_options
+      end
+    end_src
+    class_eval src, __FILE__, __LINE__
+  end
+  
+  def cms_drop_down(method, choices, options={}, html_options={})
+    add_tabindex!(html_options)
+    cms_options = options.extract!(:label, :instructions)
+    render_cms_form_partial :drop_down,
+      :object_name => @object_name, :method => method,
+      :choices => choices, :options => options, 
+      :cms_options => cms_options, :html_options => html_options
+  end  
+    
+  def cms_tag_list(options={})
+    add_tabindex!(options)
+    cms_options = options.extract!(:label, :instructions)
+    render_cms_form_partial :tag_list, 
+      :options => options, :cms_options => cms_options
+  end
+
+  def cms_text_editor(method, options = {})
+    add_tabindex!(options)
+    cms_options = options.extract!(:label, :instructions)
+    render_cms_form_partial :text_editor, 
+      :id => (options[:id] || "#{@object_name}_#{method}"), 
+      :editor_enabled => (cookies["editorEnabled"].blank? ? true : (cookies["editorEnabled"] == 'true' || cookies["editorEnabled"] == ['true'])),
+      :object_name => @object_name, :method => method, 
+      :options => options, :cms_options => cms_options
+  end
+
+  private
+
+    def set_default_value!(method, options={})
+      if options.has_key?(:default_value) && @object.send(method).blank?
+        @object.send("#{method}=", options[:default_value])
+      end
+    end
+  
+    def add_tabindex!(options)
+      if options.has_key?(:tabindex)
+        options.delete(:tabindex) if options[:tabindex].blank?
+      else 
+        options[:tabindex] = @template.next_tabindex
+      end
+      options
+    end
+  
+    def cookies
+      #Ugly, is there an easier way to get to the cookies?
+      @template.instance_variable_get("@_request").cookies || {}
+    end
+  
+    def render_cms_form_partial(field_type_name, locals)
+      @template.render :partial => "cms/form_builder/cms_#{field_type_name}",
+        :locals => {:f => self}.merge(locals)
+    end
+  
+end
+

data/app/helpers/cms/form_tag_helper.rb

@@ -0,0 +1,32 @@
+module Cms
+  module FormTagHelper
+    
+    # A drop-down is just a specialized HTML select
+    
+    def drop_down_tag(name, option_tags = nil, options = {}) 
+      select_tag(name, option_tags, options)
+    end
+    
+    def drop_down(object, method, choices, options = {}, html_options = {})
+      select(object, method, choices, options, html_options)
+    end
+    
+    # A text editor is an HTML WYSIWYG editor.  The result of this
+    # will be a div with a select and a textarea in it.
+    
+    def text_editor_options(options={})
+      opts = options.dup
+      (opts[:class] ||= "") << " editor"
+      opts
+    end
+    
+    def text_editor_tag(name, content = nil, options = {})
+      text_area_tag(name, content, text_editor_options(options))
+    end
+    
+    def text_editor(object_name, method, options = {})
+      text_area(object_name, method, text_editor_options(options))
+    end
+        
+  end
+end

data/app/helpers/cms/menu_helper.rb

@@ -0,0 +1,172 @@
+module Cms
+  module MenuHelper
+    # This will render a menu based on the page
+    # With no options passed, it will render a menu that shows all the child sections of the root
+    # and then it will show the path of decendent sections all the way to the current page.
+    # The resulting HTML is a DIV with a UL in it.  Each LI will have an A in it.  If the item is a Section,
+    # the HREF of the A will be the URL of the first non-archived page that is a direct child of that Section.
+    # Hidden pages will not show up, but if the first page in a Section is hidden, it will be used as the URL
+    # for that Section.  This is commonly done to have a page for a Section and avoid having duplicates in the 
+    # navigation.
+    #
+    # You can change the behavior with the following options:
+    #
+    # ==== Options
+    # * <tt>:page</tt> - What page should be used.  If this value is omitted, the value in @page will be used.
+    # * <tt>:from_top</tt> - How many below levels from the root the tree should start at.  
+    #   All sections at this level will be shown.  The default is 0, which means show all
+    #   section that are direct children of the root
+    # * <tt>:depth</tt> - How many levels deep should the tree go, relative to from_top.  
+    #   If no value is supplied, the tree will go all the way down to the current page.
+    #   If a value is supplied, the tree will be that many levels underneath from_top deep.
+    # * <tt>:class</tt> - The CSS Class that will be applied to the div.  The default value is "menu".
+    # * <tt>:show_all_siblings</tt> - Passing true for this option will make all sibilings appear in the tree.
+    #   the default is false, in which case only the siblings of nodes within the open path will appear.
+    # 
+    # ==== Examples
+    #
+    # Assume you have the structure the NFL, which is NFL > Conference > Division > Team,
+    # with teams being a Page, everything else a Section.  Also, assume we are on the
+    # Baltimore Ravens page. If you're not a footbal fan, see http://sports.yahoo.com/nfl/teams
+    #
+    #   render_menu
+    #   # => <div class="menu">
+    #     <ul>
+    #       <li id="section_2" class="first open">
+    #         <a href="/buf">AFC</a>
+    #         <ul>
+    #           <li id="section_3" class="first">
+    #             <a href="/buf">East</a>
+    #           </li>
+    #           <li id="section_4" class="open">
+    #             <a href="/bal">North</a>
+    #             <ul>
+    #               <li id="page_5" class="first on">
+    #                 <a href="/bal">Baltimore Ravens</a>
+    #               </li>
+    #               <li id="page_6">
+    #                 <a href="/cin">Cincinnati Bengals</a>
+    #               </li>
+    #               <li id="page_7">
+    #                 <a href="/cle">Cleveland Browns</a>
+    #               </li>
+    #               <li id="page_8" class="last">
+    #                 <a href="/pit">Pittsburgh Steelers</a>
+    #               </li>
+    #             </ul>
+    #           </li>
+    #           <li id="section_5">
+    #             <a href="/hou">South</a>
+    #           </li>
+    #           <li id="section_6" class="last">
+    #             <a href="/den">West</a>
+    #           </li>
+    #         </ul>
+    #       </li>
+    #       <li id="section_7" class="last">
+    #         <a href="/dal">NFC</a>
+    #       </li>
+    #     </ul>
+    #   </div>
+    #
+    #   render_menu(:depth => 2, :show_all_siblings => true)
+    #   # => <div class="menu">
+    #     <ul>
+    #       <li id="section_2" class="first open">
+    #         <a href="/buf">AFC</a>
+    #         <ul>
+    #           <li id="section_3" class="first">
+    #             <a href="/buf">East</a>
+    #           </li>
+    #           <li id="section_4" class="open">
+    #             <a href="/bal">North</a>
+    #           </li>
+    #           <li id="section_5">
+    #             <a href="/hou">South</a>
+    #           </li>
+    #           <li id="section_6" class="last">
+    #             <a href="/den">West</a>
+    #           </li>
+    #         </ul>
+    #       </li>
+    #       <li id="section_7" class="last">
+    #         <a href="/dal">NFC</a>
+    #         <ul>
+    #           <li id="section_8" class="first">
+    #             <a href="/dal">East</a>
+    #           </li>
+    #           <li id="section_9">
+    #             <a href="/chi">North</a>
+    #           </li>
+    #           <li id="section_10">
+    #             <a href="/atl">South</a>
+    #           </li>
+    #           <li id="section_11" class="last">
+    #             <a href="/ari">West</a>
+    #           </li>
+    #         </ul>
+    #       </li>
+    #     </ul>
+    #   </div>    
+    def render_menu(options={})
+      #Intialize parameters
+      page = options[:page] || @page
+      from_top = options.has_key?(:from_top) ? options[:from_top].to_i : 0
+      depth = options.has_key?(:depth) ? options[:depth].to_i : 1.0/0
+      id = options[:id] || "menu"
+      css_class = options[:class] || "menu"
+      show_all_siblings = !!(options[:show_all_siblings])
+
+      html = "<div id=\"#{id}\" class=\"#{css_class}\">\n"
+      
+      ancestors = page.ancestors
+      if from_top > ancestors.size
+        return html << "</div>\n"
+      else
+        ancestors = page.ancestors[from_top..-1]
+      end
+      
+      #We are defining a recursive lambda that takes the top-level sections
+      #d is the current depth
+      fn = lambda do |nodes, d|
+        indent = (d-1)*4
+        html << "<ul>\n".indent(indent+2)
+        nodes.each_with_index do |sn, i|
+
+          #Construct the CSS classes that the LI should have
+          classes = ["depth-#{d}"]
+          if i == 0
+            classes << "first"
+          elsif i == nodes.size-1
+            classes << "last"
+          end
+          classes << "open" if ancestors.include?(sn.node)
+          classes << "on" if page == sn.node
+          cls = classes.empty? ? nil : classes.join(" ")
+          
+          html << %Q{<li id="#{sn.node_type.underscore}_#{sn.node.id}"#{cls ? " class=\"#{cls}\"" : ''}>\n}.indent(indent+4)
+          
+          #Figure out what this link for this node should be
+          #If it is a page, then the page will simply be used
+          #But if is a page, we call the first_page_or_link method
+          p = sn.node_type == "Section" ? sn.node.first_page_or_link : sn.node
+          html << %Q{<a href="#{p ? p.path : '#'}"#{(p.respond_to?(:new_window) && p.new_window?) ? ' target="_blank"' : ''}>#{sn.node.name}</a>\n}.indent(indent+6)
+          
+          #Now if this is a section, we do the child nodes, 
+          #but only if the show_all_siblings parameter is true, 
+          #or if this section is one of the current page's ancestors
+          #and also if the current depth is less than the target depth
+          if sn.node_type == "Section" && (show_all_siblings || ancestors.include?(sn.node)) && d < depth
+            fn.call(sn.node.visible_child_nodes, d+1)
+          end
+          
+          html << %Q{</li>\n}.indent(indent+4)
+          
+        end
+        html << "</ul>\n".indent(indent+2)
+      end
+      fn.call(ancestors.first.visible_child_nodes, 1) unless ancestors.first.blank?
+      html << "</div>\n"
+    end
+  end
+end

data/app/helpers/cms/page_helper.rb

@@ -0,0 +1,60 @@
+module Cms
+  module PageHelper
+    def current_page
+      @page
+    end
+    
+    def container(name)
+      content = instance_variable_get("@content_for_#{name}")
+      if logged_in? && @mode == "edit"
+        render :partial => 'cms/pages/edit_container', :locals => {:name => name, :content => content}
+      else
+        content
+      end
+    end
+    
+    def container_has_block?(name, &block)
+      has_block = (@mode == "edit") || current_page.connectable_count_for_container(name) > 0
+      logger.info "mode = #{@mode}, has_block = #{has_block}"
+      if block_given?
+        concat(capture(&block)) if has_block
+      else
+        has_block
+      end
+    end
+    
+    def cms_toolbar
+      instance_variable_get("@content_for_layout")
+    end
+    
+    def render_breadcrumbs(options={})
+      start = options[:from_top] || 0
+      show_parent = options[:show_parent].nil? ? false : options[:show_parent]
+      ancestors = current_page.ancestors
+      items = []
+      ancestors[start..ancestors.size].each_with_index do |sec,i|
+        items << content_tag(:li, 
+          link_to(h(sec.name), sec.actual_path), 
+          (i == 0 ? {:class => "first"} : {}))
+      end
+      if !show_parent && current_page.section.path == current_page.path
+        items[items.size-1] = content_tag(:li, h(current_page.section.name))
+      else
+        items << content_tag(:li, h(current_page.page_title))
+      end
+      content_tag(:ul, "\n  #{items.join("\n  ")}\n", :class => "breadcrumbs")
+    end
+    
+    def render_portlet(name)
+      portlets = Portlet.all(:conditions => ["name = ?", name.to_s])
+      if portlets.size > 1
+        @mode == "edit" ? "ERROR: Multiple Portlets with name '#{name}'" : nil
+      elsif portlets.empty?
+        @mode == "edit" ? "ERROR: No Portlet with name '#{name}'" : nil
+      else
+        render_connectable(portlets.first)
+      end
+    end
+            
+  end
+end

data/app/helpers/cms/path_helper.rb

@@ -0,0 +1,48 @@
+module Cms
+  module PathHelper
+    def cms_index_path_for(resource, options={})
+      send("cms_#{resource_collection_name(resource).pluralize}_path", options)
+    end
+    
+    def cms_index_url_for(resource, options={})
+      send("cms_#{resource_collection_name(resource).pluralize}_url", options)
+    end
+    
+    def cms_new_path_for(resource, options={})
+      send("new_cms_#{resource_collection_name(resource)}_path", options)
+    end
+    
+    def cms_new_url_for(resource, options={})
+      send("new_cms_#{resource_collection_name(resource)}_url", options)
+    end
+    
+    def cms_connectable_path(connectable, options={})
+      if Portlet === connectable
+        cms_portlet_path(connectable)
+      else
+        [:cms, connectable]
+      end
+    end
+    
+    def edit_cms_connectable_path(connectable, options={})
+      if Portlet === connectable
+        edit_cms_portlet_path(connectable, options)
+      else
+        polymorphic_path([:edit, :cms, connectable], options)        
+      end
+    end
+    
+    private
+      # Returns the name of the collection that this resouce belongs to
+      # the resource can be a ContentType, ActiveRecord::Base instance
+      # or just a string or symbol
+      def resource_collection_name(resource)
+        collection_name = case resource
+          when ContentType then resource.name.underscore
+          when ActiveRecord::Base then resource.class.name.underscore
+          else resource.to_s
+        end
+      end
+        
+  end
+end

data/app/helpers/cms/section_nodes_helper.rb

@@ -0,0 +1,13 @@
+module Cms
+  module SectionNodesHelper
+    def section_icons(node)
+      
+      if (node.root? || node.parent.root? || node.parent.parent.root?)
+        node.child_nodes.empty? ? image_tag("cms/sitemap/no_contents.png", :class => "no_folder_toggle large") : image_tag("cms/sitemap/gray_expand.png", :class => "folder_toggle large")
+      else
+        node.child_nodes.empty? ? image_tag("cms/sitemap/no_contents.png", :class => "no_folder_toggle") : image_tag("cms/sitemap/expand.png", :class => "folder_toggle")
+      end
+    end
+
+  end
+end

data/app/models/abstract_file_block.rb

@@ -0,0 +1,13 @@
+class AbstractFileBlock < ActiveRecord::Base
+  
+  set_table_name "file_blocks"
+      
+  validates_presence_of :name  
+  
+  named_scope :by_section, lambda { |section| { :include => {:attachment => :section_node }, :conditions => ["section_nodes.section_id = ?", section.id] } } 
+  
+  def path
+    attachment_file_path
+  end
+
+end

data/app/models/attachment.rb

@@ -0,0 +1,193 @@
+require 'digest/sha1'
+require 'ftools'
+
+class Attachment < ActiveRecord::Base
+
+  #----- Macros ----------------------------------------------------------------
+
+  is_archivable
+  is_publishable
+  uses_soft_delete
+  is_userstamped
+  is_versioned
+  attr_accessor :temp_file
+
+  #----- Callbacks -------------------------------------------------------------
+
+  before_validation :make_dirty_if_temp_file
+  before_validation :prepend_file_path_with_slash
+  before_validation :extract_file_extension_from_file_name
+  before_validation :extract_file_type_from_temp_file
+  before_validation :extract_file_size_from_temp_file
+  before_validation :set_file_location
+  before_save :process_section
+
+  after_save :write_temp_file_to_storage_location
+  after_save :clear_ivars  
+  
+  #----- Associations ----------------------------------------------------------
+
+  has_one :section_node, :as => :node
+
+  #----- Validations -----------------------------------------------------------
+
+  validates_presence_of :temp_file, 
+    :message => "You must upload a file", :on => :create
+  validates_presence_of :file_path
+  validates_uniqueness_of :file_path
+  validates_presence_of :section_id
+    
+  #----- Virtual Attributes ----------------------------------------------------
+  
+  def section_id
+    @section_id ||= section_node ? section_node.section_id : nil
+  end
+
+  def section_id=(section_id)
+    if @section_id != section_id 
+      dirty!
+      @section_id = section_id
+    end
+  end
+
+  def section
+    @section ||= section_node ? section_node.section : nil
+  end
+
+  def section=(section)
+    if @section != section
+      dirty!
+      @section_id = section ? section.id : nil
+      @section = section
+    end
+  end
+  
+  #----- Callbacks Methods -----------------------------------------------------
+  
+  def make_dirty_if_temp_file
+    dirty! if temp_file
+  end
+  
+  def prepend_file_path_with_slash    
+    unless file_path.blank?
+      self.file_path = "/#{file_path}" unless file_path =~ /^\//
+    end
+  end
+  
+  def extract_file_extension_from_file_name
+    if file_name && file_name['.']
+      self.file_extension = file_name.split('.').last.to_s.downcase
+    end    
+  end
+  
+  def extract_file_type_from_temp_file
+    unless temp_file.blank?
+      self.file_type = temp_file.content_type
+    end    
+  end
+  
+  def extract_file_size_from_temp_file  
+    unless temp_file.blank?
+      self.file_size = temp_file.size
+    end    
+  end
+
+  # The file will be stored on disk at 
+  # Attachment.storage_location/year/month/day/sha1
+  # The sha1 is a 40 character hash based on the original_filename
+  # of the file uploaded and the current time
+  def set_file_location
+    unless temp_file.blank?
+      sha1 = Digest::SHA1.hexdigest("#{temp_file.original_filename}#{Time.now.to_f}")
+      self.file_location = "#{Time.now.strftime("%Y/%m/%d")}/#{sha1}"
+    end
+  end
+
+  def process_section
+    #logger.info "processing section, section_id => #{section_id}, section_node => #{section_node.inspect}"
+    if section_node && !section_node.new_record? && section_node.section_id != section_id
+      section_node.move_to_end(Section.find(section_id))
+    else
+      build_section_node(:node => self, :section_id => section_id)
+    end    
+  end
+    
+  def write_temp_file_to_storage_location
+    unless temp_file.blank?
+      FileUtils.mkdir_p File.dirname(full_file_location)
+      if temp_file.local_path
+        File.copy temp_file.local_path, full_file_location
+      else
+        open(full_file_location, 'w') {|f| f << temp_file.read }
+      end
+      
+      if Cms.attachment_file_permission
+        FileUtils.chmod Cms.attachment_file_permission, full_file_location
+      end
+    end
+  end  
+  
+  def clear_ivars
+    @temp_file = nil
+    @section = nil
+    @section_id = nil
+  end
+  
+  #----- Class Methods ---------------------------------------------------------
+  
+  def self.storage_location
+    @storage_location ||= File.join(Rails.root, "/tmp/uploads")
+  end
+  
+  def self.storage_location=(storage_location)
+    @storage_location = storage_location
+  end  
+  
+  def self.find_live_by_file_path(file_path)
+    Attachment.published.not_archived.first(:conditions => {:file_path => file_path})
+  end  
+  
+  #----- Instance Methods ------------------------------------------------------
+
+  def file_name
+    file_path ? file_path.split('/').last : nil
+  end
+
+  def name
+    file_name
+  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?(file_extension.to_s)
+    end
+    :file
+  end
+
+  def public?
+    section ? section.public? : false
+  end
+  
+  def full_file_location
+    File.join(Attachment.storage_location, file_location)
+  end
+
+  # Forces this record to be changed, even if nothing has changed
+  # This is necessary if just the section.id has changed, for example
+  def dirty!
+    # Seems like a hack, is there a better way?
+    self.updated_at = Time.now
+  end
+
+end