comfortable_mexican_sofa 0.0.18

data/init.rb

@@ -0,0 +1 @@
+require 'comfortable_mexican_sofa'

data/lib/comfortable_mexican_sofa.rb

@@ -0,0 +1,46 @@
+require 'comfortable_mexican_sofa/cms_rails_extensions'
+require 'comfortable_mexican_sofa/cms_acts_as_tree'
+require 'comfortable_mexican_sofa/acts_as_published'
+require 'comfortable_mexican_sofa/acts_as_categorized'
+
+require 'comfortable_mexican_sofa/cms_tag'
+require 'comfortable_mexican_sofa/cms_tags/block'
+require 'comfortable_mexican_sofa/cms_tags/page_block'
+require 'comfortable_mexican_sofa/cms_tags/snippet'
+require 'comfortable_mexican_sofa/cms_tags/partial'
+# require 'comfortable_mexican_sofa/cms_tags/helper'
+# require 'comfortable_mexican_sofa/cms_tags/attachment'
+
+# Helper inclusion
+ActionView::Base.send(:include, CmsHelper)
+
+module ComfortableMexicanSofa
+  class Config
+    def self.cattr_accessor_with_default(name, value = nil)
+      cattr_accessor name
+      self.send("#{name}=", value) if value
+    end
+    
+    cattr_accessor_with_default :http_auth_enabled,   true
+    cattr_accessor_with_default :http_auth_username,  'username'
+    cattr_accessor_with_default :http_auth_password,  'password'
+    cattr_accessor_with_default :cms_title
+    cattr_accessor_with_default :additional_cms_tabs, {}
+    cattr_accessor_with_default :paperclip_options,   {}
+  end
+  
+  def self.config(&block)
+    yield ComfortableMexicanSofa::Config
+  end
+end
+
+# loading engine routes
+class ActionController::Routing::RouteSet
+  def load_routes_with_cms!
+    cms_routes = File.join(File.dirname(__FILE__), *%w[.. config cms_routes.rb])
+    add_configuration_file(cms_routes) unless configuration_files.include? cms_routes
+    load_routes_without_cms!
+  end
+  
+  alias_method_chain :load_routes!, :cms
+end

data/lib/comfortable_mexican_sofa/acts_as_categorized.rb

@@ -0,0 +1,87 @@
+module ActsAsCategorized
+  module StubMethods
+    
+    def acts_as_categorized
+      
+      __categorized = self.to_s.underscore.to_sym
+      __categorizations = "#{__categorized}_categorizations".to_sym
+      
+      # -- Attributes -------------------------------------------------------
+      attr_accessor :attr_category_ids # hash that comes from the form
+      
+      # -- Relationships ----------------------------------------------------
+      has_many __categorizations,
+        :dependent  => :destroy
+      has_many :cms_categories, 
+        :through    => __categorizations
+      
+      # -- Callbacks --------------------------------------------------------
+      after_save :save_categorizations
+      
+      # -- Named Scopes -----------------------------------------------------
+      
+      named_scope :in_category, lambda { |category| {
+        :joins => __categorizations,
+        :conditions => { __categorizations => {:cms_category_id => (category.is_a?(CmsCategory) ? category.id : category) } }
+      }}
+      
+      # -- Instance Methods -------------------------------------------------
+      define_method :save_categorizations do
+        return if attr_category_ids.blank?
+        
+        category_ids_to_remove = attr_category_ids.select{ |k, v| v.to_i == 0}.collect{|k, v| k }
+        category_ids_to_create = attr_category_ids.select{ |k, v| v.to_i == 1}.collect{|k, v| k }
+        
+        # removing unchecked categories
+        send(__categorizations).all(:conditions => { :cms_category_id => category_ids_to_remove}).collect(&:destroy)
+        
+        # creating categorizations
+        category_ids_to_create.each do |category_id|
+          send(__categorizations).create(:cms_category_id => category_id)
+        end
+      end
+    end
+    
+    def acts_as_categorization
+      
+      __categorized = self.to_s.underscore.gsub('_categorization', '').to_sym
+      __categorized_id = "#{__categorized}_id".to_sym
+      __categorizations = "#{__categorized}_categorizations".to_sym
+      
+      # -- Relationships --------------------------------------------------------
+      belongs_to __categorized.to_sym
+      belongs_to :cms_category
+      
+      # -- Validations ----------------------------------------------------------
+      validates_presence_of __categorized_id,
+                            :cms_category_id
+                            
+      validates_uniqueness_of __categorized_id, :scope => :cms_category_id
+      
+      # -- AR Callbacks ---------------------------------------------------------
+      after_save :create_parent_categorization
+      after_destroy :destroy_children_categorizations
+      
+      # -- Instance Methods -----------------------------------------------------
+      define_method :create_parent_categorization do
+        return unless cms_category.parent
+        
+        params = {
+          :cms_category_id  => cms_category.parent_id,
+          __categorized_id  => send(__categorized).id
+        }
+        self.class.create!(params) unless self.class.exists?(params)
+      end
+      
+      define_method :destroy_children_categorizations do
+        return if cms_category.children.blank?
+        
+        cms_category.children.each do |c|
+          send(__categorized).send(__categorizations).first(:conditions => {"cms_category_id" => c.id }).try(:destroy)
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.extend(ActsAsCategorized::StubMethods)

