whiteprint 0.1.0

data/lib/whiteprint/adapters/active_record/has_and_belongs_to_many.rb

@@ -0,0 +1,22 @@
+module Whiteprint
+  module Adapters
+    class ActiveRecord::HasAndBelongsToMany < ActiveRecord
+      def self.applicable?(_)
+        false
+      end
+
+      def changes_tree
+        return {} if model.table_exists?
+        super
+      end
+
+      def changes?
+        !model.table_exists?
+      end
+
+      def transformer
+        self.class.parent
+      end
+    end
+  end
+end

data/lib/whiteprint/adapters/active_record/migration.rb

@@ -0,0 +1,17 @@
+module Whiteprint
+  module Adapters
+    class ActiveRecord::Migration < Whiteprint::Transform
+      create_rule :removed_default, kind: :removed_default, name: simple(:name)
+
+      create_table            { "    create_table :#{table_name} do |t|\n#{attributes.join("\n")}\n    end\n" }
+      create_table_without_id { "    create_table :#{table_name}, id: false do |t|\n#{attributes.join("\n")}\n    end\n" }
+      change_table            { "    change_table :#{table_name} do |t|\n#{attributes.join("\n")}\n    end\n" }
+
+      added_attribute         { "      t.#{type} :#{name}, #{options}" }
+      changed_attribute       { "      t.change :#{name}, :#{type}, #{options}" }
+      removed_attribute       { "      t.remove :#{name}" }
+      removed_default         { "      t.change_default :#{name}, nil" }
+      added_timestamps        { '      t.timestamps' }
+    end
+  end
+end

data/lib/whiteprint/adapters/test.rb

@@ -0,0 +1,20 @@
+module Whiteprint
+  module Adapters
+    class Test < ::Whiteprint::Base
+      class << self
+        def applicable?(_model)
+          false
+        end
+      end
+
+      def persisted_attributes
+        @_persisted_whiteprint.attributes
+      end
+
+      def persisted(&block)
+        @_persisted_whiteprint ||= Whiteprint::Base.new(@model)
+        @_persisted_whiteprint.instance_eval(&block)
+      end
+    end
+  end
+end

data/lib/whiteprint/attributes.rb

