six-updater-web 0.10.8 → 0.11.1

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

@@ -0,0 +1,133 @@
+# Provide separate migrations for plugins.
+
+# Goldberg::Migrator inherits from ActiveRecord::Migrator, overriding
+# some methods to allow migration data for plugins to be stored in the
+# table "plugin_schema_migrations".  This also requires modifying some
+# methods in ActiveRecord::ConnectionAdapters::SchemaStatements.
+
+# This code used to be based on PluginAWeek's plugin_migrations, but
+# has been re-written for the new "schema_migrations" system provided
+# by Rails 2.1.
+
+module Goldberg
+  module SchemaStatements
+    def self.included(base) #:nodoc:
+      base.class_eval do
+        alias_method_chain :dump_schema_information, :plugins
+        alias_method_chain :initialize_schema_migrations_table, :plugins
+        alias_method_chain :assume_migrated_upto_version, :plugins
+      end
+    end
+    
+    # Dumps the plugin schema info table as well as information about the
+    # current plugin migrations
+    def dump_schema_information_with_plugins
+      begin
+        sm_table = Goldberg::Migrator.schema_migrations_table_name
+        migrated = select_all("SELECT version FROM #{sm_table}")
+        migrated.map do |v|
+          "INSERT INTO #{sm_table} (plugin_name, version) VALUES ('#{v['plugin_name']}', '#{v['version']}');"
+        end.join("\n\n")
+      rescue ActiveRecord::StatementInvalid 
+        # No Schema Info
+        ''
+      end
+    end
+
+    # Creates the plugin schema info table
+    def initialize_schema_migrations_table_with_plugins
+      sm_table = Goldberg::Migrator.schema_migrations_table_name
+      
+      unless tables.detect { |t| t == sm_table }
+        create_table(sm_table, :id => false) do |schema_migrations_table|
+          schema_migrations_table.column :plugin_name, :string, :null => false
+          schema_migrations_table.column :version, :string, :null => false
+        end
+        #add_index sm_table, [:plugin_name, :version], :unique => true,
+        #:name => 'unique_schema_migrations'
+        
+        # Backwards-compatibility: if we find schema_info, assume we've
+        # migrated up to that point:
+        si_table = ActiveRecord::Base.table_name_prefix + 'plugin_schema_info' +
+          ActiveRecord::Base.table_name_suffix
+        if tables.detect { |t| t == si_table }
+          old_version = select_value("SELECT version FROM #{quote_table_name(si_table)} WHERE plugin_name=#{Goldberg::Migrator.plugin}").to_i
+          assume_migrated_upto_version(old_version)
+          drop_table(si_table)
+        end
+      end
+    end
+    
+    def assume_migrated_upto_version_with_plugins(version)
+      sm_table = Goldberg::Migrator.schema_migrations_table_name
+      migration_path = "#{RAILS_ROOT}/vendor/plugins/#{Goldberg::Migrator.plugin_name}/db/migrate"
+      
+      migrated = select_values("SELECT version FROM #{sm_table} WHERE plugin_name=#{Goldberg::Migrator.plugin}").map(&:to_i)
+      versions = Dir["#{migration_path}[0-9]*_*.rb"].map do |filename|
+        filename.split('/').last.split('_').first.to_i
+      end
+      
+      execute "INSERT INTO #{sm_table} (plugin_name, version) VALUES (#{Goldberg::Migrator.plugin}, '#{version}')" unless migrated.include?(version.to_i)
+      (versions - migrated).select { |v| v < version.to_i }.each do |v|
+        execute "INSERT INTO #{sm_table} (plugin_name, version) VALUES (#{Goldberg::Migrator.plugin}, '#{v}')"
+      end
+    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_migrations_table_name
+        ActiveRecord::Base.table_name_prefix + 'plugin_schema_migrations' +
+          ActiveRecord::Base.table_name_suffix
+      end
+      
+      def current_version
+        begin
+          version = ActiveRecord::Base.connection.select_values("SELECT version FROM #{schema_migrations_table_name} WHERE plugin_name=#{Goldberg::Migrator.plugin}").map(&:to_i).max
+        version || 0
+        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
+      
+    def migrated
+      sm_table = self.class.schema_migrations_table_name
+      ActiveRecord::Base.connection.select_values("SELECT version FROM #{sm_table} WHERE plugin_name=#{self.class.plugin}").map(&:to_i).sort
+    end
+    
+    private
+
+    def record_version_state_after_migrating(version)
+      sm_table = self.class.schema_migrations_table_name
+      
+      if down?
+        ActiveRecord::Base.connection.update("DELETE FROM #{sm_table} WHERE version = '#{version}' AND plugin_name=#{self.class.plugin}")
+      else
+        ActiveRecord::Base.connection.insert("INSERT INTO #{sm_table} (plugin_name, version) VALUES (#{self.class.plugin}, '#{version}')")
+      end
+    end
+
+  end  # class Migrator
+end  # module Goldberg

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

