wagn 1.12.7

data/lib/tasks/db.rake

@@ -0,0 +1,54 @@
+require 'rake'
+
+# This code lets us redefine existing Rake tasks, which is extremely
+# handy for modifying existing Rails rake tasks.
+# Credit for the original snippet of code goes to Jeremy Kemper
+# http://pastie.caboo.se/9620
+unless Rake::TaskManager.methods.include?(:redefine_task)
+  module Rake
+    module TaskManager
+      def redefine_task(task_class, args, &block)
+        task_name, arg_names, deps = resolve_args(args)
+        task_name = task_class.scope_name(@scope, task_name)
+        deps = [deps] unless deps.respond_to?(:to_ary)
+        deps = deps.collect {|d| d.to_s }
+        task = @tasks[task_name.to_s] = task_class.new(task_name, self)
+        task.application = self
+        @last_comment = nil
+        task.enhance(deps, &block)
+        task
+      end
+    end
+    class Task
+      class << self
+        def redefine_task(args, &block)
+          Rake.application.redefine_task(self, [args], &block)
+        end
+      end
+    end
+  end
+end
+
+namespace :db do  
+  namespace :fixtures do
+    desc "Load fixtures into the current environment's database.  Load specific fixtures using FIXTURES=x,y"
+    task :load => :environment do
+      require 'active_record/fixtures'
+      ActiveRecord::Base.establish_connection(::Rails.env.to_sym)
+      (ENV['FIXTURES'] ? ENV['FIXTURES'].split(/,/) : Dir.glob(File.join(Wagn.gem_root.to_s, 'test', 'fixtures', '*.{yml,csv}'))).each do |fixture_file|
+        ActiveRecord::Fixtures.create_fixtures('test/fixtures', File.basename(fixture_file, '.*'))
+      end
+    end
+  end
+    
+  namespace :test do
+    desc 'Prepare the test database and load the schema'
+    Rake::Task.redefine_task( :prepare => :environment ) do
+      if ENV['RELOAD_TEST_DATA'] == 'true' || ENV['RUN_CODE_RUN']
+        puts `env RAILS_ENV=test rake wagn:create`
+      else
+        puts "skipping loading test data.  to force, run `env RELOAD_TEST_DATA=true rake db:test:prepare`"
+      end
+    end
+  end
+end

data/lib/tasks/test.rake

@@ -0,0 +1,94 @@
+def set_database( db )
+  y = YAML.load_file("#{Wagn.root}/config/database.yml")
+  y["development"]["database"] = db if y["development"]
+  y["production"]["database"] = db if y["production"]
+  File.open( "#{Wagn.root}/config/database.yml", 'w' ) do |out|
+    YAML.dump( y, out )
+  end
+end
+
+
+
+namespace :test do
+  task :all => :environment do
+    puts 'This is not yet working; only first invocation takes effect'
+    Rake::Task['test:functionals'].invoke
+    puts 'put 2'
+    Rake::Task['test:functionals'].invoke
+    puts 'put 3'
+    
+    #    Rake::Task['test'].invoke
+    #    Rake::Task['spec'].invoke
+    #    Rake::Task['cucumber'].invoke
+  end
+  
+  ## FIXME: this generates an "Adminstrator links" card with the wrong reader_id, I have been
+  ##  setting it by hand after fixture generation.
+  desc "recreate test fixtures from fresh db"
+  task :generate_fixtures => :environment do
+    Rake::Task['wagn:reset_cache']
+    # env gets auto-set to 'test' somehow.
+    # but we need development to get the right schema dumped.
+    ENV['RAILS_ENV'] = 'development'
+
+    abcs = ActiveRecord::Base.configurations
+    config = ENV['RAILS_ENV'] || 'development'
+    olddb = abcs[config]["database"]
+    abcs[config]["database"] = "wagn_test_template"
+
+  #=begin
+    begin
+      # assume we have a good database, ie. just migrated dev db.
+      puts "setting database to wagn_test_template"
+      set_database 'wagn_test_template'
+      Rake::Task['wagn:create'].invoke
+
+      # I spent waay to long trying to do this in a less hacky way--
+      # Basically initial database setup/migration breaks your models and you really
+      # need to start rails over to get things going again I tried ActiveRecord::Base.reset_subclasses etc. to no avail. -LWH
+      puts ">>populating test data"
+      puts `rake test:populate_template_database --trace`
+      puts ">>extracting to fixtures"
+      puts `rake test:extract_fixtures --trace`
+    ensure
+      set_database olddb
+    end
+    # go ahead and load the fixtures into the test database
+    puts ">> preparing test database"
+    puts `env RELOAD_TEST_DATA=true rake db:test:prepare --trace`
+  end
+
+
+  desc "dump current db to test fixtures"
+  task :extract_fixtures => :environment do
+    YAML::ENGINE.yamler = 'syck'
+      # use old engine while we're supporting ruby 1.8.7 because it can't support Psych,
+      # which dumps with slashes that syck can't understand (also !!null stuff)
+
+    sql = "SELECT * FROM %s"
+    skip_tables = ["schema_info","schema_migrations","schema_migrations_cards","sessions"]
+    ActiveRecord::Base.establish_connection
+    (ActiveRecord::Base.connection.tables - skip_tables).each do |table_name|
+      i = "000"
+      File.open("#{Wagn.gem_root}/test/fixtures/#{table_name}.yml", 'w') do |file|
+        data = ActiveRecord::Base.connection.select_all(sql % table_name)
+        file.write data.inject({}) { |hash, record|
+
+          trsh = record['trash']
+          record['trash'] = false if trsh == 0 or trsh == '0'
+          raise "bad trash value #{record['trash'].inspect}" unless (trsh = record['trash']).nil? or trsh == false
+          #puts "test that trash is actually stored as 'false' for postgres and deleteme "
+          hash["#{table_name}_#{i.succ!}"] = record
+          hash
+        }.to_yaml
+      end
+    end
+  end
+
+  desc "create sample data for testing"
+  task :populate_template_database => :environment do
+    load 'test/seed.rb'
+    SharedData.add_test_data
+  end
+
+end

