radiant-page_factory-extension 1.0.0

data/lib/page_factory/base.rb

@@ -0,0 +1,81 @@
+class PageFactory::Base
+  include Annotatable
+  annotate :template_name, :layout, :page_class, :description
+  template_name 'Page'
+  description 'A basic Radiant page.'
+
+  class << self
+    attr_accessor :parts
+
+    def inherited(subclass)
+      subclass.parts = @parts.dup
+      subclass.layout = layout
+      subclass.page_class = page_class
+      subclass.template_name = subclass.name.to_name('Factory')
+    end
+
+    ##
+    # Add a part to this PageFactory
+    #
+    # @param [String] name The name of the page part
+    # @param [Hash] attrs A hash of attributes used to construct this part.
+    # @option attrs [String] :description Some additional text that will be
+    #   shown in the part's tab on the page editing screen. This is used to
+    #   display a part description or helper text to editors.
+    #
+    # @example Add a part with default content and some help text
+    #   part 'Sidebar', :content => "Lorem ipsum dolor",
+    #                   :description => "This appears in the right-hand sidebar."
+    def part(name, attrs={})
+      remove name
+      @parts << PagePart.new(attrs.merge(:name => name))
+    end
+
+    ##
+    # Remove a part from this PageFactory
+    #
+    # @param [<String>] names Any number of part names to remove.
+    #
+    # @example
+    #   remove 'body'
+    #   remove 'body', 'extended'
+    def remove(*names)
+      names = names.map(&:downcase)
+      @parts.delete_if { |p| names.include? p.name.downcase }
+    end
+
+    def descendants
+      load_descendants
+      super
+    end
+
+    private
+      def default_page_parts(config = Radiant::Config)
+        default_parts = config['defaults.page.parts'].to_s.strip.split(/\s*,\s*/)
+        default_parts.map do |name|
+          PagePart.new(:name => name, :filter_id => config['defaults.page.filter'])
+        end
+      end
+
+      def load_descendants
+        unless @_descendants_loaded
+          factory_paths = Radiant::Extension.descendants.inject [Rails.root.to_s + '/lib'] do |paths, ext|
+            paths << ext.root + '/app/models'
+            paths << ext.root + '/lib'
+          end
+          factory_paths.each do |path|
+            Dir["#{path}/*_page_factory.rb"].each do |page_factory|
+              if page_factory =~ %r{/([^/]+)\.rb}
+                require_dependency page_factory
+                ActiveSupport::Dependencies.explicitly_unloadable_constants << $1.camelize
+              end
+            end
+            @_descendants_loaded = true
+          end
+        end
+
+      end
+  end
+
+  @parts = default_page_parts
+end

data/lib/page_factory/manager.rb

