gluttonberg-core 2.5

data/lib/gluttonberg/content/versioning.rb

@@ -0,0 +1,43 @@
+module Gluttonberg
+  module Content
+    # A mixin which allows for any arbitrary model to have multiple versions. It will 
+    # generate the versioning models and add methods for creating, managing and 
+    # retrieving different versions of a record.
+    # In reality this is behaving like a wrapper on acts_as_versioned
+    module Versioning
+      
+      def self.setup
+        ::ActiveRecord::Base.send :include, Gluttonberg::Content::Versioning
+      end
+      
+      def self.included(klass)
+        klass.class_eval do
+          extend  ClassMethods
+          include InstanceMethods          
+        end
+      end
+      
+      module ClassMethods
+        
+        def is_versioned(options = {}, &extension)
+          excluded_columns = options.delete(:non_versioned_columns)
+          acts_as_versioned( options.merge( :limit => Gluttonberg::Setting.get_setting("number_of_revisions") ) , &extension )   
+          self.non_versioned_columns << excluded_columns 
+          self.non_versioned_columns.flatten!
+        end
+        
+        def versioned?
+          self.respond_to?(:versioned_class_name)
+        end
+        
+      end
+      
+      module InstanceMethods
+        def versioned?
+          self.class.versioned?
+        end
+      end
+      
+    end
+  end
+end  

data/lib/gluttonberg/content/workflow.rb

@@ -0,0 +1,68 @@
+module Gluttonberg
+  module Content
+    # A mixin which provides a super simple publish/approve workflow for a 
+    # model. A state machine this is not.
+    #
+    # The states are :in_progress, :pending, :approved, :rejected
+    #
+    # For each state there is an instance method for setting and saving that
+    # state. There are some additional class methods for retrieving the pending
+    # or rejected records.
+    
+    #TODO Fixme
+    module Workflow
+      def self.included(klass)
+        klass.class_eval do
+          extend ClassMethods
+          include InstanceMethods
+          
+          property :state,  DataMapper::Types::Enum[:in_progress, :pending, :rejected , :approved], :default => :in_progress
+        end
+      end
+
+      module ClassMethods
+        # Returns all records with the pending state. May take additional
+        # conditions.
+        def all_pending(options = {})
+          options[:state] = :pending
+          all(options)
+        end
+        
+        # Returns all records with the rejected state. May take additional
+        # conditions.
+        def all_rejected(options = {})
+          options[:state] = :rejected
+          all(options)
+        end
+          
+        # Returns all records with the approved state and additionally with the
+        # publish flag set. The publish flag is managed by the Publishable mixin,
+        # so obviously it need to be included in the model for this method to 
+        # work.
+        #
+        # Extra conditions can also be passed in.
+        def all_approved_and_published(options = {})
+          options.merge!(:state => :approved , :published => true)
+          all(options)  
+        end
+      end
+
+      module InstanceMethods
+        # Sets the state to :pending and saves the record.
+        def submit!
+          update_attributes(:state => :pending)
+        end
+        
+        # Sets the state to :approved and saves the record.
+        def approve!
+          update_attributes(:state=>:approved)
+        end
+        
+        # Sets the state to :rejected and saves the record.
+        def reject!
+          update_attributes(:state=>:rejected)
+        end
+      end
+    end # Workflow
+  end # Content
+end # Gluttonberg

data/lib/gluttonberg/content.rb

@@ -0,0 +1,66 @@
+content = Pathname(__FILE__).dirname.expand_path
+
+require File.join(content, 'content', 'slug_management')
+require File.join(content, "content", "block")
+require File.join(content, "content", "block_localization")
+require File.join(content, "content", "localization")
+require File.join(content, "content", "publishable")
+require File.join(content, "content", "versioning")
+require File.join(content, "content", "clean_html")
+require File.join(content, "content", "import_export_csv")
+
+module Gluttonberg
+  # The content module contains a whole bunch classes and mixins related to the 
+  # pages, localizations, content models and helpers for rendering content
+  # inside of views.
+  module Content
+    @@content_associations = nil
+    @@non_localized_associations = nil
+    @@localizations = {}
+    @@localization_associations = nil
+    @@localization_classes = nil
+    
+    # This is called after the application loads so that we can define any
+    # extra associations or do house-keeping once everything is required and
+    # running
+    def self.setup
+      # Store the names of the associations in their own array for convenience
+      @@localization_associations = @@localizations.keys
+      @@localization_classes = @@localizations.values
+      @@content_associations = Block.classes.collect { |k| k.association_name }
+    end
+        
+    # For each content class that is registered, a corresponding association is
+    # declared against the Page model. We need to keep track of these, which
+    # is what this method does. It just returns an array of the association 
+    # names.
+    def self.non_localized_associations
+      @@non_localized_associations ||= begin
+        non_localized = Block.classes.select {|c| !c.localized? }
+        non_localized.collect {|c| c.association_name }
+      end
+    end
+    
+    # Return the collection of content association names.
+    def self.content_associations
+      @@content_associations
+    end
+    
+    # If a content class has the is_localized declaration, this method is used 
+    # to register it so we can keep track of all localized content.
+    def self.register_localization(assoc_name, klass)
+      @@localizations[assoc_name] = klass
+    end
+    
+    # Returns a hash of content classes that are localized, keyed to the 
+    # association name.
+    def self.localizations
+      @@localizations
+    end
+    
+    # Returns an array of the localization association names.
+    def self.localization_associations
+      @@localization_associations
+    end
+  end
+end