@@ -0,0 +1,127 @@
+if ActiveRecord::ConnectionAdapters::const_defined?(:PostgreSQLAdapter)
+  require 'active_record/connection_adapters/postgresql_adapter'
+end
+
+# Set the appropriate table prefix using AR's "set_table_name" 
+
+# This module is included in all Goldberg's model classes.  On load it
+# adds the prefix "goldberg." to all table names if the connection is
+# to PostgreSQL; otherwise it adds the prefix "g_".
+
+module Goldberg
+  module Model
+
+    def self.included(base)
+      base.class_eval do
+        
+        def self.prefix
+          if not @prefix
+            if ActiveRecord::ConnectionAdapters::const_defined?(:PostgreSQLAdapter) &&
+                self.connection.class.to_s == 
+                'ActiveRecord::ConnectionAdapters::PostgreSQLAdapter'
+              @prefix = 'goldberg.'
+            else
+              @prefix = 'goldberg_'
+            end
+          end
+          @prefix
+        end
+        
+        (table_name =~ /goldberg/) ||
+          (set_table_name "#{self.prefix}#{self.table_name}")
+      end
+    end
+    
+  end
+
+
+  # Fixes the "pk_and_sequence_for" method in the PostgreSQL adapter, to
+  # include namespace support.
+
+  module PostgreSQL
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :pk_and_sequence_for, :goldberg
+        alias_method_chain :quote_column_name, :goldberg
+        alias_method_chain :quote_table_name, :goldberg
+      end
+    end
+
+    # (From
+    # vendor/rails/activerecord/lib/active_record/connection_adapters/
+    # postgresql_adapter.rb)  
+
+    def pk_and_sequence_for_with_goldberg(table)
+      # First try looking for a sequence with a dependency on the
+      # given table's primary key.
+      result = query(<<-end_sql, 'PK and serial sequence')[0]
+          SELECT attr.attname, name.nspname, seq.relname
+          FROM pg_class      seq,
+               pg_attribute  attr,
+               pg_depend     dep,
+               pg_namespace  name,
+               pg_constraint cons
+          WHERE seq.oid           = dep.objid
+            AND seq.relnamespace  = name.oid
+            AND seq.relkind       = 'S'
+            AND attr.attrelid     = dep.refobjid
+            AND attr.attnum       = dep.refobjsubid
+            AND attr.attrelid     = cons.conrelid
+            AND attr.attnum       = cons.conkey[1]
+            AND cons.contype      = 'p'
+            AND dep.refobjid      = '#{table}'::regclass
+    end_sql
+
+      if result.nil? or result.empty?
+        # If that fails, try parsing the primary key's default value.
+        # Support the 7.x and 8.0 nextval('foo'::text) as well as
+        # the 8.1+ nextval('foo'::regclass).
+        # TODO: assumes sequence is in same schema as table.
+        result = query(<<-end_sql, 'PK and custom sequence')[0]
+        SELECT attr.attname, name.nspname, split_part(def.adsrc, '''', 2)
+        FROM pg_class       t
+        JOIN pg_namespace   name ON (t.relnamespace = name.oid)
+        JOIN pg_attribute   attr ON (t.oid = attrelid)
+        JOIN pg_attrdef     def  ON (adrelid = attrelid AND adnum = attnum)
+        JOIN pg_constraint  cons ON (conrelid = adrelid AND adnum = conkey[1])
+        WHERE t.oid = '#{table}'::regclass
+          AND cons.contype = 'p'
+          AND def.adsrc ~* 'nextval'
+      end_sql
+      end
+      # check for existence of . in sequence name as in public.foo_sequence.  if it does not exist, return unqualified sequence
+      # We cannot qualify unqualified sequences, as rails doesn't qualify any table access, using the search path
+      # Commented out (DN):
+      # [result.first, result.last]
+
+      # Added (DN):
+      # The above consideration is irrelevant.  PostgreSQL
+      # databases always have tables in schemas, so specifying a schema
+      # (even if it is "public") is valid; and in the case where schemas
+      # *are* in use (using 'set_table_name' to set a schema on a model)
+      # the schema path is *required*, otherwise INSERTs are broken.
+
+      [ result[0], "#{result[1]}.#{result[2]}" ]
+    rescue
+      nil
+    end
+
+    def quote_column_name_with_goldberg(name)
+      prefix = 'goldberg.'
+      name.respond_to?('[]'.to_sym) &&
+        name[0 ... prefix.length] == prefix ? name :
+        quote_column_name_without_goldberg(name)
+    end
+    
+    def quote_table_name_with_goldberg(name)
+      quote_column_name_with_goldberg(name)
+    end
+    
+  end
+end
+
+if ActiveRecord::ConnectionAdapters::const_defined?(:PostgreSQLAdapter)
+  ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
+    include Goldberg::PostgreSQL
+  end
+end

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

@@ -0,0 +1,49 @@
+
+module Goldberg
+  module Routes
+    def self.included(base)
+      base.class_eval do
+        alias_method :draw_without_goldberg_routes, :draw
+        alias_method :draw, :draw_with_goldberg_routes
+      end
+    end
+
+    def draw_with_goldberg_routes(&block)
+      
+      draw_without_goldberg_routes do |map|
+        block.call map 
+      end
+
+      routes = [ 
+                ['', 
+                 {:controller => "goldberg/content_pages",
+                   :action => "view_default"}],
+
+                ['menu/*name', 
+                 {:controller => 'goldberg/menu_items', :action => 'link'}],
+
+                ['*page_name', 
+                 {:controller => "goldberg/content_pages", :action => "view"}]
+               ]
+
+      route_method = ActionController::Routing::Routes.respond_to?(:add_route)? 
+      :add_route : :connect
+
+      for route in routes do
+        ActionController::Routing::Routes.send(route_method, *route)
+      end
+
+      # Install the new routes (Rails 1.1 only)
+      if ActionController::Routing::Routes.respond_to? :write_generation and
+          ActionController::Routing::Routes.respond_to? :write_recognition
+        ActionController::Routing::Routes.write_generation
+        ActionController::Routing::Routes.write_recognition
+      end 
+    end
+
+  end
+end
+
+ActionController::Routing::RouteSet.class_eval do
+  include Goldberg::Routes
+end

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

@@ -0,0 +1,82 @@
+module Goldberg
+  # Goldberg's TestHelper module loads Goldberg's bootstrap
+  # environment for use in functional and integration testing.  It
+  # also provides some methods for logging a user in and out.
+  #
+  # The fixtures are loaded from
+  # RAILS_ROOT/vendor/plugins/goldberg/db.  By default this contains
+  # the bootstrap that came with Goldberg.  However you can configure
+  # your system (create roles, permissions, users, controllers/actions
+  # and a menu) then dump a bootstrap that represents your
+  # configuration using the Rake task:
+  #
+  #   rake goldberg:dump_bootstrap
+  #
+  # This offers an arguably more realistic approach than conventional
+  # fixtures: tests are performed using a real Goldberg setup.
+  # Furthermore dumping a bootstrap from your configured site allows
+  # you to test your security in functional and integration tests: you
+  # can log in and perform actions in your tests, and ensure that
+  # actions and/or pages are appropriately allowed or forbidden based
+  # on the security you have defined.
+  module TestHelper
+
+    def self.included(klass)
+      # The first time this is included make sure the database is
+      # up-to-date (especially applicable for PostgreSQL, for which the
+      # schema is not dumped properly), then load Goldberg's fixtures.
+      unless @already_done
+        begin
+          verbosity = ActiveRecord::Migration.verbose
+          ActiveRecord::Migration.verbose = false
+          Goldberg::Migrator.plugin_name = 'goldberg'
+          Goldberg::Migrator.migrate
+        rescue ActiveRecord::StatementInvalid
+          # Must already exist.  Continue...
+        ensure
+          ActiveRecord::Migration.verbose = verbosity
+        end
+
+        fixture_path = File.dirname(__FILE__) + '/../../db'  # default
+        # Goldberg prefers to use fixtures from its own test/fixtures dir
+        if ( (caller.first =~ %r<vendor/plugins/goldberg/test>) &&
+             File.exists?(File.dirname(__FILE__) + '/../../test/fixtures') )
+          fixture_path = File.dirname(__FILE__) + '/../../test/fixtures'
+        end
+        # Load Goldberg's bootstrap data
+        puts "Loading fixtures from '#{fixture_path}'..."
+        klasses ||= Goldberg::Migration.goldberg_classes
+        klasses.each do |klass|
+          klass.delete_all
+          Goldberg::Migration.load_for_class(klass, fixture_path)
+        end
+        puts "Done loading fixtures."
+      else
+        # Do nothing...
+      end
+      @already_done = true
+    end
+
+    # Set logged-in user (for functional testing)
+    def login_user(user_name)
+      user = Goldberg::User.find_by_name(user_name)
+      @request.session[:goldberg] = {:user_id => (user ? user.id : nil)}
+      Goldberg::AuthController.set_user(@request.session)
+      @request.session[:last_time] = Time.now
+    end
+
+    # Form-based login (for integration testing)
+    def form_login(user, password)
+      post '/goldberg/auth/login', :login => {
+        :name => user,
+        :password => password
+      }
+    end
+
+    # Form-based logout (for integration testing)
+    def form_logout
+      post '/goldberg/auth/logout'
+    end
+
+  end
+end

data/lib/vendor/plugins/goldberg/tasks/goldberg_tasks.rake

@@ -0,0 +1,81 @@
+namespace :goldberg do
+
+  desc "Dump standard Goldberg tables to files in db/"
+  task :dump_bootstrap => :environment do
+    Goldberg::Migration.dump_bootstrap
+  end
+
+  desc "Migrate Goldberg"
+  task :migrate => :environment do
+    Goldberg::Migrator.plugin_name = 'goldberg'
+    Goldberg::Migrator.migrate(ENV['VERSION'])
+  end
+  
+  desc "Load standard Goldberg tables from files in db/"
+  task :load_bootstrap => :migrate do
+    Goldberg::Migration.load_bootstrap
+  end
+
+  desc "Install Goldberg"
+  task :install => :load_bootstrap do
+    index = "#{RAILS_ROOT}/public/index.html"
+    FileTest.exists?(index) and File.delete(index)
+  end
+
+  desc "Upgrade Goldberg"
+  task :upgrade => :migrate do
+  end
+  
+  desc "Apply a site theme"
+  task :theme, :theme_name, :needs => :environment do |t, args|
+    source_dir = File.join(File.dirname(__FILE__), '..', 'themes')
+    theme = args.theme_name || 'goldberg'
+    theme_dir = File.join(source_dir, theme)
+    if File.directory?(theme_dir)
+      manifest = Rails::Generator::Manifest.new do |m|
+        # Public assets: images, javascripts and stylesheets, including both the
+        # common files and files specific to the specified theme.
+        ['images', 'javascripts', 'stylesheets'].each do |asset|
+          dest_dir = File.join('public/goldberg', asset)
+          m.directory dest_dir
+          ['common', theme].each do |src|
+            Dir["#{source_dir}/#{src}/public/#{asset}/*"].each do |file_path|
+              file = File.basename(file_path)
+              m.file "#{src}/public/#{asset}/#{file}", "#{dest_dir}/#{file}"
+            end
+          end
+        end
+        # The default site template
+        m.file "#{theme}/app/views/layouts/application.html.erb",
+        "app/views/layouts/application.html.erb"
+      end
+      # Run the manifest created above through Rails::Generator
+      Rails::Generator::Base.spec = Rails::Generator::Spec.new('', '', nil)
+      base = Rails::Generator::Base.new([], :source => source_dir)
+      commands = Rails::Generator::Commands::Create.new(base)
+      manifest.replay(commands)
+    else  # theme directory doesn't exist
+      raise ArgumentError.new,
+      "No such theme '#{theme}'"
+    end
+  end
+  
+  desc "Flush cached data out of sessions and Roles"
+  task :flush => :environment do
+    puts "Deleting any Rails session files"
+    Dir["#{RAILS_ROOT}/tmp/sessions/ruby_sess*"].each do |fname|
+      File.delete fname
+    end
+    
+    puts "Deleting any ActiveRecord sessions, and resetting the Role cache"
+    conn = ActiveRecord::Base.connection
+    begin  # Capture error if sessions table doesn't exist
+      conn.execute "delete from sessions"
+    rescue
+      nil
+    end
+    # conn.execute "update roles set cache = NULL"
+    Goldberg::Role.rebuild_cache
+  end
+
+end