whiteprint 0.1.0

data/lib/whiteprint/has_whiteprint.rb

@@ -0,0 +1,7 @@
+module Whiteprint
+  module HasWhiteprint
+    def has_whiteprint
+      send :include, ::Whiteprint::Model
+    end
+  end
+end

data/lib/whiteprint/migrator.rb

@@ -0,0 +1,66 @@
+module Whiteprint
+  module Migrator
+    class << self
+      def eager_load!
+        return unless Whiteprint.config.eager_load
+
+        Rails.application.eager_load! if defined?(Rails)
+
+        [*Whiteprint.config.eager_load_paths.uniq].each do |path|
+          Gem.find_files(path).each do |file|
+            load file
+          end
+        end
+      end
+
+      def explanations
+        Whiteprint.changed_whiteprints.map.with_index do |whiteprint, index|
+          whiteprint.explanation(index + 1)
+        end
+      end
+
+      def interactive(input: $stdin, output: $stdout, migrate_input: $stdin, migrate_output: $stdout)
+        # TODO: Clean up
+
+        eager_load!
+        cli = HighLine.new input, output
+
+        if number_of_changes == 0
+          cli.say('Whiteprint detected no changes')
+          return
+        end
+
+        cli.say "Whiteprint has detected <%= color('#{number_of_changes}', :bold, :white) %> changes to your models."
+        explanations.each do |explanation|
+          cli.say explanation
+        end
+
+        cli.choose do |menu|
+          menu.header = 'Migrations'
+          menu.prompt = 'How would you like to process these changes?'
+          menu.choice('In one migration')       { migrate_at_once(input: migrate_input, output: migrate_output) }
+          menu.choice('In separate migrations') { cli.say 'Bar' }
+        end
+      end
+
+      def migrate_at_once(input: $stdin, output: $stdout)
+        # TODO: Clean up
+
+        cli = HighLine.new input, output
+        name = cli.ask 'How would you like to name this migration?'
+        Whiteprint.changed_whiteprints
+                 .group_by(&:transformer)
+                 .map do |adapter, whiteprints|
+                   adapter.generate_migration(name, whiteprints.map(&:changes_tree))
+                 end
+
+        ActiveRecord::Migration.verbose = true
+        ActiveRecord::Migrator.migrate(ActiveRecord::Migrator.migrations_paths)
+      end
+
+      def number_of_changes
+        Whiteprint.changed_whiteprints.size
+      end
+    end
+  end
+end

data/lib/whiteprint/model.rb

@@ -0,0 +1,25 @@
+module Whiteprint
+  module Model
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def whiteprint(**options, &block)
+        return @_whiteprint unless block
+
+        @_whiteprint ||= ::Whiteprint.new(self, **options)
+        @_whiteprint.execute(&block)
+      end
+      alias_method :schema, :whiteprint
+
+      def inherited(base)
+        whiteprint.clone_to(base) if whiteprint
+        super
+      end
+    end
+
+    def self.included(model)
+      Whiteprint.models += [model]
+      super
+    end
+  end
+end

data/lib/whiteprint/railtie.rb

@@ -0,0 +1,24 @@
+module Whiteprint
+  class Railtie < Rails::Railtie
+    class << self
+      def whiteprint_config
+        ::Whiteprint.config do |c|
+          c.eager_load        = true
+          c.migration_path    = Rails.root.join(ActiveRecord::Migrator.migrations_path)
+        end
+      end
+    end
+
+    initializer "whiteprint.config_for_rails" do
+      ::Whiteprint.config do |c|
+        c.eager_load        = true
+        c.migration_path    = Rails.root.join(ActiveRecord::Migrator.migrations_path)
+      end
+    end
+
+    rake_tasks do
+      # whiteprint_config
+      load "tasks/whiteprint.rake"
+    end
+  end
+end

data/lib/whiteprint/transform.rb