data/lib/tasks/wagn.rake

@@ -0,0 +1,215 @@
+WAGN_BOOTSTRAP_TABLES = %w{ cards card_revisions card_references users }
+
+namespace :wagn do
+  desc "create a wagn database from scratch"
+  task :create do
+    puts "dropping"
+    #fixme - this should be an option, but should not happen on standard creates!
+    begin
+      Rake::Task['db:drop'].invoke
+    rescue
+      puts "not dropped"
+    end
+
+    ENV['SCHEMA'] = "#{Wagn.gem_root}/db/schema.rb"
+     
+    puts "creating"
+    Rake::Task['db:create'].invoke
+
+    puts "loading schema"
+    Rake::Task['db:schema:load'].invoke
+    
+    # inserts existing card migrations into schema_migrations_cards to avoid re-migrating
+    Wagn::MigrationHelper.schema_mode :card do
+      ActiveRecord::Schema.assume_migrated_upto_version Wagn::Version.schema(:cards), Wagn::MigrationHelper.card_migration_paths
+    end
+    
+    if Rails.env == 'test'
+      puts "loading test fixtures"
+      Rake::Task['db:fixtures:load'].invoke
+    else
+      puts "loading bootstrap"
+      Rake::Task['wagn:bootstrap:load'].invoke
+    end
+  end
+  
+  
+  
+  desc "install wagn configuration files"
+  task :install do
+    puts "wagn:install is deprecated in favor of 'wagn new'"
+  end
+  
+  desc "reset cache"
+  task :reset_cache => :environment  do
+    Wagn::Cache.reset_global
+  end
+
+
+  desc "migrate structure and cards"
+  task :migrate =>:environment do
+    stamp = ENV['STAMP_MIGRATIONS']
+
+    puts 'migrating structure'
+    Rake::Task['db:migrate'].invoke
+    if stamp
+      Rake::Task['wagn:migrate:stamp'].invoke ''
+    end
+    
+    puts 'migrating cards'
+    Wagn::Cache.reset_global
+    Rake::Task['wagn:migrate:cards'].execute #not invoke because we don't want to reload environment
+    if stamp
+      Rake::Task['wagn:migrate:stamp'].reenable
+      Rake::Task['wagn:migrate:stamp'].invoke '_cards'
+    end
+    Wagn::Cache.reset_global
+  end
+
+  namespace :migrate do
+
+    desc "migrate cards"
+    task :cards => :environment do
+      Wagn::Cache.reset_global
+      ENV['WAGN_MIGRATION'] = true
+      Card # this is needed in production mode to insure core db structures are loaded before schema_mode is set
+    
+      paths = ActiveRecord::Migrator.migrations_paths = Wagn::MigrationHelper.card_migration_paths
+    
+      Wagn::MigrationHelper.schema_mode :card do
+        ActiveRecord::Migration.verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
+        ActiveRecord::Migrator.migrate paths, ENV["VERSION"] ? ENV["VERSION"].to_i : nil
+      end
+    end
+  
+    desc 'write the version to a file (not usually called directly)' #maybe we should move this to a method? 
+    task :stamp, :suffix do |t, args|
+      ENV['WAGN_MIGRATION'] = true
+      
+      stamp_file = Wagn::Version.schema_stamp_path args[:suffix]
+      Wagn::MigrationHelper.schema_mode args[:suffix ] do
+        version = ActiveRecord::Migrator.current_version
+        puts ">>  writing version: #{version} to #{stamp_file}"
+        if file = open(stamp_file, 'w')
+          file.puts version
+        end
+      end
+    end
+  end
+
+  desc "copy over .htaccess files useful in production mode"
+  task :copy_htaccess do
+    access_file = File.join(Wagn.gem_root, 'config/samples/asset_htaccess')
+
+    %w{ files assets }.each do |dirname|
+      dir = File.join Rails.public_path, dirname
+      mkdir_p dir
+      cp access_file, File.join( dir, '.htaccess' )
+    end
+  end
+
+
+  namespace :bootstrap do
+    desc "rid template of unneeded cards, revisions, and references"
+    task :clean => :environment do
+      Wagn::Cache.reset_global
+
+      # Correct time and user stamps
+      botid = Card::WagnBotID
+      extra_sql = {
+        :cards          =>", creator_id=#{botid}, updater_id=#{botid}",
+        :card_revisions =>", creator_id=#{botid}"
+      }
+      WAGN_BOOTSTRAP_TABLES.each do |table|
+        next if table == 'card_references'
+        ActiveRecord::Base.connection.update("update #{table} set created_at=now() #{extra_sql[table.to_sym] || ''};")
+      end
+
+      # delete ignored cards
+      Account.as_bot do
+        if ignoramus = Card['*ignore']
+          ignoramus.item_cards.each do |card|
+            if card.account #have to get rid of revisions to delete account  
+              #(could also directly delete cards "manually", but would need to delete all descendants manually, too)
+              ActiveRecord::Base.connection.delete( "delete from card_revisions where card_id = #{card.id}" )
+            end
+            card.delete!
+          end
+        end
+      end
+
+      ActiveRecord::Base.connection.delete( "delete from cards where trash is true" )
+
+      # delete unwanted rows ( will need to revise if we ever add db-level data integrity checks )
+      ActiveRecord::Base.connection.delete( "delete from card_revisions where not exists " +
+        "( select name from cards where current_revision_id = card_revisions.id )"
+      )
+      ActiveRecord::Base.connection.delete( "delete from card_references where" +
+        " (referee_id is not null and not exists (select * from cards where cards.id = card_references.referee_id)) or " +
+        " (           referer_id is not null and not exists (select * from cards where cards.id = card_references.referer_id));"
+      )
+      ActiveRecord::Base.connection.delete( "delete from users where id > 2" ) #leave only anon and wagn bot
+      Wagn::Cache.reset_global
+      
+    end
+
+    desc "dump db to bootstrap fixtures"
+    task :dump => :environment do
+      Wagn::Cache.reset_global
+      
+      Rake::Task['wagn:bootstrap:mod_files'].invoke
+      
+      YAML::ENGINE.yamler = 'syck'
+      # use old engine while we're supporting ruby 1.8.7 because it can't support Psych,
+      # which dumps with slashes that syck can't understand
+      
+      WAGN_BOOTSTRAP_TABLES.each do |table|
+        i = "000"
+        File.open("#{Wagn.gem_root}/db/bootstrap/#{table}.yml", 'w') do |file|
+          data = ActiveRecord::Base.connection.select_all( "select * from #{table}" )
+          file.write YAML::dump( data.inject({}) do |hash, record|
+            record['trash'] = false if record.has_key? 'trash'
+            if record.has_key? 'content'
+              record['content'] = record['content'].gsub /\u00A0/, ' '
+              # sych was handling nonbreaking spaces oddly.  would not be needed with psych.
+            end
+            hash["#{table}_#{i.succ!}"] = record
+            hash
+          end)
+        end
+      end
+      
+    end
+
+    desc "copy files from template database to standard mod and update cards"
+    task :mod_files => :environment do
+      template_files_dir = "#{Wagn.root}/files"
+      standard_files_dir = "#{Wagn.gem_root}/mods/standard/files"
+      
+      #FIXME - this should delete old revisions
+      
+      FileUtils.remove_dir standard_files_dir, force=true
+      FileUtils.cp_r template_files_dir, standard_files_dir
+      
+      # add a fourth line to the raw content of each image (or file) to identify it as a mod file
+      Card.search( :type=>['in', 'Image', 'File'], :ne=>'' ).each do |card|
+        rev = Card::Revision.find card.current_revision_id
+        rev.update_attributes :content=>rev.content + "\nstandard"        
+      end
+    end
+
+
+    desc "load bootstrap fixtures into db"
+    task :load => :environment do
+      #FIXME - shouldn't we be more standard and use seed.rb for this code?
+      Rake.application.options.trace = true
+      puts "bootstrap load starting"
+      require 'active_record/fixtures'
+#      require 'time'
+
+      ActiveRecord::Fixtures.create_fixtures File.join( Wagn.gem_root, 'db/bootstrap'), WAGN_BOOTSTRAP_TABLES
+
+    end
+  end
+
+end

