dp_publico 0.0.1

data/Rakefile

@@ -0,0 +1,14 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+require 'rake'
+
+AdministracaoAcademica::Application.load_tasks
+
+desc "Run RSpec 2"
+RSpec::Core::RakeTask.new do |t|
+  t.name = :spec_2
+  t.verbose = false
+  t.skip_bundler = true
+end

data/dp_publico.gemspec

@@ -0,0 +1,8 @@
+Gem::Specification.new do |s|
+  s.name        = "dp_publico"
+  s.version     = "0.0.1"
+  s.description = "Webservice da base DP"
+  s.summary     = "DP Publico"
+  s.author      = "Tatiana Barboza"
+  s.files       = Dir["{lib/**/*.rb,README.rdoc,test/**/*.rb,Rakefile,*.gemspec}"]
+end

data/lib/dp_publico/app/models/dp/historico.rb

@@ -0,0 +1,2 @@
+class Historico < ActiveRecord::Base
+end

data/lib/dp_publico/arel_patch.rb

@@ -0,0 +1,10 @@
+module Arel
+  class Table
+    def table_exists?
+      # If we're checking the other database, assume the table always exists.
+      return @table_exists = true if name.to_s.include?(".")
+      # Otherwise, use the stock Arel 2.0.9 method...
+      @table_exists ||= tables.key?(@name) || engine.connection.table_exists?(name)
+    end
+  end
+end

data/lib/dp_publico/database_cleaner_patch.rb

@@ -0,0 +1,15 @@
+if Rails.env.development? || Rails.env.test?
+  require 'database_cleaner'
+  require 'database_cleaner/base'
+  require 'database_cleaner/active_record/base'
+  require 'database_cleaner/active_record/truncation'
+  module DatabaseCleaner::ActiveRecord
+    class Truncation
+      private
+      def tables_to_truncate(connection)
+        (@only || connection.tables) - @tables_to_exclude - connection.views + IduffPublico.added_cucumber_truncation_tables
+      end
+    end
+  end
+end
+

data/lib/dp_publico/rake_utils.rb

@@ -0,0 +1,26 @@
+require 'rake'
+
+module IduffPublico::RakeUtils
+
+# We want to provide a way to alias tasks so we can hook our custom logic
+# into the existing rails framework. For more information and usage, see:
+# http://www.metaskills.net/2010/5/26/the-alias_method_chain-of-rake-override-rake-task
+  Rake::TaskManager.class_eval do
+    def alias_task(fq_name)
+      new_name = "#{fq_name}:original"
+      @tasks[new_name] = @tasks.delete(fq_name)
+    end
+  end
+
+  def self.alias_task(fq_name)
+    Rake.application.alias_task(fq_name)
+  end
+
+  def self.override_task(*args, &block)
+    name, params, deps = Rake.application.resolve_args(args.dup)
+    fq_name = Rake.application.instance_variable_get(:@scope).dup.push(name).join(':')
+    self.alias_task(fq_name)
+    Rake::Task.define_task(*args, &block)
+  end
+
+end

data/lib/dp_publico/tasks.rb

