goldberg_generator 0.2.2

data/templates/vendor/plugins/goldberg/init.rb

@@ -0,0 +1,13 @@
+# Set load paths to include the plugin /app directory
+controller_path = "#{File.dirname(__FILE__)}/app/controllers"
+model_path      = "#{File.dirname(__FILE__)}/app/models"
+helper_path     = "#{File.dirname(__FILE__)}/app/helpers"
+$LOAD_PATH << controller_path
+$LOAD_PATH << model_path
+Dependencies.load_paths += [ controller_path, model_path, helper_path ]
+config.controller_paths << controller_path
+
+# Goldberg's libraries
+Dir["#{File.dirname(__FILE__)}/lib/**/*.rb"].each do |lib|
+  require lib
+end

data/templates/vendor/plugins/goldberg/lib/goldberg.rb

@@ -0,0 +1,37 @@
+# The module 'Goldberg' is the namespace for Goldberg's libraries.  It
+# also provides a number of class methods for convenient access to
+# information about the system from Goldberg's perspective (the
+# current user and the System Settings).
+module Goldberg
+
+  class << self
+
+    # Accessor to attach the current user (if logged in)
+    attr_accessor :user
+
+    # Accessor to attach the session's credentials
+    attr_accessor :credentials
+
+    # Accessor to attach the session's menu
+    attr_accessor :menu
+    
+    # return nil if there is no user
+    def user
+      begin @user rescue nil end
+    end
+
+    # Return Goldberg's System Settings
+    def settings
+      @settings ||= Goldberg::SystemSettings.find(:first)
+    end
+
+    def clear!
+      @user = nil
+      @credentials = nil
+      @menu = nil
+      @settings = nil
+    end
+
+  end
+  
+end

data/templates/vendor/plugins/goldberg/lib/goldberg/controller.rb

@@ -0,0 +1,11 @@
+module Goldberg
+  module Controller
+    def self.included(base)
+      base.class_eval do
+        base.view_paths =
+          ["#{RAILS_ROOT}/vendor/plugins/goldberg/app/views"]
+        base.layout "../../../../../app/views/layouts/application"
+      end
+    end
+  end
+end

data/templates/vendor/plugins/goldberg/lib/goldberg/filters.rb

