humpyard 0.0.1

data/lib/humpyard.rb

@@ -0,0 +1,70 @@
+####
+# Welcome to Humpyard
+require 'cancan'
+require 'humpyard_form'
+
+module Humpyard
+  # This is the actual version of the Humpyard gem
+  VERSION = ::File.read(::File.join(::File.dirname(__FILE__), "..", "VERSION")).strip  
+    
+  def self.load options = {} #:nodoc:
+    require ::File.expand_path('../humpyard/rake_tasks', __FILE__)
+  end
+  
+  # This is the path to the Humpyard gem's root directory
+  def base_directory
+    ::File.expand_path(::File.join(::File.dirname(__FILE__), '..'))
+  end
+  
+  # This is the path to the Humpyard gem's lib directory
+  def lib_directory
+    ::File.expand_path(::File.join(::File.dirname(__FILE__)))
+  end
+    
+  module_function :base_directory, :lib_directory
+
+  class << self    
+    # To access the actual configuration of your Humpyard, you can call this.
+    #
+    # An example would be <tt>Humpyard.config.www_prefix = 'cms/:locale/'</tt>
+    #
+    # See Humpyard::Config for configuration options.
+    def config
+      @config ||= Humpyard::Config.new
+    end
+    
+    def uri_parser
+      @uri_parser ||= Humpyard::UriParser
+    end
+
+    # Configure the Humpyard 
+    # See Humpyard::Config.configure for details
+    def configure(&block)
+      config.configure(&block)
+    end
+  end
+end
+
+require File.expand_path('../humpyard/config', __FILE__)
+require File.expand_path('../humpyard/engine', __FILE__)
+require File.expand_path('../humpyard/compass', __FILE__)
+require File.expand_path('../humpyard/uri_parser', __FILE__)
+require File.expand_path('../humpyard/uri_parser/pages_uri_parser', __FILE__)
+require File.expand_path('../humpyard/uri_parser/assets_uri_parser', __FILE__)
+
+require 'i18n'
+I18n.load_path += Dir.glob("#{File.dirname(__FILE__)}/../config/locales/*.yml")
+I18n.backend.reload!
+puts "=> #{I18n.t :'humpyard_cms.start', :version => Humpyard::VERSION, :raise => true}"
+
+require File.expand_path('../humpyard/action_controller/base', __FILE__)
+require File.expand_path('../humpyard/active_model/validators/publish_range', __FILE__)
+require File.expand_path('../humpyard/active_model/translation', __FILE__)
+require File.expand_path('../humpyard/active_model/naming', __FILE__)
+require File.expand_path('../humpyard/active_record/acts/element', __FILE__)
+require File.expand_path('../humpyard/active_record/acts/container_element', __FILE__)
+require File.expand_path('../humpyard/active_record/acts/page', __FILE__)
+require File.expand_path('../humpyard/active_record/acts/asset', __FILE__)
+require File.expand_path('../humpyard/active_record/has/title_for_url', __FILE__)
+
+

data/lib/humpyard/action_controller/base.rb

@@ -0,0 +1,24 @@
+module Humpyard
+  module ActionController #:nodoc:
+    module Base #:nodoc:
+
+      def self.included(base)
+        base.module_eval do
+          helper_attr :humpyard_user
+          helper_attr :humpyard_logout_path
+        end
+      end
+
+      def humpyard_user    
+        current_user
+      end
+       
+      def humpyard_logout_path
+        "?user="
+      end
+    end
+  end
+end
+
+ActionController::Base.send :include, Humpyard::ActionController::Base
+

data/lib/humpyard/active_model/naming.rb

@@ -0,0 +1,29 @@
+module Humpyard 
+  module ActiveModel #:nodoc:
+    module Name #:nodoc:
+      def self.included(base)
+        base.alias_method_chain :human, :namespaces
+      end
+      
+      def human_with_namespaces(options={})
+        # Rails orig
+        return @human unless @klass.respond_to?(:lookup_ancestors) &&
+                             @klass.respond_to?(:i18n_scope)
+
+        # Namespace patch
+        defaults = @klass.lookup_ancestors.map do |klass|
+          klass.model_name.underscore.gsub('/','.').to_sym
+        end
+        
+        # Rails orig
+        defaults << options.delete(:default) if options[:default]
+        defaults << @human
+
+        options.reverse_merge! :scope => [@klass.i18n_scope, :models], :count => 1, :default => defaults
+        I18n.translate(defaults.shift, options)
+      end
+    end
+  end
+end
+
+ActiveModel::Name.send :include, Humpyard::ActiveModel::Name

data/lib/humpyard/active_model/translation.rb

