mince_migrator 0.0.1 → 1.0.0

data/lib/mince_migrator/migrations/loader.rb

@@ -0,0 +1,52 @@
+module MinceMigrator
+  module Migrations
+    class Loader
+      def initialize(options)
+        @klass_name = options[:klass_name]
+        @full_path = options[:full_path]
+      end
+
+      def klass
+        eval "::MinceMigrator::Migrations::#{@klass_name}"
+      end
+
+      def call
+        if valid?
+          require @full_path
+          perform_post_load_validations
+        end
+      end
+
+      def valid?
+        file_exists?
+      end
+
+      private
+
+      def perform_post_load_validations
+        mince_migration? && has_valid_interface?
+      end
+
+      def mince_migration?
+        klass # Check that constant is valid and loaded
+      rescue NameError
+        raise 'invalid migration'
+      end
+
+      def has_valid_interface?
+        if !has_all_interfaces?
+          raise "migration does not have all required methods (:run, :revert, and :time_created)"
+        end
+      end
+
+      def has_all_interfaces?
+        %w(run revert time_created).all?{|a| klass.respond_to?(a) }
+      end
+
+      def file_exists?
+        raise 'migration does not exist' unless ::File.exists?(@full_path)
+        true
+      end
+    end
+  end
+end

data/lib/mince_migrator/migrations/name.rb

@@ -0,0 +1,48 @@
+module MinceMigrator
+  module Migrations
+    class Name
+      attr_reader :value
+
+      def initialize(value)
+        self.value = value if value
+        @errors = []
+      end
+
+      def filename
+        @filename ||= "#{value.downcase.gsub(" ", "_")}.rb"
+      end
+
+      def value=(val)
+        normalized_string = normalized_string(val)
+        @value = capitalized_phrase(normalized_string)
+      end
+
+      def capitalized_phrase(val)
+        val.split(' ').each_with_index.map do |word, i|
+          i == 0 ? word.capitalize : word.downcase
+        end.join(" ")
+      end
+
+      def normalized_string(val)
+        val = val.gsub(/[-_]/, ' ') # convert dashes and underscores to spaces
+        pattern = /(^[0-9]|[^a-zA-Z0-9\s])/ # only allow letters and numbers, but do not allow numbers at the beginning
+        val.gsub(pattern, '')
+      end
+
+      def valid?
+        @errors = []
+        validate_value
+        @errors.empty?
+      end
+
+      def reasons_for_failure
+        @errors.join(" ")
+      end
+
+      def validate_value
+        @errors << "Name is invalid, it must start with a character from A-Z or a-z" if value.nil? || value == ''
+      end
+    end
+  end
+end
+

data/lib/mince_migrator/migrations/runner.rb

@@ -0,0 +1,39 @@
+module MinceMigrator
+  module Migrations
+    require_relative '../migration'
+    require_relative 'runner_validator'
+    require 'mince/config'
+
+    class Runner
+      attr_reader :name, :validator
+
+      def initialize(options)
+        if options[:migration]
+          @migration = options[:migration]
+          @name = migration.name
+        elsif options[:name]
+          @name = options[:name]
+        end
+        @validator = RunnerValidator.new(migration)
+      end
+
+      def can_run_migration?
+        validator.call
+      end
+
+      def run_migration
+        migration.run
+        RanMigration.create(name: migration.name)
+        true
+      end
+
+      def reasons_for_failure
+        validator.errors.join(" ")
+      end
+
+      def migration
+        @migration ||= Migration.find(name)
+      end
+    end
+  end
+end

data/lib/mince_migrator/migrations/runner_validator.rb

@@ -0,0 +1,47 @@
+module MinceMigrator
+  module Migrations
+    require_relative '../migration'
+    require_relative 'runner_validator'
+    require 'mince/config'
+
+    class RunnerValidator
+      attr_reader :migration, :errors
+
+      def initialize(migration)
+        @migration = migration
+      end
+
+      def call
+        @errors = []
+        run_validations
+        errors.empty?
+      end
+
+      def run_validations
+        validate_mince_interface
+        validate_migration_exists
+        validate_migration_not_ran
+      end
+
+      def validate_migration_not_ran
+        @errors << "Migration has already ran" if interface_is_set? && migration_exists? && migration.ran?
+      end
+
+      def validate_migration_exists
+        @errors << "Migration does not exist" if interface_is_set? && !migration_exists?
+      end
+
+      def migration_exists?
+        !!migration
+      end
+
+      def validate_mince_interface
+        @errors << "Mince interface is not set" unless interface_is_set?
+      end
+
+      def interface_is_set?
+        !!Mince::Config.interface
+      end
+    end
+  end
+end