@@ -0,0 +1,207 @@
+module Whiteprint
+  class Attribute
+    def initialize(persisted: nil, model: nil, **options)
+      @model     = model
+      @options   = options
+      @persisted = persisted
+    end
+
+    def ==(other)
+      to_h == other.to_h
+    end
+
+    def has?(*keys, **conditions)
+      keys.none? do |key|
+        @options.values_at(*key).compact.empty?
+      end && conditions.all? do |key, value|
+        [*@options[key]] & [*value] != []
+      end
+    end
+
+    def persisted_options
+      @options.select do |key, value|
+        Whiteprint.config.persisted_attribute_options.keys.include?(key) &&
+        !(key == :default && value.is_a?(Symbol))
+      end
+    end
+
+    def to_h
+      @options
+    end
+
+    def merge(options)
+      self.class.new(persisted: @persisted, **@options, **options)
+    end
+
+    def for_meta(instance)
+      ::Whiteprint.config.meta_attribute_options.map do |option|
+        {option => send("meta_#{option}", instance)}
+      end.inject(&:merge).compact
+    end
+
+    def for_persisted(**config)
+      return merge(config) if @persisted
+      self.class.new(persisted: true, name: @options[:name], type: @options[:type], options: persisted_options, **config)
+    end
+
+    def [](name)
+      @options[name.to_sym]
+    end
+
+    def meta_enum(instance)
+      _enum = if enum.is_a?(Symbol)
+                instance.send(enum)
+              else
+                enum
+              end
+
+      return _enum if _enum.is_a?(Hash)
+
+      _enum.map do |value|
+        {value => value}
+      end.inject(&:merge)
+    end
+
+    def method_missing(name)
+      if name.to_s.starts_with?('meta_')
+        self[name.to_s.remove(/^meta_/)]
+      else
+        self[name]
+      end
+    end
+  end
+
+  class AttributeScope
+    def initialize(scope, model: nil)
+      @scope   = scope
+      @model   = model
+      @selects = []
+      @rejects = []
+    end
+
+    def where(*keys, **conditions)
+      @selects << proc do |_, attribute|
+        attribute.has?(*keys, **conditions)
+      end
+      Attributes.new(filter, model: @model)
+    end
+
+    def not(*keys, **conditions)
+      @rejects << proc do |_, attribute|
+        attribute.has?(*keys, **conditions)
+      end
+      Attributes.new(filter, model: @model)
+    end
+
+    def filter
+      select = proc { |scope, condition| scope.select(&condition) }
+      reject = proc { |scope, condition| scope.reject(&condition) }
+
+      scope = @selects.inject(@scope, &select)
+      @rejects.inject(scope, &reject)
+    end
+  end
+
+  class Attributes
+    def initialize(attributes = nil, model: nil)
+      attributes  = Hash[attributes] if attributes.is_a?(Array)
+      @attributes = (attributes || {}).dup
+      @model      = model
+    end
+
+    def add(name:, type:, **options)
+      @attributes[name.to_sym] = Attribute.new(name: name.to_sym, type: type.to_sym, model: @model, **options)
+    end
+
+    def as_json(*args)
+      super['attributes']
+    end
+
+    def diff(diff, type: nil)
+      # TODO: Clean up
+      added   = diff.slice(*(diff.keys - keys))
+      changed = diff.to_diff_a(type) - to_diff_a(type) - added.to_diff_a(type)
+      changed = Attributes.new(Hash[changed].map { |key, options| { key => Attribute.new(persisted: true, model: @model, **options) } }.inject(&:merge), model: @model)
+      removed = slice(*(keys - diff.keys))
+
+      { added: added, changed: changed, removed: removed }
+    end
+
+    def where(*keys, **conditions)
+      AttributeScope.new(@attributes, model: @model).where(*keys, **conditions)
+    end
+
+    def not(*keys, **conditions)
+      AttributeScope.new(@attributes, model: @model).not(*keys, **conditions)
+    end
+
+    def keys
+      @attributes.keys
+    end
+
+    def slice(*keys)
+      where(name: keys)
+    end
+
+    def to_h
+      @attributes
+    end
+
+    def to_a
+      @attributes.values
+    end
+
+    def for_persisted
+      persisted_scope = self.not(virtual: true)
+      persisted_scope.to_h.each do |name, attribute|
+        persisted_scope.to_h[name] = attribute.for_persisted
+      end
+      persisted_scope
+    end
+
+    def for_meta(instance)
+      where(::Whiteprint.config.meta_attribute_options).to_h.map do |key, attribute|
+        {key => attribute.for_meta(instance)}
+      end.inject(&:merge)
+    end
+
+    def for_serializer
+      self.not(type: :references).not(private: true).keys
+    end
+
+    def for_permitted
+      self.not(readonly: true).not(name: [:updated_at, :created_at]).to_h.map do |name, attribute|
+        if attribute.array
+          {name => []}
+        elsif attribute.type == :has_and_belongs_to_many
+          {"#{name.to_s.singularize}_ids" => []}
+        elsif attribute.type == :references
+          "#{attribute.name}_id"
+        else
+          name
+        end
+      end
+    end
+
+    def for_permitted_json
+      self.not(readonly: true).where(type: [:json, :jsonb]).keys
+    end
+
+    def to_diff_a(type)
+      if type
+        to_h.map { |name, attr| [name, attr.send("for_#{type}").to_h] }
+      else
+        to_h.map { |name, attr| [name, attr.to_h] }
+      end
+    end
+
+    def [](name)
+      return unless name
+      @attributes[name.to_sym]
+    end
+
+    def method_missing(name)
+      self[name]
+    end
+  end
+end

data/lib/whiteprint/base.rb