@@ -0,0 +1,120 @@
+module PageFactory
+  ##
+  # PageFactory::Manager is used to update your existing content with changes
+  #   subsequently made to your PageFactories. All of these methods take a single
+  #   optional argument, which should be the name of a PageFactory class.
+  #
+  #   If no argument is given, the method is run for all PageFactories.
+  #   Plain old pages not created with a specific factory are never affected in
+  #   this case. If the name of a PageFactory is given, the method is only run
+  #   on pages that were initially created by the specified PageFactory.
+  #
+  #   Note that it is possible to pass 'page' as an argument, if you really
+  #   need to update pages that were created without a specific factory.
+  class Manager
+    class << self
+
+      ##
+      # Remove parts not specified in a PageFactory from all pages initially
+      #   created by that PageFactory. This is useful if you decide to remove
+      #   a part from a PageFactory and you want your existing content to
+      #   reflect that change.
+      #
+      # @param [nil, String, Symbol, #to_s] page_factory The PageFactory to
+      #   restrict this operation to, or nil to run it on all PageFactories.
+      def prune_parts!(page_factory=nil)
+        select_factories(page_factory).each do |factory|
+          parts = PagePart.scoped(:include => :page).
+                           scoped(:conditions => {'pages.page_factory' => name_for(factory)}).
+                           scoped(:conditions => ['page_parts.name NOT IN (?)', factory.parts.map(&:name)])
+          PagePart.destroy parts
+        end
+      end
+
+      ##
+      # Add any parts defined in a PageFactory to all pages initially created
+      #   by that factory, if those pages are missing any parts. This can be
+      #   used when you've added a part to a factory and you want your existing
+      #   content to reflect that change.
+      #
+      # @param [nil, String, Symbol, #to_s] page_factory The PageFactory to
+      #   restrict this operation to, or nil to run it on all PageFactories.
+      def update_parts(page_factory=nil)
+        select_factories(page_factory).each do |factory|
+          Page.find(:all, :include => :parts, :conditions => {:page_factory => name_for(factory)}).each do |page|
+            existing = lambda { |f| page.parts.detect { |p| f.name.downcase == p.name.downcase } }
+            page.parts.create factory.parts.reject(&existing).map(&:attributes)
+          end
+        end
+      end
+
+      ##
+      # Replace any parts on a page that share a _name_ but not a _class_ with
+      #   the parts defined in its PageFactory. Mismatched parts will be
+      #   replaced with wholly new parts of the proper class -- this method
+      #   _will_ discard content. Unless you're using an extension that
+      #   subclasses PagePart (this is rare) you won't need this method.
+      #
+      # @param [nil, String, Symbol, #to_s] page_factory The PageFactory to
+      #   restrict this operation to, or nil to run it on all PageFactories.
+      def sync_parts!(page_factory=nil)
+        select_factories(page_factory).each do |factory|
+          Page.find(:all, :include => :parts, :conditions => {:page_factory => name_for(factory)}).each do |page|
+            unsynced = lambda { |p| factory.parts.detect { |f| f.name.downcase == p.name.downcase and f.class != p.class } }
+            unsynced_parts = page.parts.select(&unsynced)
+            page.parts.destroy unsynced_parts
+            needs_update = lambda { |f| unsynced_parts.map(&:name).include? f.name }
+            page.parts.create factory.parts.select(&needs_update).map &:attributes
+          end
+        end
+      end
+
+      ##
+      # Update the layout of all pages initially created by a PageFactory to
+      #   match the layout currently specified on that PageFactory. Used when
+      #   you decide to use a new layout in a PageFactory and you want your
+      #   existing content to reflect that change.
+      #
+      # @param [nil, String, Symbol, #to_s] page_factory The PageFactory to
+      #   restrict this operation to, or nil to run it on all PageFactories.
+      def sync_layouts!(page_factory=nil)
+        select_factories(page_factory).each do |factory|
+          Page.update_all({:layout_id => Layout.find_by_name(factory.layout, :select => :id).try(:id)}, {:page_factory => name_for(factory)})
+        end
+      end
+
+      ##
+      # Update the Page class of all pages initially created by a PageFactory
+      #   to match the class currently specified on that PageFactory. Useful
+      #   when you assign a new page class to a PageFactory and you want your
+      #   existing content to reflect that change.
+      #
+      # @param [nil, String, Symbol, #to_s] page_factory The PageFactory to
+      #   restrict this operation to, or nil to run it on all PageFactories.
+      def sync_classes!(page_factory=nil)
+        select_factories(page_factory).each do |factory|
+          Page.update_all({:class_name => factory.page_class}, {:page_factory => name_for(factory)})
+        end
+      end
+
+      private
+
+        def select_factories(page_factory)
+          [PageFactory::Base, *PageFactory::Base.descendants].select do |klass|
+            case page_factory
+            when '', nil
+              klass.name != 'PageFactory::Base'
+            when 'PageFactory', :PageFactory
+              klass.name == 'PageFactory::Base'
+            else 
+              klass.name == page_factory.to_s.camelcase
+            end
+          end
+        end
+
+        def name_for(factory)
+          factory == PageFactory::Base ? nil : factory.name
+        end
+    end
+  end
+end

data/lib/page_factory/page_extensions.rb

@@ -0,0 +1,25 @@
+module PageFactory
+  module PageExtensions
+    def self.included(base)
+      base.instance_eval do
+        def default_page_parts(config=Radiant::Config)
+          PageFactory.current_factory.parts
+        end
+        private_class_method :default_page_parts
+      end
+      base.class_eval do
+        ##
+        # The PageFactory that was used to create this page. Note that Plain
+        #   Old Pages do not have an assigned factory.
+        #
+        # @return [PageFactory, nil] This Page's initial PageFactory
+        def page_factory
+          (factory = read_attribute(:page_factory)).blank? ? nil : factory.constantize
+        rescue NameError => e # @page.page_factory is not a constant. class was removed?
+          logger.warn "Couldn't find page factory: #{e.message}"
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/page_factory/page_part_extensions.rb

