drailties 0.4.3 → 0.5.0.pre

data/lib/generators/drails/scaffold_controller/templates/controller.rb

@@ -0,0 +1,68 @@
+<% if namespaced? -%>
+require_dependency '<%= namespaced_file_path %>/application_controller'
+
+<% end -%>
+<% module_namespacing do -%>
+class <%= controller_class_name %>Controller < ApplicationController
+  before_action :set_event_id, only: [:index, :show]
+
+  def index
+    @<%= plural_table_name %> = <%= orm_class.all(class_name) %>
+  end
+
+  def show
+    @<%= singular_table_name %> = <%= orm_class.find(class_name, 'params[:id]') %>
+  end
+
+  def new
+    @<%= singular_table_name %> = <%= command_class_name('create') %>Command.new
+  end
+
+  def edit
+    @<%= singular_table_name %> = <%= command_class_name('update') %>Command.new <%= orm_class.find(class_name, 'params[:id]') %>.attributes
+  end
+
+  def create
+    @<%= singular_table_name %> = <%= command_class_name('create') %>Command.new <%= singular_table_name %>_params
+    if @<%= singular_table_name %>.valid? && (session[:tmp_event_id] = Domain.run_command(@<%= singular_table_name %>))
+      redirect_to @<%= singular_table_name %>, notice: <%= "'#{human_name} was successfully created.'" %>
+    else
+      render action: 'new'
+    end
+  end
+
+  def update
+    @<%= singular_table_name %> = <%= command_class_name('update') %>Command.new <%= singular_table_name %>_params.merge(id: params[:id])
+    if @<%= singular_table_name %>.valid? && (session[:tmp_event_id] = Domain.run_command(@<%= singular_table_name %>))
+      redirect_to @<%= singular_table_name %>, notice: <%= "'#{human_name} was successfully updated.'" %>
+    else
+      render action: 'edit'
+    end
+  end
+
+  def destroy
+    delete_<%= singular_table_name %> = <%= command_class_name('delete') %>Command.new(id: params[:id])
+    session[:tmp_event_id] = event_id = Domain.run_command(delete_<%= singular_table_name %>)
+    if event_id
+      redirect_to <%= index_helper %>_url, notice: <%= "'#{human_name} was successfully destroyed.'" %>
+    else
+      redirect_to <%= singular_table_name %>_url(id: params[:id]), error: <%= "'#{human_name} could not be deleted.'" %>
+    end
+  end
+
+  private
+
+  def <%= "#{singular_table_name}_params" %>
+    <%- if attributes_names.empty? -%>
+        params[<%= ":#{singular_table_name}" %>]
+    <%- else -%>
+    params.require(<%= ":#{singular_table_name}" %>).permit(<%= attributes_names.map { |name| ":#{name}" }.join(', ') %>)
+    <%- end -%>
+  end
+
+  def set_event_id
+    @event_id = session[:tmp_event_id]
+    session[:tmp_event_id] = nil
+  end
+end
+<% end -%>

data/lib/generators/drails/{controller → scaffold_controller}/templates/controller_test.rb

@@ -1,45 +1,45 @@
-require 'test_helper'
-
-<% module_namespacing do -%>
-class <%= controller_class_name %>ControllerTest < ActionController::TestCase
-  setup do
-    @<%= singular_table_name %> = <%= table_name %>(:one)
-  end
-
-  test "should get index" do
-    get :index
-    assert_response :success
-    assert_not_nil assigns(:<%= table_name %>)
-  end
-
-  test "should get new" do
-    get :new
-    assert_response :success
-  end
-
-  #test "should create <%= singular_table_name %>" do
-  #  #removed for now, because there is no reason to test the post here, cause the projection creates it
-  #  #maybe we could test something else here instead
-  #end
-
-  test "should show <%= singular_table_name %>" do
-    get :show, id: <%= "@#{singular_table_name}" %>
-    assert_response :success
-  end
-
-  test "should get edit" do
-    get :edit, id: <%= "@#{singular_table_name}" %>
-    assert_response :success
-  end
-
-  #test "should update <%= singular_table_name %>" do
-  #  #removed for now, because there is no reason to test the update here, cause the projection updates it
-  #  #maybe we could test something else here instead
-  #end
-
-  #test "should destroy <%= singular_table_name %>" do
-  #  #removed for now, because there is no reason to test the destroy here, cause the projection destroys it
-  #  #maybe we could test something else here instead
-  #end
-end
-<% end -%>
+require 'test_helper'
+
+<% module_namespacing do -%>
+class <%= controller_class_name %>ControllerTest < ActionController::TestCase
+  setup do
+    @<%= singular_table_name %> = <%= table_name %>(:one)
+  end
+
+  test "should get index" do
+    get :index
+    assert_response :success
+    assert_not_nil assigns(:<%= table_name %>)
+  end
+
+  test "should get new" do
+    get :new
+    assert_response :success
+  end
+
+  #test "should create <%= singular_table_name %>" do
+  #  #removed for now, because there is no reason to test the post here, cause the projection creates it
+  #  #maybe we could test something else here instead
+  #end
+
+  test "should show <%= singular_table_name %>" do
+    get :show, id: <%= "@#{singular_table_name}" %>
+    assert_response :success
+  end
+
+  test "should get edit" do
+    get :edit, id: <%= "@#{singular_table_name}" %>
+    assert_response :success
+  end
+
+  #test "should update <%= singular_table_name %>" do
+  #  #removed for now, because there is no reason to test the update here, cause the projection updates it
+  #  #maybe we could test something else here instead
+  #end
+
+  #test "should destroy <%= singular_table_name %>" do
+  #  #removed for now, because there is no reason to test the destroy here, cause the projection destroys it
+  #  #maybe we could test something else here instead
+  #end
+end
+<% end -%>

