whiteprint 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ac5d879aa5d240df5fb1689636e8c15462f9a192
-  data.tar.gz: 464a364c30c9edc45f9418d4f1f9ab8eaf57fb43
+  metadata.gz: cef8249f6ad8c0449c9a9348f5d57f08e5ff552e
+  data.tar.gz: 64abf99090a1f2b2cb26e91c46e7f27eb9fd3698
 SHA512:
-  metadata.gz: 78358814f2b3e688cdb5720a4049c3bd3b0951d83f74627aaa754688ffa2b9792d5c8d44de038b824f44b785c55046b69299d84048a932f5157cfd223dde64f4
-  data.tar.gz: 2304c58e46b558e2833ebb1fe8d8aafed433e060a4f62afb814a1ea95389e5ab5793cdb82f04c06bee692bf8c9f753851b97325d299aaf25047eeef2d48bcc50
+  metadata.gz: 9da7bbb71e51c8831a685ecccb948870618bb027b3f4316e423c9821e783482c56da0b081f5ab15d0841327a31d42d49b886dc291e9289ddf6d0db28293bcc0d
+  data.tar.gz: 54f8d2b975b4afcb6e6eebff5f4bd05ce63df83515ae98afde32974bc950de3806b7bc4b7c56b03e1a1f427e2af79e4a1789ae0c1fcb7c067f241bfa6c06070d

data/README.md

@@ -241,11 +241,207 @@ end
 
 ### Method as default value
 
+You can specify a symbol as the default value for an attribute for dynamic defaults.
+
+```ruby
+class Car < ActiveRecord::Base
+  include Whiteprint::Model
+
+  whiteprint do
+    references :user, default: :current_user
+  end
+
+  private
+
+  def current_user
+    User.current
+  end
+end
+```
+
 ### Accessor
 
+You can use the accessor type to add attr_accessors to your model
+
+```ruby
+class User < ActiveRecord::Base
+  include Whiteprint::Model
+
+  whiteprint do
+    text     :password_digest
+    accessor :password
+    accessor :password_confirmation
+  end
+end
+```
+
 ## Attributes
 
+The whiteprint instance of a model can be accessed using the whiteprint method: `Model.whiteprint`. The attributes of a whiteprint are available using the attributes method: `Model.whiteprint.attributes`.
+These attributes are an instance of `Whiteprint::Attributes` and have several helper methods available.
+
+### for_serializer
+
+The for_serializer helper lists all attributes that aren't private or associations.
+
+```ruby
+class Car < ActiveRecord::Base
+  include Whiteprint::Model
+
+  whiteprint do
+    string     :brand, default: 'Ford'
+    string     :name
+    decimal    :price, precision: 10, scale: 5, private: true
+    references :color
+  end
+end
+
+Car.whiteprint.attributes.for_serializer
+# [:id, :created_at, :updated_at, :brand, :name]
+
+# usage example
+class CarSerializer < ActiveModel::Serializer
+  attributes *Car.whiteprint.attributes.for_serializer
+end
+```
+
+### for_permitted
+
+The for_serializer helper lists all attributes that aren't private or readonly in a format suitable for Rails' strong paramters.
+
+```ruby
+class Car < ActiveRecord::Base
+  include Whiteprint::Model
+
+  whiteprint do
+    string     :brand,  default: 'Ford'
+    string     :name,   readonly: true
+    text       :specs,  array: true
+    decimal    :price,  precision: 10, scale: 5, private: true
+    references :color
+    habtm      :owners, class_name: 'User'
+  end
+end
+
+Car.whiteprint.attributes.for_permitted
+# [:id, :brand, {:specs=>[]}, :color_id, {:owner_ids=>[]}]
+
+# usage example
+def permitted_params
+  params.require(:car).permit(*Car.whiteprint.attributes.for_permitted)
+end
+```
+
+### for_meta
+
+The for_meta helper lists all meta info that is specified for attributes. The `meta_attribute_options` config determines which options should be listed by this helper.
+
+```ruby
+Whiteprint.config do |c|
+  c.meta_attribute_options = [:enum, :label]
+end
+
+class Car < ActiveRecord::Base
+  include Whiteprint::Model
+
+  whiteprint do
+    string     :brand,  default: 'Ford', enum: {"Ford"=>"Ford", "BMW"=>"BMW", "Audi"=>"Audi"}, label: 'Merk'
+    string     :name,   label: 'Naam'
+    text       :specs,  array: true
+    decimal    :price,  precision: 10, scale: 5, private: true
+    references :color
+    habtm      :owners, class_name: 'User'
+  end
+end
+
+Car.whiteprint.attributes.for_meta
+# {:brand=>{:enum=>{"Ford"=>"Ford", "BMW"=>"BMW", "Audi"=>"Audi"}, :label=>"Merk"}, :name=>{:label=>"Naam"}}
+
+# example usage
+render json: @car, meta: Car.whiteprint.attributes.for_meta
+```
+
+## Composability
+
+Whiteprints are inherited and can be composed.
+
+```ruby
+class Animal
+  include Whiteprint::Model
+
+  whiteprint do
+    text :name
+    text :description
+  end
+end
+
+module Mammal
+  extend ActiveSupport::Concern
+
+  included do
+    whiteprint do
+      integer :gestation_period
+    end
+  end
+end
+
+class Dog < Animal
+  include Mammal
+
+  whiteprint do
+    string :breed
+  end
+end
+
+class Cat < Animal
+  include Mammal
+
+  whiteprint do
+    boolean :domestic, default: true
+  end
+end
+
+Cat.whiteprint.attributes.to_a.map(&:to_h)
+# [{:name=>:name, :type=>:text}, {:name=>:description, :type=>:text}, {:name=>:gestation_period, :type=>:integer}, {:name=>:domestic, :type=>:boolean, :default=>true}]
+
+Dog.whiteprint.attributes.to_a.map(&:to_h)
+#[{:name=>:name, :type=>:text}, {:name=>:description, :type=>:text}, {:name=>:gestation_period, :type=>:integer}, {:name=>:breed, :type=>:string}]
+```
+
 ## Configuration
 