data/lib/mince_migrator/migrations/template.mustache

@@ -0,0 +1,24 @@
+module MinceMigrator
+  module Migrations
+    require 'time'
+
+    module {{klass_name}}
+      def self.run
+        # Actual migration goes here
+      end
+
+      def self.revert
+        # In case you need to revert this one migration
+      end
+
+      # So you can change the order to run more easily
+      def self.time_created
+        Time.parse "{{time_created}}"
+      end
+
+      module Temporary
+        # Migration dependent classes go here
+      end
+    end
+  end
+end

data/lib/mince_migrator/migrations/template.rb

@@ -0,0 +1,16 @@
+module MinceMigrator
+  module Migrations
+    require 'mustache'
+
+    class Template < Mustache
+      self.template_file = File.expand_path('../template.mustache', __FILE__)
+
+      attr_reader :klass_name, :time_created
+
+      def initialize(klass_name)
+        @klass_name = klass_name
+        @time_created = Time.now.utc.to_s
+      end
+    end
+  end
+end

data/lib/mince_migrator/migrations/versioned_file.rb

@@ -0,0 +1,38 @@
+module MinceMigrator
+  module Migrations
+    require_relative 'file'
+
+    class VersionedFile
+      attr_reader :version
+
+      def initialize(name, version = 1)
+        @version = version
+        @name = name
+      end
+
+      def name
+        version > 1 ? "#{@name}_#{version}" : @name
+      end
+
+      def file
+        @file ||= File.new(name)
+      end
+
+      def next_unused_version
+        if file.persisted?
+          bump
+          next_unused_version
+        else
+          file
+        end
+      end
+
+      private
+
+      def bump
+        @version += 1
+        @file = File.new(name)
+      end
+    end
+  end
+end

data/lib/mince_migrator/ran_migration.rb

@@ -0,0 +1,27 @@
+module MinceMigrator
+  require 'mince/model'
+  require 'mince/data_model'
+
+  class RanMigrationDataModel
+    include Mince::DataModel
+
+    data_collection :migrations
+    data_fields :name
+  end
+
+  class RanMigration
+    include Mince::Model
+
+    data_model RanMigrationDataModel
+    field :name
+
+    def self.find_by_name(name)
+      data = data_model.find_by_field(:name, name)
+      new data if data
+    end
+
+    def delete
+      data_model.delete_by_params(name: name)
+    end
+  end
+end

data/lib/mince_migrator/reverter.rb

@@ -0,0 +1,57 @@
+module MinceMigrator
+  require_relative 'migrations/name'
+  require_relative 'migration'
+  require_relative 'config'
+
+  class Reverter
+    attr_reader :name, :migration_name
+
+    def initialize(options)
+      if options[:migration]
+        @migration = options[:migration]
+        @migration_name = Migrations::Name.new migration.name
+      elsif options[:name]
+        @migration_name = Migrations::Name.new options[:name]
+      end
+      @name = migration_name.value
+      @errors = []
+    end
+
+    def can_revert_migration?
+      @errors = []
+      validate_migration
+      validate_ran_migration
+      @errors.empty?
+    end
+
+    def validate_ran_migration
+      @errors << "Migration has not ran" if migration_not_ran?
+    end
+
+    def validate_migration
+      @errors << "Migration does not exist with name '#{name}'" if migration.nil?
+    end
+
+    def revert_migration
+      migration.revert
+      ran_migration.delete
+      true
+    end
+
+    def reasons_for_failure
+      @errors.join ", "
+    end
+
+    def migration
+      @migration ||= Migration.find(name)
+    end
+
+    def migration_not_ran?
+      migration && !migration.ran?
+    end
+
+    def ran_migration
+      migration.ran_migration if migration
+    end
+  end
+end

data/lib/mince_migrator/status_report.rb