@@ -0,0 +1,197 @@
+require 'goldberg/system_settings'
+require 'goldberg/credentials'
+require 'goldberg/menu'
+require 'goldberg/user'
+require 'goldberg/content_page'
+require 'goldberg/role'
+
+module Goldberg
+  module Filters
+
+    ERROR_SELF_REG_CONFIRMATION_REQUIRED =
+      [1, "Your registration has not yet been confirmed."]
+    ERROR_SESSION_EXPIRED =
+      [2, "Your session has expired.  Please log in again."]
+    ERROR_NOT_FOUND =
+      [3, "The page or resource you requested was not found."]
+    ERROR_PERMISSION_DENIED =
+      [4, "You do not have permission to access that page or resource."]
+    
+    def goldberg_security_up
+      if Goldberg.settings
+        session[:goldberg] ||= Hash.new
+        session[:goldberg][:path] = request.path
+
+        logger.debug "Setting user..."
+        set_user or return false
+        
+        # Perform some preliminary checks for logged-in users.
+        if Goldberg.user
+          # Check that the user is not pending registration confirmation.
+          logger.debug "Check user not pending registration confirmation..."
+          check_not_pending or return false
+          # If the user's session has expired, kick out the user.
+          logger.debug "Check session not expired..."
+          check_not_expired or return false
+        end
+        
+        # The default is false.  check_page_exists() will set this to true if the current request is for a ContentPage.
+        @is_page_request = false
+
+        # If this is a page request check that it exists, and if not
+        # redirect to the "unknown" page.
+        logger.debug "Checking that page exists..."
+        check_page_exists or return false
+        
+
+        # The default is false. check_permissions() will set this to true if the user is authorised for the current action.
+        @authorised = false
+        
+        # Check whether the user is authorised for this page or action.
+        logger.debug "Checking permissions..."
+        check_permissions or return false
+        
+      end  # if Goldberg.settings
+      
+      session[:last_time] = Time.now
+      
+      return true
+    end
+
+
+    protected
+
+    def set_user
+      Goldberg.clear!
+      Goldberg::AuthController.set_user(session)
+      return true
+    end
+
+    def check_not_pending
+      if Goldberg.settings.self_reg_enabled and
+          Goldberg.user.self_reg_confirmation_required 
+        logger.info "User not confirmed"
+        Goldberg::AuthController.logout(session)
+        respond_to do |format|
+          format.html do
+            redirect_to Goldberg.settings.self_reg_confirmation_error_page.url
+          end
+          format.js do
+            render :status => 400, :text =>
+              Goldberg.settings.self_reg_confirmation_error_page.content_html
+          end
+          format.xml do
+            render :status => 400, :xml =>
+              error_xml(*ERROR_SELF_REG_CONFIRMATION_REQUIRED)
+          end
+        end
+        return false
+      end
+
+      return true
+    end
+    
+    def check_not_expired
+      if Goldberg.settings.session_timeout > 0 and session[:last_time]
+        if (Time.now - session[:last_time]) > Goldberg.settings.session_timeout
+          logger.info "Session: time expired"
+          Goldberg::AuthController.logout(session)
+          respond_to do |format|
+            format.html do
+              redirect_to Goldberg.settings.session_expired_page.url
+            end
+            format.js do
+              render :status => 400, :text =>
+                Goldberg.settings.session_expired_page.content_html
+            end
+            format.xml do
+              render :status => 400, :xml =>
+                error_xml(*ERROR_SESSION_EXPIRED)
+            end
+          end
+          return false
+        else
+          logger.info "Session: time NOT expired"
+        end
+      end
+      
+      return true
+    end
+
+    def check_page_exists
+      if params[:controller] == 'goldberg/content_pages' and
+          params[:action] == 'view'
+        @is_page_request = true
+        if not Goldberg.credentials.pages.has_key?(params[:page_name].join '/')
+          logger.warn "(Unknown page? #{params[:page_name].join '/'})"
+          respond_to do |format|
+            format.html do
+              redirect_to Goldberg.settings.not_found_page.url
+            end
+            format.js do
+              render :status => 404, :text => Goldberg.settings.not_found_page.content_html
+            end
+            format.xml  do
+              render :status => 404, :xml => error_xml(*ERROR_NOT_FOUND)
+            end
+          end
+          return false
+        end
+      end
+
+      return true
+    end
+
+    def check_permissions
+      if @is_page_request
+        @authorised =
+          Goldberg.credentials.page_authorised?(params[:page_name].join '/')
+      else
+        @authorised = Goldberg.credentials.action_authorised?(params[:controller],
+                                                              params[:action])
+      end
+      if not @authorised
+        respond_to do |format|
+          format.html do
+            if Goldberg.user
+              redirect_to Goldberg.settings.permission_denied_page.url
+            else
+              session[:pending_request] = url_for(params)
+              redirect_to :controller => 'goldberg/auth', :action => 'login'
+            end
+          end
+          format.js do
+            render :status => 400, :text =>
+              Goldberg.settings.permission_denied_page.content_html
+          end
+          format.xml  do
+            render :status => 400, :xml => error_xml(*ERROR_PERMISSION_DENIED)
+          end
+        end
+        return false
+      end
+      
+      return true
+    end
+    
+    def error_xml(code, message)
+      target = ''
+      xml = Builder::XmlMarkup.new(:target => target)
+      xml.instruct!
+      xml.error do
+        xml.code(code)
+        xml.message(message)
+        Goldberg.user ? xml.user_id(Goldberg.user.id) : xml.user_id
+        xml.params(params.inspect)
+      end
+      return target
+    end
+
+  end  
+end
+
+
+ActionController::Base.class_eval do
+  include Goldberg::Filters
+  prepend_before_filter :goldberg_security_up
+end