data/lib/gluttonberg/drag_tree/action_controller.rb

@@ -0,0 +1,61 @@
+module Gluttonberg
+  module DragTree
+    module ActionController
+
+      def self.included(base)
+           base.extend(ClassMethods)
+      end
+
+
+      module ClassMethods
+        def drag_tree(model_class, options = {})
+          self.send(:include, Gluttonberg::DragTree::ActionController::ControllerHelperClassMethods)
+          self.set_drag_tree(model_class, options)
+        end
+
+      end # class methods
+
+      module ControllerHelperClassMethods
+        def self.included(klass)
+          klass.class_eval do
+            @drag_tree_model_class = nil
+            @drag_tree_route_name = nil
+
+            def klass.drag_class
+              @drag_tree_model_class
+            end
+
+            def klass.set_drag_tree(model_class, options = {})
+              @drag_tree_route_name = options[:route_name] if options[:route_name]
+              @drag_tree_model_class = model_class
+            end
+
+            def klass.drag_tree_route_name
+              if @drag_tree_route_name then
+                @drag_tree_route_name
+              else
+                "#{self.controller_name}/move_node".to_sym
+              end
+            end
+
+            def move_node
+              if params[:element_ids].blank?
+                render :json => {:success => false}
+                return
+              end
+              ids = params[:element_ids].split(",")
+              elements = self.class.drag_class.find_by_sorted_ids(ids )
+              elements.each_with_index do |element , index|
+                attr = {:position => index + 1  }
+                element.update_attributes!( attr   )
+              end
+              render :json => {:success => true}
+            end
+
+          end
+        end
+      end
+
+    end
+  end #DragTree
+end  # Gluttonberg

data/lib/gluttonberg/drag_tree/action_view.rb

@@ -0,0 +1,60 @@
+module Gluttonberg
+  module DragTree
+    module ActionView
+      module Helpers
+
+
+        def drag_tree_url(klass = self.class)
+          controller_class = controller.class
+          if controller_class.respond_to?(:drag_tree_route_name) then
+            url_for(controller_class.drag_tree_route_name)
+          else
+            ''
+          end
+        end
+
+
+        def drag_tree_table_class(klass = self.class)
+          # drag-tree treeTable
+          controller_class = controller.class
+          css_class_str = ''
+          if controller_class.respond_to?(:drag_class) then
+            if controller_class.drag_class then
+              if controller_class.drag_class.respond_to?(:behaves_as_a_drag_tree) then
+                css_class_str = 'drag-tree'
+                if controller_class.drag_class.behaves_as_a_flat_drag_tree then
+                  css_class_str = css_class_str + ' drag-flat'
+                end
+              end
+            end
+          end
+          css_class_str
+        end
+
+        def drag_tree_row_class(model)
+          css_class_str = ''
+          if model.class.respond_to?(:behaves_as_a_drag_tree) then
+            css_class_str = 'node-pos-' + model.position.to_s
+            if !model.class.behaves_as_a_flat_drag_tree then
+              unless model.class.behaves_as_a_flat_drag_tree then
+                css_class_str = css_class_str + ' child-of-node-' + model.parent_id.to_s
+              end
+            end
+          end
+          css_class_str
+        end
+
+        def drag_tree_drag_point_class
+          'drag-node'
+        end
+
+        def drag_tree_row_id(model)
+          "node-#{model.id}"
+        end
+
+
+      end
+
+    end
+  end #DragTree
+end  #Gluttonberg

data/lib/gluttonberg/drag_tree/active_record.rb