@@ -0,0 +1,35 @@
+module Whiteprint
+  class Transform < Parslet::Transform
+    class << self
+      def create_rule(name, **expression)
+        define_singleton_method name do |&block|
+          rule(expression, &block)
+        end
+      end
+
+      def table_expression
+        {
+          table_name: simple(:table_name),
+          attributes: subtree(:attributes)
+        }
+      end
+
+      def attribute_expression
+        {
+          name: simple(:name),
+          type: simple(:type),
+          options: subtree(:options)
+        }
+      end
+    end
+
+    create_rule :create_table,             table_exists: false, has_id: true,  **table_expression
+    create_rule :create_table_without_id,  table_exists: false, has_id: false, **table_expression
+    create_rule :change_table,             table_exists: true,                 **table_expression
+
+    create_rule :added_attribute,          kind: :added,   **attribute_expression
+    create_rule :changed_attribute,        kind: :changed, **attribute_expression
+    create_rule :removed_attribute,        kind: :removed, **attribute_expression
+    create_rule :added_timestamps,         kind: :added,   type: :timestamps
+  end
+end

data/lib/whiteprint/version.rb

@@ -0,0 +1,3 @@
+module Whiteprint
+  VERSION = '0.1.0'.freeze
+end

data/test/cases/active_record_test.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+
+class ActiveRecordTest < ActiveSupport::TestCase
+  def setup
+    @persisted_attributes = User.whiteprint.persisted_attributes
+  end
+
+  test 'the active_record adapter can read the persisted attributes from the database' do
+    assert_equal Whiteprint::Attribute.new(name: :name, type: :string, default: 'John').for_persisted,   @persisted_attributes.name
+    assert_equal Whiteprint::Attribute.new(name: :age, type: :integer, default: 0).for_persisted,        @persisted_attributes.age
+    assert_equal Whiteprint::Attribute.new(name: :date_of_birth, type: :date).for_persisted,             @persisted_attributes.date_of_birth
+  end
+end

data/test/cases/attributes_test.rb

@@ -0,0 +1,62 @@
+require 'test_helper'
+
+class AttributesTest < ActiveSupport::TestCase
+  def setup
+    @attribute  = Whiteprint::Attribute.new type: :integer, default: 10
+
+    @attributes = Whiteprint::Attributes.new
+
+    @attributes.add name: 'name',           type: :string,  default: 'John'
+    @attributes.add name: 'age',            type: :integer
+    @attributes.add name: 'height',         type: :integer, default: 180
+    @attributes.add name: 'date_of_birth',  type: :date
+  end
+
+  test 'an attribute can be asked whether it has a certain key or keys' do
+    assert_equal true,  @attribute.has?(:type)
+    assert_equal true,  @attribute.has?(:type, :default)
+    assert_equal false, @attribute.has?(:type, :foo)
+  end
+
+  test 'an attribute can be asked whether it has a certain values' do
+    assert_equal true,  @attribute.has?(type: :integer)
+    assert_equal false, @attribute.has?(type: :string)
+    assert_equal true,  @attribute.has?(type: :integer, default: 10)
+    assert_equal true,  @attribute.has?(:type, default: 10)
+    assert_equal false, @attribute.has?(:type, default: 11)
+  end
+
+  test 'attributes can be queried' do
+    assert_equal @attributes.to_h.slice(:name, :height),        @attributes.where(:default).to_h
+    assert_equal @attributes.to_h.slice(:name),                 @attributes.where(default: 'John').to_h
+    assert_equal @attributes.to_h.slice(:age, :height),         @attributes.where(type: :integer).to_h
+    assert_equal @attributes.to_h.slice(:name, :date_of_birth), @attributes.not(type: :integer).to_h
+    assert_equal @attributes.to_h.slice(:name),                 @attributes.where(:default).not(type: :integer).to_h
+  end
+
+  test 'attributes can be diffed' do
+    diff = @attributes.where(:default).diff(@attributes)
+
+    assert_equal @attributes.to_h.slice(:age, :date_of_birth), diff[:added].to_h
+    assert_equal({},                                           diff[:removed].to_h)
+    assert_equal({},                                           diff[:changed].to_h)
+
+    diff = @attributes.diff(@attributes.where(:default))
+
+    assert_equal({},                                           diff[:added].to_h)
+    assert_equal @attributes.to_h.slice(:age, :date_of_birth), diff[:removed].to_h
+    assert_equal({},                                           diff[:changed].to_h)
+
+    diff_attributes = Whiteprint::Attributes.new
+
+    diff_attributes.add name: 'name',           type: :string,  default: 'Joe'
+    diff_attributes.add name: 'weight',         type: :integer
+    diff_attributes.add name: 'height',         type: :integer, default: 160
+
+    diff = @attributes.diff(diff_attributes)
+
+    assert_equal diff_attributes.to_h.slice(:weight),          diff[:added].to_h
+    assert_equal @attributes.to_h.slice(:age, :date_of_birth), diff[:removed].to_h
+    assert_equal diff_attributes.to_h.slice(:name, :height),   diff[:changed].to_h
+  end
+end