data/templates/vendor/plugins/goldberg/lib/goldberg/helper.rb

@@ -0,0 +1,66 @@
+module Goldberg
+  # Goldberg::Helper will be added as a helper to ActionController::Base,
+  # so its methods will be available in the views throughout all
+  # controllers (just as if they'd been added to ApplicationHelper).
+  module Helper
+
+    # Renders the title of the page: either the ContentPage.name or the
+    # current controller and action.
+    def goldberg_title
+      if params[:controller] == 'goldberg/content_pages' and
+          ( params[:action] == 'view' or 
+            params[:action] == 'view_default')
+        "#{@content_page.title}"
+      else
+        "#{params[:controller]} | #{params[:action]}" 
+      end
+    end
+
+    # Renders a top (i.e. one level deep) static menu.
+    def goldberg_main_menu
+      render :file => "#{RAILS_ROOT}/vendor/plugins/goldberg/app/views/goldberg/menu_items/_menubar.rhtml", :use_full_path => false, :locals => {:level => 0, :depth => 0, :class_attr => nil}
+    end
+
+    # Renders a nested side menu, for all levels below the main menu.
+    def goldberg_left_menu
+      render :file => "#{RAILS_ROOT}/vendor/plugins/goldberg/app/views/goldberg/menu_items/_menubar.rhtml", :use_full_path => false,  
+      :locals => {:level => 1, :depth => (Goldberg.settings.menu_depth - 2),
+        :class_attr => 'sidemenu'}
+    end
+
+    # Renders an entire multilevel suckerfish menu.  Whether this is to
+    # be rendered along the top, left hand or right hand side of the
+    # page depends on the page's stylesheet.  This code just returns the
+    # menu structure.
+    def goldberg_suckerfish_menu
+      render :file => "#{RAILS_ROOT}/vendor/plugins/goldberg/app/views/goldberg/menu_items/_suckerfish.rhtml", :use_full_path => false, :locals => {:items => Goldberg.menu.get_menu(0)}
+    end
+
+    # Renders the breadcrumbs (i.e. representing the user's current
+    # position in the menu hierarchy).
+    def goldberg_breadcrumbs
+      render :file => "#{RAILS_ROOT}/vendor/plugins/goldberg/app/views/goldberg/menu_items/_breadcrumbs.rhtml", :use_full_path => false, :locals => {:crumbs => Goldberg.menu.crumbs}
+    end
+
+    # Renders the login prompt.  This changes depending on whether a
+    # user is logged in or not.  If a user is logged in, a mini-form is
+    # presented with a button to log out.  If not, a link to the
+    # auth/login page is presented.
+    def goldberg_login
+      render :file => "#{RAILS_ROOT}/vendor/plugins/goldberg/app/views/goldberg/auth/_login.rhtml", :use_full_path => false
+    end
+
+  end  
+end
+
+# You'd think this would work, but it only works on the first request
+# after a server restart because helpers get reloaded on each request:
+
+# ApplicationHelper.module_eval do
+#  include Goldberg::Helper
+# end
+
+# This works:
+ActionController::Base.class_eval do
+  helper Goldberg::Helper
+end

data/templates/vendor/plugins/goldberg/lib/goldberg/migration.rb