@@ -0,0 +1,41 @@
+module MinceMigrator
+  require 'command_line_reporter'
+  
+  class StatusReport
+    include CommandLineReporter
+
+    attr_reader :migration
+
+    def initialize(migration)
+      @migration = migration
+    end
+
+    def run
+      vertical_spacing 2
+      header title: "Migration Details for #{migration.name}", bold: true, rule: true, align: 'center', width: 70, timestamp: true
+
+      table border: false do
+        row do
+          column 'Name', width: 15
+          column migration.name, width: 30
+        end
+        row do
+          column 'Status'
+          if migration.status == 'not ran'
+            column migration.status, color: 'red'
+          else
+            column migration.status, color: 'green'
+          end
+        end
+        row do
+          column 'Age'
+          column migration.age
+        end
+        row do
+          column 'Date Created'
+          column migration.time_created.strftime("%m/%d/%Y")
+        end
+      end
+    end
+  end
+end

data/lib/mince_migrator/version.rb

@@ -1,3 +1,20 @@
 module MinceMigrator
-  VERSION = "0.0.1"
+  module Version
+    def self.major
+      1
+    end
+
+    def self.minor
+      0
+    end
+
+    def self.patch
+      0
+    end
+  end
+
+  def self.version
+    [Version.major, Version.minor, Version.patch].join('.')
+  end
 end
+

data/lib/mince_migrator.rb

@@ -1,5 +1,6 @@
 require "mince_migrator/version"
-
-module MinceMigrator
-  # Your code goes here...
-end
+require "mince_migrator/reverter"
+require "mince_migrator/creator"
+require "mince_migrator/deleter"
+require "mince_migrator/list"
+require "mince_migrator/migrations/runner"

data/spec/integration/create_a_migration_spec.rb

@@ -0,0 +1,57 @@
+require_relative '../integration_helper'
+
+describe "The creation of a migration:" do
+  subject { MinceMigrator::Creator.new name }
+
+  context "when a name is not provided" do
+    let(:name) { nil }
+
+    it "returns reasons why a migration could not be created" do
+      subject.can_create_migration?.should be_false
+    end
+  end
+
+  describe "Creating a mince migration with a name" do
+    let(:name) { "Create seeded admin users" }
+
+    it "can create the migration" do
+      subject.can_create_migration?.should be_true
+    end
+
+    it "creates the migration file" do
+      subject.create_migration
+
+      relative_path = Dir.pwd
+      expected_migration_file_destination = ::File.join(MinceMigrator::Config.migration_dir, "create_seeded_admin_users.rb")
+      ::File.open(expected_migration_file_destination, 'r') do |f|
+        expected_content = <<-eos
+module MinceMigrator
+  module Migrations
+    require 'time'
+
+    module CreateSeededAdminUsers
+      def self.run
+        # Actual migration goes here
+      end
+
+      def self.revert
+        # In case you need to revert this one migration
+      end
+
+      # So you can change the order to run more easily
+      def self.time_created
+        Time.parse "#{Time.now.utc.to_s}"
+      end
+
+      module Temporary
+        # Migration dependent classes go here
+      end
+    end
+  end
+end
+eos
+        f.read.should == expected_content
+      end
+    end
+  end
+end

data/spec/integration/deleting_a_migration_spec.rb

@@ -0,0 +1,40 @@
+require_relative '../integration_helper'
+
+describe 'Deleting a migration' do
+  subject { MinceMigrator::Deleter.new(name: name) }
+
+  let(:name) { 'name of migration' }
+  let(:expected_name) { 'Name of migration' }
+
+  context 'when the migration exists' do
+    before do
+      MinceMigrator::Creator.create(name)
+    end
+
+    its(:can_delete_migration?) { should be_true }
+
+    it 'deletes it from the file system' do
+      expected_migration_destination = ::File.join(MinceMigrator::Config.migration_dir, 'name_of_migration.rb')
+      subject.delete_migration
+
+      ::File.exists?(expected_migration_destination).should be_false
+    end
+
+    context 'when the migration has ran' do
+      before do
+        MinceMigrator::Migrations::Runner.new(name: name).run_migration
+      end
+
+      it 'deletes it from the database' do
+        subject.delete_migration
+
+        MinceMigrator::RanMigration.all.should be_empty
+      end
+    end
+  end
+
+  context 'when the migration does not exist' do
+    its(:can_delete_migration?) { should be_false }
+    its(:reasons_for_failure) { should == "Migration does not exist with name '#{expected_name}'" }
+  end
+end

