phil_columns 0.1.0

data/lib/phil_columns/command/mulligan.rb

@@ -0,0 +1,22 @@
+require 'pathname'
+
+module PhilColumns
+  module Command
+    class Mulligan < Base
+
+      def execute
+        load_environment
+
+        say( "- DRY RUN -", :yellow ) if dry_run?
+
+        unless dry_run?
+          migrator.mulligan
+          archivist.clear_seeds
+        end
+
+        seeder.execute
+      end
+
+    end
+  end
+end

data/lib/phil_columns/command/seed.rb

@@ -0,0 +1,44 @@
+require 'pathname'
+
+module PhilColumns
+  module Command
+    class Seed < Base
+
+      def execute
+        load_environment
+
+        say( "- DRY RUN -", :yellow ) if config.dry_run
+        say "Seeding #{method_name} to version #{config.version}", :green
+
+        seeds.each do |seed_meta|
+          say ''
+          say "* Executing seed: #{seed_meta.filepath}", :cyan
+
+          instance = seed_meta.klass.new( config )
+          instance.send( method_name )
+          record_seed( seed_meta )
+        end
+      end
+
+    protected
+
+      def record_seed( seed_meta )
+        if method_name == :up
+          archivist.record_seed( seed_meta.timestamp )
+        else
+          archivist.remove_seed( seed_meta.timestamp )
+        end
+      end
+
+      def method_name
+        return :down if down?
+        :up
+      end
+
+      def down?
+        config.down
+      end
+
+    end
+  end
+end

data/lib/phil_columns/configuration.rb

@@ -0,0 +1,88 @@
+require 'hashie'
+require 'pathname'
+require 'yaml'
+
+module PhilColumns
+  class Configuration < SimpleDelegator
+
+    TAG_REGEX = /^~@?(\w+)$/
+
+    def initialize( options={} )
+      @_config = Hashie::Mash.new( read_config_file ).
+                              merge( options )
+
+      super( _config )
+    end
+
+    def tags
+      (_config[:tags].nil? || _config[:tags].empty?) ?
+        _config.default_tags :
+        _config.tags
+    end
+
+    def partitioned_tags
+      @partitioned_tags ||= tags.partition { |tag| TAG_REGEX.match( tag ) }
+    end
+
+    def exclusion_tags
+      partitioned_tags.first.
+                       map { |tag| TAG_REGEX.match( tag )[1] }
+    end
+
+    def inclusion_tags
+      partitioned_tags.last
+    end
+
+    def config_filepath
+      Pathname.new( '.phil_columns' )
+    end
+
+    # Not sure why we need these explicit proxies
+    def down;      _config.down;      end
+    def dry_run;   _config.dry_run;   end
+    def operation; _config.operation; end
+
+    def version
+      if _config.down &&
+          _config.version == 'all'
+        '0'
+      else
+        _config.version
+      end
+    end
+
+    def slice( *keys )
+      Hashie::Mash.new( _config.select { |k,v| keys.map( &:to_s ).include?( k.to_s ) } )
+    end
+
+    def save_to_file
+      File.open( config_filepath, 'w' ) do |f|
+        f.write( YAML::dump( config_as_hash ))
+      end
+    end
+
+  protected
+
+    attr_reader :_config
+
+    def read_config_file
+      return {} unless config_filepath.file?
+      YAML::load_file( config_filepath.expand_path )
+    end
+
+    def config_as_hash
+      slice( *keys_to_persist ).to_h
+    end
+
+    def keys_to_persist
+      %w(
+        default_tags
+        env_files
+        schema_load_strategy
+        schema_unload_strategy
+        seeds_path
+      )
+    end
+
+  end
+end

data/lib/phil_columns/error.rb

@@ -0,0 +1,5 @@
+module PhilColumns
+  class Error < StandardError
+
+  end
+end

data/lib/phil_columns/filter.rb

@@ -0,0 +1,66 @@
+module PhilColumns
+  class Filter
+
+    include SeedUtils
+
+    def initialize( config )
+      @config      = config
+      @seeds_path  = config.seeds_path
+      @tags        = config.tags
+    end
+
+    def seeds
+      load_seeds
+      calculate_seed_set
+    end
+
+    def calculate_seed_set_all
+    end
+
+    def calculate_seed_set_any
+      if any_exclusion_tags?
+        raise PhilColumns::Error,
+              "Cannot provide exclusion tags (#{config.exclusion_tags.join( ', ' )}) when operation is any"
+      end
+
+      seeds_for_current_env.tap do |seeds|
+        unless tags.empty?
+          seeds.select! { |seed_meta| (seed_meta.tags & tags).size > 0 }
+        end
+      end
+    end
+
+  protected
+
+    attr_reader :config,
+                :seeds_path,
+                :tags
+
+    def calculate_seed_set
+      send( "calculate_seed_set_#{config.operation}" ).tap do |seeds|
+        unless config.version.blank?
+          if config.down
+            seeds.select! { |seed_meta| seed_meta.timestamp > config.version }
+          else
+            seeds.select! { |seed_meta| seed_meta.timestamp <= config.version }
+            seeds.reject! { |seed_meta| seed_already_executed?( seed_meta.timestamp ) }
+          end
+        end
+
+      end
+    end
+
+    def seed_already_executed?( version )
+      archivist.seed_already_executed?( version )
+    end
+
+    def archivist
+      @archivist ||= PhilColumns::Archivist.new
+    end
+
+    def any_exclusion_tags?
+      config.exclusion_tags.size > 0
+    end
+
+  end
+end

data/lib/phil_columns/migrator.rb

