humpyard 0.0.1

data/lib/humpyard/active_record/has/title_for_url.rb

@@ -0,0 +1,75 @@
+module Humpyard
+  module ActiveRecord
+    module Has
+      module TitleForUrl
+        def self.included(base)
+          base.extend ClassMethods
+          base.before_save :assign_title_for_url         
+        end
+
+        module ClassMethods
+          def find_by_title_for_url(url, options = {})
+            options[:locale] ||= ::I18n.locale
+
+            unless Humpyard::config.locales.include? options[:locale].to_sym
+              options[:locale] = Humpyard::config.locales.first
+            end
+            
+            if options[:skip_fallbacks]
+              locales = [options[:locale].to_sym]
+            else
+              locales = [options[:locale].to_sym] + (Humpyard::config.locales.map{|l| l.to_sym} - [options[:locale].to_sym])
+            end
+            
+            locales.each do |l|
+              #t = self.with_locale(l){find_first_by_translated_attr_and_locales(:title_for_url, url)}
+              t = self.translation_class.where('locale = ? AND title_for_url = ?', l.to_s, url.to_s).first
+              
+              if t
+                return self.find(t["#{self.name.underscore.gsub('/', '_')}_id"])
+              end
+            end
+            
+            nil
+          end       
+        end
+   
+        def query_title_for_url(locale = I18n.locale)
+          given = translations.all
+          ([locale.to_sym] + (Humpyard::config.locales.map{|l| l.to_sym} - [locale.to_sym])).each do |l|
+            t = given.select{|tx| tx.locale.to_sym == l}.first
+            return t.title_for_url if t and not t.title_for_url.blank?
+          end    
+          nil 
+        end
+        
+        def suggested_title_for_url(locale = I18n.locale)
+          return nil if title.blank?
+          
+          title_for_url = (self.title(locale) ? self.title(locale) : self.title).parameterize('_').to_s
+          
+          # Check if parameterized totally failed
+          if title_for_url == ''
+            title_for_url = CGI::escape(self.title.gsub(/[a-z0-9\-_\x00-\x7F]+/, '_'))
+          end 
+          
+          while obj = self.class.find_by_title_for_url(title_for_url, :skip_fallbacks => true, :locale => locale) and obj.id != self.id do
+            title_for_url += '_'
+          end
+          return title_for_url
+        end
+
+        protected
+        def assign_title_for_url
+          self.title_for_url = suggested_title_for_url
+        end     
+      end
+    end
+  end
+end
+
+class ActiveRecord::Base
+  def self.has_title_for_url(options = {})
+    include Humpyard::ActiveRecord::Has::TitleForUrl
+  end
+end

data/lib/humpyard/compass.rb

@@ -0,0 +1,6 @@
+require 'compass' 
+
+options = Hash.new
+options[:stylesheets_directory] = ::File.expand_path(::File.join(::File.dirname(__FILE__), '..', '..', 'compass', 'stylesheets'))
+options[:templates_directory] = ::File.expand_path(::File.join(File.dirname(__FILE__), '..', '..', 'compass', 'templates'))
+::Compass::Frameworks.register('humpyard', options)

data/lib/humpyard/config.rb

