gluttonberg-core 2.5

data/lib/gluttonberg/page_description.rb

@@ -0,0 +1,284 @@
+module Gluttonberg
+  # This defines a DSL for for creating page descriptions. Page descriptions 
+  # are used to declare the page archetypes in an installation.
+  # 
+  # * Name & description
+  # * Sections
+  #   - Html
+  #   - Plain text
+  #   - Image  
+  # * Redirections
+  # * Rewrites to controllers
+  #
+  # It also provides access to any page descriptions that have been declared.
+  class PageDescription
+    @@_descriptions = {}
+    @@_categorised_descriptions = {}
+    @@_description_names = {}
+    @@_home_page    = nil
+    
+    
+    attr_accessor :options
+    
+    def initialize(name)
+      @position = 0
+      @options = {
+        :name       => name,
+        :home       => false,
+        :domain       => nil, 
+        :behaviour  => :default,
+        :layout     => "public",
+        :view       => "default"
+      }
+      @sections = {}
+      @@_descriptions[name] = self
+    end
+    
+    %w(label view layout limit description).each do |opt|
+      class_eval %{
+        def #{opt}(opt_value)
+          @options[:#{opt}] = opt_value
+        end
+      }
+    end
+    
+    # This is a destructive method which removes all page definitions. Mainly
+    # used for testing and debugging.
+    def self.clear!
+      @@_descriptions.clear
+      @@_categorised_descriptions.clear
+      @@_description_names.clear
+      @@_home_page = nil
+    end
+    
+    # This just loads the page_descriptions.rb file from the config dir.
+    #
+    # The specified file should contain the various page descriptions.
+    def self.setup
+      path = File.join(Rails.root, "config", "page_descriptions.rb")
+      require path if File.exists?(path)
+    end
+    
+    def self.add(&blk)
+      class_eval(&blk)
+    end
+    
+    # Define a page. This can be called directly, but is generally used inside
+    # of an #add block.
+    def self.page(name, &blk)
+      new(name).instance_eval(&blk)
+    end
+    
+    # Returns the definition for a specific page description.
+    def self.[](name)
+      # puts @@_descriptions
+      # puts @@_descriptions[name.to_s.downcase.to_sym].options
+      @@_descriptions[name.to_s.downcase.to_sym]
+    end
+    
+    # Returns the full list of page descriptions as a hash, keyed to each
+    # description’s name.
+    def self.all
+      @@_descriptions
+    end
+    
+    # Returns all the descriptions with the matching behaviour in an array.
+    def self.behaviour(name)
+      @@_categorised_descriptions[name] ||= @@_descriptions.inject([]) do |memo, desc|
+        memo << desc[1] if desc[1][:behaviour] == name
+        memo
+      end
+    end
+    
+    # Collects all the names of the descriptions which have the specified 
+    # behaviour.
+    def self.names_for(name)
+      @@_description_names[name] ||= self.behaviour(name).collect {|d| d[:name]}
+    end
+    
+    # Returns the value the specified option — label, description etc.
+    def [](opt)
+      @options[opt]
+    end
+    
+    # Returns the collection of sections defined for a page description.
+    def sections
+      @sections
+    end
+    
+    def contains_section?(sec_name , type_name)
+      @sections.each do |name, section|
+        return true if sec_name.to_s == name.to_s && section[:type].to_s == type_name.to_s
+      end
+      false
+    end
+    
+    # Set a description as the home page.
+    def home(bool)
+      @options[:home] = bool
+      if bool
+        @@_home_page = self
+        @options[:limit] = 1
+      elsif @@_home_page == self
+        @@_home_page = nil
+        @options.delete(:limit)
+      end
+    end
+    
+    # Set a description as the home page.
+    def domain(domain_name)
+      @options[:domain] = domain_name
+    end
+    
+    # Sugar for defining a section.
+    def section(name, &blk)
+      new_section = Section.new(name , @position)
+      #new_section.position = @position
+      new_section.instance_eval(&blk)
+      @sections[name] = new_section
+      @position += 1
+    end
+    
+    def top_level_page?
+       @options[:name] == :top_level_page
+    end
+    
+    def name
+       @options[:name]
+    end
+    
+    def redirection_required?
+      @options[:behaviour] == :rewrite
+    end
+    
+    # Configures the page to act as a rewrite to named route. This doesn’t 
+    # work like a rewrite in the traditional sense, since it is intended to be
+    # used to redirect requests to a controller. Becuase of this it can't rewrite
+    # to a path, it needs to use a named route.
+    def rewrite_to(route)
+      @rewrite_route = route
+      @options[:behaviour] = :rewrite
+    end
+
+    # Allows us to check if this page needs to have a path rewritten to point
+    # to a controller.
+    def rewrite_required?
+      @options[:behaviour] == :rewrite
+    end
+    
+    # Returns the named route to be used when rewriting the request.
+    def rewrite_route
+      @rewrite_route
+    end
+    
+    # Declare this description as a redirect. The redirect type can be:
+    #
+    # :remote - A full url to another domain
+    # :block  - A block that will be evaluated and it’s return value will be 
+    #           used to handle the redirect
+    # :path   - The path to redirect to, hey, simple!
+    # :page   - Allows the user to specify which other page they want to 
+    #           redirect to.
+    def redirect_to(type = nil, opt = nil, &blk)
+      if block_given?
+        @redirect_block = blk
+        @redirect_type  = :block
+      else
+        @redirect_option  = opt if opt
+        @redirect_type    = type
+      end
+      @options[:behaviour]  = :redirect
+    end
+    
+    # Checks to see if the description has been defined as a redirect.
+    def redirect?
+      !@redirect_type.nil?
+    end
+    
+    # Checks to see if this is home. Duh.
+    def home?
+      @options[:home]
+    end
+    
+    # Checks to see if this is home for a domain. Duh.
+    def home_for_domain?(domain_name)
+      if Rails.configuration.multisite == false
+        home?
+      else
+        @options[:home] && Rails.configuration.multisite[@options[:domain]] == domain_name
+      end  
+    end
+    
+    # Returns the path that this description wants to redirect to. It accepts 
+    # the current page — from which is extracts the redirect options — and the 
+    # params for the current request.
+    def redirect_url(page, params)
+      case @redirect_type
+        when :remote
+          @redirect_option
+        when :block
+          @redirect_block.call(page, params)
+        when :path
+          Router.localized_url(redirect_value(page, params), params)
+        when :page
+          path_to_page(page, params)
+      end
+    end
+    
+    private
+    
+    # This method is used in conjunction with #redirect_url when a redirect to
+    # another page has been specified. It finds and examines the specified page 
+    # to figure out what it’s path is.
+    def path_to_page(page, params)
+      localization = PageLocalization.find(:first,
+        :conditions => {
+          :page_id  => page.redirect_target_id,
+          :locale   => params[:locale]
+        }  
+      )
+      raise ActiveRecord::RecordNotFound if localization.blank?
+      localization.path
+    end
+    
+    # This class is used to define the sections of content in a page 
+    # description. This class should never be instantiated direction, instead
+    # sections should be declared in the description DSL.
+    class Section
+      
+      #attr_accessor :position
+      
+      def initialize(name , pos)
+        @options = {:name => name, :limit => 1 , :position => pos}
+        @custom_config = {}
+      end
+      
+      %w(type limit label).each do |opt|
+        class_eval %{
+          def #{opt}(opt_value)
+            @options[:#{opt}] = opt_value
+          end
+        }
+      end
+      
+      # Stores additional configuration options, which can be used by arbitrary
+      # code. Generally however it is intended to be used to provide 
+      # configuration for the particular content class associated with this 
+      # section.
+      def configure(opts)
+        @custom_config ||= {}
+        @custom_config.merge!(opts)
+      end
+      
+      # Returns the value for the specified option — name, description etc.
+      def [](opt)
+        @options[opt]
+      end
+      
+      # Returns the custom configuration as a hash.
+      def config
+        @custom_config
+      end
+    end # Section
+  end # PageDescription
+end # Gluttonberg

data/lib/gluttonberg/record_history.rb

@@ -0,0 +1,95 @@
+
+module Gluttonberg
+  module RecordHistory
+    def self.setup
+      ::ActionController::Base.send  :include, Gluttonberg::RecordHistory::ActionController  
+    end
+
+    module ActionController
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+  
+  
+      module ClassMethods
+        def record_history(object_name, title_field_name="", options = {})
+          class << self; 
+            attr_accessor :object_name, :title_field_name;
+          end
+          self.object_name = object_name
+          self.title_field_name = title_field_name
+          self.send(:include, Gluttonberg::RecordHistory::ActionController::ControllerHelperClassMethods)
+          after_filter :log_create , :only => [:create]
+          after_filter :log_update , :only => [:update]
+          after_filter :log_destroy, :only => [:destroy]
+        end
+    
+      end # class methods
+
+      module ControllerHelperClassMethods
+        def log_create
+          unless object.blank?
+            if object.new_record?
+            else
+              Gluttonberg::Feed.log(current_user, object ,object_title , "created")
+            end  
+          end  
+        end
+
+        def log_update
+          unless object.blank?
+            if object.errors.blank?
+              Gluttonberg::Feed.log(current_user, object ,object_title , "updated")
+            end  
+          end  
+        end
+
+        def log_destroy
+          if object && object.destroyed?()
+            Gluttonberg::Feed.log(current_user, object ,object_title , "deleted")
+          end   
+        end
+
+        def object
+          unless self.class.object_name.blank?
+            self.instance_variable_get(self.class.object_name)
+          end
+        end
+
+
+
+        #this method is used to get title or name for the object
+        def object_title
+          unless object.blank?
+            field_name = ""
+            if self.class.title_field_name.blank?
+              if object.respond_to?(:name)
+                field_name = :name
+              elsif object.respond_to?(:title)
+                field_name = :title
+              elsif object.respond_to?(:title_or_name?)
+                field_name = :title_or_name?
+              else
+                field_name = :id
+              end
+            else
+              field_name = self.class.title_field_name     
+            end
+            puts "====================  field_name  #{field_name}"
+            unless field_name.blank?
+              object.send(field_name)
+            end
+          end  
+        end  
+
+      end #ControllerHelperClassMethods
+
+
+    end
+
+  end #RecordHistory  
+end #Gluttonberg
+
+
+
+

data/lib/gluttonberg/tasks/asset.rake

@@ -0,0 +1,48 @@
+require 'rubygems'
+
+ASSET_LIBRARY_BASE_DIR = File.join(File.dirname(__FILE__), "../..")
+
+namespace :gluttonberg do
+  namespace :library do
+
+    desc "Try and generate thumbnails for all assets"
+    task :create_thumbnails => :environment do
+      category = Gluttonberg::AssetCategory.find( :first , :conditions =>{  :name => "image" } )
+      if category
+        assets = category.assets #Asset.all
+        assets.each do |asset|
+          p "thumb-nailing '#{asset.file_name}'  "
+          asset.generate_image_thumb
+          asset.generate_proper_resolution
+          asset.save
+        end
+      end
+    end
+
+    desc "Rebuild AssetType information and reassociate with existing Assets"
+    task :bootstrap => :environment do
+      Gluttonberg::Library.bootstrap
+    end
+
+    desc "Rebuild AssetType information and reassociate with existing Assets"
+    task :rebuild_asset_types => :environment do
+      Gluttonberg::Library.rebuild
+    end
+
+    desc "Assign file_name as name of those asset whose name is null"
+    task :generate_asset_names => :environment do
+      Gluttonberg::Asset.generate_name
+    end
+
+    desc "Make assets from files in bulks folder"
+    task :generate_asset_from_bulks_folder => :environment do
+      Gluttonberg::Asset.create_assets_from_ftp
+    end
+
+    desc "Update assets synopsis through csv"
+    task :update_assets_synopsis_from_csv => :environment do
+      Gluttonberg::Asset.update_assets_synopsis_from_csv
+    end
+
+  end
+end

data/lib/gluttonberg/tasks/gluttonberg.rake

@@ -0,0 +1,59 @@
+namespace :gluttonberg do 
+  
+  desc "Generate default locale (en-au)"
+  task :generate_default_locale => :environment do
+    Gluttonberg::Locale.generate_default_locale
+  end
+  
+  desc "Generate or update default settings"
+  task :generate_or_update_default_settings => :environment do
+    Gluttonberg::Setting.generate_common_settings
+  end
+  
+  desc "Update page descriptions"
+  task :update_page_descriptions => :environment do
+    Gluttonberg::Page.repair_pages_structure
+  end
+  
+  
+  desc "Copies missing assets from Railties (e.g. plugins, engines). You can specify Railties to use with FROM=railtie1,railtie2"
+  task :copy_assets => :rails_env do
+    begin
+      Rails.application.initialize!
+      app_root_path = Rails.root
+      engine_root_path = Gluttonberg::Engine.root
+
+      ["images" , "stylesheets", "javascripts"].each do |assets_dir|
+        FileUtils.mkdir_p File.join(app_root_path , "app/assets/")
+        FileUtils.cp_r File.join(engine_root_path , "app/assets/#{assets_dir}"), File.join(app_root_path , "vendor/assets")
+      end # loop
+      puts "Completed"
+    rescue => e
+      puts "#{e}"
+    end
+  end #task
+  
+  desc "Clean Html for all models"
+  task :clean_html_for_all_models => :environment do
+    Rails.application.initialize!
+    [Gluttonberg::HtmlContentLocalization , Gluttonberg::Page , Gluttonberg::Article , Gluttonberg::Blog , Gluttonberg::Article , Theme , Idea , User , Speaker ].each do |constant|
+      if not constant.nil? and constant.is_a? Class and constant.superclass == ActiveRecord::Base
+        puts constant
+        begin
+          constant.all.each do |v|
+            v.save
+          end
+        rescue => e
+          puts e
+        end  
+        
+      end
+    end
+    
+    Gluttonberg::HtmlContentLocalization.all.each do |l|
+      l.text = Gluttonberg::HtmlContentLocalization.clean_tags(l.text)
+      l.save_without_revision
+    end  
+  end
+  
+end

data/lib/gluttonberg/templates.rb

@@ -0,0 +1,12 @@
+module Gluttonberg
+  # This module mainly acts as container for configuration related to the
+  # Gluttonberg templates.
+  module Templates
+    
+    
+    def self.editor_template_path(type)
+      "/gluttonberg/admin/content/editors/#{type}"
+    end
+    
+  end
+end

data/lib/gluttonberg/version.rb

@@ -0,0 +1,3 @@
+module Gluttonberg
+  VERSION = "2.5"
+end

data/lib/gluttonberg.rb

@@ -0,0 +1,47 @@
+module Gluttonberg
+  require 'engine' if defined?(Rails) && Rails::VERSION::MAJOR == 3
+  require 'haml'
+  require 'authlogic'
+  require 'will_paginate'
+  require 'zip/zip'
+  require 'acts_as_tree'
+  require 'acts_as_list'
+  require 'acts_as_versioned'
+  require 'delayed_job'
+  require 'paperclip'
+  require 'cancan'
+  require 'texticle'
+  require 'audio_job'
+  require 'aws'
+  require 'acl9'
+  require 'sitemap_generator'
+  require 'gluttonberg/authorizable'
+  require 'gluttonberg/components'
+  require 'gluttonberg/content'
+  require 'gluttonberg/drag_tree'
+  require 'gluttonberg/extensions'
+  require 'gluttonberg/helpers'
+  require 'gluttonberg/library'
+  require 'gluttonberg/page_description'
+  require 'gluttonberg/templates'
+  require 'gluttonberg/middleware'
+  require 'gluttonberg/can_flag'
+  require 'gluttonberg/record_history'
+
+
+    # These should likely move into one of the initializers inside of the
+    # engine config. This will ensure they only run after Rails and the app
+    # has been loaded.
+    #Helpers.setup
+    DragTree.setup
+    RecordHistory.setup
+
+  # Check to see if Gluttonberg is configured to be localized.
+  def self.localized?
+    Engine.config.localize
+  end
+
+  require 'jeditable-rails'
+end
+
+

data/lib/pagination_list_link_renderer.rb

@@ -0,0 +1,67 @@
+class PaginationListLinkRenderer < WillPaginate::ViewHelpers::LinkRenderer
+
+  protected
+
+    def page_number(page)
+      unless page == current_page
+        tag(:li, link(page, page, :rel => rel_value(page)))
+      else
+        tag(:li, link(page, "#", :rel => rel_value(page)), :class => "active")
+      end
+    end
+
+    def previous_or_next_page(page, text, classname)
+      if page
+        tag(:li, link(text, page), :class => classname)
+      else
+        tag(:li, link(text, "#"), :class => classname + ' disabled')
+      end
+    end
+
+    def html_container(html)
+      tag(:ul, html, container_attributes)
+    end
+    
+    def default_url_params
+      {}
+    end
+
+    def gap
+      text = @template.will_paginate_translate(:page_gap) { '&hellip;' }
+      %(<li class="disabled"><a href="#">#{text}</a></li>)
+    end
+
+    def url(page)
+      @base_url_params ||= begin
+        url_params = merge_get_params(default_url_params)
+        merge_optional_params(url_params)
+      end
+
+      url_params = @base_url_params.dup
+      add_current_page_param(url_params, page)
+
+      @template.url_for(url_params)
+    end
+    
+    def merge_get_params(url_params)
+      if @template.respond_to? :request and @template.request and @template.request.get?
+        symbolized_update(url_params, @template.params)
+      end
+      url_params
+    end
+
+    def merge_optional_params(url_params)
+      symbolized_update(url_params, @options[:params]) if @options[:params]
+      url_params
+    end
+
+    def add_current_page_param(url_params, page)
+      unless param_name.index(/[^\w-]/)
+        url_params[param_name.to_sym] = page
+      else
+        page_param = parse_query_parameters("#{param_name}=#{page}")
+        symbolized_update(url_params, page_param)
+      end
+    end
+
+end

data/lib/rails/railties/tasks.rake

@@ -0,0 +1,3 @@
+namespace :gluttonberg do
+  
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Gluttonberg
+  VERSION = "2.5.0"
+end