data/test/cases/blueprint_test.rb

@@ -0,0 +1,125 @@
+require 'test_helper'
+
+class WhiteprintTest < ActiveSupport::TestCase
+  def setup
+    @model     = Class.new
+    @whiteprint = ::Whiteprint::Base.new(@model)
+  end
+
+  test 'a whiteprint is tied to a model' do
+    assert_equal @model, @whiteprint.model
+  end
+
+  test 'a whiteprint is initialized with an empty set of attributes' do
+    assert_equal({}, @whiteprint.attributes.to_h)
+  end
+
+  test 'a whiteprint saves attributes with a type and options' do
+    @whiteprint.string  :name, default: 'John'
+    @whiteprint.integer 'age'
+
+    assert_equal({ name: :name, type: :string,  default: 'John' }, @whiteprint.attributes.name.to_h)
+    assert_equal({ name: :age,  type: :integer },                  @whiteprint.attributes.age.to_h)
+  end
+
+  test 'attributes can be accessed like a hash with indifferent access, but they can also be accessed as methods' do
+    @whiteprint.string :name, default: 'John'
+
+    assert_equal :string, @whiteprint.attributes['name'][:type]
+    assert_equal :string, @whiteprint.attributes.name.type
+    assert_equal 'John',  @whiteprint.attributes[:name]['default']
+    assert_equal 'John',  @whiteprint.attributes.name.default
+  end
+end
+
+class WhiteprintModelTest < ActiveSupport::TestCase
+  test 'a model responds to whiteprint (and schema) if Whiteprint::Model is included' do
+    model = Class.new do
+      include Whiteprint::Model
+    end
+    assert_respond_to model, :whiteprint
+    assert_respond_to model, :schema
+  end
+
+  test 'if a model inherits from ActiveRecord::Base has_whiteprint does the same as including Whiteprint::Model' do
+    model = Class.new(ActiveRecord::Base) do
+      has_whiteprint
+    end
+
+    assert model < Whiteprint::Model
+  end
+
+  test 'a model can add attribtues to its whiteprint by passing the whiteprint method a block' do
+    model = Class.new do
+      include Whiteprint::Model
+
+      whiteprint do
+        string  :name, default: 'John'
+        integer :age
+      end
+    end
+
+    assert_instance_of ::Whiteprint::Base, model.whiteprint
+    assert_equal({ name: :name, type: :string,  default: 'John' }, model.whiteprint.attributes.name.to_h)
+    assert_equal({ name: :age,  type: :integer },                  model.whiteprint.attributes.age.to_h)
+  end
+
+  test "attributes can also be added to a model's whiteprint via composition" do
+    concern = Module.new do
+      extend ActiveSupport::Concern
+      include Whiteprint::Model
+
+      included do
+        whiteprint do
+          string  :name, default: 'John'
+        end
+      end
+    end
+
+    model = Class.new do
+      include Whiteprint::Model
+      include concern
+
+      whiteprint do
+        integer :age
+      end
+    end
+
+    assert_equal({ name: :name, type: :string,  default: 'John' }, model.whiteprint.attributes.name.to_h)
+    assert_equal({ name: :age,  type: :integer },                  model.whiteprint.attributes.age.to_h)
+  end
+
+  test 'an adapter can be set by the user or is automatically determined if possible' do
+    model = Class.new do
+      include Whiteprint::Model
+
+      whiteprint(adapter: :active_record) do
+      end
+    end
+
+    assert_instance_of ::Whiteprint::Adapters::ActiveRecord, model.whiteprint
+
+    model = Class.new(ActiveRecord::Base) do
+      include Whiteprint::Model
+
+      whiteprint do
+      end
+    end
+
+    assert_instance_of ::Whiteprint::Adapters::ActiveRecord, model.whiteprint
+
+    model = Class.new(ActiveRecord::Base) do
+      include Whiteprint::Model
+
+      whiteprint(adapter: :base) do
+      end
+    end
+
+    assert_instance_of ::Whiteprint::Base, model.whiteprint
+  end
+
+  def teardown
+    Whiteprint.models = []
+    Whiteprint::Migrator.eager_load!
+  end
+end

