whiteprint 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ac5d879aa5d240df5fb1689636e8c15462f9a192
+  data.tar.gz: 464a364c30c9edc45f9418d4f1f9ab8eaf57fb43
+SHA512:
+  metadata.gz: 78358814f2b3e688cdb5720a4049c3bd3b0951d83f74627aaa754688ffa2b9792d5c8d44de038b824f44b785c55046b69299d84048a932f5157cfd223dde64f4
+  data.tar.gz: 2304c58e46b558e2833ebb1fe8d8aafed433e060a4f62afb814a1ea95389e5ab5793cdb82f04c06bee692bf8c9f753851b97325d299aaf25047eeef2d48bcc50

data/README.md

@@ -0,0 +1,251 @@
+# Whiteprint
+by [10KB](https://10kb.nl)
+
+
+Whiteprint keeps track of the attributes of your models. It:
+* Generates migrations for you if you update your model's whiteprint (only ActiveRecord at the moment)
+* Provides you with helpers to use in your serializers or permitted attributes definition
+* Can be extended with plugins
+* Has support for inheritance and composition
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'whiteprint'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install whiteprint
+
+## Usage
+
+### 1. Add Whiteprint to your model
+
+```ruby
+class Car
+  include Whiteprint::Model
+end
+```
+
+Alternatively, in an ActiveRecord model you could also use `has_whiteprint`.
+
+```ruby
+class Car < ActiveRecord::Base
+  has_whiteprint
+end
+```
+
+### 2. Add some attributes
+
+```ruby
+class Car < ActiveRecord::Base
+  include Whiteprint::Model
+
+  whiteprint do
+    string  :brand, default: 'BMW'
+    string  :name
+    text    :description
+    decimal :price, precision: 5, scale: 10
+  end
+end
+```
+
+### 3. Generate a migration
+Let Whiteprint generate a migration to update your database schema for you (only ActiveRecord at the moment). Run:
+
+```
+rake whiteprint:migrate
+```
+
+Whiteprint will check all your models for changes and list them in your terminal. If multiple models have changes it will ask you if you want to apply these changes in one or separate migrations.
+
+```
+Whiteprint has detected 1 changes to your models.
++----------------------------+------------------------+--------------------------------------------+
+|                                    1. Create a new table cars                                    |
++----------------------------+------------------------+--------------------------------------------+
+| name                       | type                   | options                                    |
++----------------------------+------------------------+--------------------------------------------+
+| brand                      | string                 | {:default=>"BMW"}                          |
+| name                       | string                 | {}                                         |
+| description                | text                   | {}                                         |
+| price                      | decimal                | {:precision=>10, :scale=>5}                |
+| timestamps                 |                        |                                            |
++----------------------------+------------------------+--------------------------------------------+
+Migrations:
+1. In one migration
+2. In separate migrations
+How would you like to process these changes?
+> 1
+How would you like to name this migration?
+> Create cars
+```
+Your migration wil be **created** and **migrated**.
+
+```ruby
+# db/migrate/*********_create_cars.rb
+
+class CreateCars < ActiveRecord::Migration
+  def change
+    create_table :cars do |t|
+      t.string :brand, {:default=>"BMW"}
+      t.string :name, {}
+      t.text :description, {}
+      t.decimal :price, {:precision=>10, :scale=>5}
+      t.timestamps
+    end
+  end
+end
+```
+
+```
+== 20160905153022 CreateCars: migrating =======================================
+-- create_table(:cars)
+   -> 0.0081s
+== 20160905153022 CreateCars: migrated (0.0082s) ==============================
+```
+
+### 4. Make some changes to your model
+If we make some changes to our `Car` model and run `whiteprint:migrate` again, Whiteprint will detect these changes and create a migration to update your table.
+
+```ruby
+class Car < ActiveRecord::Base
+  include Whiteprint::Model
+
+  whiteprint do
+    string     :brand, default: 'Ford'
+    string     :name
+    decimal    :price, precision: 10, scale: 5
+    references :color
+  end
+end
+```
+
+```
+> rake whiteprint:migrate
+Whiteprint has detected 1 changes to your models.
++--------+-------------+------------+------------------+--------------------+----------------------+
+|                                     1. Make changes to cars                                      |
++--------+-------------+------------+------------------+--------------------+----------------------+
+| action | name        | type       | type (currently) | options            | options (currently)  |
++--------+-------------+------------+------------------+--------------------+----------------------+
+| added  | color       | references |                  | {}                 |                      |
+| change | brand       | string     | string           | {:default=>"Ford"} | {:default=>"BMW"}    |
+| remove | description |            |                  |                    |                      |
++--------+-------------+------------+------------------+--------------------+----------------------+
+Migrations:
+1. In one migration
+2. In separate migrations
+How would you like to process these changes?
+1
+How would you like to name this migration?
+Add color change default brand and remove description for cars
+== 20160905162923 AddColorChangeDefaultBrandAndRemoveDescriptionForCars: migrating
+-- change_table(:cars)
+   -> 0.0032s
+== 20160905162923 AddColorChangeDefaultBrandAndRemoveDescriptionForCars: migrated (0.0034s)
+```
+
+## Adapters
+Whiteprint is made to be persistence layer agnostic, but at this moment only an ActiveRecord adapter is implemented. If you would like to implement an adapter for another persistence layer please contact us. We'd love to help you.
+
+An example of a Whiteprint adapter:
+```ruby
+module Whiteprint
+  module Adapters
+    class MyOwnAdapater < ::Whiteprint::Base
+      class << self
+        def applicable?(model)
+          # method used to automatically select an adapter for a model.
+          # for example:
+          model < MyOrm::Base
+        end
+
+        def generate_migration(name, trees)
+          # create a migration here given a set of trees with changes
+          # look at the activerecord adapter for further implementation details
+        end
+      end
+
+      def persisted_attributes
+        # this method has to return the current attributes of the persistance layer
+        # return an instance of Whiteprint::Attributes
+      end
+
+      # The whiteprint do ... end block in your model is executed in the context of your adapter instance
+      # you can add methods to add functionality to your adapter. For example:
+      def address(name)
+        @attributes.add name: "#{name}_street",       type: :text
+        @attributes.add name: "#{name}_house_number", type: :integer
+        @attributes.add name: "#{name}_city",         type: :text
+      end
+      # And then you could do:
+      # class Company < MyOrm::Base
+      #   include Whiteprint::Model
+      #
+      #   whiteprint do
+      #     address :office
+      #   end
+      # end
+    end
+  end
+end
+```
+
+## ActiveRecord Adapter
+The ActiveRecord adapter has some special properties which are explained in this section.
+
+### Default id and timestamps
+By default the adapter will add id and timestamps columns. You can disable this behaviour by passing arguments to the whiteprint method.
+
+Model without an id:
+```ruby
+whiteprint(id: false) do
+  # ...
+end
+```
+
+Model without timestamps:
+```ruby
+whiteprint(timestamps: false) do
+  # ...
+end
+```
+
+### References
+Adding an references columns will automatically set a `belongs_to` association on the model. Any options for the association can be passed in the whiteprint block.
+
+```ruby
+whiteprint do
+  references :fileable, polymorphic: true
+end
+```
+
+You can disable this behaviour by passing `auto_belongs_to: false` to the whiteprint method.
+
+### Has and belongs to many
+The activerecord adapter has support for a has_and_belongs_to_many attribute. This won't add a column to your model's table, but instead create a join table and set the association.
+
+```ruby
+whiteprint do
+  has_and_belongs_to_many :categories
+end
+```
+
+`habtm` is added as an alias
+
+### Method as default value
+
+### Accessor
+
+## Attributes
+
+## Configuration
+
+## Origin
+Whiteprint is extracted from an application framework we use internally. Right now, our framework is lacking tests and documentation, but we intend to open source more parts of our framework in the future.

data/Rakefile

@@ -0,0 +1,55 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require 'rubocop/rake_task'
+
+test = File.expand_path('../test', __FILE__)
+$LOAD_PATH.unshift(test) unless $LOAD_PATH.include?(test)
+
+task default: :test
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+  t.warning = true
+end
+
+namespace :analysis do
+  RuboCop::RakeTask.new
+
+  desc 'Analyze code style'
+  task style: [:rubocop]
+
+  desc 'Analyze code duplication'
+  task :duplication do
+    output = `bundle exec flay lib/`
+    if output.include? 'Similar code found'
+      puts output
+      exit 1
+    end
+  end
+
+  desc 'Analyze code complexity'
+  task :comlexity do
+    output = `bundle exec flog -m lib/`
+    exit_code = 0
+    minimum_score = 30
+    output = output.lines
+
+    # Skip total and average complexity score
+    output.shift
+    output.shift
+
+    output.each do |line|
+      score, method = line.split(' ')
+      score = score.to_i
+
+      if score > minimum_score
+        exit_code = 1
+        puts "High complexity in #{method}. Score: #{score}"
+      end
+    end
+
+    exit exit_code
+  end
+end

data/lib/tasks/blueprint.rake

@@ -0,0 +1,5 @@
+namespace :whiteprint do
+  task migrate: :environment do
+    Whiteprint::Migrator.interactive
+  end
+end

data/lib/whiteprint.rb

@@ -0,0 +1,99 @@
+require 'whiteprint/version'
+
+module Whiteprint
+  require 'active_support/concern' unless defined?(ActiveSupport)
+  require 'active_support/inflections'
+
+  require 'parslet'
+  require 'terminal-table'
+  require 'highline'
+
+  require 'whiteprint/config'
+  require 'whiteprint/attributes'
+  require 'whiteprint/base'
+  require 'whiteprint/explanation'
+  require 'whiteprint/model'
+  require 'whiteprint/migrator'
+  require 'whiteprint/transform'
+
+  config do |c|
+    c.default_adapter             = :base
+    c.eager_load                  = false
+    c.eager_load_paths            = []
+    c.persisted_attribute_options = {
+      array: false,
+      limit: nil,
+      precision: nil,
+      scale: nil,
+      polymorphic: false,
+      null: true,
+      default: nil
+    }
+    c.meta_attribute_options      = [:enum]
+  end
+
+  if defined?(ActiveRecord)
+    require 'whiteprint/has_whiteprint'
+    ActiveSupport.on_load :active_record do
+      ActiveRecord::Base.send :extend, Whiteprint::HasWhiteprint
+    end
+  end
+
+  require 'whiteprint/railtie' if defined?(Rails)
+
+  require 'whiteprint/adapters/active_record'
+  require 'whiteprint/adapters/test'
+
+  ADAPTERS = {
+    active_record:            Adapters::ActiveRecord,
+    has_and_belongs_to_many:  Adapters::ActiveRecord::HasAndBelongsToMany,
+    test:                     Adapters::Test,
+    base:                     Base
+  }.freeze
+
+  class << self
+    def new(model, adapter: nil, **options)
+      if adapter
+        ADAPTERS[adapter].new(model, **options)
+      else
+        adapter = ADAPTERS.find do |_, whiteprint|
+          whiteprint.applicable?(model)
+        end
+
+        adapter[-1].new(model, **options)
+      end
+    end
+
+    @@models  = []
+    @@plugins = {}
+
+    def models=(models)
+      @@models = models
+    end
+
+    def models
+      @@models.select  { |model| model.is_a?(Class) }
+              .reject  { |model| model.respond_to?(:abstract_class) && model.abstract_class }
+              .sort_by { |model| model.respond_to?(:table_name) && model.table_name || model.name || model.object_id.to_s }
+              .sort    { |a, b|  -1 * (a <=> b).to_i }
+              .uniq    { |model| model.respond_to?(:table_name) && model.table_name || model.name || model.object_id.to_s }
+              .sort_by { |model| model.name || model.object_id.to_s }
+    end
+
+    def whiteprints
+      models.map(&:whiteprint).compact
+    end
+
+    def changed_whiteprints
+      whiteprints.select(&:changes?)
+    end
+
+    def plugins
+      @@plugins
+    end
+
+    def register_plugin(name, constant)
+      @@plugins[name] = constant
+    end
+  end
+end

data/lib/whiteprint/adapters/active_record.rb

@@ -0,0 +1,193 @@
+module Whiteprint
+  module Adapters
+    class ActiveRecord < ::Whiteprint::Base
+      require 'whiteprint/adapters/active_record/migration'
+      require 'whiteprint/adapters/active_record/has_and_belongs_to_many'
+
+      BELONGS_TO_OPTIONS = [:class_name, :anonymous_class, :foreign_key, :validate, :autosave,
+                            :dependent, :primary_key, :inverse_of, :required, :foreign_type,
+                            :polymorphic, :touch, :counter_cache, :cached]
+
+      class << self
+        def applicable?(model)
+          return false unless defined?(::ActiveRecord)
+          model < ::ActiveRecord::Base
+        end
+
+        def underscore(name)
+          name = name.tr(' ', '_')
+          name.gsub(/([a-z])([A-Z])/) { "#{Regexp.last_match[1]}_#{Regexp.last_match[2].downcase}" }.downcase
+        end
+
+        def camelize(name)
+          name = underscore(name)
+          name = name.gsub(/^([a-z])/) { Regexp.last_match[1].upcase }
+          name.gsub(/_([a-zA-Z])/) { Regexp.last_match[1].upcase }
+        end
+
+        def generate_migration(name, trees)
+          filename = "#{Time.now.strftime('%Y%m%d%H%M%S')}_#{underscore(name)}.rb"
+          File.open(File.join(Whiteprint.config.migration_path, filename), 'w') do |f|
+            f.write migration(name, trees)
+          end
+        end
+
+        def migration(name, trees)
+          "class #{camelize(name)} < ActiveRecord::Migration\n  def change\n" + transform(trees) + "  end\nend\n"
+        end
+
+        private
+
+        def transform(trees)
+          Migration.new.apply(trees).join("\n")
+        end
+      end
+
+      def initialize(model, id: true, timestamps: true, auto_belongs_to: true, **_options)
+        super(model, id: true, timestamps: true, **_options)
+
+        @has_id          = id
+        @has_timestamps  = timestamps
+        @auto_belongs_to = auto_belongs_to
+        @attributes.add(name: :id, type: :integer, null: false) if id
+        @attributes.add(name: :created_at, type: :datetime)     if timestamps
+        @attributes.add(name: :updated_at, type: :datetime)     if timestamps
+      end
+
+      def accessor(name, options)
+        @attributes.add(name: name, type: :accessor, virtual: true, **options)
+        model.send :attr_accessor, name
+      end
+
+      def changes_tree
+        changes_tree = super
+
+        unless changes_tree[:table_exists]
+          changes_tree[:has_id] = @has_id
+          changes_tree[:attributes].reject! { |attribute| attribute[:name] == :id }
+        end
+
+        added_created_at = changes_tree[:attributes].select { |attribute| attribute[:name] == :created_at && attribute[:kind] == :added }
+        added_updated_at = changes_tree[:attributes].select { |attribute| attribute[:name] == :updated_at && attribute[:kind] == :added }
+
+        if added_created_at.size == 1 && added_updated_at.size == 1
+          changes_tree[:attributes] -= [*added_created_at, *added_updated_at]
+          changes_tree[:attributes] += [{ type: :timestamps, kind: :added }]
+        end
+
+        changes_tree[:attributes].each do |attribute|
+          persisted_attribute = persisted_attributes[attribute[:name]]
+          if persisted_attribute && attribute[:options][:default].nil? && persisted_attribute[:options][:default]
+            changes_tree[:attributes] += [{ name: attribute[:name], kind: :removed_default }]
+          end
+        end
+
+        changes_tree
+      end
+
+      def has_and_belongs_to_many(name, **options)
+        super(name, **options.merge(virtual: true))
+        model.send(:has_and_belongs_to_many, name.to_sym, **options) unless model.reflect_on_association(name)
+
+        association = model.reflect_on_association(name)
+
+        Class.new do
+          include Whiteprint::Model
+
+          @association = association
+          @join_table  = association.join_table
+
+          whiteprint(adapter: :has_and_belongs_to_many, id: false, timestamps: false) do
+            integer association.foreign_key
+            integer association.association_foreign_key
+          end
+
+          class << self
+            def name
+              "#{@join_table}_habtm_model"
+            end
+
+            def table_name
+              @join_table
+            end
+
+            def table_exists?
+              ::ActiveRecord::Base.connection.table_exists?(table_name)
+            end
+          end
+        end
+      end
+      alias_method :habtm, :has_and_belongs_to_many
+
+      def migration(name)
+        self.class.migration(name, [changes_tree])
+      end
+
+      def options_from_column(column)
+        [:name, :type, *Whiteprint.config.persisted_attribute_options.keys].map do |option|
+          association_by_foreign_key = find_association_by_foreign_key(column)
+          overridden_name            = association_by_foreign_key && association_by_foreign_key.name || column.name
+          current_attribute          = attributes[overridden_name]
+
+          next {name: overridden_name}               if option == :name        && association_by_foreign_key
+          next {type: :references}                   if option == :type        && association_by_foreign_key
+          next {polymorphic: true}                   if option == :polymorphic && association_by_foreign_key && model.column_names.include?(association_by_foreign_key.foreign_type)
+          next                                       unless column.respond_to?(option)
+          next {default: current_attribute.default}  if option == :default && current_attribute && current_attribute.default.is_a?(Symbol)
+
+          value = column.send(option)
+          value = column.type_cast_from_database(value) if option == :default
+          next if value == Whiteprint.config.persisted_attribute_options[option]
+          { option => value }
+        end.compact.inject(&:merge)
+      end
+
+      def persisted_attributes
+        attributes = Whiteprint::Attributes.new
+        return attributes unless table_exists?
+        model.columns.each do |column|
+          next if find_association_by_foreign_type(column)
+
+          attributes.add options_from_column(column)
+        end
+        attributes.for_persisted
+      end
+
+      def references(name, **options)
+        super
+        return unless @auto_belongs_to
+        model.send :belongs_to, name.to_sym, **options.slice(*BELONGS_TO_OPTIONS)
+      end
+
+      def table_exists?
+        model.connection.schema_cache.clear!
+        model.connection.table_exists?(table_name)
+      end
+
+      def method_missing(type, name, **options)
+        super
+
+        if options[:default] && options[:default].is_a?(Symbol)
+          model.send :after_initialize do
+            next if self.send(name) || !new_record?
+            self.send "#{name}=", send(options[:default])
+          end
+        end
+      end
+
+      private
+
+      def find_association_by_foreign_key(column)
+        model.reflect_on_all_associations.find do |association|
+          association.foreign_key == column.name
+        end
+      end
+
+      def find_association_by_foreign_type(column)
+        model.reflect_on_all_associations.find do |association|
+          association.polymorphic? && association.foreign_type.to_s == column.name.to_s
+        end
+      end
+    end
+  end
+end