data/lib/generators/drails/use_domain_option.rb

@@ -1,54 +1,54 @@
-require 'active_support/concern'
-require 'generators/drails/domain.rb'
-
-module Drails
-  module Generators
-    module UseDomainOption
-      extend ActiveSupport::Concern
-
-      include Domain
-
-      included do
-        class_option :domain, type: :boolean, default: false, desc: "generate for the domain"
-      end
-
-      protected
-
-      def use_domain?
-        options[:domain]
-      end
-
-      def use_domain(file_name)
-        if use_domain?
-          "domain_#{file_name}"
-        else
-          file_name
-        end
-      end
-
-      def use_domain_class_path
-        if use_domain?
-          domain_class_path
-        else
-          class_path
-        end
-      end
-
-      def use_domain_base_path
-        if use_domain?
-          'domain'
-        else
-          'app'
-        end
-      end
-
-      def use_domain_class_file_path(type, file_name)
-        File.join use_domain_base_path, type, use_domain_class_path, file_name
-      end
-
-      def use_domain_param
-        '--domain' if use_domain?
-      end
-    end
-  end
+require 'active_support/concern'
+require 'generators/drails/domain.rb'
+
+module Drails
+  module Generators
+    module UseDomainOption
+      extend ActiveSupport::Concern
+
+      include Domain
+
+      included do
+        class_option :domain, type: :boolean, default: false, desc: "generate for the domain"
+      end
+
+      protected
+
+      def use_domain?
+        options[:domain]
+      end
+
+      def use_domain(file_name)
+        if use_domain?
+          "domain_#{file_name}"
+        else
+          file_name
+        end
+      end
+
+      def use_domain_class_path
+        if use_domain?
+          domain_class_path
+        else
+          class_path
+        end
+      end
+
+      def use_domain_base_path
+        if use_domain?
+          'domain'
+        else
+          'app'
+        end
+      end
+
+      def use_domain_class_file_path(type, file_name)
+        File.join use_domain_base_path, type, use_domain_class_path, file_name
+      end
+
+      def use_domain_param
+        '--domain' if use_domain?
+      end
+    end
+  end
 end

data/lib/rails-disco/version.rb

@@ -1,9 +1,9 @@
 module RailsDisco
   module VERSION
     MAJOR = 0
-    MINOR = 4
-    TINY  = 3
-    PRE   = nil
+    MINOR = 5
+    TINY  = 0
+    PRE   = "pre"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/tasks/db.rake

@@ -1,123 +1,222 @@
 require 'yaml'
-require 'logger'
 require 'active_record'
 
-namespace :drails do
+namespace :disco do
   namespace :db do
-    def create_database(config)
-      options = {:charset => 'utf8', :collation => 'utf8_unicode_ci'}
+    def disco_database_configuration(disco_config, database)
+      disco_config.reduce({}) do |map, (key, value)|
+        if value.is_a?(Hash) && value.has_key?(database)
+          map[key] = value[database]
+        end
+        map
+      end
+    end
 