@@ -0,0 +1,96 @@
+module Gluttonberg
+  module DragTree
+    module ActiveRecord
+
+      def self.included(base)
+         base.extend(ClassMethods)
+      end
+
+
+      module ClassMethods
+        def is_drag_tree(options = {})
+          options[:flat] = true unless options.has_key?(:flat)
+          self.send(:include, Gluttonberg::DragTree::ActiveRecord::ModelHelpersClassMethods)
+          if options.has_key?(:scope)
+            acts_as_list :scope => options[:scope]
+          else
+            acts_as_list
+          end
+          unless options[:flat]
+            acts_as_tree options
+          else
+            self.make_flat_drag_tree
+          end
+        end
+
+        def repair_list(list)
+          unless list.blank?
+            list.each_with_index do |sibling , index|
+              sibling.position = index
+              sibling.save
+            end
+          end
+        end
+
+        def find_by_sorted_ids(new_sorted_element_ids)
+          # find records in unorder list
+          elements = self.find(new_sorted_element_ids )
+          # sort it using ruby method
+          sorted_elements = []
+          new_sorted_element_ids.each do |id|
+            id = id.to_i
+            sorted_elements << elements.find{ |x| x.id == id }
+          end
+          sorted_elements
+        end
+
+
+
+      end #module ClassMethods
+
+      module ModelHelpersClassMethods
+        def self.included(klass)
+          klass.class_eval do
+            cattr_accessor :is_flat_drag_tree
+            #@is_flat_drag_tree = false
+            def klass.behaves_as_a_drag_tree
+              true
+            end
+
+            def klass.make_flat_drag_tree
+              self.is_flat_drag_tree = true
+            end
+
+            def klass.behaves_as_a_flat_drag_tree
+              self.is_flat_drag_tree
+            end
+
+            def klass.repair_drag_tree
+              if behaves_as_a_flat_drag_tree
+                if list_options[:scope].empty?
+                  repair_list
+                else
+                  # this is wasteful as it does a repair on every item
+                  # which means for items of the same scope they keep
+                  # getting re-repaired. :-(
+                  items = all()
+                  items.each{ |item| item.repair_list}
+                end
+              end
+              # todo: add support for non flat trees
+            end
+            def klass.all_sorted(query={})
+              all({:order => [:position.asc]}.merge(query))
+            end
+          end # class_eval
+        end #included
+      end #ModelHelpersClassMethods
+
+
+    end # ActiveRecord
+
+
+
+
+  end #DragTree
+end  #Gluttonberg

data/lib/gluttonberg/drag_tree.rb

@@ -0,0 +1,122 @@
+#
+#  DragTree is a mix of ActiveRecord plugin, Rails Plugin and jQuery Plugin
+#  It provides a simple way of defining a Model that is ordered (and optionally a tree)
+#  and have the ability to simply provide an Ajax table/tree to reorganise
+#  the order and parenting.
+#
+#  To get started you need to declare in your DataMapper class is_drag_tree
+#
+#  format:
+#    is_drag_tree(options)
+#
+#    options:
+#       :flat (true|false) default is true. If true the class supports
+#             reordering, but not parenting, i.e. is NOT a tree.
+#
+#      Options is passed through to the is_list and is_tree DataMapper
+#      declarations.
+#
+#  Examples:
+#
+#   class Page
+#     is_drag_tree :scope => :parent_id, :flat => false
+#   end
+#
+#   class Article
+#     # this class is a flat table
+#     is_drag_tree
+#   end
+#
+#  Then in your controller for that class add the drag_tree declaration
+#
+#  format:
+#    drag_tree(class, options)
+#
+#    class: The DataMapper Model class of that has the is_drag_tree declaration.
+#
+#    options:
+#      :route_name (symbol) This is the name of the route used to access the
+#                  move_node() action added to the controller. You must set this to
+#                  the route you have created.
+#
+#
+#    NOTE: This adds the action :move_node to your controller
+#          you may need to exclude this action from your before
+#          filters to prevent them running (and possible failing)
+#          e.g.
+#            before_filter :find_panel, :exclude => [:index, :create, :new, :move_node]
+#
+#    Example
+#
+#    class PagesController < Gluttonberg::Application
+#      # this requires you to manually create the route named :page_move
+#      # support for the Page class is added to the controller
+#      drag_tree Page, :route_name => :page_move
+#    end
+#
+#    class ArticlesController < Application
+#      # support for the Article class is added to the controller
+#      # this requires you to manually create the route named :article_move
+#      drag_tree Article , :route_name => :article_move
+#    end
+#
+#    To now render this is a view you need to use the following view helpers:
+#
+#      drag_tree_url
+#          This returns the url required for the callback from the clientside
+#          javascript. This should be placed in the rel tag of the table. If
+#          you are calling this from within a slice use the drag_tree_slice_url
+#          call instead.
+#
+#
+#      drag_tree_table_class
+#          this returns the css classes required for the table tag. Classes are
+#          returned as a space delimited string.
+#
+#      drag_tree_row_class(model)
+#          this returns the css classes required for the row. The <model> parameter
+#          is the instance of the DataMapper class for this row. Classes are
+#          returned as a space delimited string.
+#
+#      drag_tree_drag_point_class
+#          this returns the css classes required for the tag that will be used
+#          as the drag point. Generally this is a <span> tag within the first
+#          cell of each row. Classes are returned as a space delimited string.
+#
+#      drag_tree_row_id(model)
+#          this returns the css id required for a row. The <model> parameter
+#          is the instance of the DataMapper class for this row. A string is
+#          returned.
+#
+#    (Examples in HAML)
+#
+#      %table{:class => drag_tree_table_class, :cellpadding => 0, :cellspacing => 0, :rel => drag_tree_url, :summary => "Drag Tree Table"}
+#        - for article in @articles
+#          %tr{:id => drag_tree_row_id(article), :class => drag_tree_row_class(article)}
+#            %td
+#              %span{:class => drag_tree_drag_point_class}
+#                = h(article.title)
+#            %td
+#              = h(article.content)
+#
+
+
+lib = Pathname(__FILE__).dirname.expand_path
+require File.join(lib, "drag_tree", "action_controller")
+require File.join(lib, "drag_tree", "action_view")
+require File.join(lib, "drag_tree", "active_record")
+
+
+module Gluttonberg
+  module DragTree
+    def self.setup
+      ::ActiveRecord::Base.send :include, Gluttonberg::DragTree::ActiveRecord
+      ::ActionController::Base.send  :include, Gluttonberg::DragTree::ActionController
+      #::ActionView::Helpers.send(:include,  Gluttonberg::DragTree::ActionView::Helpers)
+    end
+  end #DragTree
+end #Gluttonberg
+
+
+
+