data/spec/integration/list_all_migrations_spec.rb

@@ -0,0 +1,57 @@
+require_relative '../integration_helper'
+
+describe 'List of migrations' do
+  subject { MinceMigrator::List.new }
+
+  context 'when there are not any migrations' do
+    its(:number_of_migrations) { should == 0 }
+
+    it 'is empty' do
+      subject.all.should be_empty
+    end
+  end
+
+  context 'when there is one migration' do
+    let(:migration_name) { "first migration" }
+
+    before do
+      MinceMigrator::Creator.create(migration_name)
+    end
+
+    its(:number_of_migrations) { should == 1 }
+
+    it 'contains a record of the migration' do
+      subject.all.size.should == 1
+      subject.all.first.name.should == "First migration"
+      subject.all.first.status.should == 'not ran'
+      subject.all.first.relative_path.should == File.join(MinceMigrator::Config.migration_relative_dir, 'first_migration.rb')
+      subject.all.first.path.should == File.join(MinceMigrator::Config.migration_dir, 'first_migration.rb')
+    end
+  end
+
+  context 'when there are some migrations' do
+    let(:migration_1_name) { "first migration" }
+    let(:migration_2_name) { "a second migration" }
+    let(:migration_1) { MinceMigrator::Migration.find(migration_1_name) }
+    let(:migration_2) { MinceMigrator::Migration.find(migration_2_name) }
+
+    before do
+      MinceMigrator::Creator.create(migration_1_name)
+      MinceMigrator::Creator.create(migration_2_name)
+    end
+
+    its(:number_of_migrations) { should == 2 }
+
+    it 'contains a record of those migrations' do
+      expected_migrations = [migration_2, migration_1]
+      subject.all.size.should == expected_migrations.size
+      subject.all.each_with_index do |migration, index|
+        expected_migration = expected_migrations.find{|a| a.name == migration.name }
+        migration.name.should == expected_migration.name
+        migration.status.should == 'not ran'
+        migration.relative_path.should == migration.relative_path
+        migration.path.should == migration.path
+      end
+    end
+  end
+end

data/spec/integration/reverting_a_migration_spec.rb

@@ -0,0 +1,59 @@
+require_relative '../integration_helper'
+
+describe 'Reverting a migration' do
+  subject { MinceMigrator::Reverter.new(name: name) }
+
+  let(:name) { 'name of migration' }
+  let(:expected_name) { 'Name of migration' }
+
+  context 'when the migration exists' do
+    let(:name) { "test migration" }
+    let(:spec_migration) { File.expand_path('../../support/test_migration.rb', __FILE__) }
+    let(:db_dir) { MinceMigrator::Config.migration_dir }
+    let(:data_model) { MinceMigrator::Migrations::TestMigration::Temporary::UserDataModel }
+
+    before do
+      FileUtils.mkdir_p(db_dir)
+      FileUtils.cp(spec_migration, db_dir)
+    end
+
+    context 'and the migration has not yet been ran' do
+      before do
+        subject.can_revert_migration?
+      end
+
+      its(:reasons_for_failure) { should == "Migration has not ran" }
+      its(:can_revert_migration?) { should be_false }
+    end
+
+    context 'when the migration has ran' do
+      before do
+        MinceMigrator::Migrations::Runner.new(name: name).run_migration
+      end
+
+      its(:can_revert_migration?) { should be_true }
+      its(:reasons_for_failure) { should be_empty }
+
+      it 'reverts the migration' do
+        subject.revert_migration
+
+        data_model.all.size.should == 0
+      end
+
+      it 'reverts it from the database' do
+        subject.revert_migration
+
+        MinceMigrator::RanMigration.all.should be_empty
+      end
+    end
+  end
+
+  context 'when the migration does not exist' do
+    before do
+      subject.can_revert_migration?
+    end
+
+    its(:can_revert_migration?) { should be_false }
+    its(:reasons_for_failure) { should == "Migration does not exist with name '#{expected_name}'" }
+  end
+end