@@ -0,0 +1,26 @@
+require 'active_model/translation'
+
+module ActiveModel #:nodoc:
+  module Translation #:nodoc:
+    def human_attribute_name_with_namespaces(attribute, options = {})    
+      # Namespace patch
+      defaults = []
+      lookup_ancestors.each do |klass|
+        name = klass.model_name.underscore.split('/')
+        while name.size > 0
+          defaults << :"#{self.i18n_scope}.attributes.#{name * '.'}.#{attribute}"
+          name.pop
+        end
+      end
+    
+      # Rails orig
+      defaults << :"attributes.#{attribute}"
+      defaults << options.delete(:default) if options[:default]
+      defaults << attribute.to_s.humanize
+
+      options.reverse_merge! :count => 1, :default => defaults
+      I18n.translate(defaults.shift, options)
+    end
+    alias_method_chain :human_attribute_name, :namespaces
+  end
+end

data/lib/humpyard/active_model/validators/publish_range.rb

@@ -0,0 +1,14 @@
+module Humpyard
+  module ActiveModel
+    class PublishRangeValidator < ::ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        if attribute == :display_from and not record.display_from.blank? and not record.display_until.blank? and record.display_until < record.display_from
+          record.errors.add attribute, :cannot_be_after_display_until
+        end
+        if attribute == :display_until and not record.display_until.blank? and not record.display_from.blank? and record.display_until <= record.display_from
+          record.errors.add attribute, :cannot_be_before_display_from
+        end
+      end
+    end
+  end
+end

data/lib/humpyard/active_record/acts/asset.rb

@@ -0,0 +1,68 @@
+module Humpyard
+  module ActiveRecord
+    module Acts
+      module Asset
+        
+        def self.included(base)
+          base.has_one :asset, :as => :content_data, :class_name => 'Humpyard::Asset', :autosave => true
+          base.validate :asset_must_be_valid
+          
+          begin
+            all_attributes = Humpyard::Asset.column_names.map{|a| a.to_s}
+          rescue
+            # Table not migrated
+            all_attributes = []
+          end
+          ignored_attributes = ['id', 'created_at', 'updated_at', 'content_data_id', 'content_data_type']
+          attributes_to_delegate = all_attributes - ignored_attributes
+          attributes_to_delegate.each do |attrib|
+            base.delegate "#{attrib}", "#{attrib}=", "#{attrib}?", :to => :asset
+            if attrib.match /_id$/
+              attrib = attrib.gsub /(_id)$/, ''
+              base.delegate "#{attrib}", "#{attrib}=", "#{attrib}?", :to => :asset
+            end
+          end
+          
+          Humpyard::Asset.attr_accessible.each do |attr|
+            base.attr_accessible attr
+          end
+          
+          base.extend ClassMethods
+          
+          base.alias_method_chain :asset, :autobuild 
+          base.alias_method_chain :column_for_attribute, :asset_column_for_attribute
+          
+        end
+        
+        def asset_with_autobuild
+          asset_without_autobuild || build_asset
+        end
+
+        def column_for_attribute_with_asset_column_for_attribute(attr)
+          ret = column_for_attribute_without_asset_column_for_attribute(attr) || Humpyard::Asset.new.column_for_attribute(attr)       
+        end
+
+        module ClassMethods
+ 
+        end
+        
+      protected
+        def asset_must_be_valid
+          unless asset.valid?
+            asset.errors.each do |attr, message|
+              errors.add(attr, message)
+            end
+          end
+        end
+        
+      end
+    end
+  end
+end
+
+class ActiveRecord::Base
+  def self.acts_as_humpyard_asset(options = {})
+    set_table_name "#{Humpyard::config.table_name_prefix}assets_#{name.split('::').last.underscore.pluralize}" if options[:system_asset]
+    include Humpyard::ActiveRecord::Acts::Asset
+  end
+end

data/lib/humpyard/active_record/acts/container_element.rb

@@ -0,0 +1,26 @@
+module Humpyard
+  module ActiveRecord
+    module Acts
+      module ContainerElement
+        def self.included(base)
+          base.delegate "elements", "elements=", "elements?", :to => :element
+          
+          base.extend ClassMethods
+        end
+        
+        module ClassMethods
+          def is_humpyard_container_element?
+            true
+          end          
+        end
+      end
+    end
+  end
+end
+
+class ActiveRecord::Base
+  def self.acts_as_humpyard_container_element(options = {})
+    acts_as_humpyard_element options
+    include Humpyard::ActiveRecord::Acts::ContainerElement
+  end
+end

data/lib/humpyard/active_record/acts/element.rb