@@ -0,0 +1,235 @@
+module Humpyard
+  ####
+  # Humpyard::Config is responsible for holding and managing the configuration
+  # for your Humpyard Rails Application.
+  #
+  # Possible configuration options are:
+  # +table_name_prefix+:: 
+  #    The prefix for the SQL tables
+  #
+  #    The default value is <tt>"humpyard_"</tt>
+  # +www_prefix+::        
+  #    The prefix for the pages in your routes
+  #
+  #    You may use some variables that will be replaced by 
+  #    Humpyard::Page.human_url
+  #    <tt>":locale"</tt>:: The current ::I18n.locale
+  #
+  #    Leading slashes ("/") as it would result in invalid URLs and will be ignored.
+  #
+  #    A tailing slash ("/") indicates, that the value should be a path.
+  #    Without the tailing slash the last part would become a prefix
+  #    to the pages URL.
+  #    A page with the path "about/config.html" with the ::I18n.locale="en" 
+  #    and the given prefix will result in:
+  #    <tt>":locale/"</tt>:: <tt>"/en/about/config.html"</tt>
+  #    <tt>":locale/cms_"</tt>:: <tt>"/en/cms_about_config.html"</tt>
+  #    <tt>"cms/"</tt>:: <tt>"/cms/about/config.html"</tt>
+  #    <tt>""</tt>: <tt>"/about/config.html"</tt>
+  #
+  #    The default value is <tt>":locale/"</tt>
+  # +admin_prefix+::      
+  #    The prefix for the admin controllers
+  #
+  #    The default value is <tt>"admin"</tt>
+  # +locales+::
+  #    The locales used for the pages
+  #
+  #    This option can be configured by giving an Array or comma separated String,
+  #    e.g. <tt>'en,de,fr'</tt> or <tt>['en', 'de', 'fr']</tt>.
+  #
+  #    Setting this option will also alter the HumpyardForm.config.locales to the 
+  #    given value
+  #
+  #
+  #    The default value is <tt>['en']</tt>
+  class Config 
+    attr_writer :table_name_prefix, :element_types, :page_types # :nodoc:
+    attr_writer :templates, :default_template, :browser_title_prefix, :browser_title_postfix # :nodoc:
+    attr_writer :users_framework, :js_framework, :compass_format, :compass_stylesheet_link_tag_path # :nodoc:
+    
+    def initialize(&block) #:nodoc:
+      configure(&block) if block_given?
+    end
+
+    # Configure your Humpyard Rails Application with the given parameters in 
+    # the block. For possible options see above.
+    def configure(&block)
+      yield(self)
+    end
+    
+    def table_name_prefix #:nodoc:
+      @table_name_prefix ||= 'humpyard_'
+    end
+          
+    def www_prefix #:nodoc:
+      @www_prefix ||= ':locale/'
+    end
+    
+    def www_prefix=(prefix)
+      if prefix
+        @www_prefix = prefix.gsub /^\//, ''
+      else
+        @www_prefix = nil
+      end
+    end
+    
+    def element_types #:nodoc:
+      @element_types ||= {
+        'box_element' => Humpyard::Elements::BoxElement,
+        'text_element' => Humpyard::Elements::TextElement,
+        'media_element' => Humpyard::Elements::MediaElement,
+        'news_element' => Humpyard::Elements::NewsElement,
+        'sitemap_element' => Humpyard::Elements::SitemapElement
+      }
+    end
+    
+    def page_types #:nodoc:
+      @page_types ||= {
+        'static' => Humpyard::Pages::StaticPage,
+        'virtual' => Humpyard::Pages::VirtualPage,
+        'news' => Humpyard::Pages::NewsPage
+      }
+    end
+    
+    def asset_types #:nodoc:
+      @asset_types ||= {
+        'paperclip' => Humpyard::Assets::PaperclipAsset,
+        'youtube' => Humpyard::Assets::YoutubeAsset
+      }
+    end
+    
+    def templates #:nodoc:
+      @templates ||= {
+        'application' => {:yields => [:sidebar]}
+      }
+    end
+    
+    def toolbar_actions #:nodoc:
+      @toolbar_actions ||= {
+        #'edit' => {
+        #  :title => 'humpyard_cms.toolbar.edit',
+        #  :command => 'toggleEditMode',
+        #  :icon => 'ui-icon-pencil'
+        #},
+        'hy_pages' => {
+          :title => 'humpyard_cms.toolbar.pages',
+          :controller => '/humpyard/pages',
+          :action => :index,
+          :dialog => "size:800x700;dialog_id:pages-dialog",
+          :icon => 'ui-icon-document',
+          :class => Humpyard::Page
+        },
+        'hy_assets' => {
+          :title => 'humpyard_cms.toolbar.assets',
+          :controller => '/humpyard/assets',
+          :action => :index,
+          :dialog => "size:800x700;dialog_id:assets-dialog",
+          :icon => 'ui-icon-video',
+          :class => Humpyard::Asset
+        }
+      }
+    end
+    
+    def default_template #:nodoc:
+      @default_template ||= templates.keys.first
+    end
+    
+    def default_template_name
+      default_template.to_s
+    end
+ 
+    def browser_title_prefix #:nodoc:
+      @browser_title_prefix ||= ''
+    end
+    
+    def browser_title_postfix #:nodoc:
+      @browser_title_postfix ||= ''
+    end 
+    
+    # Get the prefix of your pages with interpreted variables given as params.
+    # You normally don't want to call it yourself. Instead use the
+    # Humpyard::Page.human_url which will put the current ::I18n.locale into
+    # the params.
+    def parsed_www_prefix(params)
+      prefix = "#{www_prefix}"
+      params.each do |key,value|
+        prefix.gsub!(":#{key}", value.to_s)
+      end
+      prefix
+    end
+    
+    def admin_prefix #:nodoc:
+      @admin_prefix.blank? ? 'admin' : @admin_prefix
+    end
+    
+    def admin_prefix=(prefix)
+      if prefix
+        @admin_prefix = prefix.gsub /^\//, ''
+      else
+        @admin_prefix = nil
+      end
+    end
+    
+    def locales=(locales) #:nodoc:
+      if locales.nil? 
+        @locales = nil
+      elsif locales.class == Array
+        @locales = locales.map{|l| l.to_sym}
+      else
+        @locales = locales.split(',').collect{|l| l.to_sym}
+      end
+      
+      # Keep HumpyardForm locales in sync
+      HumpyardForm.config.locales = locales
+    end
+    
+    def locales #:nodoc:
+      @locales ||= [:en]
+    end
+    
+    # Get the given locales as Regexp constraint. 
+    # This may be used to see if a locale matches the configured locales.
+    # Usage is e.g. in the routes.
+    def locales_contraint
+      Regexp.new locales * '|'
+    end
+    
+    def users_framework
+      @users_framework ||= 'simple'
+    end
+    
+    def js_framework
+      @js_framework ||= 'jquery-ui-18'
+    end
+    
+    def compass_format
+      @compass_format ||= 'scss'
+    end
+    
+    def compass_stylesheet_link_tag_path
+      @compass_stylesheet_link_tag_path ||= 'compiled/'
+    end
+    
+    def page_formats=(formats) #:nodoc:
+      if formats.nil? 
+        @page_formats = nil
+      elsif formats.class == Array
+        @page_formats = formats.map{|l| l.to_sym}
+      else
+        @page_formats = formats.split(',').collect{|l| l.to_sym}
+      end
+    end
+    
+    def page_formats #:nodoc:
+      @page_formats ||= [:html]
+    end
+    
+    # Get the given locales as Regexp constraint. 
+    # This may be used to see if a locale matches the configured locales.
+    # Usage is e.g. in the routes.
+    def page_formats_contraint
+      Regexp.new page_formats * '|'
+    end
+  end
+end