-      create_db = lambda do |config|
-        ActiveRecord::Base.establish_connection config.merge('database' => nil)
-        ActiveRecord::Base.connection.create_database config['database'], options
-        ActiveRecord::Base.establish_connection config
+    task :load_config => :environment do
+      migrate_path = 'db/migrate'
+      ActiveRecord::Tasks::DatabaseTasks.db_dir = Rails.application.config.paths['db'].first
+      ActiveRecord::Tasks::DatabaseTasks.seed_loader = Rails.application
+      ActiveRecord::Base.clear_all_connections!
+
+      if ENV['SYSTEM'] == 'domain'
+        migrate_path = 'db/migrate_domain'
+        ActiveRecord::Tasks::DatabaseTasks.env = ENV['DOMAIN_ENV'] || Rails.env
+        disco_config = YAML.load_file(File.join Rails.root, 'config', 'disco.yml')
+        ActiveRecord::Tasks::DatabaseTasks.database_configuration = disco_database_configuration(disco_config, 'domain_database')
+        ActiveRecord::Tasks::DatabaseTasks.migrations_paths =
+            Array(ENV['DOMAIN_MIGRATIONS_DIR'] || Rails.application.paths[migrate_path] || File.join(Rails.root, migrate_path))
+        ActiveRecord::Tasks::DatabaseTasks.fixtures_path = File.join Rails.root, 'test', 'fixtures_domain'
+        ENV['SCHEMA'] = File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, 'schema_domain.rb')
+        ENV['DB_STRUCTURE'] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, 'structure_domain.sql')
+
+      else # 'projection' - normal rails
+        ActiveRecord::Tasks::DatabaseTasks.env = ENV['PROJECTION_ENV'] || Rails.env
+        ActiveRecord::Tasks::DatabaseTasks.database_configuration = Rails.application.config.database_configuration
+        ActiveRecord::Tasks::DatabaseTasks.migrations_paths = Array(Rails.application.paths[migrate_path])
+        ActiveRecord::Tasks::DatabaseTasks.fixtures_path = File.join Rails.root, 'test', 'fixtures'
+        ENV['SCHEMA'] = File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, 'schema.rb')
+        ENV['DB_STRUCTURE'] = File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, 'structure.sql')
       end
 
-      begin
-        create_db.call config
-      rescue Mysql::Error => sqlerr
-        if sqlerr.errno == 1405
-          print "#{sqlerr.error}. \nPlease provide the root password for your mysql installation\n>"
-          root_password = $stdin.gets.strip
-
-          grant_statement = <<-SQL
-          GRANT ALL PRIVILEGES ON #{config['database']}.*
-            TO '#{config['username']}'@'localhost'
-            IDENTIFIED BY '#{config['password']}' WITH GRANT OPTION;
-          SQL
-
-          create_db.call config.merge('database' => nil, 'username' => 'root', 'password' => root_password)
-        else
-          $stderr.puts sqlerr.error
-          $stderr.puts "Couldn't create database for #{config.inspect}, charset: utf8, collation: utf8_unicode_ci"
-          $stderr.puts "(if you set the charset manually, make sure you have a matching collation)" if config['charset']
+      if defined?(ENGINE_PATH) && (engine = Rails::Engine.find(ENGINE_PATH))
+        if engine.paths[migrate_path].existent
+          ActiveRecord::Tasks::DatabaseTasks.migrations_paths += Array(engine.paths[migrate_path])
+        elsif Dir.exists?(File.join engine.root, migrate_path)
+          ActiveRecord::Tasks::DatabaseTasks.migrations_paths << File.join(engine.root, migrate_path)
         end
       end
+      Rails.env = ActiveRecord::Tasks::DatabaseTasks.env
+      ActiveRecord::Tasks::DatabaseTasks.root = Rails.root if ActiveRecord::Tasks::DatabaseTasks.respond_to? :root
+
+      #puts "env = #{ActiveRecord::Tasks::DatabaseTasks.env}"
+      puts "system = #{ENV['SYSTEM']}"
+      #puts "config = #{ActiveRecord::Tasks::DatabaseTasks.database_configuration[ActiveRecord::Tasks::DatabaseTasks.env]}"
     end
 
-    task :db_env do
-      DATABASE_ENV = ENV['DATABASE_ENV'] || 'development'
+    def connect
+      ActiveRecord::Base.establish_connection ActiveRecord::Tasks::DatabaseTasks.env
     end
 