@@ -0,0 +1,89 @@
+module Humpyard
+  module ActiveRecord
+    module Acts
+      module Element
+        def self.included(base)
+          base.has_one :element, :as => :content_data, :class_name => 'Humpyard::Element', :autosave => true
+          base.validate :element_must_be_valid
+          base.alias_method_chain :element, :autobuild 
+          base.alias_method_chain :column_for_attribute, :element_column_for_attribute
+          
+          begin
+            all_attributes = Humpyard::Element.column_names
+          rescue
+            # Table not migrated
+            all_attributes = []
+          end
+          ignored_attributes = ['id', 'created_at', 'updated_at', 'content_data_id', 'content_data_type']
+          attributes_to_delegate = all_attributes - ignored_attributes
+          attributes_to_delegate.each do |attrib|
+            base.delegate "#{attrib}", "#{attrib}=", "#{attrib}?", :to => :element
+            if attrib.match /_id$/
+              attrib = attrib.gsub /(_id)$/, ''
+              base.delegate "#{attrib}", "#{attrib}=", "#{attrib}?", :to => :element
+            end
+          end
+          
+          Humpyard::Element.attr_accessible.each do |attr|
+            base.attr_accessible attr
+          end
+             
+          base.extend ClassMethods
+
+        end
+
+        def element_with_autobuild
+          element_without_autobuild || build_element
+        end
+        
+        def column_for_attribute_with_element_column_for_attribute(attr)
+          ret = column_for_attribute_without_element_column_for_attribute(attr) || element.column_for_attribute(attr)
+        end
+        
+        def is_humpyard_element?
+          self.class.is_humpyard_element?
+        end
+        
+        def is_humpyard_container_element?
+          self.class.is_humpyard_container_element?
+        end
+        
+#        def method_missing(meth, *args, &blk)
+#          element.send(meth, *args, &blk)
+#        rescue NoMethodError
+#          super
+#        end
+
+        module ClassMethods
+          def is_humpyard_element?
+            true
+          end
+
+          def is_humpyard_container_element?
+            false
+          end          
+        end
+
+        module InstanceMethods
+
+        end
+        
+      protected
+        def element_must_be_valid
+          unless element.valid?
+            element.errors.each do |attr, message|
+              errors.add(attr, message)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+class ActiveRecord::Base
+  def self.acts_as_humpyard_element(options = {})
+    set_table_name "#{Humpyard::config.table_name_prefix}elements_#{name.split('::').last.underscore.pluralize}" if options[:system_element]
+    include Humpyard::ActiveRecord::Acts::Element
+  end
+end

data/lib/humpyard/active_record/acts/page.rb

@@ -0,0 +1,101 @@
+module Humpyard
+  module ActiveRecord
+    module Acts
+      module Page
+        
+        def self.included(base)
+          base.has_one :page, :as => :content_data, :class_name => 'Humpyard::Page', :autosave => true
+          base.validate :page_must_be_valid
+          
+          begin
+            all_attributes = Humpyard::Page.column_names + Humpyard::Page.translated_attribute_names.map{|a| a.to_s}
+          rescue
+            # Table not migrated
+            all_attributes = []
+          end
+          ignored_attributes = ['id', 'created_at', 'updated_at', 'content_data_id', 'content_data_type']
+          attributes_to_delegate = all_attributes - ignored_attributes
+          attributes_to_delegate.each do |attrib|
+            base.delegate "#{attrib}", "#{attrib}=", "#{attrib}?", :to => :page
+            if attrib.match /_id$/
+              attrib = attrib.gsub /(_id)$/, ''
+              base.delegate "#{attrib}", "#{attrib}=", "#{attrib}?", :to => :page
+            end
+          end
+          
+          Humpyard::Page.attr_accessible.each do |attr|
+            base.attr_accessible attr
+          end
+          
+          base.extend ClassMethods
+          
+          base.alias_method_chain :page, :autobuild 
+          base.alias_method_chain :column_for_attribute, :page_column_for_attribute
+          
+        end
+        
+        def page_with_autobuild
+          page_without_autobuild || build_page
+        end
+
+        def column_for_attribute_with_page_column_for_attribute(attr)
+          ret = column_for_attribute_without_page_column_for_attribute(attr) || Humpyard::Page.new.column_for_attribute(attr) || Humpyard::Page.translation_class.new.column_for_attribute(attr)
+        end
+
+        def parse_path(path)
+          nil
+        end
+
+        def is_humpyard_page?
+          self.class.is_humpyard_page?
+        end
+
+        def is_humpyard_dynamic_page?
+          self.class.is_humpyard_dynamic_page?
+        end
+        
+        def is_humpyard_virtual_page?
+          self.class.is_humpyard_virtual_page?
+        end
+        
+        # Return the logical modification time for the page, suitable for http caching, generational cache keys, etc.
+        def last_modified
+          rails_root_mtime = Time.zone.at(::File.new("#{Rails.root}").mtime)
+          timestamps = [rails_root_mtime, self.updated_at] + self.page.elements.collect{|e| e.last_modified}
+          timestamps.sort.last
+        end
+
+        module ClassMethods
+          def is_humpyard_page?
+            true
+          end
+
+          def is_humpyard_dynamic_page?
+            true
+          end    
+          
+          def is_humpyard_virtual_page?
+            false
+          end      
+        end
+        
+      protected
+        def page_must_be_valid
+          unless page.valid?
+            page.errors.each do |attr, message|
+              errors.add(attr, message)
+            end
+          end
+        end
+        
+      end
+    end
+  end
+end
+
+class ActiveRecord::Base
+  def self.acts_as_humpyard_page(options = {})
+    set_table_name "#{Humpyard::config.table_name_prefix}pages_#{name.split('::').last.underscore.pluralize}" if options[:system_page]
+    include Humpyard::ActiveRecord::Acts::Page
+  end
+end