@@ -0,0 +1,113 @@
+module Goldberg
+  module Migration 
+
+    def self.included(base)
+      base.class_eval do
+        
+        def self.prefix
+          if not @prefix
+            if self.pg_conn?
+              self.create_goldberg_schema
+              @prefix = 'goldberg.'
+            else
+              @prefix = 'goldberg_'
+            end
+          end
+          @prefix
+        end
+        
+        def self.pg_conn?
+          ActiveRecord::Base.connection.class.to_s == 
+            'ActiveRecord::ConnectionAdapters::PostgreSQLAdapter'
+        end
+        
+        def self.goldberg_schema_exists?
+          if self.pg_conn?
+            count = ActiveRecord::Base.connection.select_value <<-END
+SELECT COUNT(*) FROM pg_namespace WHERE nspname = 'goldberg'
+END
+            count.to_i > 0
+          else
+            false
+          end
+        end
+        
+        def self.create_goldberg_schema
+          if self.pg_conn? and not self.goldberg_schema_exists?
+            ActiveRecord::Base.connection.execute <<-END
+CREATE SCHEMA goldberg
+END
+          end
+        end
+        
+        def self.drop_goldberg_schema
+          if self.pg_conn? and self.goldberg_schema_exists?
+            ActiveRecord::Base.connection.execute <<-END
+DROP SCHEMA goldberg
+END
+          end
+        end
+        
+      end  # class_eval
+    end  # self.included
+    
+
+    def self.load_bootstrap
+      self.goldberg_classes.each do |klass|
+        self.load_for_class klass, "#{File.dirname(__FILE__)}/../../db"
+      end
+    end
+
+    def self.dump_bootstrap
+      # Before dumping a bootstrap configuration, copy the existing
+      # bootstrap to tst/fixtures (unless already exists)
+      fixtures_path = "#{File.dirname(__FILE__)}/../../test/fixtures"
+      unless File.exists?(fixtures_path)
+        Dir.mkdir(fixtures_path)
+        Dir["#{File.dirname(__FILE__)}/../../db/*.yml"].each do |fixture|
+          FileUtils.cp(fixture, fixtures_path)
+        end
+      end
+      self.goldberg_classes.each do |klass|
+        self.dump_for_class klass, "#{File.dirname(__FILE__)}/../../db"
+      end
+    end
+
+    def self.goldberg_classes
+      return [ Goldberg::Permission, Goldberg::SiteController, 
+               Goldberg::ContentPage, Goldberg::ControllerAction,
+               Goldberg::MenuItem, Goldberg::Role,
+               Goldberg::RolesPermission, Goldberg::SystemSettings,
+               Goldberg::User ]
+    end
+    
+    def self.dump_for_class(klass, dest)
+      filename = "#{dest}/#{klass.to_s.sub(/^Goldberg::/, '')}.yml"
+      records = klass.find(:all).collect do |record|
+        record.attributes
+      end
+      File.open(filename, 'w') do |out|  
+        YAML.dump(records, out)
+      end
+    end
+    
+    def self.load_for_class(klass, src)
+      filename = "#{src}/#{klass.to_s.sub(/^Goldberg::/, '')}.yml"
+      File.open(filename) do |src|
+        records = YAML::load(src)
+        records.each do |src_rec|
+          attrs = (src_rec.respond_to?(:attributes) ? src_rec.attributes :
+                   src_rec)
+          record = klass.new(attrs)
+          record.id = attrs['id']
+          record.save!
+        end
+      end
+      # Reset table sequence if applicable (i.e. PostgreSQL)
+      if klass.connection.respond_to?(:reset_pk_sequence!)
+        klass.connection.reset_pk_sequence!(klass.table_name)
+      end
+    end
+    
+  end
+end

data/templates/vendor/plugins/goldberg/lib/goldberg/migrator.rb

