refinerycms 0.9.8.9 → 0.9.9

data/lib/refinery.rb

@@ -0,0 +1 @@
+require File.expand_path('../../base/lib/refinery', __FILE__)

data/lib/refinerycms.rb

@@ -0,0 +1,10 @@
+# Load all dependencies generically using the same name as the folder they're in.
+# This is the naming convention we'll have to stick to and it also happens
+# to be the standard naming convention and assumes each engine has a gemspec.
+# lib/refinery.rb is loaded first and this assumes we're in Refinery.root.join('lib')
+(Pathname.glob(File.expand_path('../refinery.rb', __FILE__)) |
+ Pathname.glob(File.expand_path('../../**/*.gemspec', __FILE__)).map{|gemspec|
+  gemspec.parent.join('lib', "#{gemspec.parent.split.last.to_s.downcase}.rb")
+}).each do |engine_file|
+  require engine_file if engine_file.file?
+end

data/license.md

@@ -1,6 +1,6 @@
 # MIT License
  
-Copyright (c) 2005-2010 [Resolve Digital Ltd.](http://www.resolvedigital.co.nz)
+Copyright (c) 2005-2010 [Resolve Digital](http://www.resolvedigital.com)
  
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

data/pages/app/controllers/admin/page_parts_controller.rb

@@ -0,0 +1,24 @@
+module Admin
+  class PagePartsController < Admin::BaseController
+
+    def new
+      render :partial => "/admin/pages/page_part_field", :locals => {
+        :part => PagePart.new(:title => params[:title], :body => params[:body]),
+        :new_part => true,
+        :part_index => params[:part_index]
+      }
+    end
+
+    def destroy
+      part = PagePart.find(params[:id])
+      page = part.page
+      if part.destroy
+        page.reposition_parts!
+        render :text => "'#{part.title}' deleted."
+      else
+        render :text => "'#{part.title}' not deleted."
+      end
+    end
+
+  end
+end

data/pages/app/controllers/admin/pages_controller.rb

@@ -0,0 +1,37 @@
+module Admin
+  class PagesController < Admin::BaseController
+
+    crudify :page,
+            :conditions => {:parent_id => nil},
+            :order => "lft ASC",
+            :include => [:parts, :slugs, :children, :parent, :translations],
+            :paging => false
+
+    rescue_from FriendlyId::ReservedError, :with => :show_errors_for_reserved_slug
+
+    def new
+      @page = Page.new
+      Page.default_parts.each_with_index do |page_part, index|
+        @page.parts << PagePart.new(:title => page_part, :position => index)
+      end
+    end
+
+  protected
+
+    def globalize!
+      Thread.current[:globalize_locale] = (params[:switch_locale] || (@page.present? && @page.slug.present? && @page.slug.locale) || ::Refinery::I18n.default_frontend_locale)
+    end
+
+    def show_errors_for_reserved_slug(exception)
+      flash[:error] = t('reserved_system_word', :scope => 'admin.pages')
+      if params[:action] == 'update'
+        find_page
+        render :edit
+      else
+        @page = Page.new(params[:page])
+        render :new
+      end
+    end
+
+  end
+end

data/pages/app/controllers/admin/pages_dialogs_controller.rb

@@ -0,0 +1,87 @@
+require 'net/http'
+
+module Admin
+  class PagesDialogsController < Admin::DialogsController
+
+    crudify :page
+
+    def link_to
+      @pages = Page.paginate :page => params[:page],
+                             :conditions => {:parent_id => nil},
+                             :order => 'position ASC',
+                             :per_page => Page.per_page(dialog=true)
+
+      if ::Refinery::Plugins.registered.names.include?('refinery_files')
+        @resources = Resource.paginate :page => params[:resource_page],
+                                       :order => 'created_at DESC',
+                                       :per_page => Resource.per_page(dialog=true)
+
+        # resource link
+        if params[:current_link].present?
+         is_resource_link = params[:current_link].include?("/system/resources")
+        end
+      end
+
+      # web address link
+      @web_address_text = "http://"
+      @web_address_text = params[:current_link] if params[:current_link].to_s =~ /^http:\/\//
+      @web_address_target_blank = (params[:target_blank] == "true")
+
+      # mailto link
+      if params[:current_link].present?
+        if params[:current_link] =~ /^mailto:/
+          @email_address_text = params[:current_link].split("mailto:")[1].split('?')[0]
+        end
+        @email_default_subject_text = params[:current_link].split('?subject=')[1] || params[:subject]
+        @email_default_body_text = params[:current_link].split('?body=')[1] || params[:body]
+      end
+
+      if params[:paginating].present?
+        @page_area_selected = (params[:paginating] == "your_page")
+        @resource_area_selected = (params[:paginating] == "resource_file")
+      else
+        @page_area_selected = (!is_resource_link and @web_address_text == "http://" and @email_address_text.blank?)
+        @web_address_area_selected = (@web_address_text != "http://")
+        @email_address_area_selected = @email_address_text.present?
+        @resource_area_selected = is_resource_link
+      end
+    end
+
+    def test_url
+      unless params[:url].blank?
+        url = URI.parse(params[:url])
+        if url.host.nil? && params[:url].start_with?('/')
+          url.host = URI.parse(request.url).host
+        end
+
+        http = Net::HTTP.new(url.host)
+        request = Net::HTTP::Get.new(url.path.blank? ? "/" : url.path)
+
+        response = http.request request
+
+        render :json => {:result => case response
+        when Net::HTTPSuccess, Net::HTTPRedirection
+          'success'
+        else
+          'failure'
+        end }
+      end
+
+      rescue
+        render :json => {:result => 'failure'}
+    end
+
+    def test_email
+      unless params[:email].blank?
+        valid = params[:email] =~ /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i
+
+        render :json => if valid
+          {:result => 'success'}
+        else
+          {:result => 'failure'}
+        end
+      end
+    end
+
+  end
+end

data/pages/app/controllers/pages_controller.rb

@@ -0,0 +1,32 @@
+class PagesController < ApplicationController
+
+  # This action is usually accessed with the root path, normally '/'
+  def home
+    error_404 unless (@page = Page.where(:link_url => '/').first).present?
+  end
+
+  # This action can be accessed normally, or as nested pages.
+  # Assuming a page named "mission" that is a child of "about",
+  # you can access the pages with the following URLs:
+  #
+  #   GET /pages/about
+  #   GET /about
+  #
+  #   GET /pages/mission
+  #   GET /about/mission
+  #
+  def show
+    # Find the page by the newer 'path' or fallback to the page's id if no path.
+    @page = Page.find(params[:path] ? params[:path].to_s.split('/').last : params[:id])
+
+    if @page.try(:live?) or (refinery_user? and current_user.authorized_plugins.include?("refinery_pages"))
+      # if the admin wants this to be a "placeholder" page which goes to its first child, go to that instead.
+      if @page.skip_to_first_child and (first_live_child = @page.children.order('lft ASC').where(:draft=>false).first).present?
+        redirect_to first_live_child.url
+      end
+    else
+      error_404
+    end
+  end
+
+end

data/pages/app/models/page.rb

@@ -0,0 +1,290 @@
+require 'globalize3'
+
+class Page < ActiveRecord::Base
+
+  translates :title, :meta_keywords, :meta_description, :browser_title if self.respond_to?(:translates)
+  attr_accessor :locale # to hold temporarily
+  validates :title, :presence => true
+
+  acts_as_nested_set
+
+  # Docs for friendly_id http://github.com/norman/friendly_id
+  has_friendly_id :title, :use_slug => true,
+                  :default_locale => (defined?(::Refinery::I18n.default_frontend_locale) ? ::Refinery::I18n.default_frontend_locale : :en),
+                  :reserved_words => %w(index new session login logout users refinery admin images wymiframe),
+                  :approximate_ascii => RefinerySetting.find_or_set(:approximate_ascii, false, :scoping => "pages")
+
+  has_many :parts,
+           :class_name => "PagePart",
+           :order => "position ASC",
+           :inverse_of => :page,
+           :dependent => :destroy
+
+  accepts_nested_attributes_for :parts, :allow_destroy => true
+
+  # Docs for acts_as_indexed http://github.com/dougal/acts_as_indexed
+  acts_as_indexed :fields => [:title, :meta_keywords, :meta_description,
+                              :custom_title, :browser_title, :all_page_part_content]
+
+  before_destroy :deletable?
+  after_save :reposition_parts!
+  after_save :invalidate_child_cached_url
+
+  scope :live, where(:draft => false)
+
+  # shows all pages with :show_in_menu set to true, but it also
+  # rejects any page that has not been translated to the current locale.
+  scope :in_menu, lambda {
+    pages = Arel::Table.new(Page.table_name)
+    translations = Arel::Table.new(Page.translations_table_name)
+
+    includes(:translations).where(:show_in_menu => true).where(
+      translations[:locale].eq(Globalize.locale)).where(pages[:id].eq(translations[:page_id]))
+  }
+
+  # when a dialog pops up to link to a page, how many pages per page should there be
+  PAGES_PER_DIALOG = 14
+
+  # when listing pages out in the admin area, how many pages should show per page
+  PAGES_PER_ADMIN_INDEX = 20
+
+  # when collecting the pages path how is each of the pages seperated?
+  PATH_SEPARATOR = " - "
+
+  # Am I allowed to delete this page?
+  # If a link_url is set we don't want to break the link so we don't allow them to delete
+  # If deletable is set to false then we don't allow this page to be deleted. These are often Refinery system pages
+  def deletable?
+    deletable && link_url.blank? and menu_match.blank?
+  end
+
+  # Repositions the child page_parts that belong to this page.
+  # This ensures that they are in the correct 0,1,2,3,4... etc order.
+  def reposition_parts!
+    parts.each_with_index do |part, index|
+      part.update_attribute(:position, index)
+    end
+  end
+
+  # Before destroying a page we check to see if it's a deletable page or not
+  # Refinery system pages are not deletable.
+  def destroy
+    if deletable?
+      super
+    else
+      unless Rails.env.test?
+        # give useful feedback when trying to delete from console
+        puts "This page is not deletable. Please use .destroy! if you really want it deleted "
+        puts "unset .link_url," if link_url.present?
+        puts "unset .menu_match," if menu_match.present?
+        puts "set .deletable to true" unless deletable
+      end
+
+      return false
+    end
+  end
+
+  # If you want to destroy a page that is set to be not deletable this is the way to do it.
+  def destroy!
+    self.menu_match = nil
+    self.link_url = nil
+    self.deletable = true
+
+    destroy
+  end
+
+  # Used for the browser title to get the full path to this page
+  # It automatically prints out this page title and all of it's parent page titles joined by a PATH_SEPARATOR
+  def path(options = {})
+    # Handle deprecated boolean
+    if [true, false].include?(options)
+      warning = "Page::path does not want a boolean (you gave #{options.inspect}) anymore. "
+      warning << "Please change this to {:reversed => #{options.inspect}}. "
+      warn(warning << "\nCalled from #{caller.first.inspect}")
+      options = {:reversed => options}
+    end
+
+    # Override default options with any supplied.
+    options = {:reversed => true}.merge(options)
+
+    unless parent.nil?
+      parts = [title, parent.path(options)]
+      parts.reverse! if options[:reversed]
+      parts.join(PATH_SEPARATOR)
+    else
+      title
+    end
+  end
+
+  # When this page is rendered in the navigation, where should it link?
+  # If a custom "link_url" is set, it uses that otherwise it defaults to a normal page URL.
+  # The "link_url" is often used to link to a plugin rather than a page.
+  #
+  # For example if I had a "Contact" page I don't want it to just render a contact us page
+  # I want it to show the Inquiries form so I can collect inquiries. So I would set the "link_url"
+  # to "/contact"
+  def url
+    if link_url.present?
+      link_url_localised?
+    elsif use_marketable_urls?
+      url_marketable
+    elsif to_param.present?
+      url_normal
+    end
+  end
+
+  def link_url_localised?
+    if link_url =~ %r{^/} and defined?(::Refinery::I18n) and ::Refinery::I18n.enabled? and
+       ::I18n.locale != ::Refinery::I18n.default_frontend_locale
+      "/#{::I18n.locale}#{link_url}"
+    else
+      link_url
+    end
+  end
+
+  def url_marketable
+    # :id => nil is important to prevent any other params[:id] from interfering with this route.
+    {:controller => "/pages", :action => "show", :path => nested_url, :id => nil}
+  end
+
+  def url_normal
+    {:controller => "/pages", :action => "show", :id => to_param}
+  end
+
+  # Returns an array with all ancestors to_param, allow with its own
+  # Ex: with an About page and a Mission underneath,
+  # Page.find('mission').nested_url would return:
+  #
+  #   ['about', 'mission']
+  #
+  def nested_url
+    Rails.cache.fetch(url_cache_key) { uncached_nested_url }
+  end
+
+  def uncached_nested_url
+    [parent.try(:nested_url), to_param].compact.flatten
+  end
+
+  # Returns the string version of nested_url, i.e., the path that should be generated
+  # by the router
+  def nested_path
+    @nested_path ||= "/#{nested_url.join('/')}"
+  end
+
+  def url_cache_key
+    "#{cache_key}#nested_url"
+  end
+
+  def cache_key
+    "#{Refinery.base_cache_key}/#{super}"
+  end
+
+  def use_marketable_urls?
+    RefinerySetting.find_or_set(:use_marketable_urls, true, :scoping => 'pages')
+  end
+
+  # Returns true if this page is "published"
+  def live?
+    not draft?
+  end
+
+  # Return true if this page can be shown in the navigation.
+  # If it's a draft or is set to not show in the menu it will return false.
+  def in_menu?
+    live? && show_in_menu?
+  end
+
+  # Returns true if this page is the home page or links to it.
+  def home?
+    link_url == "/"
+  end
+
+  # Returns all visible sibling pages that can be rendered for the menu
+  def shown_siblings
+    siblings.reject { |sibling| not sibling.in_menu? }
+  end
+
+  class << self
+    # Accessor to find out the default page parts created for each new page
+    def default_parts
+      RefinerySetting.find_or_set(:default_page_parts, ["Body", "Side Body"])
+    end
+
+    # Returns how many pages per page should there be when paginating pages
+    def per_page(dialog = false)
+      dialog ? PAGES_PER_DIALOG : PAGES_PER_ADMIN_INDEX
+    end
+
+    # Returns all the top level pages, usually to render the top level navigation.
+    def top_level
+      warn("Please use .live.in_menu instead of .top_level")
+      roots.where(:show_in_menu => true, :draft => false)
+    end
+  end
+
+  # Accessor method to get a page part from a page.
+  # Example:
+  #
+  #    Page.first[:body]
+  #
+  # Will return the body page part of the first page.
+  def [](part_title)
+    # don't want to override a super method when trying to call a page part.
+    # the way that we call page parts seems flawed, will probably revert to page.parts[:title] in a future release.
+    if (super_value = super).blank?
+      # self.parts is already eager loaded so we can now just grab the first element matching the title we specified.
+      part = self.parts.detect do |part|
+        part.title.present? and #protecting against the problem that occurs when have nil title
+        part.title == part_title.to_s or
+        part.title.downcase.gsub(" ", "_") == part_title.to_s.downcase.gsub(" ", "_")
+      end
+
+      return part.body unless part.nil?
+    end
+
+    super_value
+  end
+
+  # In the admin area we use a slightly different title to inform the which pages are draft or hidden pages
+  def title_with_meta
+    title = self.title.to_s
+    title << " <em>(#{::I18n.t('hidden', :scope => 'admin.pages.page')})</em>" unless show_in_menu?
+    title << " <em>(#{::I18n.t('draft', :scope => 'admin.pages.page')})</em>" if draft?
+
+    title.strip
+  end
+
+  # Used to index all the content on this page so it can be easily searched.
+  def all_page_part_content
+    parts.collect {|p| p.body}.join(" ")
+  end
+
+  ##
+  # Protects generated slugs from title if they are in the list of reserved words
+  # This applies mostly to plugin-generated pages.
+  #
+  # Returns the sluggified string
+  def normalize_friendly_id(slug_string)
+    sluggified = super
+    if use_marketable_urls? && self.class.friendly_id_config.reserved_words.include?(sluggified)
+      sluggified << "-page"
+    end
+    sluggified
+  end
+
+  private
+
+  def invalidate_child_cached_url
+    return true unless use_marketable_urls?
+    children.each do |child|
+      Rails.cache.delete(child.url_cache_key)
+    end
+  end
+
+  def warn(msg)
+    warning = ["\n*** DEPRECATION WARNING ***"]
+    warning << "#{msg}"
+    warning << ""
+    $stdout.puts warning.join("\n")
+  end
+end