@@ -0,0 +1,253 @@
+# Baseado em https://github.com/karledurante/secondbase/blob/master/lib/secondbase/tasks.rb
+require "dp_publico/rake_utils.rb"
+
+namespace :db do
+  DpPublico::RakeUtils.override_task :create do
+    DpPublico.tasks_up
+    Rake::Task["db:create:original"].invoke
+    DpPublico.tasks_down
+    Rake::Task["db:create:publico"].invoke if DpPublico.tasks_allowed?
+  end
+
+  DpPublico::RakeUtils.override_task :migrate do
+    DpPublico.tasks_up
+    Rake::Task["db:migrate:original"].invoke
+    DpPublico.tasks_down
+    Rake::Task["db:migrate:publico"].invoke if DpPublico.tasks_allowed?
+  end
+
+  DpPublico::RakeUtils.override_task :abort_if_pending_migrations do
+    DpPublico.tasks_up
+    Rake::Task["db:abort_if_pending_migrations:original"].invoke
+    DpPublico.tasks_down
+    Rake::Task["db:abort_if_pending_migrations:publico"].invoke if DpPublico.tasks_allowed?
+  end
+
+  namespace :test do
+    DpPublico::RakeUtils.override_task :prepare do
+      DpPublico.tasks_up
+      Rake::Task["db:test:prepare:original"].invoke
+      DpPublico.tasks_down
+      Rake::Task["db:test:prepare:publico"].invoke if DpPublico.tasks_allowed?
+    end
+    DpPublico::RakeUtils.override_task :load do
+      DpPublico.tasks_up
+      Rake::Task["db:test:load:original"].invoke
+      DpPublico.tasks_down
+      Rake::Task["db:test:load:publico"].invoke if DpPublico.tasks_allowed?
+    end
+  end
+
+  namespace :structure do
+    DpPublico::RakeUtils.override_task :dump do
+      DpPublico.tasks_up
+      Rake::Task["db:structure:dump:original"].invoke
+      DpPublico.tasks_down
+      Rake::Task["db:structure:dump:publico"].invoke if DpPublico.tasks_allowed?
+    end
+  end
+
+  namespace :schema do
+    DpPublico::RakeUtils.override_task :dump do
+      DpPublico.tasks_up
+      Rake::Task["db:schema:dump:original"].invoke
+      DpPublico.tasks_down
+      Rake::Task["db:schema:dump:publico"].invoke if DpPublico.tasks_allowed?
+    end
+
+    DpPublico::RakeUtils.override_task :load do
+      DpPublico.tasks_up
+      Rake::Task["db:schema:load:original"].invoke
+      DpPublico.tasks_down
+      Rake::Task["db:schema:load:publico"].invoke if DpPublico.tasks_allowed?
+    end
+  end
+
+  ##################################
+  # Tarefas específicas do publico
+  #
+  namespace :abort_if_pending_migrations do
+    task :publico => :environment do
+      if DpPublico.tasks_allowed?
+        DpPublico::publico_connect(Rails.env)
+
+        pending_migrations = ActiveRecord::Migrator.new(:up, DpPublico::MIGRATION_PATH).pending_migrations
+
+#        if pending_migrations.any?
+#          puts "Você tem #{pending_migrations.size} migrações pendentes no banco de dados publico:"
+#          pending_migrations.each do |pending_migration|
+#            puts '  %4d %s' % [pending_migration.version, pending_migration.name]
+#          end
+#          abort %{Execute "rake db:migrate" para atualizar o banco de dados e então tente novamente.}
+#        end
+        DpPublico::application_connect(Rails.env)
+      end
+    end
+  end
+
+  namespace :migrate do
+    #    desc "Migra o banco de dados publico"
+    task :publico => [:environment, :load_config] do
+      if DpPublico.tasks_allowed?
+        DpPublico::publico_connect(Rails.env)
+
+        ActiveRecord::Migration.verbose = true
+        ActiveRecord::Migrator.migrate(DpPublico::MIGRATION_PATH, ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
+        Rake::Task["db:schema:dump:publico"].invoke if ActiveRecord::Base.schema_format == :ruby
+        DpPublico::application_connect(Rails.env)
+      end
+    end
+
+    namespace :up do
+      #      desc 'Roda a tarefa "up" para uma determinada VERSION do publico.'
+      task :publico => :environment do
+        if DpPublico.tasks_allowed?
+          version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
+          raise "VERSION é necessario" unless version
+
+          DpPublico::publico_connect(Rails.env)
+
+          ActiveRecord::Migrator.run(:up, DpPublico::MIGRATION_PATH, version)
+          Rake::Task["db:schema:dump:publico"].invoke if ActiveRecord::Base.schema_format == :ruby
+          DpPublico::application_connect(Rails.env)
+        end
+      end
+    end
+
+    namespace :down do
+      #      desc 'Roda a tarefa "down" para uma determinada VERSION do publico.'
+      task :publico => :environment do
+        if DpPublico.tasks_allowed?
+          version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
+          raise "VERSION necessario" unless version
+
+          DpPublico::publico_connect(Rails.env)
+
+          ActiveRecord::Migrator.run(:down, DpPublico::MIGRATION_PATH, version)
+          Rake::Task["db:schema:dump:publico"].invoke if ActiveRecord::Base.schema_format == :ruby
+          DpPublico::application_connect(Rails.env)
+        end
+      end
+    end
+  end
+
+  namespace :create do
+    #    desc 'Cria o banco de dados especificado no config/database.yml para o RAILS_ENV atual'
+    task :publico => :load_config do
+      if DpPublico.tasks_allowed?
+        if Rails.env.development? && DpPublico.publico_config('test')
+          create_database(DpPublico.publico_config('test'))
+        end
+        create_database(DpPublico.publico_config(Rails.env))
+      end
+    end
+  end
+
+  namespace :structure do
+    namespace :dump do
+      #      desc "Faz dump da estrutura do database publico."
+      task :publico => :environment do
+        dump_file = "#{Rails.root}/db/publico_#{Rails.env}_structure.sql"
+
+        DpPublico::publico_connect(Rails.env)
+
+        File.open(dump_file, "w+") do |f|
+          f << ActiveRecord::Base.connection.structure_dump
+        end
+
+        if ActiveRecord::Base.connection.supports_migrations?
+          File.open(dump_file, "a") { |f| f << ActiveRecord::Base.connection.dump_schema_information }
+        end
+        DpPublico::application_connect(Rails.env)
+      end
+    end
+  end
+
+  namespace :test do
+    namespace :prepare do
+      #desc 'Prepara o ambiente de testes do banco publico'
+      task :publico => 'db:abort_if_pending_migrations:publico' do
+        Rails.env = "test"
+        DpPublico::publico_connect("test")
+        Rake::Task["db:test:clone_structure:publico"].invoke
+        #Rake::Task["db:test:load:publico"].invoke
+        DpPublico::application_connect('test')
+      end
+    end
+
+    namespace :load do
+      #desc 'Prepara o ambiente de testes do banco publico'
+      task :publico => 'db:abort_if_pending_migrations:publico' do
+        Rails.env = "test"
+        DpPublico::publico_connect("test")
+        ActiveRecord::Schema.verbose = false
+        Rake::Task["db:schema:load:publico"].invoke
+        DpPublico::application_connect('test')
+      end
+    end
+
+    namespace :purge do
+      task :publico do
+        Rails.env = "test"
+        conn = DpPublico.publico_config('test')
+        case conn['adapter']
+        when /mysql/
+          ActiveRecord::Base.connection.recreate_database(conn["database"], conn)
+        else
+          raise "Task not supported by '#{conn['test']['adapter']}'"
+        end
+        DpPublico::application_connect('test')
+      end
+    end
+
+    namespace :clone_structure do
+      task :publico => ['db:structure:dump:publico', 'db:test:purge:publico'] do
+        Rails.env = "test"
+        if DpPublico.publico_config("test")['adapter'][/mysql/]
+
+          DpPublico::publico_connect("test")
+
+          ActiveRecord::Base.connection.execute('SET foreign_key_checks = 0')
+
+          IO.readlines("#{Rails.root}/db/publico_#{Rails.env}_structure.sql").join.split("\n\n").each do |table|
+            ActiveRecord::Base.connection.execute(table)
+          end
+        else
+          raise "Esta tarefa ainda não foi implementada para o adaptador '#{DpPublico.publico_config("test")['adapter']}'"
+        end
+        DpPublico::application_connect('test')
+      end
+    end
+  end
+
+  namespace :schema do
+    namespace :dump do
+      #      desc 'Cria o arquivo db/schema_publico.rb que pode ser portado usando qualquer banco de dados suportado pelo AR'
+      task :publico => :load_config do
+        require 'active_record/schema_dumper'
+
+        DpPublico::publico_connect(Rails.env)
+
+        File.open(ENV['SCHEMA'] || "#{Rails.root}/db/schema_publico.rb", "w:utf-8") do |file|
+          ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
+        end
+        Rake::Task["db:schema:dump:publico"].reenable
+        DpPublico::application_connect(Rails.env)
+      end
+    end
+
+    namespace :load do
+      #      desc 'Carrega um arquivo schema_publico.rb para o banco de dados publico'
+      task :publico do
+        file = ENV['SCHEMA'] || "#{Rails.root}/db/schema_publico.rb"
+        if File.exists?(file)
+          DpPublico::publico_connect(Rails.env)
+          load(file)
+        else
+          abort %{#{file} não existe ainda. Execute "rake db:migrate" para cria-lo.}
+        end
+        DpPublico::application_connect(Rails.env)
+      end
+    end
+  end
+end

data/lib/dp_publico/version.rb

@@ -0,0 +1,3 @@
+module DpPublico
+  VERSION = "0.0.1"
+end

data/lib/dp_publico.rb

@@ -0,0 +1,91 @@
+require 'active_record'
+#require 'ruby-debug'
+require 'dp_publico/arel_patch'
+require 'dp_publico/database_cleaner_patch'
+require 'dp_publico/app/models/pub'
+require 'dp_publico/app/models/pub/historico'
+
+module DpPublico
+
+  MIGRATION_PATH = "#{File.dirname(__FILE__)}/dp_publico/db/migrate"
+  
+  @@added_cucumber_truncation_tables = [] 
+  def self.added_cucumber_truncation_tables
+    @@added_cucumber_truncation_tables
+  end
+
+  @tasks_allowed = 0
+
+  def self.tasks_allowed?
+    @tasks_allowed == 0
+  end
+
+  def self.tasks_up
+    @tasks_allowed += 1
+  end
+
+  def self.tasks_down
+    @tasks_allowed -= 1
+  end
+
+  def self.publico_config(env)
+    publico_config = ActiveRecord::Base.configurations["publico"]
+    return publico_config[env] if publico_config
+    nil
+  end
+
+  def self.publico_connect(env)
+    ActiveRecord::Base.establish_connection(publico_config(env))
+  end
+
+  def self.application_connect(env)
+    ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations[env])
+  end
+
+
+  class DpPublicoEngine < Rails::Engine
+
+    initializer "dp_publico_engine.configurar_banco_publico" do
+      abort "As configurações do publico para o ambiente #{Rails.env} não foram definidas.\nInformaçoes lidas: #{Marshal.dump(ActiveRecord::Base.configurations)}" unless DpPublico.publico_config(Rails.env)
+    end
+
+    rake_tasks do
+      load "dp_publico/tasks.rb"
+    end
+
+    config.to_prepare do
+      DpPublico.inject_table_names!
+    end
+
+    console do
+      DpPublico.inject_table_names!
+    end
+  end
+
+
+  def self.inject_table_names!
+
+    # TODO: Remover o warning de constantes já carregadas
+    Dir[File.join("#{Rails.root}/app/models", '*.rb')].each { |f| require f }
+    Dir[File.join("#{Rails.root}/app/models/pub", '*.rb')].each { |f| require f }
+
+    database_name = ActiveRecord::Base.configurations[Rails.env]["database"]
+    model_names = ActiveRecord::Base.descendants.collect { |klass| klass.name unless klass.abstract_class? }.compact
+    model_names.each do |model_name|
+      klass = model_name.constantize
+      table_name = klass.table_name
+      next if table_name.include? '.'
+
+      if klass.respond_to?(:dp_publico?) && klass.dp_publico?
+        new_table_name = "#{DpPublico.publico_config(Rails.env)["database"]}.#{table_name}"
+        DpPublico.added_cucumber_truncation_tables << new_table_name
+        klass.set_table_name new_table_name
+      else
+        klass.set_table_name "#{database_name}.#{table_name}"
+      end
+    end
+  end
+
+end
+
+

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: dp_publico
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Tatiana Barboza
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-02-09 00:00:00 Z
+dependencies: []
+
+description: Webservice da base DP
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/dp_publico/version.rb
+- lib/dp_publico/tasks.rb
+- lib/dp_publico/app/models/dp/historico.rb
+- lib/dp_publico/database_cleaner_patch.rb
+- lib/dp_publico/arel_patch.rb
+- lib/dp_publico/rake_utils.rb
+- lib/dp_publico.rb
+- Rakefile
+- dp_publico.gemspec
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: DP Publico
+test_files: []
+