@@ -0,0 +1,128 @@
+# Goldberg::Migrator is a plugin migration system based on
+# PluginAWeek's (http://pluginaweek.org) plugin_migrations.  It allows
+# plugins to have their own migration streams.  These can be made
+# available as rake tasks that work similarly to Rails' "db:migrate"
+# task, including respecting the VERSION environment variable.  See
+# Goldberg's "goldberg:migrate" task.
+# 
+# This code is included in the Goldberg project in order to remove the
+# dependency on the plugin_migrations gem, while retaining schema
+# compatibilty so that users can use Goldberg alongside other plugins
+# that utilise plugin_migrations.
+
+module Goldberg
+  module SchemaStatements
+    def self.included(base) #:nodoc:
+      base.class_eval do
+        alias_method_chain :initialize_schema_information, :plugins
+        alias_method_chain :dump_schema_information, :plugins
+      end
+    end
+    
+    # Creates the plugin schema info table
+    def initialize_schema_information_with_plugins
+      initialize_schema_information_without_plugins
+      
+      begin
+        execute <<-EOS
+CREATE TABLE #{Goldberg::Migrator.schema_info_table_name}
+(plugin_name #{type_to_sql(:string)}, version #{type_to_sql(:integer)})
+EOS
+      rescue ActiveRecord::StatementInvalid
+        # Schema has already been initialised?
+      end
+    end
+    
+    # Dumps the plugin schema info table as well as information about the
+    # current plugin migrations
+    def dump_schema_information_with_plugins
+      schema_information = []
+      
+      dump = dump_schema_information_without_plugins
+      dump && (schema_information << dump)
+      
+      begin
+        plugins = ActiveRecord::Base.connection.select_all <<-EOS
+SELECT * FROM #{Goldberg::Migrator.schema_info_table_name}
+EOS
+        plugins.each do |plugin|
+          if (version = plugin['version'].to_i) > 0
+            plugin_esc = ActiveRecord::Base.quote_value(plugin['plugin_name'])
+            schema_information << %Q<
+INSERT INTO #{Goldberg::Migrator.schema_info_table_name}
+(plugin_name, version) VALUES (#{plugin_esc}, #{version})>
+          end
+        end
+      rescue ActiveRecord::StatementInvalid 
+        # No Schema Info
+      end
+      
+      schema_information.join(";\n")
+    end
+  end  # module SchemaStatements
+
+
+  class Migrator < ActiveRecord::Migrator
+    class << self
+      # Set the plugin name before performing any migrations
+      attr_accessor :plugin_name
+      
+      # Runs the migrations from a plugin, up (or down) to the version given
+      def migrate(version = nil)
+        ActiveRecord::ConnectionAdapters::SchemaStatements.class_eval do
+          include Goldberg::SchemaStatements
+        end
+
+        version && (version = version.to_i)
+        super("#{RAILS_ROOT}/vendor/plugins/#{plugin_name}/db/migrate", version)
+      end
+      
+      def schema_info_table_name
+        ActiveRecord::Base.table_name_prefix + 'plugin_schema_info' +
+          ActiveRecord::Base.table_name_suffix
+      end
+      
+      def current_version
+        begin
+          if result = ActiveRecord::Base.connection.select_one(%Q<
+SELECT version FROM #{schema_info_table_name} WHERE plugin_name=#{plugin}>)
+            result['version'].to_i
+          else
+            # No such plugin migrated yet?
+            0
+          end
+        rescue ActiveRecord::StatementInvalid
+          # No migration info table, so never migrated
+          0
+        end
+      end
+
+      # Escape the current plugin name
+      def plugin
+        ActiveRecord::Base.quote_value(plugin_name)
+      end
+    end  # class << self
+      
+    # Sets the version of the current plugin
+    def set_schema_version(version)
+      version = down? ? version.to_i - 1 : version.to_i
+      
+      if ActiveRecord::Base.connection.select_one <<-EOS
+SELECT version FROM #{self.class.schema_info_table_name}
+WHERE plugin_name = #{self.class.plugin}
+EOS
+        ActiveRecord::Base.connection.update <<-EOS
+UPDATE #{self.class.schema_info_table_name} SET version = #{version}
+WHERE plugin_name = #{self.class.plugin}
+EOS
+      else
+        # We need to create the entry since it doesn't exist yet
+        ActiveRecord::Base.connection.execute <<-EOS
+INSERT INTO #{self.class.schema_info_table_name} (version, plugin_name)
+VALUES (#{version}, #{self.class.plugin})
+EOS
+      end
+    end
+
+  end  # class Migrator
+end  # module Goldberg