storey 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ae5569721f64878b097e1b98b07c035fb36a9d71
-  data.tar.gz: 4dca637ae254650c11a1140143b3242923eb015c
+  metadata.gz: f43d4bfca6dbcd859c187fb920e7e296d6c1809b
+  data.tar.gz: 322eb8906efac105f0a0c153bc4d8c47209eea28
 SHA512:
-  metadata.gz: e62da00edaffe209439f36791dca9709cd9442b3c44a4046071cb7331ed6d0cf2bd3d4cf859da83b6c367673141dd635f558f36eb47ad5f2edb1f8384015a613
-  data.tar.gz: 2e5ae11654ed101a414c955e00d71cfd3e79c3341509c6a9b1b17c536d79da84c4cdfcb5f494a1161b8bb20827eb31c659f53822296e00c5b94d60031d8c6d14
+  metadata.gz: 27fb55a9705fe0a214855fb5c9a6a08f8a0fc4983cb877daff4daf2c2e0bdceab06ed6cdb006e95e72e4c200dc706198ea872f56f78524198aafcf87b02157d3
+  data.tar.gz: e29bed608be63691d0d7a62efa278b8b57eb7ea82d0154665522a479cd74c14fc61e40eac2e7712b4407ef74806c60a426345b9385a0d512aaa3780b55987171

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+# v0.5.0
+
+- Removed attr_accessors from Storey::Duplicator (they were never meant to be part of the public API anyway)
+- Validate the schema name when creating schemas
+- Clean source and target files after duplicating [#18](https://github.com/ramontayag/storey/issues/18)
+
 # v0.4.2
 
 - `rake storey:migrate VERSION=xxxx` now works and uses the `VERSION` environment variable

data/lib/storey/builds_dump_command.rb

@@ -0,0 +1,36 @@
+module Storey
+  class BuildsDumpCommand
+
+    easy_class_to_instance
+
+    def initialize(options={})
+      @options = options
+      if @options[:database].blank?
+        raise ArgumentError, 'database must be supplied'
+      end
+    end
+
+    def execute
+
+      switches = {}
+      switches['schema-only'] = nil if @options[:structure_only]
+      switches['no-privileges'] = nil
+      switches['no-owner'] = nil
+      switches[:file] = Shellwords.escape(@options[:file])
+
+      if @options[:schemas]
+        schemas = @options[:schemas].split(',')
+        schemas_switches = schemas.map do |part|
+          Utils.command_line_switches_from({schema: Shellwords.escape(part) })
+        end
+      end
+
+      command_parts = ['pg_dump',
+                       Utils.command_line_switches_from(switches),
+                       schemas_switches,
+                       @options[:database]]
+      command_parts.compact.join(' ')
+    end
+
+  end
+end

data/lib/storey/builds_load_command.rb

@@ -0,0 +1,31 @@
+module Storey
+  class BuildsLoadCommand
+
+    easy_class_to_instance
+
+    def initialize(options={})
+      @options = options
+    end
+
+    def execute
+      switches = {}
+      if @options[:file].present?
+        switches[:file] = Shellwords.escape(@options[:file])
+      end
+      switches[:dbname] = @options[:database]
+      switches[:username] = @options[:username] if @options[:username].present?
+      switches[:host] = @options[:host] if @options[:host].present?
+      switches[:port] = @options[:port] if @options[:port].present?
+      if @options[:password].present?
+        switches[:password] = @options[:password]
+      else
+        switches['no-password'] = nil
+      end
+      switches[:command] = %Q("#{@options[:command]}") if @options[:command].present?
+      command_parts = ['psql',
+                       Utils.command_line_switches_from(switches)]
+      command_parts.join(' ')
+    end
+
+  end
+end

data/lib/storey/dumper.rb

@@ -1,12 +1,9 @@
 module Storey
-    class Dumper
+  class Dumper
 
+    easy_class_to_instance
     delegate :dump, to: :dumper
 
-    def self.dump(*args)
-      self.new(*args).dump
-    end
-
     def initialize(options={})
       @options = options
     end
@@ -17,10 +14,9 @@ module Storey
 
     def dumper_class
       schema_format = Rails.configuration.active_record.schema_format || :ruby
-      klass = case schema_format
-              when :sql; SqlDumper
-              when :ruby; RubyDumper
-              end
+      class_name = "#{schema_format.to_s.classify}Dumper"
+      namespace = self.class.name.deconstantize.constantize
+      namespace.const_get class_name
     end
 
   end

data/lib/storey/duplicator.rb

@@ -1,86 +1,84 @@
 module Storey
   class Duplicator
 
-    attr_accessor(:source_schema,
-                  :target_schema,
-                  :source_file,
-                  :target_file,
-                  :structure_only,
-                  :file_prefix,
-                  :dump_path,
-                  :source_dump_path,
-                  :target_dump_path)
-
     def initialize(from_schema, to_schema, options={})
       unless from_schema
         fail SchemaNotFound, "cannot duplicate from nil schema"
       end
 
-      self.dump_path = File.join Rails.root, 'tmp', 'schema_dumps'
-      self.source_dump_path = File.join self.dump_path, 'source'
-      self.target_dump_path = File.join self.dump_path, 'target'
-      self.structure_only = options[:structure_only] || false
-
-      self.source_schema = suffixify(from_schema)
-      self.target_schema = suffixify(to_schema)
-      self.file_prefix = "#{Time.now.to_i}_#{rand(100000)}"
-      self.source_file = File.join(
-        self.source_dump_path,
-        "#{self.file_prefix}_#{self.source_schema}.sql"
-      )
-      self.target_file = File.join(
-        self.target_dump_path,
-        "#{self.file_prefix}_#{self.target_schema}.sql"
-      )
+      @dump_dir = File.join(Rails.root, 'tmp', 'schema_dumps')
+      @source_dump_dir = File.join(@dump_dir, 'source')
+      @target_dump_dir = File.join(@dump_dir, 'target')
+      @structure_only = options[:structure_only] || false
+
+      @source_schema = suffixify(from_schema)
+      @target_schema = suffixify(to_schema)
+      @file_prefix = "#{Time.now.to_i}_#{rand(100000)}"
+      @source_file = File.join(@source_dump_dir,
+                               "#{@file_prefix}_#{@source_schema}.sql")
+      @target_file = File.join(@target_dump_dir,
+                               "#{@file_prefix}_#{@target_schema}.sql")
     end
 
     def perform!
       dump_schema
       replace_occurrences
       load_schema
+      clean_source
+      clean_target
     end
 
     private
 
+    def clean_source
+      FileUtils.rm(@source_file)
+    end
+
+    def clean_target
+      FileUtils.rm(@target_file)
+    end
+
     def dump_schema(options={})
       ENV['PGPASSWORD'] = Storey.database_config[:password]
       prepare_schema_dump_directories
 
-      unless Storey.database_config[:host].blank?
+      if Storey.database_config[:host].present?
         options[:host] ||= Storey.database_config[:host]
       end
-      options[:username] ||= Storey.database_config[:username]
-      options[:file]     ||= self.source_file
-      options[:schema]   ||= self.source_schema
 
-      switches = options.map { |k, v| "--#{k}=#{v}" }
-      switches << '--schema-only' if self.structure_only
-      switches = switches.join(" ")
+      arg_options = options.dup
+      arg_options[:username] ||= Storey.database_config[:username]
+      arg_options[:file]     ||= @source_file
+      arg_options[:schema]   ||= @source_schema
+      arg_options['schema-only'] = nil if @structure_only
+
+      switches = Utils.command_line_switches_from(arg_options)
 
       success = system("pg_dump #{switches} #{Storey.database_config[:database]}")
       unless success
-        raise StoreyError, "There seems to have been a problem dumping `#{self.source_schema}` to make a copy of it into `#{self.target_schema}`"
+        raise StoreyError, "There seems to have been a problem dumping `#{@source_schema}` to make a copy of it into `#{@target_schema}`"
       end
     end
 
     def prepare_schema_dump_directories
-      [self.source_dump_path, self.target_dump_path].each do |d|
+      [@source_dump_dir, @target_dump_dir].each do |d|
         FileUtils.mkdir_p(d)
       end
     end
 
     def load_schema(options={})
-      options[:file] ||= self.target_file
-      switches = Storey.command_line_switches(options)
+      options[:file] ||= @target_file
+      psql_options = Storey.database_config.merge(options)
 
       if duplicating_from_default?
         # Since we are copying the source schema and we're after structure only,
         # the dump_schema ended up creating a SQL file without the "CREATE SCHEMA" command
         # thus we have to create it manually
-        ::Storey.create_plain_schema self.target_schema
+        ::Storey.create_plain_schema @target_schema
       end
 
-      `psql #{switches}`
+      psql_load_command = BuildsLoadCommand.execute(psql_options)
+      system psql_load_command
 
       copy_source_schema_migrations
 
@@ -88,7 +86,7 @@ module Storey
     end
 
     def copy_source_schema_migrations
-      ::Storey.switch self.target_schema do
+      ::Storey.switch @target_schema do
         source_schema_migrations.each do |version|
           unless target_schema_migrations.include?(version)
             command = "INSERT INTO schema_migrations (version) VALUES ('#{version}');"
@@ -99,28 +97,28 @@ module Storey
     end
 
     def source_schema_migrations
-      ::Storey.switch(self.source_schema) do
+      ::Storey.switch(@source_schema) do
         ::ActiveRecord::Migrator.get_all_versions
       end
     end
 
     def target_schema_migrations
-      ::Storey.switch(self.target_schema) do
+      ::Storey.switch(@target_schema) do
         ::ActiveRecord::Migrator.get_all_versions
       end
     end
 
     def replace_occurrences
-      File.open(self.source_file, 'r') do |file|
+      File.open(@source_file, 'r') do |file|
         file.each_line do |line|
-          new_line = line.gsub(/#{self.source_schema}/, self.target_schema)
-          File.open(self.target_file, 'a') {|tf| tf.puts new_line}
+          new_line = line.gsub(/#{@source_schema}/, @target_schema)
+          File.open(@target_file, 'a') {|tf| tf.puts new_line}
         end
       end
     end
 
     def duplicating_from_default?
-      ::Storey.matches_default_search_path?(self.source_schema) && self.structure_only
+      ::Storey.matches_default_search_path?(@source_schema) && @structure_only
     end
 
     def suffixify(schema_name)

data/lib/storey/exceptions.rb

@@ -1,6 +1,8 @@
 module Storey
   class StoreyError < StandardError; end
   class SchemaExists < StoreyError; end
+  class SchemaReserved < StoreyError; end
+  class SchemaInvalid < StoreyError; end
   class SchemaNotFound < StoreyError; end
   class TableNotFOund < StoreyError; end
   class WithinTransaction < StoreyError; end

data/lib/storey/ruby_dumper.rb

@@ -1,11 +1,7 @@
-require 'active_record/schema_dumper'
-
 module Storey
   class RubyDumper
 
-    def self.dump(*args)
-      self.new(*args).dump
-    end
+    easy_class_to_instance
 
     def initialize(options={})
       default_file_path = File.join(Rails.root, 'db', 'schema.rb')

data/lib/storey/schema_name.rb

@@ -0,0 +1,38 @@
+module Storey
+  class SchemaName < String
+    RESERVED_SCHEMAS = %w(hstore)
+
+    easy_class_to_instance
+
+    def initialize(name)
+      @name = if @name.respond_to?(:to_s)
+                name.to_s
+              else
+                name
+              end
+      super @name
+    end
+
+    def valid?
+      (@name =~ /^[^0-9][\w]*$/ || @name == '"$user"') &&
+        @name !~ /^pg_/
+    end
+
+    def reserved?
+      RESERVED_SCHEMAS.include?(@name)
+    end
+
+    def validate_format!
+      unless self.valid?
+        raise SchemaInvalid, "`#{@name}` is not a valid schema name"
+      end
+    end
+
+    def validate_reserved!
+      if self.reserved?
+        raise SchemaReserved, "`#{@name}` is a reserved schema name"
+      end
+    end
+
+  end
+end

data/lib/storey/sql_dumper.rb

@@ -1,24 +1,36 @@
 module Storey
   class SqlDumper
 
-    def self.dump(*args)
-      self.new(*args).dump
-    end
+    easy_class_to_instance
 
     def initialize(options={})
       @file = options[:file] || File.join(Rails.root, "db", "structure.sql")
     end
 
     def dump
-      abcs = ::ActiveRecord::Base.configurations
-      set_psql_env(abcs[Rails.env])
-      search_path = abcs[Rails.env]['schema_search_path']
-      unless search_path.blank?
-        search_path = search_path.split(",").map{|search_path_part| "--schema=#{Shellwords.escape(search_path_part.strip)}" }.join(" ")
-      end
-      `pg_dump -i -s -x -O -f #{Shellwords.escape(@file)} #{search_path} #{Shellwords.escape(abcs[Rails.env]['database'])}`
+      `#{command}`
       raise 'Error dumping database' if $?.exitstatus == 1
-      File.open(@file, "a") { |f| f << "SET search_path TO #{::ActiveRecord::Base.connection.schema_search_path};\n\n" }
+    end
+
+    private
+
+    def abcs
+      @abcs ||= ::ActiveRecord::Base.configurations.with_indifferent_access[Rails.env]
+    end
+
+    def search_path
+      @search_path ||= abcs[:schema_search_path]
+    end
+
+    def database_name
+      @database_name ||= Shellwords.escape(abcs[:database])
+    end
+
+    def command
+      @command ||= BuildsDumpCommand.execute(structure_only: true,
+                                             file: @file,
+                                             schemas: search_path,
+                                             database: database_name)
     end
 
   end

data/lib/storey/utils.rb

@@ -0,0 +1,23 @@
+module Storey
+  class Utils
+
+    def self.db_command_line_switches_from(db_config={}, extra_config={})
+      switches = {}
+      if db_config.has_key?(:host)
+        switches[:host] = db_config[:host]
+      end
+      switches[:dbname] = db_config[:database]
+      switches[:username] = db_config[:username]
+      command_line_switches_from switches.merge(extra_config)
+    end
+
+    def self.command_line_switches_from(hash={})
+      hash.map do |k, v|
+        arg = "--#{k}"
+        arg << "=#{v}" if v
+        arg
+      end.join(' ')
+    end
+
+  end
+end

data/lib/storey/version.rb

@@ -1,3 +1,3 @@
 module Storey
-  VERSION = "0.4.2"
+  VERSION = "0.5.0"
 end

data/lib/storey.rb

@@ -1,22 +1,26 @@
+require 'easy_class_to_instance_method'
+require "active_support/core_ext/module" # so we can use mattr_accessor
+
 require "storey/version"
 require "rails/all"
-require "active_support/core_ext/module" # so we can use mattr_accessor
-require 'easy_class_to_instance_method'
 require 'storey/railtie' if defined?(Rails)
 require 'storey/exceptions'
 require 'storey/migrator'
 require 'storey/duplicator'
 require 'storey/hstore'
-require 'storey/dumper'
 require 'storey/ruby_dumper'
 require 'storey/sql_dumper'
+require 'storey/dumper'
 require 'storey/native_schema_matcher'
 require 'storey/suffixifier'
 require 'storey/unsuffixifier'
 require 'storey/resets_column_info'
+require 'storey/utils'
+require 'storey/builds_dump_command'
+require 'storey/builds_load_command'
+require 'storey/schema_name'
 
 module Storey
-  RESERVED_SCHEMAS = %w(hstore)
 
   mattr_accessor :suffix, :persistent_schemas
   mattr_writer :default_search_path
@@ -60,17 +64,12 @@ module Storey
   end
 
   def create(name, options={}, &block)
-    if name.blank?
-      fail ArgumentError, "Must pass in a valid schema name"
-    end
-
-    if RESERVED_SCHEMAS.include?(name) && !options[:force]
-      fail ArgumentError, "'#{name}' is a reserved schema name"
-    end
+    name = SchemaName.new(name)
+    name.validate_format!
+    name.validate_reserved! unless options[:force]
 
     if self.schemas.include?(name)
-      fail(Storey::SchemaExists,
-           %{The schema "#{name}" already exists.})
+      fail(Storey::SchemaExists, %{The schema "#{name}" already exists.})
     end
 
     if options[:load_database_structure].nil?
@@ -93,20 +92,8 @@ module Storey
 
   def create_plain_schema(schema_name)
     name = suffixify schema_name
-    command = %{"CREATE SCHEMA #{name}"}
-    switches = self.command_line_switches(command: command)
-    `psql #{switches}`
-  end
-
-  def command_line_switches(options={})
-    switches = {}
-    if self.database_config.has_key?(:host)
-      switches[:host] = self.database_config[:host]
-    end
-    switches[:dbname] = self.database_config[:database]
-    switches[:username] = self.database_config[:username]
-    switches = switches.merge(options)
-    switches.map {|k, v| "--#{k}=#{v}"}.join(' ')
+    command = "CREATE SCHEMA #{name}"
+    system psql_load_command(command: command)
   end
 
   def schemas(options={})
@@ -208,6 +195,10 @@ module Storey
     self.default_search_path == schema_name
   end
 
+  def db_command_line_switches_from(extra_config={})
+    Utils.db_command_line_switches_from(self.database_config, extra_config)
+  end
+
   protected
 
   def schema_migrations
@@ -248,4 +239,8 @@ module Storey
     end
   end
 
+  def psql_load_command(options={})
+    BuildsLoadCommand.execute(self.database_config.merge(options))
+  end
+
 end

data/spec/spec_helper.rb

@@ -18,6 +18,8 @@ RSpec.configure do |config|
     # We don't want configuration to leak into other tests
     Storey.reload_config!
 
+    FileUtils.rm_rf File.join(Rails.root, 'tmp', 'schema_dumps')
+
     # Clean the public schema
     Storey.switch do
       tables = ::ActiveRecord::Base.connection.tables

data/spec/storey/builds_dump_command_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe Storey::BuildsDumpCommand do
+
+  describe '.execute' do
+    subject do
+      described_class.execute(options)
+    end
+
+    let(:options) do
+      {
+        structure_only: true,
+        file: 'myfile.sql',
+        schemas: 'public',
+        database: 'mydb'
+      }
+    end
+
+    context 'when structure_only: true' do
+      let(:options) do
+        {
+          database: 'mydb',
+          structure_only: true
+        }
+      end
+      it { should include('--schema-only') }
+    end
+
+    context 'when structure_only: false' do
+      let(:options) do
+        {
+          database: 'mydb',
+          structure_only: false
+        }
+      end
+      it { should_not include('--schema-only') }
+    end
+
+    it { should include('--no-privileges') }
+    it { should include('--no-owner') }
+
+    context 'file: is "/path/to/file name.sql"' do
+      let(:options) do
+        {
+          database: 'mydb',
+          file: '/path/to/file name.sql'
+        }
+      end
+      it { should include('/path/to/file\ name.sql') }
+    end
+
+    context "schemas: 'public'" do
+      let(:options) do
+        {
+          database: 'mydb',
+          schemas: %q(public)
+        }
+      end
+      it { should include('--schema=public') }
+    end
+
+    context "schemas: '$user','public'" do
+      let(:options) do
+        {
+          database: 'mydb',
+          schemas: %q($user,public)
+        }
+      end
+      it { should include('--schema=\$user --schema=public') }
+    end
+
+    it { should match(/mydb$/)}
+
+    context 'no database is given' do
+      let(:options) { {} }
+      it 'should fail' do
+        expect{subject}.to raise_error(ArgumentError, 'database must be supplied')
+      end
+    end
+
+    it 'should build a valid full executable command' do
+      expect(subject).
+        to eq("pg_dump --schema-only --no-privileges --no-owner --file=myfile.sql --schema=public mydb")
+    end
+  end
+
+end

data/spec/storey/builds_load_command_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Storey::BuildsLoadCommand do
+
+  describe '.execute' do
+    let(:options) do
+      {
+        file: '/path/file dump.sql',
+        database: 'mydb',
+        username: 'myuser',
+        host: 'localhost',
+        port: '5467',
+        password: '12345'
+      }
+    end
+
+    subject { described_class.execute(options) }
+
+    it { should include('--file=/path/file\ dump.sql') }
+    it { should include('--dbname=mydb') }
+    it { should include('--username=myuser') }
+    it { should include('--host=localhost') }
+    it { should include('--password=12345')}
+
+    context 'when host is not set' do
+      before { options[:host] = nil }
+      it { should_not include('--host=') }
+    end
+
+    context 'when username is not set' do
+      before { options[:username] = nil }
+      it { should_not include('--username') }
+    end
+
+    context 'when no password is given' do
+      before { options[:password] = nil }
+      it { should_not include('--password') }
+      it { should include('--no-password') }
+    end
+
+    context 'when no file is given' do
+      before { options[:file] = nil }
+      it { should_not include('--file=')}
+    end
+
+    context 'command is given' do
+      before { options[:command] = "EXECUTE THIS!" }
+      it { should include('--command="EXECUTE THIS!"')}
+    end
+
+    it 'should generate a valid command' do
+      expect(subject).to eq('psql --file=/path/file\ dump.sql --dbname=mydb --username=myuser --host=localhost --port=5467 --password=12345')
+    end
+  end
+
+end

data/spec/storey/create_spec.rb

@@ -1,6 +1,32 @@
 require 'spec_helper'
 
 describe Storey, "#create" do
+
+  context 'given an invalid schema' do
+    it 'should fail' do
+      expect { Storey.create('a a') }.to raise_error(Storey::SchemaInvalid)
+    end
+  end
+
+  context 'given a reserved schema' do
+    context 'force is true' do
+      it 'should create the schema' do
+        reserved_schema = Storey::SchemaName::RESERVED_SCHEMAS.sample
+        expect { Storey.create(reserved_schema, force: true) }.
+          to_not raise_error
+        expect(Storey.schemas).to include(reserved_schema)
+      end
+    end
+
+    context 'force is not true' do
+      it 'should fail' do
+        reserved_schema = Storey::SchemaName::RESERVED_SCHEMAS.sample
+        expect { Storey.create(reserved_schema) }.
+          to raise_error(Storey::SchemaReserved)
+      end
+    end
+  end
+
   it "should load the database structure into the new schema" do
     public_tables = Storey.switch { ::ActiveRecord::Base.connection.tables }.sort
     Storey.create "foobar" do
@@ -44,7 +70,7 @@ describe Storey, "#create" do
 
   context "when a blank string is passed" do
     it "should raise an argument error about an invalid schema name" do
-      expect {Storey.create ""}.to raise_error(ArgumentError, "Must pass in a valid schema name")
+      expect {Storey.create ""}.to raise_error
     end
   end
 
@@ -97,19 +123,4 @@ describe Storey, "#create" do
     end
   end
 
-  context 'when creating a reserved schema' do
-    it 'should fail' do
-      expect {Storey.create('hstore')}.to raise_error(ArgumentError, "'hstore' is a reserved schema name")
-    end
-
-    context 'when force: true is passed in' do
-      it 'should create the schema' do
-        expect {
-          Storey.create 'hstore', force: true
-        }.to_not raise_error(ArgumentError)
-        Storey.schemas.should include('hstore')
-      end
-    end
-  end
-
 end

data/spec/storey/duplicator_spec.rb

@@ -14,6 +14,18 @@ describe Storey::Duplicator do
         )
       end
     end
+
+    it 'should remove the target and source sql files after work' do
+      Storey.create 'boo'
+      duplicator = described_class.new('boo', 'ya')
+      duplicator.perform!
+      source_dump_dir =
+        File.join(Rails.root, 'tmp', 'schema_dumps', 'source', '*.*')
+      target_dump_dir =
+        File.join(Rails.root, 'tmp', 'schema_dumps', 'target', '*.*')
+      expect(Dir[source_dump_dir]).to be_empty
+      expect(Dir[target_dump_dir]).to be_empty
+    end
   end
 
 end

data/spec/storey/schema_name_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe Storey::SchemaName do
+
+  it 'should behave just like a string' do
+    expect(described_class.new('hi')).to eq('hi')
+  end
+
+  describe '#valid?' do
+    subject { described_class.new(schema_name) }
+
+    context 'when the name starts with `pg_`' do
+      let(:schema_name) { 'pg_shouldbereserved' }
+      it { should_not be_valid }
+    end
+
+    context 'when the name starts with a number' do
+      let(:schema_name) { '8isthemagicnumber' }
+      it { should_not be_valid }
+    end
+
+    context 'when the name has a space' do
+      let(:schema_name) { 'almost valid' }
+      it { should_not be_valid }
+    end
+
+    context 'when the name is valid' do
+      let(:schema_name) { 'a_5' }
+      it { should be_valid }
+    end
+
+    context 'when the name is valid with $ and "' do
+      let(:schema_name) { '"$user"' }
+      it { should be_valid }
+    end
+
+    context 'when the string is blank' do
+      let(:schema_name) { '' }
+      it { should_not be_valid }
+    end
+
+    context 'when the string is nil' do
+      let(:schema_name) { nil }
+      it { should_not be_valid }
+    end
+  end
+
+  describe '#reserved?' do
+    subject { described_class.new(schema_name) }
+
+    context 'when the schema name is reserved' do
+      let(:schema_name) { described_class::RESERVED_SCHEMAS.sample }
+      it { should be_reserved }
+    end
+
+    context 'when the schema name is not reserved' do
+      let(:schema_name) { 'available' }
+      it { should_not be_reserved }
+    end
+  end
+
+  describe '#validate_format!' do
+    subject { described_class.validate_format!(schema_name) }
+
+    context 'an invalid name is given' do
+      let(:schema_name) { 'a a' }
+      it 'should fail' do
+        expect { subject }.
+          to raise_error(Storey::SchemaInvalid, '`a a` is not a valid schema name')
+      end
+    end
+
+    context 'a valid name is given' do
+      let(:schema_name) { 'a_5' }
+      it 'should initialize without exceptions' do
+        expect { subject }.to_not raise_error
+      end
+    end
+  end
+
+  describe '#validate_reserved!' do
+    context 'when the name is a reserved schema name' do
+      let(:schema_name) { described_class::RESERVED_SCHEMAS.sample }
+
+      it 'should fail with reserved schema argument error' do
+        expect { described_class.validate_reserved!(schema_name) }.
+          to raise_error(Storey::SchemaReserved, "`#{schema_name}` is a reserved schema name")
+      end
+    end
+  end
+
+end

data/spec/storey/utils_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Storey::Utils do
+
+  describe '.command_line_switches_from(hash)' do
+    it 'should build command line switches from the hash' do
+      hash = {some: 'key',
+              pretty: 'cool'}
+      expect(described_class.command_line_switches_from(hash)).
+        to eq("--some=key --pretty=cool")
+    end
+  end
+
+  describe '.db_command_line_switches_from(db_config)' do
+    subject do
+      described_class.db_command_line_switches_from(db_config, extra_config)
+    end
+
+    context 'db_config does not have :host' do
+      let(:db_config) { {} }
+      it { should_not include('--host=') }
+    end
+
+    context 'db_config has :host' do
+      let(:db_config) { {host: 'localhost'} }
+      it { should include('--host=localhost') }
+    end
+
+    let(:db_config) do
+      {
+        database: 'mydb',
+        username: 'uname'
+      }
+    end
+
+    let(:extra_config) do
+      {
+        extra: 'config',
+        'without-arg' => nil
+      }
+    end
+
+    it 'should set the database' do
+      expect(subject).to include('--dbname=mydb')
+    end
+
+    it 'should set the username' do
+      expect(subject).to include('--username=uname')
+    end
+
+    it 'should include extra config' do
+      expect(subject).to include('--extra=config')
+    end
+
+    it 'should set flag arguments' do
+      expect(subject).to match(/--without-arg$/)
+    end
+  end
+
+end

data/storey.gemspec

@@ -23,6 +23,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency "pg", "~> 0.12.2"
   s.add_development_dependency "database_cleaner"
   s.add_development_dependency "pry"
-  s.add_runtime_dependency 'easy_class_to_instance_method', '~> 0.0.1'
+  s.add_runtime_dependency 'easy_class_to_instance_method', '~> 0.0.2'
   s.add_runtime_dependency "rails", "~> 3.2.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: storey
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Ramon Tayag
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-12 00:00:00.000000000 Z
+date: 2013-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec-rails
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.0.1
+        version: 0.0.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.0.1
+        version: 0.0.2
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -109,6 +109,8 @@ files:
 - README.md
 - Rakefile
 - lib/storey.rb
+- lib/storey/builds_dump_command.rb
+- lib/storey/builds_load_command.rb
 - lib/storey/dumper.rb
 - lib/storey/duplicator.rb
 - lib/storey/exceptions.rb
@@ -118,9 +120,11 @@ files:
 - lib/storey/railtie.rb
 - lib/storey/resets_column_info.rb
 - lib/storey/ruby_dumper.rb
+- lib/storey/schema_name.rb
 - lib/storey/sql_dumper.rb
 - lib/storey/suffixifier.rb
 - lib/storey/unsuffixifier.rb
+- lib/storey/utils.rb
 - lib/storey/version.rb
 - lib/tasks/storey.rake
 - rvmrc.sample
@@ -166,7 +170,8 @@ files:
 - spec/fixtures/.gitkeep
 - spec/migrator_spec.rb
 - spec/spec_helper.rb
-- spec/storey/command_line_switches_spec.rb
+- spec/storey/builds_dump_command_spec.rb
+- spec/storey/builds_load_command_spec.rb
 - spec/storey/configuration_spec.rb
 - spec/storey/create_plain_schema_spec.rb
 - spec/storey/create_spec.rb
@@ -182,6 +187,7 @@ files:
 - spec/storey/persistent_schemas_spec.rb
 - spec/storey/ruby_dumper_spec.rb
 - spec/storey/schema_exists_spec.rb
+- spec/storey/schema_name_spec.rb
 - spec/storey/schema_search_path_for_spec.rb
 - spec/storey/schema_spec.rb
 - spec/storey/schemas_spec.rb
@@ -189,6 +195,7 @@ files:
 - spec/storey/suffixifier_spec.rb
 - spec/storey/switch_spec.rb
 - spec/storey/unsuffixifier_spec.rb
+- spec/storey/utils_spec.rb
 - spec/tasks/storey_rake_spec.rb
 - storey.gemspec
 homepage: https://github.com/ramontayag/storey
@@ -257,7 +264,8 @@ test_files:
 - spec/fixtures/.gitkeep
 - spec/migrator_spec.rb
 - spec/spec_helper.rb
-- spec/storey/command_line_switches_spec.rb
+- spec/storey/builds_dump_command_spec.rb
+- spec/storey/builds_load_command_spec.rb
 - spec/storey/configuration_spec.rb
 - spec/storey/create_plain_schema_spec.rb
 - spec/storey/create_spec.rb
@@ -273,6 +281,7 @@ test_files:
 - spec/storey/persistent_schemas_spec.rb
 - spec/storey/ruby_dumper_spec.rb
 - spec/storey/schema_exists_spec.rb
+- spec/storey/schema_name_spec.rb
 - spec/storey/schema_search_path_for_spec.rb
 - spec/storey/schema_spec.rb
 - spec/storey/schemas_spec.rb
@@ -280,4 +289,5 @@ test_files:
 - spec/storey/suffixifier_spec.rb
 - spec/storey/switch_spec.rb
 - spec/storey/unsuffixifier_spec.rb
+- spec/storey/utils_spec.rb
 - spec/tasks/storey_rake_spec.rb

data/spec/storey/command_line_switches_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe Storey, '.command_line_switches' do
-  it 'should build default command line switches for calling the psql command' do
-    described_class.stub(:database_config).and_return(:host => 'hoop',
-                                                      :database => 'db',
-                                                      :username => 'jj')
-    described_class.command_line_switches.
-      should == "--host=hoop --dbname=db --username=jj"
-  end
-
-  context 'given options' do
-    it 'should add the options to the switches, overriding any default' do
-      described_class.stub(:database_config).and_return(:host => 'hoop',
-                                                        :database => 'db',
-                                                        :username => 'jj')
-
-      described_class.command_line_switches(:a => 'boo', :host => 'loop').
-        should == "--host=loop --dbname=db --username=jj --a=boo"
-    end
-  end
-end