data/test/cases/changes_tree_test.rb

@@ -0,0 +1,51 @@
+require 'test_helper'
+
+class ChangesTreeTest < ActiveSupport::TestCase
+  def setup
+    @model = Class.new do
+      include Whiteprint::Model
+
+      whiteprint(adapter: :test) do
+        string  :name,  default: 'John'
+        integer :age,   default: 0
+        date    :date_of_birth
+
+        persisted do
+          string  :name
+          integer :age,   default: 0
+          integer :weight
+        end
+      end
+
+      def self.table_name
+        'persons'
+      end
+
+      def self.table_exists?
+        true
+      end
+    end
+  end
+
+  test 'the test adapter can set its persisted attributes with a block' do
+    assert_equal Whiteprint::Attribute.new(name: :name, type: :string),             @model.whiteprint.persisted_attributes.name
+    assert_equal Whiteprint::Attribute.new(name: :age, type: :integer, default: 0), @model.whiteprint.persisted_attributes.age
+    assert_equal Whiteprint::Attribute.new(name: :weight, type: :integer),          @model.whiteprint.persisted_attributes.weight
+  end
+
+  test 'a whiteprint can generate a changes_tree with all the differences between the persisted attributes and the actual attributes' do
+    changes_tree = @model.whiteprint.changes_tree
+
+    attributes = [
+      { name: :date_of_birth, type: :date, options: {}, kind: :added },
+      { name: :name, type: :string, options: { default: 'John' }, kind: :changed },
+      { name: :weight, type: :integer, options: {}, kind: :removed }
+    ]
+    assert_equal({ table_name: 'persons', table_exists: true, attributes: attributes }, changes_tree)
+  end
+
+  def teardown
+    Whiteprint.models = []
+    Whiteprint::Migrator.eager_load!
+  end
+end

data/test/cases/explanation_test.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+class ExplanationTest < ActiveSupport::TestCase
+  test 'the changes whiteprint is about to process can be visualized in a table' do
+    user_explanation = <<-TXT.sub(/\n$/, '')
++--------+---------------+---------+------------------+-------------------+------------------------+
+|                                     1. Make changes to users                                     |
++--------+---------------+---------+------------------+-------------------+------------------------+
+| action | name          | type    | type (currently) | options           | options (currently)    |
++--------+---------------+---------+------------------+-------------------+------------------------+
+| change | name          | string  | string           | {:default=>"Joe"} | {:default=>"John"}     |
+| change | age           | integer | integer          | {:default=>10}    | {:default=>0}          |
+| remove | date_of_birth |         |                  |                   |                        |
++--------+---------------+---------+------------------+-------------------+------------------------+
+TXT
+
+    car_explanation = <<-TXT.sub(/\n$/, '')
++---------------------------+------------------------+---------------------------------------------+
+|                                    1. Create a new table cars                                    |
++---------------------------+------------------------+---------------------------------------------+
+| name                      | type                   | options                                     |
++---------------------------+------------------------+---------------------------------------------+
+| brand                     | string                 | {:default=>"BMW"}                           |
+| price                     | decimal                | {:precision=>5, :scale=>10}                 |
+| timestamps                |                        |                                             |
++---------------------------+------------------------+---------------------------------------------+
+    TXT
+
+    assert_equal user_explanation, User.whiteprint.explanation.to_s
+    assert_equal car_explanation,  Car.whiteprint.explanation.to_s
+  end
+end