@@ -0,0 +1,9 @@
+module PageFactory
+  module PagePartExtensions
+    def self.included(base)
+      base.class_eval do
+        attr_accessor :description
+      end
+    end
+  end
+end

data/lib/page_factory/pages_controller_extensions.rb

@@ -0,0 +1,32 @@
+module PageFactory
+  module PagesControllerExtensions
+    def self.included(base)
+      base.class_eval do
+        around_filter :set_page_factory, :only => :new
+        before_filter { |c| c.include_stylesheet 'admin/dropdown' }
+        before_filter { |c| c.include_javascript 'admin/dropdown' }
+        before_filter { |c| c.include_javascript 'admin/pagefactory' }
+        responses do |r|
+          r.singular.default { set_page_defaults if 'new' == action_name }
+        end
+      end
+    end
+
+    def set_page_factory
+      begin
+        PageFactory.current_factory = params[:factory]
+      rescue NameError => e # bad factory name passed
+        logger.error "Tried to create page with invalid factory: #{e.message}"
+      ensure
+        yield
+        PageFactory.current_factory = nil
+      end
+    end
+
+    def set_page_defaults
+      model.class_name = PageFactory.current_factory.page_class
+      model.layout = Layout.find_by_name(PageFactory.current_factory.layout)
+      model.page_factory = PageFactory.current_factory.name unless PageFactory::Base == PageFactory.current_factory
+    end
+  end
+end

data/lib/tasks/page_factory_extension_tasks.rake