-    task :environment => :db_env do
-      if ENV['ENV'] == 'domain'
-        @migration_dir = ENV['MIGRATIONS_DIR'] || 'db/migrate_domain'
-        @env = 'domain'
-      else
-        @migration_dir = ENV['MIGRATIONS_DIR'] || 'db/migrate'
-        @env = 'projection'
+    namespace :migrate do
+      desc 'Copys the migrations files from the gems directories (options: SYSTEM=(projection|domain))'
+      task :copy => :load_config do
+        target_path = ActiveRecord::Tasks::DatabaseTasks.migrations_paths.first
+        gems = %w(active_event active_domain)
+        gems = %w(active_projection) if ENV['SYSTEM'] != 'domain'
+        gems.each do |gem|
+          gem_spec = Gem::Specification.find_by_name(gem)
+          if gem.nil?
+            puts "missing gem #{gem}!"
+          elsif Dir.exists?(File.join gem_spec.gem_dir, 'db/migrate')
+            cp_r (File.join gem_spec.gem_dir, 'db/migrate/.'), target_path
+          else
+            puts "missing db/migrate in gem #{gem}!"
+          end
+        end
       end
-    end
 
-    task :configuration => :environment do
-      @config = YAML.load_file("config/disco.yml")[DATABASE_ENV]["#{@env}_database"]
-    end
+      desc 'Copy and run migrations (options: SYSTEM=(projection|domain))'
+      task :setup do
+        Rake::Task[:'disco:db:migrate:copy'].invoke
+        Rake::Task[:'disco:db:create'].invoke
+        Rake::Task[:'disco:db:migrate'].invoke
+      end
 
-    task :configure_connection => :configuration do
-      ActiveRecord::Base.establish_connection @config
-      ActiveRecord::Base.logger = Logger.new STDOUT if @config['logger']
+      # make sure the right database is connected
+      task :down do connect end
+      task :up do connect end
+      task :status do connect end
     end
 
-    desc 'Create the database from config/disco.yml for the current DATABASE_ENV (options: ENV=(projection|domain))'
-    task :create => :configure_connection do
-      create_database @config
-    end
+    task :migrate do connect end
 
-    desc 'Drops the database for the current DATABASE_ENV (options: ENV=(projection|domain))'
-    task :drop => :configure_connection do
-      ActiveRecord::Base.connection.drop_database @config['database']
+    namespace :schema do
+      task :load do connect end
     end
+    namespace :structure do
+      task :load do connect end
+    end
+  end
 
-    desc 'Rolls the schema back to the previous version (specify steps w/ STEP=n) (options: ENV=(projection|domain)).'
-    task :rollback => :configure_connection do
-      step = ENV['STEP'] ? ENV['STEP'].to_i : 1
-      ActiveRecord::Migrator.rollback @migration_dir, step
+  load 'active_record/railties/databases.rake'
+
+  namespace :domain do
+    task :environment do
+      ENV['SYSTEM'] = 'domain'
     end
 
-    desc 'Retrieves the current schema version number'
-    task :version => :configure_connection do
-      puts "Current version: #{ActiveRecord::Migrator.current_version}"
+    namespace :create do
+      task :all => [:environment, :'disco:db:create:all']
     end
 
-    desc 'Copys the migrations files from the gems directories (options: ENV=(projection|domain))'
-    task :copy_migrations => :environment do
-      if @env == 'domain'
-        cp_r Gem::Specification.find_by_name('active_event').gem_dir + '/db/migrate/.', @migration_dir
-        cp_r Gem::Specification.find_by_name('active_domain').gem_dir + '/db/migrate/.', @migration_dir
-      else
-        cp_r Gem::Specification.find_by_name('active_projection').gem_dir + '/db/migrate/.', @migration_dir
-      end
+    desc 'Create the database from config/disco.yml (use create:all to create all dbs in the config)'
+    task :create => [:environment, :'disco:db:create']
+
+    namespace :drop do
+      task :all => [:environment, :'disco:db:drop:all']
     end
 