+```ruby
+Whiteprint.config do |c|
+  # which adapter to use if none is applicable
+  c.default_adapter             = :base
+
+  # Models have to be loaded before whiteprint:migrate runs. Set to true to let Whiteprint do this for you.
+  c.eager_load                  = false # default true for Rails projects
+
+  # Define  which path(s) contain whiteprint models
+  c.eager_load_paths            = []
+
+  # Define which attribute options are persisted
+  c.persisted_attribute_options = {
+    array: false,
+    limit: nil,
+    precision: nil,
+    scale: nil,
+    polymorphic: false,
+    null: true,
+    default: nil
+  }
+
+  # Define the attribute options for the for_meta gelper
+  c.meta_attribute_options      = [:enum]
+
+  # Define if changes should be run in a single or separately migrations. One of: :ask, :separately, :together
+  c.migration_strategy          = :ask
+
+  # Define if migrations should be automatically added to git
+  c.add_migration_to_git        = false
+end
+```
+
 ## 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/lib/whiteprint.rb

@@ -30,6 +30,8 @@ module Whiteprint
       default: nil
     }
     c.meta_attribute_options      = [:enum]
+    c.migration_strategy          = :ask
+    c.add_migration_to_git        = false
   end
 
   if defined?(ActiveRecord)
@@ -88,6 +90,25 @@ module Whiteprint
       whiteprints.select(&:changes?)
     end
 
+    def migrate(cli, separately:)
+      changed_whiteprints.group_by(&:transformer).map do |adapter, whiteprints|
+        if separately
+          cli.say 'Processing as separate migrations...'
+          whiteprints.each do |whiteprint|
+            cli.say whiteprint.explanation
+            migration_path = adapter.generate_migration(*adapter.migration_params(cli), [whiteprint.changes_tree])
+            `git add #{migration_path}` if Whiteprint.config.add_migration_to_git
+          end
+        else
+          cli.say 'Processing as a single migration...'
+          migration_path = adapter.generate_migration(*adapter.migration_params(cli), whiteprints.map(&:changes_tree))
+          `git add #{migration_path}` if Whiteprint.config.add_migration_to_git
+        end
+
+        adapter.migrate
+      end
+    end
+
     def plugins
       @@plugins
     end

data/lib/whiteprint/adapters/active_record.rb

@@ -27,15 +27,27 @@ module Whiteprint
 
         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|
+          path     = File.join(Whiteprint.config.migration_path, filename)
+          File.open(path, 'w') do |f|
             f.write migration(name, trees)
           end
+          path
+        end
+
+        def migrate
+          ::ActiveRecord::Migration.verbose = true
+          ::ActiveRecord::Migrator.migrate(::ActiveRecord::Migrator.migrations_paths)
         end
 
         def migration(name, trees)
           "class #{camelize(name)} < ActiveRecord::Migration\n  def change\n" + transform(trees) + "  end\nend\n"
         end
 
+        def migration_params(cli)
+          name = cli.ask 'How would you like to name this migration?'
+          [name]
+        end
+
         private
 
         def transform(trees)

data/lib/whiteprint/attributes.rb

@@ -36,7 +36,7 @@ module Whiteprint
     def for_meta(instance)
       ::Whiteprint.config.meta_attribute_options.map do |option|
         {option => send("meta_#{option}", instance)}
-      end.inject(&:merge).compact
+      end.inject(&:merge).select { |_, value| !value.nil? }
     end
 
     def for_persisted(**config)
@@ -55,6 +55,7 @@ module Whiteprint
                 enum
               end
 
+      return nil unless _enum
       return _enum if _enum.is_a?(Hash)
 
       _enum.map do |value|