data/lib/wagn.rb

@@ -0,0 +1,33 @@
+# should be able to move these to more appropriate places
+
+WAGN_GEM_ROOT = File.expand_path('../..', __FILE__)
+
+module Wagn
+
+  class << self
+    def root
+      Rails.root
+    end
+  
+    def application
+      Rails.application
+    end
+    
+    def config
+      application.config
+    end
+    
+    def paths
+      application.paths
+    end
+    
+    def gem_root
+      WAGN_GEM_ROOT
+    end
+    
+    def future_stamp
+      ## used in test data
+      @@future_stamp ||= Time.local 2020,1,1,0,0,0
+    end
+  end
+end

data/lib/wagn/all.rb

@@ -0,0 +1,16 @@
+require 'rails/all'
+require 'wagn/application'
+
+require 'recaptcha'
+require 'airbrake'
+
+require 'smart_name'
+require 'htmlentities'
+require 'uuid'
+require 'RMagick'
+require 'paperclip'
+
+# require 'xmlscan'
+# require 'rubyzip'
+require 'coderay'
+require 'sass'

data/lib/wagn/application.rb

@@ -0,0 +1,96 @@
+# -*- encoding : utf-8 -*-
+
+require 'wagn/all'
+
+if defined?(Bundler)
+  # If you precompile assets before deploying to production, use this line
+  Bundler.require *Rails.groups(:assets => %w(development test))
+  # If you want your assets lazily compiled in production, use this line
+  # Bundler.require(:default, :assets, Rails.env)
+end
+
+
+module Wagn
+  class Application < Rails::Application
+    
+    class << self
+      def inherited(base)
+        Rails.application = base.instance
+        Rails.application.add_lib_to_load_path!
+        ActiveSupport.run_load_hooks(:before_configuration, base.instance)
+      end      
+    end
+    
+    def config
+      @config ||= begin
+        config = super
+        
+        config.autoload_paths += Dir["#{Wagn.gem_root}/app/**/"]
+        config.autoload_paths += Dir["#{Wagn.gem_root}/lib/**/"]
+        config.autoload_paths += Dir["#{Wagn.gem_root}/mods/standard/lib/**/"]
+        
+        config.assets.enabled = true
+        config.assets.version = '1.0'
+        
+        
+        config.encoding              = "utf-8"
+        config.filter_parameters    += [:password]
+        config.read_only             = !!ENV['WAGN_READ_ONLY']
+        config.allow_inline_styles   = false
+        config.files_web_path        = 'files'
+        config.cache_store           = :file_store, 'tmp/cache'
+        
+        config.recaptcha_public_key  = nil
+        config.recaptcha_private_key = nil
+        config.recaptcha_proxy       = nil
+        
+        config.email_defaults        = nil
+        config.override_host         = nil
+        config.override_protocol     = nil
+        
+        config
+      end
+    end
+    
+
+    def paths
+      @paths ||= begin
+        paths = super
+        add_wagn_path paths, 'public'
+        add_wagn_path paths, "app",                 :eager_load => true, :glob => "*"
+        add_wagn_path paths, "app/assets",          :glob => "*"
+        add_wagn_path paths, "app/controllers",     :eager_load => true
+        add_wagn_path paths, "app/models",          :eager_load => true
+        add_wagn_path paths, "app/mailers",         :eager_load => true
+        add_wagn_path paths, "app/views"
+        add_wagn_path paths, "lib/tasks",           :glob => "**/*.rake"
+        add_wagn_path paths, "config"
+        add_wagn_path paths, "config/environments", :glob => "#{Rails.env}.rb"
+        add_wagn_path paths, "config/initializers", :glob => "**/*.rb"
+        add_wagn_path paths, "config/routes",       :with => "config/routes.rb"
+        add_wagn_path paths, "db"
+        add_wagn_path paths, "db/migrate"
+        add_wagn_path paths, "db/seeds",            :with => "db/seeds.rb"        
+        add_wagn_path paths, 'gem-mods',            :with => 'mods'
+
+        paths['local-mods'] = approot_is_gemroot? ? [] : 'mods'        
+        paths.add 'files'
+        
+        paths
+      end
+    end
+
+    def approot_is_gemroot?
+      Wagn.gem_root.to_s == config.root.to_s
+    end
+    
+    def add_wagn_path paths, path, options={}
+      wagn_path        = File.join( Wagn.gem_root, path )
+      options[:with] &&= File.join( Wagn.gem_root, options[:with]) 
+      with = options[:with] || wagn_path
+      paths[path] = Rails::Paths::Path.new(paths, wagn_path, with, options)
+    end
+
+  end
+end
+