-    desc 'Migrates the database (options: VERSION=x, ENV=(projection|domain))'
-    task :migrate => :configure_connection do
-      ActiveRecord::Migration.verbose = true
-      ActiveRecord::Migrator.migrate @migration_dir, ENV['VERSION'] ? ENV['VERSION'].to_i : nil
+    desc 'Drops the database using config/disco.yml (use drop:all to drop all databases)'
+    task :drop => [:environment, :'disco:db:drop']
+
+    desc 'run domain migrations'
+    task :migrate => [:environment, :'disco:db:migrate']
+
+    namespace :migrate do
+      desc 'Display status of migrations'
+      task :status => [:environment, :'disco:db:migrate:status']
+
+      desc 'Copy migrations from rails disco'
+      task :copy => [:environment, :'disco:db:migrate:copy']
+
+      desc 'Copy and run migrations from rails disco'
+      task :setup => [:environment, :'disco:db:migrate:setup']
+
+      desc 'drop and create, copy and run migrations from rails disco'
+      task :reset => [:environment, :'disco:db:migrate:reset']
     end
 
-    desc 'Copys the domain migrations and migrates the domain database'
-    task :setup_domain do
-      ENV['ENV'] = 'domain'
-      Rake::Task[:'drails:db:copy_migrations'].invoke
-      Rake::Task[:'drails:db:migrate'].invoke
+    desc 'create and load schema and seeds for domain database'
+    task :setup => [:environment, :'disco:db:setup']
+  end
+
+  def reenable
+    Rake::Task.tasks.map &:reenable
+  end
+
+  desc 'creates the domain and projection databases for the current environment'
+  task :create do
+    ENV['SYSTEM'] = 'projection'
+    Rake::Task[:'disco:db:create'].invoke
+
+    reenable
+    Rake::Task[:'disco:domain:create'].invoke
+  end
+
+  desc 'drops the domain and projection databases for the current environment'
+  task :drop do
+    ENV['SYSTEM'] = 'projection'
+    Rake::Task[:'disco:db:drop'].invoke
+
+    reenable
+    Rake::Task[:'disco:domain:drop'].invoke
+  end
+
+  desc 'migrates the domain and projection databases for the current environment'
+  task :migrate do
+    ENV['SYSTEM'] = 'projection'
+    Rake::Task[:'disco:db:migrate'].invoke
+
+    reenable
+    Rake::Task[:'disco:domain:migrate'].invoke
+  end
+
+  desc 'Create and load schema and seeds for domain and projection databases'
+  task :setup do
+    ENV['SYSTEM'] = 'projection'
+    Rake::Task[:'disco:db:setup'].invoke
+
+    reenable
+    Rake::Task[:'disco:domain:setup'].invoke
+  end
+
+  desc 'Drop, recreate and load schema and seeds for domain and projection databases'
+  task :reset do
+    ENV['SYSTEM'] = 'projection'
+    Rake::Task[:'disco:db:drop'].invoke
+    Rake::Task[:'disco:db:setup'].invoke
+
+    reenable
+    Rake::Task[:'disco:domain:drop'].invoke
+    Rake::Task[:'disco:domain:setup'].invoke
+  end
+
+  namespace :migrate do
+    desc 'copies, creates and runs all migrations for domain and projection databases for the current environment'
+    task :setup do
+      ENV['SYSTEM'] = 'projection'
+      Rake::Task[:'disco:db:migrate:setup'].invoke
+
+      reenable
+      Rake::Task[:'disco:domain:migrate:setup'].invoke
     end
 
-    desc 'Copys the projection migrations and migrates the projection database'
-    task :setup_projection do
-      ENV['ENV'] = 'projection'
-      Rake::Task[:'drails:db:copy_migrations'].invoke
-      Rake::Task[:'drails:db:migrate'].invoke
+    desc 'Resets your domain and projection databases using your migrations for the current environment'
+    task :reset do
+      ENV['SYSTEM'] = 'projection'
+      Rake::Task[:'disco:db:migrate:reset'].invoke
+
+      reenable
+      Rake::Task[:'disco:domain:migrate:reset'].invoke
     end
 
-    desc 'Copys the gem migrations and migrates the domain and the projection database after'
-    task :setup do
-      Rake::Task[:'drails:db:setup_domain'].invoke
-      Rake::Task[:'drails:db:environment'].reenable
-      Rake::Task[:'drails:db:configure_connection'].reenable
-      Rake::Task[:'drails:db:configuration'].reenable
-      Rake::Task[:'drails:db:migrate'].reenable
-      Rake::Task[:'drails:db:copy_migrations'].reenable
-      Rake::Task[:'drails:db:setup_projection'].invoke
+    desc 'Display status of domain and projection migrations'
+    task :status do
+      ENV['SYSTEM'] = 'projection'
+      Rake::Task[:'disco:db:migrate:status'].invoke
+
+      reenable
+      Rake::Task[:'disco:domain:migrate:status'].invoke
     end
   end
-end
+end