@@ -0,0 +1,80 @@
+module PhilColumns
+  class Migrator
+
+    include PhilColumns::Output
+    include PhilColumns::WithBackend
+
+    def initialize( config )
+      @backend = PhilColumns::migrator_klass.new
+      @config  = config
+    end
+
+    def clear_migrations_table
+      raise( *error ) unless backend_responds?( :clear_migrations_table )
+      backend.send :clear_migrations_table
+    end
+
+    def down( version=0 )
+      raise( *error ) unless backend_responds?( :down )
+      backend.send :down, version
+    end
+
+    def drop_table( table )
+      raise( *error ) unless backend_responds?( :drop_table )
+      backend.send :drop_table, table
+    end
+
+    def drop_tables
+      raise( *error ) unless backend_responds?( :drop_tables )
+      backend.send :drop_tables
+    end
+
+    def latest_version
+      raise( *error ) unless backend_responds?( :latest_version )
+      backend.send :latest_version
+    end
+
+    def load_schema
+      raise( *error ) unless backend_responds?( :load_schema )
+      backend.send :load_schema
+    end
+
+    def mulligan
+      if config.schema_unload_strategy == 'drop'
+        confirm "Dropping all tables ... ", :cyan do
+          drop_tables
+          clear_migrations_table
+        end
+      else
+        confirm "Migrating DB to version 0 ... ", :cyan do
+          down
+        end
+      end
+
+      if config.schema_load_strategy == 'load'
+        confirm "Loading schema ... ", :cyan do
+          load_schema
+        end
+      else
+        confirm "Migrating DB to latest version ... ", :cyan do
+          up
+        end
+      end
+    end
+
+    def tables
+      raise( *error ) unless backend_responds?( :tables )
+      backend.send :tables
+    end
+
+    def up( version=nil )
+      raise( *error ) unless backend_responds?( :up )
+      backend.send :up, version
+    end
+
+  protected
+
+    attr_reader :config
+
+  end
+end

data/lib/phil_columns/output.rb

@@ -0,0 +1,29 @@
+module PhilColumns
+  module Output
+
+    def write( msg, color=:white )
+      $stdout.write( Rainbow( msg ).color( color ))
+    end
+
+    def say( msg, color=:white )
+      $stdout.puts( Rainbow( msg ).color( color ))
+    end
+
+    def say_ok
+      say 'OK', :green
+    end
+
+    def say_error
+      say 'ERROR', :red
+    end
+
+    def confirm( msg, color=:white, &block )
+      write msg, color
+      block.call
+      say_ok
+    rescue
+      say_error
+      raise
+    end
+  end
+end

data/lib/phil_columns/railtie.rb

@@ -0,0 +1,18 @@
+require 'phil_columns'
+require 'rails'
+
+module PhilColumns
+  class Railtie < Rails::Railtie
+
+    #initializer 'phil_columns.insert_into_active_record' do |app|
+      #ActiveSupport.on_load :active_record do
+        #ActiveRecord::Base.send :include, Genesis::ActiveRecordExtensions
+      #end
+    #end
+
+    rake_tasks do
+      Dir[File.join(File.dirname(__FILE__),'tasks/*.rake')].each { |f| load f }
+    end
+
+  end
+end

data/lib/phil_columns/seed.rb

@@ -0,0 +1,37 @@
+module PhilColumns
+  class Seed
+
+    def self.envs( *envs )
+      @_envs = envs.sort.map( &:to_s )
+    end
+
+    def self.tags( *tags )
+      @_tags = tags.sort.map( &:to_s )
+    end
+
+    def self._envs
+      @_envs || []
+    end
+
+    def self._tags
+      @_tags || []
+    end
+
+    def initialize( config )
+      @config = config
+    end
+
+  protected
+
+    attr_reader :config
+
+    def dry_run?
+      config.dry_run
+    end
+
+    def protect( &block )
+      block.call unless dry_run?
+    end
+
+  end
+end

data/lib/phil_columns/seed_utils.rb

@@ -0,0 +1,59 @@
+module PhilColumns
+  module SeedUtils
+
+    SEED_REGEX =  /^\w+\/\w+\/(\d{14})_(.+)\.rb$/
+
+    def load_seeds
+      seed_filepaths.each do |seed_filepath|
+        load seed_filepath
+      end
+    end
+
+    def map_seeds
+      seed_filepaths.map do |seed_filepath|
+        klass = discover_seed_class( seed_filepath )
+
+        Hashie::Mash.new( envs: klass._envs,
+                          filepath: seed_filepath,
+                          klass: klass,
+                          tags: klass._tags,
+                          timestamp: discover_seed_timestamp( seed_filepath ))
+      end
+    end
+
+    def seed_filepaths
+      seeds = Dir.glob( "#{seeds_path}/*" )
+      if config.down
+        seeds.sort { |a,b| b <=> a }
+      else
+        seeds.sort
+      end
+    end
+
+    def seeds_for_current_env
+      map_seeds.select { |seed_meta| seed_meta.envs.include?( config.env ) }
+    end
+
+    def each_seed_meta_for_current_env( &block )
+      seeds_for_current_env.each do |seed_meta|
+        block.call( seed_meta )
+      end
+    end
+
+    def seeds_path
+      config.seeds_path
+    end
+
+    def discover_seed_timestamp( filepath )
+      matches = SEED_REGEX.match( filepath )
+      matches[1]
+    end
+
+    def discover_seed_class( filepath )
+      matches = SEED_REGEX.match( filepath )
+      snakecased = matches[2]
+      snakecased.camelize.constantize
+    end
+
+  end
+end