@@ -62,7 +63,7 @@ module Whiteprint
       end.inject(&:merge)
     end
 
-    def method_missing(name)
+    def method_missing(name, *args)
       if name.to_s.starts_with?('meta_')
         self[name.to_s.remove(/^meta_/)]
       else
@@ -159,24 +160,28 @@ module Whiteprint
       persisted_scope
     end
 
-    def for_meta(instance)
+    def for_meta(instance = nil)
       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
+      # TODO: move specifics to activerecord adapater
+
+      self.not(type: :references).not(type: :has_and_belongs_to_many).not(private: true).keys
     end
 
     def for_permitted
-      self.not(readonly: true).not(name: [:updated_at, :created_at]).to_h.map do |name, attribute|
+      # TODO: move specifics to activerecord adapater
+
+      self.not(readonly: true).not(private: 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" => []}
+          {:"#{name.to_s.singularize}_ids" => []}
         elsif attribute.type == :references
-          "#{attribute.name}_id"
+          :"#{attribute.name}_id"
         else
           name
         end

data/lib/whiteprint/config.rb

@@ -7,7 +7,7 @@ module Whiteprint
   module Config
     class << self
       attr_accessor :default_adapter, :persisted_attribute_options, :eager_load, :eager_load_paths,
-                    :migration_path, :meta_attribute_options, :plugins
+                    :migration_path, :meta_attribute_options, :plugins, :migration_strategy, :add_migration_to_git
 
       def plugin(name)
         self.plugins << name

data/lib/whiteprint/migrator.rb

@@ -1,5 +1,25 @@
 module Whiteprint
   module Migrator
+    class Cli
+      def initialize(input, output)
+        @cli = HighLine.new input, output
+      end
+
+      def ask(*args)
+        @cli.ask(*args)
+      end
+
+      def choose(*args, &block)
+        @cli.choose(*args, &block)
+      end
+
+      def say(*messages)
+        messages.each do |message|
+          @cli.say(message)
+        end
+      end
+    end
+
     class << self
       def eager_load!
         return unless Whiteprint.config.eager_load
@@ -19,45 +39,32 @@ module Whiteprint
         end
       end
 
-      def interactive(input: $stdin, output: $stdout, migrate_input: $stdin, migrate_output: $stdout)
-        # TODO: Clean up
+      def no_changes?
+        number_of_changes == 0
+      end
 
+      def interactive(input: $stdin, output: $stdout)
         eager_load!
-        cli = HighLine.new input, output
+        cli = Cli.new(input, output)
 
-        if number_of_changes == 0
-          cli.say('Whiteprint detected no changes')
-          return
-        end
+        # return if there are no changes
+        cli.say('Whiteprint detected no changes') and return if no_changes?
 
-        cli.say "Whiteprint has detected <%= color('#{number_of_changes}', :bold, :white) %> changes to your models."
-        explanations.each do |explanation|
-          cli.say explanation
-        end
+        # list all changes
+        cli.say "Whiteprint has detected <%= color('#{number_of_changes}', :bold, :white) %> changes to your models.", *explanations
 
-        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' }
+        if Whiteprint.config.migration_strategy == :ask
+          cli.choose do |menu|
+            menu.header = 'Migrations'
+            menu.prompt = 'How would you like to process these changes?'
+            menu.choice('In one migration')       { Whiteprint.migrate cli, separately: false }
+            menu.choice('In separate migrations') { Whiteprint.migrate cli, separately: true }
+          end
+        else
+          Whiteprint.migrate cli, separately: (Whiteprint.config.migration_strategy == :separately)
         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

data/lib/whiteprint/railtie.rb

@@ -1,14 +1,5 @@
 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
@@ -17,7 +8,6 @@ module Whiteprint
     end
 
     rake_tasks do
-      # whiteprint_config
       load "tasks/whiteprint.rake"
     end
   end

data/lib/whiteprint/version.rb

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

data/test/cases/migrator_test.rb

@@ -50,13 +50,10 @@ end
 
     input = StringIO.new
     input << '1' << "\n"
+    input << 'test migration' << "\n"
     input.rewind
 
-    migrate_input = StringIO.new
-    migrate_input << 'test migration' << "\n"
-    migrate_input.rewind
-
-    Whiteprint::Migrator.interactive input: input, migrate_input: migrate_input
+    Whiteprint::Migrator.interactive input: input
 
     migration = File.read(Dir.glob('test/db/migrate/*_test_migration.rb').first)
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: whiteprint
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Ewout Kleinsmann
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-05 00:00:00.000000000 Z
+date: 2016-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
@@ -204,7 +204,7 @@ extra_rdoc_files: []
 files:
 - README.md
 - Rakefile
-- lib/tasks/blueprint.rake
+- lib/tasks/whiteprint.rake
 - lib/whiteprint.rb
 - lib/whiteprint/adapters/active_record.rb
 - lib/whiteprint/adapters/active_record/has_and_belongs_to_many.rb