data/lib/comfortable_mexican_sofa/acts_as_published.rb

@@ -0,0 +1,60 @@
+module ActsAsPublished
+  module StubMethods
+    def acts_as_published
+      
+      extend ClassMethods
+      include InstanceMethods
+      
+      named_scope :published, lambda { |*at_time| {
+        :conditions => published_find_conditions(*at_time)
+      }}
+      named_scope :unpublished, lambda { |*at_time| {
+        :conditions => unpublished_find_conditions(*at_time)
+      }}
+    end
+  end
+  
+  module ClassMethods
+    def published_find_conditions(at_time = Time.now.utc)
+      [ "(#{self.table_name}.published_at IS NOT NULL AND #{self.table_name}.published_at <= ?)
+        AND
+        (#{self.table_name}.unpublished_at IS NULL OR #{self.table_name}.unpublished_at > ?)", 
+        at_time, at_time
+      ]
+    end
+    
+    def unpublished_find_conditions(at_time = Time.now.utc)
+      [ "(#{self.table_name}.published_at IS NULL OR #{self.table_name}.published_at > ?)
+        AND
+        (#{self.table_name}.unpublished_at IS NULL OR #{self.table_name}.unpublished_at <= ?)",
+        at_time, at_time
+      ]
+    end
+  end
+  
+  module InstanceMethods
+    
+    def is_published?(at_time = Time.now.utc)
+      published_at && published_at <= at_time && !(unpublished_at && unpublished_at <= at_time)
+    end
+    
+    def published_status
+      is_published? ? "published" : "unpublished"
+    end
+    
+    def publish!(at_time = Time.now.utc)
+      update_attributes(
+        :published_at   => at_time,
+        :unpublished_at => nil
+      )
+    end
+    
+    def unpublish!(at_time = Time.now.utc)
+      update_attributes(
+        :unpublished_at => at_time
+      )
+    end
+  end
+end
+
+ActiveRecord::Base.extend(ActsAsPublished::StubMethods)

data/lib/comfortable_mexican_sofa/cms_acts_as_tree.rb

@@ -0,0 +1,108 @@
+module ActiveRecord
+  module Acts
+    module Tree
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # Specify this +acts_as+ extension if you want to model a tree structure by providing a parent association and a children
+      # association. This requires that you have a foreign key column, which by default is called +parent_id+.
+      #
+      #   class Category < ActiveRecord::Base
+      #     acts_as_tree :order => "name"
+      #   end
+      #
+      #   Example:
+      #   root
+      #    \_ child1
+      #         \_ subchild1
+      #         \_ subchild2
+      #
+      #   root      = Category.create("name" => "root")
+      #   child1    = root.children.create("name" => "child1")
+      #   subchild1 = child1.children.create("name" => "subchild1")
+      #
+      #   root.parent   # => nil
+      #   child1.parent # => root
+      #   root.children # => [child1]
+      #   root.children.first.children.first # => subchild1
+      #
+      # In addition to the parent and children associations, the following instance methods are added to the class
+      # after calling <tt>acts_as_tree</tt>:
+      # * <tt>siblings</tt> - Returns all the children of the parent, excluding the current node (<tt>[subchild2]</tt> when called on <tt>subchild1</tt>)
+      # * <tt>self_and_siblings</tt> - Returns all the children of the parent, including the current node (<tt>[subchild1, subchild2]</tt> when called on <tt>subchild1</tt>)
+      # * <tt>ancestors</tt> - Returns all the ancestors of the current node (<tt>[child1, root]</tt> when called on <tt>subchild2</tt>)
+      # * <tt>root</tt> - Returns the root of the current node (<tt>root</tt> when called on <tt>subchild2</tt>)
+      module ClassMethods
+        # Configuration options are:
+        #
+        # * <tt>foreign_key</tt> - specifies the column name to use for tracking of the tree (default: +parent_id+)
+        # * <tt>order</tt> - makes it possible to sort the children according to this SQL snippet.
+        # * <tt>counter_cache</tt> - keeps a count in a +children_count+ column if set to +true+ (default: +false+).
+        def acts_as_tree(options = {})
+          configuration = { :foreign_key => "parent_id", :order => nil, :counter_cache => nil }
+          configuration.update(options) if options.is_a?(Hash)
+
+          belongs_to :parent, :class_name => name, :foreign_key => configuration[:foreign_key], :counter_cache => configuration[:counter_cache]
+          has_many :children, :class_name => name, :foreign_key => configuration[:foreign_key], :order => configuration[:order], :dependent => :destroy
+
+          class_eval <<-EOV
+            include ActiveRecord::Acts::Tree::InstanceMethods
+
+            def self.roots
+              find(:all, :conditions => "#{configuration[:foreign_key]} IS NULL", :order => #{configuration[:order].nil? ? "nil" : %Q{"#{configuration[:order]}"}})
+            end
+
+            def self.root
+              find(:first, :conditions => "#{configuration[:foreign_key]} IS NULL", :order => #{configuration[:order].nil? ? "nil" : %Q{"#{configuration[:order]}"}})
+            end
+          EOV
+        end
+      end
+
+      module InstanceMethods
+        # Returns list of ancestors, starting from parent until root.
+        #
+        #   subchild1.ancestors # => [child1, root]
+        def ancestors
+          node, nodes = self, []
+          nodes << node = node.parent while node.parent
+          nodes
+        end
+        
+        # Returns all children and children of children
+        def descendants
+          nodes = []
+          self.children.each do |c|
+            nodes << c
+            nodes << c.descendants
+          end
+          nodes.flatten
+        end
+
+        # Returns the root node of the tree.
+        def root
+          node = self
+          node = node.parent while node.parent
+          node
+        end
+
+        # Returns all siblings of the current node.
+        #
+        #   subchild1.siblings # => [subchild2]
+        def siblings
+          self_and_siblings - [self]
+        end
+
+        # Returns all siblings and a reference to the current node.
+        #
+        #   subchild1.self_and_siblings # => [subchild1, subchild2]
+        def self_and_siblings
+          parent ? parent.children : self.class.roots
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send :include, ActiveRecord::Acts::Tree

data/lib/comfortable_mexican_sofa/cms_rails_extensions.rb

@@ -0,0 +1,12 @@
+class String
+
+  # Converts string to something suitable to be used as an element id
+  def idify
+    self.strip.gsub(/\W/, '_').gsub(/\s|^_*|_*$/, '').squeeze('_')
+  end
+  
+  # Converts a string to something usable as a url slug
+  def slugify
+    self.downcase.gsub(/\W|_/, ' ').strip.squeeze(' ').gsub(/\s/, '-')
+  end
+end

data/lib/comfortable_mexican_sofa/cms_tag.rb

@@ -0,0 +1,109 @@
+module CmsTag
+  
+  class TagError < StandardError; end
+  
+  # Initializes all tags found in the provided content
+  # Will ignore duplicate tags. Will use format definition of the first one.
+  def self.parse_tags(*args)
+    options = args.extract_options!
+    content = args.first
+    
+    # bailing out if nothing was sent for parsing
+    return [] if content.blank?
+      
+    tags = []
+    CmsTag::Tag.subclasses.each do |tag|
+      tag = tag.constantize
+      tags << tag.parse_tags(content).group_by{|s| s.split(':')[0...2].join(':')}.collect{|g, tag_signature| tag.new(tag_signature.first, options)}
+    end
+    tags.flatten
+  end
+  
+  class Tag
+    attr_accessor :tag_signature, :label, :view, :page
+    
+    # Returns tag type based on it's classname
+    #   CmsTag::MyAwesomeTag.tag_type => 'cms_my_awesome_tag'
+    def self.tag_type
+      'cms_' + to_s.split('::').last.underscore
+    end
+    
+    def tag_type
+      self.class.tag_type
+    end
+    
+    # regular expression that finds tag signature
+    def self.regex
+      'tag regex not defined'
+    end
+    
+    # regex needed for content substitution
+    def regex
+      'tag regex not defined'
+    end
+    
+    # Returns tag identifiers from passed content based on regex defined
+    # for the particular tag
+    def self.parse_tags(content)
+      content.scan(regex).flatten
+    end
+    
+    # order at which tags get replaced with their content during page rendering
+    def self.render_priority
+      0
+    end
+    
+    def self.has_form?
+      false
+    end
+    
+    def initialize(*args)
+      options = args.extract_options!
+      self.tag_signature = args.first
+      
+      # provides access to action view methods for rendering form elements
+      if options[:view]
+        unless options[:view].is_a?(ActionView::Base)
+          raise TagError, "Expected ActionView::Base but got #{options[:view].class}" 
+        end
+        self.view = options[:view]
+      end
+      
+      # owner of the the tag
+      if options[:page]
+        unless options[:page].is_a?(CmsPage)
+          raise TagError, "Expected CmsPage but got #{options[:page].class}"
+        end
+        self.page = options[:page]
+      end
+      
+      tokens = self.tag_signature.split(':')
+      self.label = tokens[1]
+      
+      assign_accessors
+    end
+    
+    def assign_accessors
+      # ... FIX: looks retarded
+    end
+    
+    def form_label
+      "Label Undefined!"
+    end
+    
+    def form_input
+      "Form Field Undefined!"
+    end
+    
+    def content
+      'Undefined Tag'
+    end
+    
+    # when cms_page renders its content this is what tag outputs on the page
+    def render
+      content
+    end
+    
+  end
+  
+end

data/lib/comfortable_mexican_sofa/cms_tags/attachment.rb

@@ -0,0 +1,3 @@
+class CmsTag::Attachment < CmsTag::Tag
+  
+end

data/lib/comfortable_mexican_sofa/cms_tags/block.rb

@@ -0,0 +1,117 @@
+class CmsTag::Block < CmsTag::Tag
+  
+  FORMAT = {
+    :text   => {
+      :db_column    => :content_text,
+      :description  => '',
+      :form_output  => lambda { |tag|
+        tag.view.text_area_tag "cms_page[blocks][#{tag.label}][content_text]", tag.content, 
+          :rows => 20
+      }
+    },
+    :string => {
+      :db_column    => :content_string,
+      :description  => '',
+      :form_output  => lambda { |tag| 
+        tag.view.text_field_tag "cms_page[blocks][#{tag.label}][content_string]", tag.content
+      }
+    },
+    :rich_text => {
+      :db_column    => :content_text,
+      :description  => '',
+      :form_output  => lambda { |tag| 
+        tag.view.text_area_tag "cms_page[blocks][#{tag.label}][content_text]", tag.content,
+          :rows   => 20, 
+          :class  => 'mceEditor'
+      }
+    },
+    :code => {
+      :db_column    => :content_text,
+      :description  => '',
+      :form_output  => lambda { |tag| 
+        tag.view.content_tag :div, :class => 'codemirror' do 
+          tag.view.text_area_tag "cms_page[blocks][#{tag.label}][content_text]", tag.content,
+            :rows   => 20, 
+            :class  => 'codeTextArea'
+        end
+      }
+    },
+    :integer => {
+      :db_column    => :content_integer,
+      :description  => '',
+      :form_output  => lambda { |tag| 
+        tag.view.text_field_tag "cms_page[blocks][#{tag.label}][content_integer]", tag.content
+      }
+    },
+    :boolean => {
+      :db_column    => :content_boolean,
+      :description  => '',
+      :form_output  => lambda { |tag| 
+        tag.view.check_box_tag "cms_page[blocks][#{tag.label}][content_boolean]", tag.content
+      }
+    },
+    :date => {
+      :db_column   => :content_datetime,
+      :description => '',
+      :form_output => lambda { |tag| 
+        tag.view.fields_for "cms_page[blocks][#{tag.label}]" do |field|
+          field.date_select :content_datetime, :default => tag.content
+        end
+      }
+    },
+    :time => {
+      :db_column   => :content_datetime,
+      :description => '',
+      :form_output => lambda { |tag| 
+        tag.view.fields_for "cms_page[blocks][#{tag.label}]" do |field|
+          field.datetime_select :content_datetime, :default => tag.content
+        end
+      }
+    }
+  }
+  
+  attr_accessor :format
+  
+  def self.regex
+    /\{\{\s*?(cms_block:.*?)\s*?\}\}/
+  end
+  
+  def regex
+    /\{\{\s*?cms_block:#{Regexp.escape(label)}.*?\s*?\}\}/
+  end
+  
+  def self.render_priority
+    1
+  end
+  
+  def self.has_form?
+    true
+  end
+  
+  def assign_accessors
+    tokens = self.tag_signature.split(':')
+    self.label = tokens[1]
+    self.format = tokens[2]
+  end
+  
+  def form_label
+    view.label_tag label.titleize
+  end
+  
+  def form_input
+    if FORMAT.has_key? self.format.to_sym
+      FORMAT[self.format.to_sym][:form_output].call(self)
+    else
+      'Unknown tag format'
+    end
+  end
+  
+  def content
+    page && page.cms_block_content(self.label, FORMAT[self.format.to_sym][:db_column])
+  end
+  
+  def render
+    ''
+  end
+
+end