@@ -0,0 +1,95 @@
+namespace :radiant do
+  namespace :extensions do
+    namespace :page_factory do
+
+      namespace :refresh do
+        def factory_class(factory)
+          factory_class = case factory
+          when '', nil : nil
+          when 'page', 'Page' : 'PageFactory'
+          else factory.capitalize + 'PageFactory'
+          end
+        end
+        task :update_parts, :factory, :needs => :environment do |task, args|
+          updated = PageFactory::Manager.update_parts factory_class(args[:factory])
+          puts "Added missing parts from #{updated.join(', ')}"
+        end
+        task :prune_parts, :factory, :needs => :environment do |task, args|
+          updated = PageFactory::Manager.prune_parts! factory_class(args[:factory])
+          puts "Removed extra parts from #{updated.join(', ')}"
+        end
+        task :sync_parts, :factory, :needs => :environment do |task, args|
+          updated = PageFactory::Manager.sync_parts! factory_class(args[:factory])
+          puts "Synchronized part classes on #{updated.join(', ')}"
+        end
+        task :sync_layouts, :factory, :needs => :environment do |task, args|
+          updated = PageFactory::Manager.sync_layouts! factory_class(args[:factory])
+          puts "Synchronized layouts on #{updated.join(', ')}"
+        end
+        task :sync_classes, :factory, :needs => :environment do |task, args| factory_class(args[:factory])
+          updated = PageFactory::Manager.sync_classes! factory_class(args[:factory])
+          puts "Synchronized page classes on #{updated.join(', ')}"
+        end
+        desc "Add missing page parts, but don't change or remove any data."
+        task :soft, :factory, :needs => :environment do |task, args|
+          Rake::Task['radiant:extensions:page_factory:refresh:update_parts'].invoke args[:factory]
+        end
+        desc "Make pages look exactly like their factory definitions, including layout and page class."
+        task :hard, :factory, :needs => :environment do |task, args|
+          Rake::Task['radiant:extensions:page_factory:refresh:prune_parts'].invoke args[:factory]
+          Rake::Task['radiant:extensions:page_factory:refresh:sync_parts'].invoke args[:factory]
+          Rake::Task['radiant:extensions:page_factory:refresh:update_parts'].invoke args[:factory]
+          Rake::Task['radiant:extensions:page_factory:refresh:sync_layouts'].invoke args[:factory]
+          Rake::Task['radiant:extensions:page_factory:refresh:sync_classes'].invoke args[:factory]
+        end
+      end
+      
+      desc "Runs the migration of the Page Factory extension"
+      task :migrate => :environment do
+        require 'radiant/extension_migrator'
+        if ENV["VERSION"]
+          PageFactoryExtension.migrator.migrate(ENV["VERSION"].to_i)
+        else
+          PageFactoryExtension.migrator.migrate
+        end
+      end
+      
+      desc "Copies public assets of the Page Factory to the instance public/ directory."
+      task :update => :environment do
+        is_svn_or_dir = proc {|path| path =~ /\.svn/ || File.directory?(path) }
+        puts "Copying assets from PageFactoryExtension"
+        Dir[PageFactoryExtension.root + "/public/**/*"].reject(&is_svn_or_dir).each do |file|
+          path = file.sub(PageFactoryExtension.root, '')
+          directory = File.dirname(path)
+          mkdir_p RAILS_ROOT + directory, :verbose => false
+          cp file, RAILS_ROOT + path, :verbose => false
+        end
+        unless PageFactoryExtension.root.starts_with? RAILS_ROOT # don't need to copy vendored tasks
+          puts "Copying rake tasks from PageFactoryExtension"
+          local_tasks_path = File.join(RAILS_ROOT, %w(lib tasks))
+          mkdir_p local_tasks_path, :verbose => false
+          Dir[File.join PageFactoryExtension.root, %w(lib tasks *.rake)].each do |file|
+            cp file, local_tasks_path, :verbose => false
+          end
+        end
+      end  
+      
+      desc "Syncs all available translations for this ext to the English ext master"
+      task :sync => :environment do
+        # The main translation root, basically where English is kept
+        language_root = PageFactoryExtension.root + "/config/locales"
+        words = TranslationSupport.get_translation_keys(language_root)
+        
+        Dir["#{language_root}/*.yml"].each do |filename|
+          next if filename.match('_available_tags')
+          basename = File.basename(filename, '.yml')
+          puts "Syncing #{basename}"
+          (comments, other) = TranslationSupport.read_file(filename, basename)
+          words.each { |k,v| other[k] ||= words[k] }  # Initializing hash variable as empty if it does not exist
+          other.delete_if { |k,v| !words[k] }         # Remove if not defined in en.yml
+          TranslationSupport.write_file(filename, basename, comments, other)
+        end
+      end
+    end
+  end
+end

data/page_factory_extension.rb

@@ -0,0 +1,25 @@
+require_dependency 'application_controller'
+
+class PageFactoryExtension < Radiant::Extension
+  version "0.1"
+  description "A small DSL for intelligently defining content types."
+  url "http://github.com/joshfrench/radiant-page_factory-extension"
+  
+  define_routes do |map|
+    map.namespace :admin do |admin|
+      admin.factory_link '/pages/factories', :controller => 'page_factories', :action => 'index'
+    end
+  end
+  
+  def activate
+    Page.send :include, PageFactory::PageExtensions
+    PagePart.send :include, PageFactory::PagePartExtensions
+    Admin::PagesController.send :include, PageFactory::PagesControllerExtensions
+    Admin::PagesController.helper 'admin/part_description'
+    Admin::PagePartsController.helper 'admin/part_description'
+    admin.pages.new.add :form, 'page_factory_field'
+    admin.pages.edit.add :part_controls, 'admin/page_parts/part_description'
+    admin.pages.index.add :bottom, 'admin/pages/page_factories'
+    ActiveSupport::Dependencies.load_paths << File.join(Rails.root, 'lib')
+  end
+end

data/public/javascripts/admin/dropdown.js