@@ -0,0 +1,95 @@
+module Whiteprint
+  class Base
+    attr_accessor :model, :attributes, :configs, :options
+
+    class << self
+      def applicable?(_)
+        true
+      end
+
+      def load_plugins
+        Whiteprint.config.plugins.each do |plugin|
+          include Whiteprint.plugins[plugin]
+        end
+      end
+    end
+
+    def initialize(model, **_options)
+      singleton_class.send :load_plugins
+
+      self.model                 = model
+      self.options               = _options
+      self.attributes            = Attributes.new(nil, model: model)
+      self.configs               = []
+    end
+
+    def execute(&block)
+      self.configs << block
+      instance_eval(&block)
+    end
+
+    def explanation(index = 1, width = 100)
+      return unless changes?
+      table = Terminal::Table.new(Explanation.apply(self, index, width: width))
+      table.render
+      table
+    rescue => e
+      explanation(index, width + 10)
+    end
+
+    def changes_tree
+      changes = persisted_attributes.diff(attributes.not(virtual: true), type: :persisted)
+
+      attributes = changes.flat_map do |kind, changed_attributes|
+        changed_attributes.to_a.map do |attribute|
+          next if attribute.virtual
+          attribute.for_persisted(kind: kind).to_h
+        end.compact
+      end
+
+      table_name_without_schema = table_name.split('.').last
+
+      { table_name: table_name_without_schema, table_exists: table_exists?, attributes: attributes }
+    end
+
+    def changes?
+      changes = persisted_attributes.diff(attributes, type: :persisted)
+      changes.any? do |_, attributes|
+        !attributes.to_a.reject(&:virtual).empty?
+      end
+    end
+
+    def clone_to(model)
+      clone = ::Whiteprint.new(model, **self.options)
+      self.configs.each do |config|
+        clone.execute(&config)
+      end
+      model.instance_variable_set :@_whiteprint, clone
+      Whiteprint.models += [model]
+    end
+
+    def persisted_attributes
+      Whiteprint::Attributes.new
+    end
+
+    def set_model(model)
+      self.model = model
+    end
+
+    def table_name
+      model.table_name
+    end
+
+    def table_exists?
+      model.table_exists?
+    end
+
+    def transformer
+      self.class
+    end
+
+    def method_missing(type, name, **options)
+      @attributes.add name: name.to_sym, type: type, **options
+    end
+  end
+end

data/lib/whiteprint/config.rb

@@ -0,0 +1,19 @@
+module Whiteprint
+  def self.config(&block)
+    return Config unless block
+    Config.instance_exec(Config, &block)
+  end
+
+  module Config
+    class << self
+      attr_accessor :default_adapter, :persisted_attribute_options, :eager_load, :eager_load_paths,
+                    :migration_path, :meta_attribute_options, :plugins
+
+      def plugin(name)
+        self.plugins << name
+      end
+    end
+
+    self.plugins = []
+  end
+end

data/lib/whiteprint/explanation.rb

@@ -0,0 +1,73 @@
+module Whiteprint
+  module Explanation
+    class << self
+      def apply(whiteprint, index, width: 100)
+        @table     = { title: "#{index}. ", rows: [], style: { width: width } }
+        @whiteprint = whiteprint
+        transformer.new.apply(whiteprint.changes_tree)
+        @table
+      end
+
+      private
+
+      def helpers
+        type_was = lambda do |name|
+          @whiteprint.persisted_attributes[name][:type].to_s
+        end
+
+        options_was = lambda do |name|
+          @whiteprint.persisted_attributes[name][:options].to_s
+        end
+
+        table_exists = @whiteprint.changes_tree[:table_exists]
+
+        [type_was, options_was, table_exists]
+      end
+
+      def transformer
+        table, type_was, options_was, table_exists = @table, *helpers
+
+        Class.new(Whiteprint::Transform) do
+          create_table do
+            table[:headings]  = %w(name type options)
+            table[:title]    += "Create a new table #{table_name}"
+          end
+
+          create_table_without_id do
+            table[:headings]  = %w(name type options)
+            table[:title]    += "Create a new table #{table_name} (without id)"
+          end
+
+          change_table do
+            table[:headings]  = ['action', 'name', 'type', 'type (currently)', 'options', 'options (currently)']
+            table[:title]    += "Make changes to #{table_name}"
+          end
+
+          added_attribute do
+            table[:rows] << if table_exists
+                              ['added', name, type, nil, options.to_s, nil]
+                            else
+                              [name, type, options.to_s]
+                            end
+          end
+
+          added_timestamps do
+            table[:rows] << if table_exists
+                              ['added', 'timestamps', nil, nil, nil, nil]
+                            else
+                              ['timestamps', nil, nil]
+                            end
+          end
+
+          changed_attribute do
+            table[:rows] << ['change', name, type, type_was[name],  options.to_s, options_was[name]]
+          end
+
+          removed_attribute do
+            table[:rows] << ['remove', name, nil, nil, nil, nil]
+          end
+        end
+      end
+    end
+  end
+end