gluttonberg-core 2.5

data/lib/generators/gluttonberg/resource/templates/backend_view_index.html.haml

@@ -0,0 +1,82 @@
+- @window_title = "Content"
+- @page_title = "<%= plural_class_name %>"
+
+.row-fluid
+  = render :partial => "/gluttonberg/admin/content/main/sidebar"
+  .span9
+    .row-fluid
+      .page-header
+        %h1
+          = @page_title
+      .subnav
+        = sub_nav do
+          = nav_link('New', new_admin_<%= singular_name %>_path)
+          <% if importable? %>
+          = nav_link('Import', admin_<%= plural_name %>_import_path)
+          = nav_link('Export', admin_<%= plural_name %>_export_path)
+          <% end %>
+        <% unless draggable? %>
+        - if !@<%= plural_name %>.blank? || !params[:query].blank?
+          - form_tag(admin_<%=plural_name%>_path, :method => :get  , :id => "list_search_form") do
+            = text_field_tag :query, params[:query]
+            = submit_tag "Search" , :class => "button"
+
+        <%end%>
+
+      - if @<%= plural_name %>.empty?
+        %p.empty
+          No <%= plural_class_name %>
+      - else
+
+        <% if draggable? %>
+        %table{:id => 'pages_table', :class => "table table-bordered #{(can?(:reorder , <%=class_name%>) ? "#{drag_tree_table_class} " : " " )}", :cellpadding => 0, :cellspacing => 0, :rel => "" , :summary => "<%= plural_name %>" , :rel => drag_tree_url }
+        <%else%>
+        %table{:cellpadding => 0, :cellspacing => 0 , :class => "table table-bordered"}
+        <%end%>
+          %thead
+            %tr
+              <% if draggable? %>
+              %th Name
+              %th Published At
+              %th Created At
+              <%else %>
+              %th= sortable_column("<%= attributes.find{|attr| attr.name == "name"}.blank? ? "title" : "name" %>" , "Name")
+              %th= sortable_column("published_at" , "Published At")
+              %th= sortable_column("created_at" , "Created At")
+              <%end %>
+              %th.controls Controls
+          %tbody
+            - @<%= plural_name %>.each do |<%= singular_name %>|
+              <% if draggable? %>
+              %tr{:id => drag_tree_row_id(<%= singular_name %>), :class => drag_tree_row_class(<%= singular_name %>) + " #{cycle("even", "odd")}"}
+              <%else%>
+              %tr{ :class => "#{cycle("even", "odd")}"}
+              <%end%>
+                %td
+                  <% if draggable? %>
+                  %span{:class => "#{drag_tree_drag_point_class} page" , :rel => drag_tree_row_id(<%= singular_name %>)}
+                  <%end%>
+                  = link_to <%= singular_name %>.title_or_name?, edit_admin_<%= singular_name %>_path(<%= singular_name %>)
+
+                %td
+                  - unless <%= singular_name%>.published_at.blank?
+                    = <%= singular_name%>.published_at.strftime("%d/%m/%Y at %H:%M")
+                %td
+                  = <%= singular_name%>.created_at.strftime("%d/%m/%Y at %H:%M")
+                %td.controls
+                  .btn-group
+                    %a{ :class => "btn dropdown-toggle" , "data-toggle" => "dropdown" , :href => "#"}
+                      Actions
+                      %span.caret
+                    %ul.dropdown-menu
+                      %li= link_to "Show", admin_<%= singular_name %>_path(<%= singular_name %>) , :class => ""
+                      %li= link_to "Edit", edit_admin_<%= singular_name %>_path(<%= singular_name %>) , :class => ""
+                      %li.divider
+                      %li= link_to "Duplicate", duplicate_admin_<%= singular_name %>_path(<%= singular_name %>) , :class => ""
+                      - if can? :destroy , <%= class_name %>
+                        %li.divider
+                        %li= link_to "Delete", delete_admin_<%= singular_name %>_path(<%= singular_name %>)  , :class => ""
+
+        <% unless draggable? %>
+        = will_paginate @<%= plural_name %>
+        <%end%>

data/lib/generators/gluttonberg/resource/templates/backend_view_new.html.haml

@@ -0,0 +1,14 @@
+- @window_title = "Content"
+- @page_title = "#{link_to("<%= plural_class_name %>", admin_<%= plural_name %>_path)} > Add New <%= class_name %>"
+.row-fluid
+  = render :partial => "/gluttonberg/admin/content/main/sidebar"
+  .span9
+    .page-header
+      %h1
+        = @page_title.html_safe
+        
+    .row-fluid
+      = form_for(@<%= singular_name %>, :url => admin_<%= plural_name %>_path) do  |f|
+        = gb_error_messages_for(@<%= singular_name %>)
+
+        = render :partial => "form", :locals => {:f => f}

data/lib/generators/gluttonberg/resource/templates/backend_view_show.html.haml

@@ -0,0 +1,27 @@
+// This page needs to be edited accordingly to suit your content
+
+- @window_title = "Content"
+- @page_title = "#{link_to("<%= plural_class_name %>", admin_<%= plural_name %>_path)} > #{@<%= singular_name %>.title_or_name?}"
+
+= sub_nav do
+  = nav_link("Edit", edit_admin_<%= singular_name %>_path(@<%= singular_name %>))
+  - if can? :destroy , <%= class_name %>
+    = nav_link("Delete", delete_admin_<%= singular_name %>_path(@<%= singular_name %>))
+
+%div#show_wrapper
+  %div.pageBlock
+    %dl
+    <% attributes.each do |attribute| -%>
+  %dt <%= attribute.name %>
+      %dd #{@<%= singular_name %>.<%= attribute.name %>.humanize}
+    <% end %>
+
+  %dl.meta
+    %dt
+      Created at
+    %dd
+      = @<%= singular_name %>.created_at.to_s(:long)
+    %dt
+      Updated at
+    %dd
+      = @<%= singular_name %>.updated_at.to_s(:long)

data/lib/generators/gluttonberg/resource/templates/migration.rb

@@ -0,0 +1,39 @@
+class Create<%= class_name %> < ActiveRecord::Migration
+
+  def change
+    create_table :<%= table_name %> do |t|
+    <% unless localized? %><% attributes.each do |attribute| -%>
+  t.<%= attr_db_type_wrapper(attribute)%> :<%= attr_db_name_wrapper(attribute) %>
+    <% end -%> <% end %>
+      t.string :slug
+      t.string :previous_slug
+      t.integer :position
+      t.column :state , :string #use for publishing
+      t.datetime :published_at
+      <% unless localized? %>
+      t.string :seo_title
+      t.text :seo_keywords
+      t.text :seo_description
+      t.integer :fb_icon_id
+      t.integer :parent_id
+      t.integer :locale_id
+      <%end%>
+      t.timestamps
+    end
+    <% if localized? %>
+    create_table :<%= singular_name %>_localizations do |t|
+  <% attributes.each do |attribute| -%>
+    t.<%= attr_db_type_wrapper(attribute)%> :<%= attr_db_name_wrapper(attribute) %>
+  <% end -%>
+    t.string :seo_title
+      t.text :seo_keywords
+      t.text :seo_description
+      t.integer :fb_icon_id
+      t.integer :parent_id
+      t.integer :locale_id
+      t.timestamps
+    end
+    <% end %>
+  end
+
+end

data/lib/generators/gluttonberg/resource/templates/model.rb

@@ -0,0 +1,39 @@
+class <%= class_name %> < ActiveRecord::Base
+  include Gluttonberg::Content::Publishable
+  include Gluttonberg::Content::SlugManagement
+  #self.slug_source_field_name = :name  #uncomment this line and provide your source for slug. by default it looks for name or title or id
+  attr_accessible <%= attributes.collect{|attr| ":#{attr_db_name_wrapper(attr)}"}.join(",") %>, :slug, :seo_title, :seo_keywords, :seo_description, :fb_icon_id, :state, :published_at
+  <% if localized? %>include Gluttonberg::Content::Localization
+  delegate :fb_icon , :to =>  :current_localization
+  <% attributes.find_all{|attr| ['asset', 'image','video','document','audio'].include?(attr.type.to_s) }.each do |attr| %>
+  delegate :<%=attr_name_wrapper(attr)%> , :to =>  :current_localization
+  <%end%>
+  <% end %>
+  <% unless localized? %>belongs_to :fb_icon , :class_name => "Gluttonberg::Asset" , :foreign_key => "fb_icon_id"<% end %>
+  <% if importable? %>import_export_csv(<%=attributes.collect{|attr| "#{attr.name}"} %>) <% end %>
+  <%if draggable? %>is_drag_tree :flat => true , :order => "position"<%end%>
+  <% if localized? %>is_localized do
+    belongs_to :fb_icon , :class_name => "Gluttonberg::Asset" , :foreign_key => "fb_icon_id"
+  <% attributes.find_all{|attr| ['asset', 'image','video','document', 'audio'].include?(attr.type.to_s) }.each do |attr| %>
+    belongs_to :<%=attr_name_wrapper(attr)%> , :foreign_key => "<%=attr_db_name_wrapper(attr)%>" , :class_name => "Gluttonberg::Asset"
+  <% end %>end<% end %>
+  <% unless localized? %><% attributes.find_all{|attr| ['asset', 'image','video','document', 'audio'].include?(attr.type.to_s) }.each do |attr| %>
+  belongs_to :<%=attr_name_wrapper(attr)%> , :foreign_key => "<%=attr_db_name_wrapper(attr)%>" , :class_name => "Gluttonberg::Asset"
+  <% end %><% end %>
+
+  def title_or_name?
+    <% if attributes.find{|attr| attr.name == "name"}.blank?  %><% if attributes.find{|attr| attr.name == "title"}.blank?  %>id<%else%>title<%end%><%else%>name<%end%>
+  end
+
+  def duplicate!
+    @cloned_<%= singular_name %> = self.dup
+    @cloned_<%= singular_name %>.position = nil
+    @cloned_<%= singular_name %>.unpublish
+    @cloned_<%= singular_name %>.created_at = Time.now
+    if @cloned_<%= singular_name %>.save
+      @cloned_<%= singular_name %>
+    else
+      nil
+    end
+  end
+end

data/lib/generators/gluttonberg/resource/templates/public_controller.rb

@@ -0,0 +1,18 @@
+class <%= plural_class_name %>Controller < Gluttonberg::Public::BaseController
+
+  def index
+    @<%= plural_name %> = <%= class_name %>.published<% if draggable? %>.order('position asc') <%end%>
+  end
+
+  def show
+    @custom_model_object = @<%= singular_name %> = <%= class_name %>.published.where(:slug => params[:id]).first
+    if @<%= singular_name %>.blank?
+      @<%= singular_name %> = <%= class_name %>.published.where(:previous_slug => params[:id]).first
+      unless @<%= singular_name %>.blank?
+        redirect_to <%= singular_name %>_path(@<%= singular_name %>.slug) , :status => 301
+      end
+    end
+    raise ActiveRecord::RecordNotFound.new if @<%= singular_name %>.blank?
+  end
+
+end

data/lib/generators/gluttonberg/resource/templates/public_view_index.html.haml

@@ -0,0 +1,13 @@
+%h1
+  <%= plural_class_name %>
+  
+- if @<%= plural_name %>.blank?
+  %p
+    No <%= plural_class_name %>
+- else
+  - @<%= plural_name %>.each do |<%= singular_name %>|
+    %p
+      <% attributes.each do |attribute| -%>
+= link_to <%= singular_name %>.<%= attribute.name %>, <%= singular_name %>_path(<%= singular_name %>.slug) 
+      %br
+      <% end %>

data/lib/generators/gluttonberg/resource/templates/public_view_show.html.haml

@@ -0,0 +1,7 @@
+%h1
+  <%= singular_name %>
+  
+<% attributes.each do |attribute| -%>
+%p
+  = @<%= singular_name %>.<%= attribute.name %>.humanize
+<% end %>

data/lib/gluttonberg/authorizable.rb

@@ -0,0 +1,51 @@
+module Gluttonberg  
+    # A mixin that will add simple authorization functionality to any arbitrary 
+    # model. This includes finders for retrieving authorized records and 
+    # instance methods for quickly changing the state.
+    module Authorizable
+      # Add the class and instance methods, declare the relationship we store the
+      # published state in.
+      def self.included(klass)
+        klass.class_eval do
+          extend ClassMethods
+          include InstanceMethods
+          
+          belongs_to :user , :class_name => "Gluttonberg::User"
+        end
+      end
+
+      module ClassMethods
+        
+        # Returns all matching records that are authorize to provided user. 
+        # For Super admin users returns all records
+        # For other non-super-users checks th condition of user_id
+        # May be called with additional conditions.
+        def all_for_user(user , options = {})
+          if user.is_super_admin
+            all(options)
+          else
+            options[:user_id] = user.id
+            all(options)
+          end
+        end  
+        
+        # Returns first matching records that is authorize to provided user with given id. 
+        # For Super admin users it checks only id but for non-super-users checks additionally it checks condition of user_id
+        
+        def get_for_user(user , id)
+          options = {:id => id }
+          if user.is_super_admin            
+            first(options)
+          else
+            options[:user_id] = user.id
+            first(options)
+          end
+        end  
+      end  #ClassMethods
+
+      module InstanceMethods
+        
+      end #InstanceMethods
+      
+    end # Authorizable  
+end # Gluttonberg

data/lib/gluttonberg/can_flag/rails_commands.rb

@@ -0,0 +1,30 @@
+# Stolen from Technoweenie's restful_authentication
+Rails::Generator::Commands::Create.class_eval do
+  def route_resource(*resources)
+    resource_list = resources.map { |r| r.to_sym.inspect }.join(', ')
+    sentinel = 'ActionController::Routing::Routes.draw do |map|'
+
+    logger.route "map.resource #{resource_list}"
+    unless options[:pretend]
+      gsub_file 'config/routes.rb', /(#{Regexp.escape(sentinel)})/mi do |match|
+        "#{match}\n  map.resource #{resource_list}\n"
+      end
+    end
+  end
+end
+
+Rails::Generator::Commands::Destroy.class_eval do
+  def route_resource(*resources)
+    resource_list = resources.map { |r| r.to_sym.inspect }.join(', ')
+    look_for = "\n  map.resource #{resource_list}\n"
+    logger.route "map.resource #{resource_list}"
+    gsub_file 'config/routes.rb', /(#{look_for})/mi, ''
+  end
+end
+
+Rails::Generator::Commands::List.class_eval do
+  def route_resource(*resources)
+    resource_list = resources.map { |r| r.to_sym.inspect }.join(', ')
+    logger.route "map.resource #{resource_list}"
+  end
+end

data/lib/gluttonberg/can_flag.rb

@@ -0,0 +1,93 @@
+# CanFlag
+module Gluttonberg
+  module CanFlag
+      def self.setup
+        ::ActiveRecord::Base.send :include, Gluttonberg::CanFlag
+      end
+      
+      def self.included(klass)
+        klass.class_eval do
+          extend ClassMethods
+          #include InstanceMethods
+          if defined?(::ActiveSupport::Callbacks)
+            klass.define_callbacks :after_flagged
+          end
+          
+        end
+      end
+      
+
+      module ClassMethods
+        # Call can_be_flagged from your content model, or from anything
+        # you want to flag.
+        def can_be_flagged(opts={})
+          has_many :flags, :as => :flaggable, :dependent => :destroy
+          validates_associated :flags, :message => 'failed to validate'
+          include Gluttonberg::CanFlag::InstanceMethods
+          extend  Gluttonberg::CanFlag::SingletonMethods
+          cattr_accessor :reasons
+          self.reasons = opts[:reasons] || [:inappropriate]
+          (::Flag.flaggable_models ||= []) << self
+        end
+        
+        # Call can_flag from your user model, or anything that can own a flagging.
+        # That's a paddlin!
+        # Limitation for now: you should only allow one model to own flags.
+        # This is ridiculously easy to make polymorphic, but no ponies yet.
+        def can_flag
+          # has_many :flaggables, :foreign_key => "user_id"
+          # User created these flags
+          has_many :flags, :foreign_key => "user_id", :order => "id desc"
+          
+          # User was responsible for creating this filth
+          has_many :flaggings, :foreign_key => "flaggable_user_id", :class_name => "Flag"
+          include CanFlagInstanceMethods
+          
+          # Associate the flag back here
+          # Flag.belongs_to :user
+          # Flag.belongs_to :owner, :foreign_key => flaggable_user_id
+          ::Flag.class_eval "belongs_to :#{name.underscore}, :foreign_key => :user_id; 
+            belongs_to :owner, :foreign_key => :flaggable_user_id, :class_name => '#{name}'"
+        end
+      end
+      
+      # This module contains class methods
+      module SingletonMethods
+      
+      end
+      
+      module CanFlagInstanceMethods
+        def flagged?(content)
+          logger.warn "Looking for flags with #{content.inspect} #{content.class.name}"
+          ::Flag.find(:first,
+            :conditions => { :flaggable_type => content.class.name, :flaggable_id => content[:id] })
+        end
+        
+        def flagged_by?(content, user)
+          ::Flag.find(:first,
+            :conditions => { :flaggable_type => content.class.name, :flaggable_id => content[:id], :flaggable_user_id => user.id })
+        end
+      end
+      
+      ## This module contains instance methods
+      module InstanceMethods
+        
+        def flagged?
+          flags.size > 0
+        end
+        
+        def inappropriate?
+          flags.find_all{|f| f.approved == true }.size > 0
+        end
+          
+        # Flag content with a mass-updater; sets the flagging user.
+        # article.update_attributes { 'flagged' => current_user.id }
+        def flagged=(by_who)
+          flags.build :user_id => by_who
+        end
+      
+      end
+      
+  end
+end
+

data/lib/gluttonberg/components.rb

@@ -0,0 +1,62 @@
+module Gluttonberg
+  # This module allows custom controllers to be registered wtih Gluttonberg’s
+  # administration. Typically, these controllers will be registered in the 
+  # application’s before_app_loads block.
+  module Components
+    @@components  = {}
+    @@routes      = {}
+    @@nav_entries = nil
+    @@main_nav_entries = []
+    @@registered  = nil
+    Component     = Struct.new(:name, :label , :admin_url, :only_for_super_admin )
+    
+    # Registers a controller — or set of controllers — based on the URLs 
+    # specified in the routes.
+    #
+    #   Components.register(:forum, :label => "Forum", :admin_url => url) do |scope|
+    #     scope.resources(:posts)
+    #     scope.resources(:threads)
+    #   end
+    def self.register(name, opts = {}, &routes)
+      @@components[name] = opts
+      @@routes[name] = routes if block_given?
+    end
+    
+    
+    # Returns a hash of the registered components, keyed to their label.
+    def self.registered
+      @@registered ||= @@components.collect {|k, v| Component.new(k.to_s, v[:label] , v[:only_for_super_admin])}
+    end
+    
+    # Returns an array of components that have been given a nav_label —
+    # the label implicitly registers them as nav entries. Components without
+    # a label won’t turn up.
+    def self.nav_entries      
+      @@nav_entries ||= @@components.collect do |k, v| 
+        
+        url = if v[:admin_url]
+          if v[:admin_url].is_a? Symbol
+            v[:admin_url]
+          else
+            v[:admin_url]
+          end
+        end 
+        [v[:label], k, url , v[:only_for_super_admin]]
+      end
+    end
+    
+   
+   def self.register_for_main_nav(name , url , only_for_super_admin = false )
+      @@main_nav_entries << [name , url , only_for_super_admin]
+    end 
+    
+   # Returns an array of components that have been given a nav_label —
+    # the label implicitly registers them as nav entries. Components without
+    # a label won’t turn up.
+    def self.main_nav_entries      
+      @@main_nav_entries 
+    end
+
+    
+  end
+end

data/lib/gluttonberg/content/block.rb

@@ -0,0 +1,147 @@
+module Gluttonberg
+  module Content
+    # This module can be mixed into a class to make it behave like a content
+    # block. A content block is a class that can be associated with a section
+    # on in a page description.
+    module Block
+      # A collection of the classes which have this module included in it.
+      @classes = []
+
+      # This included hook is used to declare the various properties and class
+      # ivars we need.
+      def self.included(klass)
+
+        klass.class_eval do
+          extend Block::ClassMethods
+          include Block::InstanceMethods
+
+          cattr_accessor :localized, :label, :content_type, :association_name
+          @localized = false
+
+          attr_reader :current_localization
+
+          belongs_to :page
+
+          # Generate the various names to be used in associations
+          type = self.name.demodulize.underscore
+          self.association_name = type.pluralize.to_sym
+          self.content_type = type.to_sym
+          # Let's generate a label from the class — this might be over-ridden later
+          self.label = type.humanize
+
+        end
+
+
+      end
+
+      # register content classes. We can do this inside included block, but in rails lazyloading behavior it is not properly working.
+      def self.register(klass)
+        @classes << klass
+        @classes.uniq!
+      end
+
+      # An accessor which provides the collection of classes with mixin this
+      # module.
+      def self.classes
+        @classes
+      end
+
+      module ClassMethods
+        # This declaration is used to create properties on a model which need
+        # to be localized. It does this by generating a localized class and
+        # association.
+        #
+        # It also registers the class as being localized.
+        def is_localized(&blk)
+          self.localized = true
+          self.attr_accessible :section_name
+
+          # Generate the localization model
+          class_name = "#{self.name.demodulize}Localization"
+          storage_name = "gb_#{class_name.tableize}"
+          localized_model = Class.new(ActiveRecord::Base)
+          foreign_key = self.name.foreign_key
+          localized_model.table_name = storage_name
+          Gluttonberg.const_set(class_name, localized_model)
+
+          # Mix in our base set of properties and methods
+          localized_model.send(:include, Gluttonberg::Content::BlockLocalization)
+          # Generate additional properties from the block passed in
+          localized_model.class_eval(&blk)
+          # Store the name so we can easily access it without having to look
+          # at this parent class
+          localized_model.content_type = self.content_type
+
+          # Tell the content module that we are localized
+          localized_model.association_name = "#{self.content_type}_localizations"
+          Gluttonberg::Content.register_localization( "#{self.content_type}_localizations".to_sym , localized_model)
+
+          # Set up the associations
+          has_many :localizations, :class_name => Gluttonberg.const_get(class_name).to_s  , :foreign_key => "#{self.content_type}_id" , :dependent => :destroy
+          localized_model.belongs_to(:parent, :class_name => self.name , :foreign_key => "#{self.content_type}_id")
+
+          localized_model.attr_accessible :text, :parent, :page_localization
+          localized_model.is_versioned
+
+        end
+
+        # Does this class have an associated localization class.
+        def localized?
+          self.localized
+        end
+
+        # Returns all the matching models with the specificed localization loaded.
+        def all_with_localization(opts)
+          page_localization_id = opts.delete(:page_localization_id)
+          results = all(opts)
+          results.each { |r| r.load_localization(page_localization_id) }
+          results
+        end
+      end
+
+      module InstanceMethods
+        # Returns the section this content instance is associated with. It does
+        # this by looking at the associated page, it’s description then the
+        # matching section.
+        def section
+          @section ||= page.description.sections[section_name.to_sym]
+        end
+
+        # Checks to see if this content class has localized properties.
+        def localized?
+          self.class.localized?
+        end
+
+        # The name of the generated association. This is the association that
+        def association_name
+          self.class.association_name
+        end
+
+
+        def section_label
+          section[:label]
+        end
+
+        def section_position
+          section[:position]
+        end
+
+        # Content type is simply the inflected version of the content class
+        # name, e.g. FooContent becomes :foo_content
+        def content_type
+          self.class.content_type
+        end
+
+        # Loads a localized version based on the specified page localization,
+        # then stashes it in an accessor
+        def load_localization(id_or_model)
+          if localized?
+            localization_id = id_or_model.is_a?(Numeric) ? id_or_model : id_or_model.id
+            conditions = {:page_localization_id => localization_id, :"#{self.class.content_type}_id" => id}
+            @current_localization = localizations.find(:first , :conditions => conditions)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gluttonberg/content/block_localization.rb

@@ -0,0 +1,38 @@
+module Gluttonberg
+  module Content
+    # The mixin used when generating a localization for content classes. It
+    # adds the base properties — e.g. id — and associations. It also comes with
+    # some convenience methods for accessing the associated section in a page.
+    # 
+    # These just defer to the parent class.
+    module BlockLocalization
+      def self.included(klass)
+        klass.class_eval do
+          class << self; attr_accessor :content_type, :association_name end
+          
+          belongs_to :page_localization
+        end
+      end
+      
+      def association_name
+        self.class.association_name
+      end
+      
+      def content_type
+        self.class.content_type
+      end
+      
+      def section_name
+        parent.section[:name]
+      end
+      
+      def section_position
+        parent.section[:position]
+      end
+      
+      def section_label
+        parent.section[:label] unless parent.blank?
+      end
+    end
+  end
+end