@@ -0,0 +1,153 @@
+/*
+ *  dropdown.js
+ *
+ *  dependencies: prototype.js, effects.js, lowpro.js
+ *
+ *  --------------------------------------------------------------------------
+ *  
+ *  Allows you to easily create a dropdown menu item. Simply create a link
+ *  with a class of "dropdown" that references the ID of the list that you
+ *  would like to use as a dropdown menu.
+ *  
+ *  A link like this:
+ *  
+ *    <a class="dropdown" href="#dropdown">Menu</a>
+ *  
+ *  will dropdown a list of choices in the list with the ID of "dropdown".
+ *  
+ *  You will need to install the following hook:
+ *  
+ *    Event.addBehavior({'a.dropdown': Dropdown.TriggerBehavior()});
+ *  
+ *  --------------------------------------------------------------------------
+ *  
+ *  Copyright (c) 2010, John W. Long
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a
+ *  copy of this software and associated documentation files (the "Software"),
+ *  to deal in the Software without restriction, including without limitation
+ *  the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ *  and/or sell copies of the Software, and to permit persons to whom the
+ *  Software is furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ *  DEALINGS IN THE SOFTWARE.
+ *  
+ */
+
+var Dropdown = {
+  
+  DefaultPosition: 'bottom',
+  
+  DefaultEffect: 'slide',
+  DefaultEffectDuration: 0.1,
+  
+  EffectPairs: {
+    'slide' : ['SlideDown', 'SlideUp'],
+    'blind' : ['BlindDown', 'BlindUp'],
+    'appear': ['Appear', 'Fade']
+  }
+  
+};
+
+Dropdown.TriggerBehavior = Behavior.create({
+  initialize: function(options) {
+    var options = options || {};
+    options.position = (options.position || Dropdown.DefaultPosition).toLowerCase();
+    options.effect = (options.effect || Dropdown.DefaultEffect).toLowerCase();
+    options.duration = (options.duration || Dropdown.DefaultEffectDuration);
+    this.options = options;
+    
+    var matches = this.element.href.match(/\#(.+)$/);
+    if (matches) this.menu = Dropdown.Menu.findOrCreate(matches[1]);
+  },
+  
+  onclick: function(event) {
+    if (this.menu) this.menu.toggle(this.element, this.options);
+    event.stop();
+  }
+});
+
+Dropdown.Menu = Class.create({
+  
+  initialize: function(element) {
+    element.remove();
+    this.element = element;
+    this.wrapper = $div({'class': 'dropdown_wrapper', 'style': 'position: absolute; display: none'}, element);
+    document.body.insert(this.wrapper);
+  },
+  
+  open: function(trigger, options) {
+    this.wrapper.hide();
+    trigger.addClassName('selected');
+    this.position(trigger, options);
+    var name = options.effect;
+    var effect = Effect[Dropdown.EffectPairs[name][0]];
+    effect(this.wrapper, {duration: options.duration});
+  },
+  
+  close: function(trigger, options) {
+    var name = options.effect;
+    var effect = Effect[Dropdown.EffectPairs[name][1]];
+    effect(this.wrapper, {duration: options.duration});
+    trigger.removeClassName('selected');
+  },
+  
+  toggle: function(trigger, options) {
+    if (this.lastTrigger == trigger) {
+      if (this.wrapper.visible()) {
+        this.close(trigger, options);
+      } else {
+        this.open(trigger, options);
+      }
+    } else {
+      if (this.lastTrigger) this.lastTrigger.removeClassName('selected');
+      this.open(trigger, options);
+    }
+    this.lastTrigger = trigger;
+  },
+  
+  position: function(trigger, options) {
+    switch(options.position) {
+      case 'top':     this.positionTop(trigger);     break;
+      case 'bottom':  this.positionBottom(trigger);  break;
+      default:        this.positionBottom(trigger);
+    }
+  },
+  
+  positionTop: function(trigger) {
+    var offset = trigger.cumulativeOffset();
+    var height = this.wrapper.getHeight();
+    this.wrapper.setStyle({
+      left: offset.left + 'px',
+      top:  (offset.top - height) + 'px'
+    });
+  },
+  
+  positionBottom: function(trigger) {
+    var offset = trigger.cumulativeOffset();
+    var height = trigger.getHeight();
+    this.wrapper.setStyle({
+      left: offset.left + 'px',
+      top:  (offset.top + height) + 'px'
+    });
+  }
+  
+});
+
+Dropdown.Menu.findOrCreate = function(element) {
+  var element = $(element);
+  var key = element.identify();
+  var menu = Dropdown.Menu.controls[key];
+  if (menu == null) menu = Dropdown.Menu.controls[key] = new Dropdown.Menu(element);
+  return menu;
+}
+Dropdown.Menu.controls = {};