data/lib/gluttonberg/extensions/array.rb

@@ -0,0 +1,13 @@
+class Array
+  if !respond_to?(:pluck)
+    # Accepts a block and returns the first element for which the block
+    # returns true.
+    def pluck(&blk)
+      i = 0
+      while i < length
+        return self[i] if blk.call(self[i])
+        i += 1
+      end
+    end
+  end
+end

data/lib/gluttonberg/extensions/kernel.rb

@@ -0,0 +1,5 @@
+# Returns the locale stored in the current thread. This value is set either 
+# explicitly in the backend, or via the DEFER_TO_PROC in the router.
+def current_locale
+  Thread.current[:locale]
+end

data/lib/gluttonberg/extensions.rb

@@ -0,0 +1,4 @@
+extensions = Pathname(__FILE__).dirname.expand_path
+
+require File.join(extensions, "extensions", "array")
+require File.join(extensions, "extensions", "kernel")

data/lib/gluttonberg/helpers/form_builder.rb

@@ -0,0 +1,57 @@
+module Gluttonberg
+    class FormBuilder < ActionView::Helpers::FormBuilder
+      include ActionView::Helpers::TagHelper
+
+      def text_field(attribute, options={})
+        box_class = add_class!('text', options)
+        field(super, attribute, options, box_class)
+      end
+
+      def text_area(attribute, options={})
+        box_class = add_class!('text', options)
+        field(super, attribute, options, box_class)
+      end
+
+      def radio_button(attribute, value, label, options = {})
+        add_class!('radio', options)
+        label_for = "#{object_name}_#{attribute}_#{value}"
+        super(attribute, value, options) + label(attribute, :label => label, :class => 'inline', :for => label_for)
+      end
+
+      def select(attribute, choices, options={})
+        box_class = add_class!('text', options)
+        field(super, attribute, options, box_class)
+      end
+
+      private
+
+      def label(method, options = {})
+        if options.has_key?(:label)
+          super(method, options.delete(:label), options)
+        else
+          super(method, nil, options)
+        end
+      end
+
+      def add_class!(klass, options)
+        classes = [klass]
+        classes << options[:class] if options.has_key?(:class)
+        if options.has_key? :size
+          parts = options[:size].split('.')
+          classes << parts.last
+          options[:class] = classes.join(' ')
+          parts.first
+        else
+          options[:class] = classes.join(' ')
+          nil
+        end
+      end
+
+      def field(field, attribute, options, size = nil)
+        content = label(attribute, options) + field
+        klass = size ? 'field ' + size : 'field'
+        content_tag(:p, content, :class => klass)
+      end
+    end # FormBuilder
+end # Gluttonberg
+

data/lib/gluttonberg/helpers.rb

@@ -0,0 +1,20 @@
+helpers = File.join(Pathname(__FILE__).dirname.expand_path, "helpers")
+#require File.join(helpers, "content")
+#require File.join(helpers, "asset_library")
+#require File.join(helpers, "public")
+#require File.join(helpers, "admin")
+#require File.join(helpers, "form_builder")
+
+module Gluttonberg
+  # A whole heaping helping of helpers for both the administration back-end and
+  # the public views.
+  module Helpers
+    # Mixes all the helpers into the GlobalHelpers module. Slighly messy, but
+    # hey it works.
+    def self.setup
+      [AssetLibrary, Admin, Public, Content].each do |helper|
+        ActionView::Helpers.send(:include, helper)
+      end
+    end
+  end
+end