data/lib/humpyard/engine.rb

@@ -0,0 +1,7 @@
+module Humpyard
+  ####
+  # Humpyard::Engine is the ::Rails::Engine running the Humpyard
+  class Engine < ::Rails::Engine
+    #engine_name :humpyard
+  end
+end

data/lib/humpyard/uri_parser.rb

@@ -0,0 +1,16 @@
+module Humpyard
+  module UriParser
+    class << self    
+      def parsers
+        @parsers ||= [::Humpyard::UriParser::PagesUriParser, ::Humpyard::UriParser::AssetsUriParser]
+      end
+    
+      def substitute content, options = {}
+        parsers.each do |parser|
+          content = parser.substitute content, options
+        end
+        return content
+      end
+    end
+  end
+end

data/lib/humpyard/uri_parser/assets_uri_parser.rb

@@ -0,0 +1,15 @@
+module Humpyard
+  module UriParser
+    class AssetsUriParser
+      def self.substitute content, options = {}
+        content.gsub(/humpyard:\/\/asset\/([0-9]*)/) do |uri| 
+          begin
+            "#{options[:prefix]}#{Asset.find($1).url}#{options[:postfix]}"  
+          rescue
+            ''
+          end
+        end
+      end
+    end
+  end
+end

data/lib/humpyard/uri_parser/pages_uri_parser.rb

@@ -0,0 +1,15 @@
+module Humpyard
+  module UriParser
+    class PagesUriParser
+      def self.substitute content, options = {}
+        content.gsub(/humpyard:\/\/page\/([0-9]*)/) do |uri| 
+          begin
+            "#{options[:prefix]}#{Page.find($1).human_url}#{options[:postfix]}"          
+          rescue
+            "#{options[:prefix]}#{Page.root_page.human_url}#{options[:postfix]}"  
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tasks/humpyard.rake

@@ -0,0 +1,103 @@
+namespace :humpyard do  
+  namespace :db do
+    desc "Migrate the database through scripts in db/migrate and update db/schema.rb by invoking db:schema:dump. Target specific version with VERSION=x. Turn off output with VERBOSE=false."
+    task :migrate => [:environment, :prepare_namespace] do
+      ActiveRecord::Migration.verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
+      ActiveRecord::Migrator.migrate("#{File.dirname(__FILE__)}/../../db/migrate/", ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
+      Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+    end
+    
+    task :prepare_namespace do
+      require 'active_record'
+      puts 'prepage humpyard table_name_prefix'
+      ActiveRecord::Base.configurations = Rails.application.config.database_configuration
+      
+      class ActiveRecord::Base
+        self.table_name_prefix = "#{::ActiveRecord::Base.table_name_prefix}#{Humpyard::config.table_name_prefix}"
+      end
+    end
+    
+    task :remove_namespace do
+      puts 'remove humpyard table_name_prefix'
+      
+      class ActiveRecord::Base
+        self.table_name_prefix = "#{::ActiveRecord::Base.table_name_prefix[Humpyard::config.table_name_prefix.length,1000]}"
+      end
+    end
+  
+    namespace :migrate do
+      desc  'Rollbacks the database one migration and re migrate up. If you want to rollback more than one step, define STEP=x. Target specific version with VERSION=x.'
+      task :redo => [:environment, :prepare_namespace] do
+        if ENV["VERSION"]
+          Rake::Task["humpyard:db:migrate:down"].invoke
+          Rake::Task["humpyard:db:migrate:up"].invoke
+        else
+          Rake::Task["humpyard:db:rollback"].invoke
+          Rake::Task["humpyard:db:migrate"].invoke
+        end
+      end
+
+      desc 'Runs the "up" for a given migration VERSION.'
+      task :up => [:environment, :prepare_namespace] do
+        version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
+        raise "VERSION is required" unless version
+        ActiveRecord::Migrator.run(:up, "#{File.dirname(__FILE__)}/../../db/migrate/", version)
+        Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+      end
+
+      desc 'Runs the "down" for a given migration VERSION.'
+      task :down => [:environment, :prepare_namespace] do
+        version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
+        raise "VERSION is required" unless version
+        ActiveRecord::Migrator.run(:down, "#{File.dirname(__FILE__)}/../../db/migrate/", version)
+        Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+      end
+    end
+
+    desc 'Rolls the schema back to the previous version. Specify the number of steps with STEP=n'
+    task :rollback => [:environment, :prepare_namespace] do
+      step = ENV['STEP'] ? ENV['STEP'].to_i : 1
+      ActiveRecord::Migrator.rollback("#{File.dirname(__FILE__)}/../../db/migrate/", step)
+      Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+    end
+
+    desc 'Pushes the schema to the next version. Specify the number of steps with STEP=n'
+    task :forward => [:environment, :prepare_namespace] do
+      step = ENV['STEP'] ? ENV['STEP'].to_i : 1
+      ActiveRecord::Migrator.forward("#{File.dirname(__FILE__)}/../../db/migrate/", step)
+      Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+    end
+
+    desc "Retrieves the current schema version number"
+    task :version => [:environment, :prepare_namespace] do
+      puts "Current version: #{ActiveRecord::Migrator.current_version}"
+    end
+
+    desc "Raises an error if there are pending migrations"
+    task :abort_if_pending_migrations => [:environment, :prepare_namespace] do
+      if defined? ActiveRecord
+        pending_migrations = ActiveRecord::Migrator.new(:up, "#{File.dirname(__FILE__)}/../../db/migrate/").pending_migrations
+        if pending_migrations.any?
+          puts "You have #{pending_migrations.size} pending migrations:"
+          pending_migrations.each do |pending_migration|
+            puts '  %4d %s' % [pending_migration.version, pending_migration.name]
+          end
+          abort %{Run "rake humpyard:db:migrate" to update your database then try again.}
+        end
+      end
+    end
+  end
+  
+  namespace :pages do
+    desc "Create root page if it does not exists"
+    task :create_root  => [:environment] do
+      if Humpyard::Page.root_page
+        puts "There is already a root page"
+      else
+        Humpyard::Pages::StaticPage.create :title => 'index'
+      end
+    end
+  end
+end
+
+task :'db:migrate' => [:'humpyard:db:migrate', :'humpyard:db:remove_namespace']