seedify 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e30b80245438020aa56db7572c512e6ca73e7963
+  data.tar.gz: 8305c4c190fa2b0b8a00ef283d84f2579a1842e0
+SHA512:
+  metadata.gz: a4b44586fd7466317f4e6fff838e5daf8b4ecb8e05594edcba16ee7c9d407916031e9c751cef0c51e948077d7e730cc706bbaef1ad67182840f6ce3c24347d94
+  data.tar.gz: fccdcef4b2ecc48aa17ac3910347fb51ee3fed97f7650a02813afab5d672bb9ab0b2d6b519de0a27f917e5a031e72c6c8f8979d97c64221737308c293ccebde6

data/README.md

@@ -0,0 +1,269 @@
+# seedify
+
+[![Gem Version](https://img.shields.io/gem/v/seedify.svg?style=flat-square&label=version)](https://rubygems.org/gems/seedify)
+[![Downloads](https://img.shields.io/gem/dt/seedify.svg?style=flat-square)](https://rubygems.org/gems/seedify)
+[![Scrutinizer Code Quality](https://img.shields.io/scrutinizer/g/visualitypl/seedify.svg?style=flat-square)](https://scrutinizer-ci.com/g/visualitypl/seedify/?branch=master)
+[![Code Climate](https://img.shields.io/codeclimate/github/visualitypl/seedify.svg?style=flat-square)](https://codeclimate.com/github/visualitypl/seedify)
+
+Let your seed code become a first-class member of the Rails app and put it into seed objects. **seedify** allows to implement and organize seeds in object-oriented fashion, putting them into `app/seeds` alongside the controllers, models etc. It also provides handy syntax for command line parameters and progress logging.
+
+Here's an overview of what you can achieve with **seedify**:
+
+- organize seed code in object-oriented, Rails convention fitting fashion
+- take advantage of inheritance and modularization when writing seeds
+- invoke seeds as rake tasks or from within the app/console
+- allow to specify custom parameters for your seeds, typed and with defaults
+- log the seed progress (e.g. mass creation) without effort
+- combine with [factory_girl](https://github.com/thoughtbot/factory_girl) to simplify object creation and share fixtures with specs
+
+## Usage
+
+### Basic example
+
+You should start by implementing the `ApplicationSeed` class:
+
+```ruby
+# app/seeds/application_seed.rb
+class ApplicationSeed < Seedify::Base
+  def call
+    if Admin.empty?
+      log 'create first admin'
+
+      Admin.create!(email: 'admin@example.com', password: 'password')
+    else
+      log "admin already exists: '#{Admin.first.email}'"
+    end
+  end
+end
+```
+
+This will create an admin if there's none and output existing admin's e-mail otherwise.
+
+Now, call the seed as rake task:
+
+```sh
+rake seedify
+```
+
+or from Rails console:
+
+```ruby
+ApplicationSeed.call
+```
+
+### Using fixtures
+
+[factory_girl](https://github.com/thoughtbot/factory_girl) is great for sharing model fixtures between tests and seeds. Add `factory_girl_rails` gem to development group and include its methods, so you can use `#create` in seeds:
+
+```ruby
+class ApplicationSeed < Seedify::Base
+  include FactoryGirl::Syntax::Methods
+
+  def call
+    create :admin
+  end
+end
+```
+
+### Custom parameters
+
+You'll often need to parameterize your seed. You can do this easily via `param_reader`:
+
+```ruby
+class ApplicationSeed < Seedify::Base
+  include FactoryGirl::Syntax::Methods
+
+  param_reader :prefix,    default: 'user'
+  param_reader :count,     type: :integer, default: 5
+  param_reader :with_post, type: :boolean, default: false
+
+  def call
+    count.times do |index|
+      user = create :user, email: "#{prefix}-#{index}@example.com"
+
+      create :post, user: user if with_post?
+    end
+  end
+end
+```
+
+You can specify the type of your param and have it casted automatically. Supported types are:
+
+- `:string` default type, default value: **nil**
+- `:integer` default value: **0**
+- `:boolean` default value: **false**, accessor with `?` suffix
+
+Specify the parameters for rake task:
+
+```sh
+rake seedify prefix=guy count=20 with_post=true
+```
+
+or from Rails console:
+
+```ruby
+ApplicationSeed.call prefix: 'guy', count: 20, with_post: true
+```
+
+### Logging
+
+Seed with detailed progress logging feels responsive and is easier to debug in case of a failure. That's why **seedify** provides three log methods for your convenience:
+
+**Simple message** (block is optional):
+
+```ruby
+log "create user '#{email}'" do
+  create :user, email: email
+end
+```
+
+**Array evaluation with live progress**:
+
+```ruby
+log_each ['a', 'b', 'c'], 'create users' do |prefix|
+  create :user, email: "#{prefix}@example.com"
+end
+```
+
+**N-times evaluation with live progress**:
+
+```ruby
+log_times 5, 'create users' do |n|
+  create :user, email: "user-#{n}@example.com"
+end
+```
+
+Notes:
+
+- `log_each`/`log_times` is great for creating large amounts of data with live progress indication
+- texts between `'`, `"` or `*` (like in first example above) quotes are colorized for emphasis
+- logging to `stdout` is enabled by default; disable it by setting the `log` parameter to false
+
+### Organizing seed code
+
+Your seed code will grow along with application development so keeping it clean and well-separated will become important. It's easy thanks to **seedify**'s object-oriented approach. Imagine all-in-one application seed like below:
+
+```ruby
+class ApplicationSeed < Seed::Base
+  include FactoryGirl::Syntax::Methods
+
+  param_reader :admin_email, default: 'admin@example.com'
+  param_reader :user_prefix, default: 'user'
+  param_reader :user_count,  type: :integer, default: 5
+
+  param_reader :clear_method, default: 'destroy'
+
+  def call
+    clear_model(Admin)
+    clear_model(User)
+
+    log "create admin *#{admin_email}* with root priviliges" do
+      create :admin, :with_root_priviliges, email: admin_email
+    end
+
+    log user_count, 'create users' do |index|
+      create :user, email: "#{user_prefix}-#{index}@example.com"
+    end
+  end
+
+  private
+
+  def clear_model(model)
+    case clear_method
+    when 'truncate'
+      ActiveRecord::Base.connection.execute("TRUNCATE #{model.table_name}")
+    when 'destroy'
+      model.destroy_all
+    end
+  end
+end
+```
+
+You can separate the seed code into domains that fit your application best (including modules). In this case, we'll create model-oriented seeds for `Admin` and `User` models and keep application-wide code and param readers in application seed:
+
+```ruby
+# app/seeds/application_seed.rb
+class ApplicationSeed < Seed::Base
+  include FactoryGirl::Syntax::Methods
+
+  param_reader :clear_method, default: 'destroy'
+
+  def call
+    AdminSeed.call
+    UserSeed.call
+  end
+
+  protected
+
+  def clear_model(model)
+    case clear_method
+    when 'truncate'
+      ActiveRecord::Base.connection.execute("TRUNCATE #{model.table_name}")
+    when 'destroy'
+      model.destroy_all
+    end
+  end
+end
+```
+
+```ruby
+# app/seeds/admin_seed.rb
+class AdminSeed < ApplicationSeed
+  param_reader :admin_email, default: 'admin@example.com'
+
+  def call
+    clear_model(Admin)
+
+    log "create admin *#{admin_email}* with root priviliges" do
+      create :admin, :with_root_priviliges, email: admin_email
+    end
+  end
+end
+```
+
+```ruby
+# app/seeds/user_seed.rb
+class UserSeed < ApplicationSeed
+  param_reader :user_prefix, default: 'user'
+  param_reader :user_count,  type: :integer, default: 5
+
+  def call
+    clear_model(User)
+
+    log user_count, 'create users' do |index|
+      create :user, email: "#{user_prefix}-#{index}@example.com"
+    end
+  end
+end
+```
+
+> Params defined in application seed will be available in seeds that inherit from it too.
+
+You can now invoke each seed separately:
+
+```sh
+rake seedify:admin clear_method=none
+rake seedify:user user_count=10
+```
+
+or all at once like before with `rake seedify`.
+
+You should try to write each seed object in a way that makes it possible to use it either stand-alone or as a sub-seed called from another seed object. This way, for instance, you'll be able to generate more objects in specific domain without touching rest of the system or recreate whole system data - depending on your needs - with the same seed code.
+
+You can customize sub-seed invocation with a syntax you already know - the call parameters:
+
+```ruby
+# excerpt from app/seeds/application_seed.rb
+UserSeed.call user_prefix: 'user_generated_by_app_seed'
+```
+
+This way, within **UserSeed**, the `user_prefix` param will equal to *user_generated_by_app_seed* regardless of the one specified when calling the application seed from console or command-line.
+
+## Contributing
+
+1. Fork it (https://github.com/visualitypl/seedify/fork)
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+

data/lib/seedify.rb

@@ -0,0 +1,7 @@
+require 'seedify/railtie'
+require 'seedify/param_reader'
+require 'seedify/base'
+require 'seedify/logger'
+require 'seedify/storage'
+require 'seedify/param_value'
+require 'seedify/call_stack'

data/lib/seedify/base.rb

@@ -0,0 +1,42 @@
+module Seedify
+  class Base
+    extend Seedify::ParamReader
+
+    attr_reader :params
+
+    param_reader :log, type: :boolean, default: true
+    param_reader :task, type: :boolean, default: false
+
+    def self.call(overrides = {})
+      seed = self.new(params(overrides))
+
+      Seedify::CallStack.call(seed)
+    end
+
+    def self.params(overrides)
+      stacked_params = (Seedify::CallStack.last.try(:params) || {}).merge(overrides)
+      defined_params = get_param_readers.map do |param_name, options|
+        [param_name, Seedify::ParamValue.get(param_name, options)]
+      end.to_h
+
+      defined_params.merge(stacked_params)
+    end
+
+    def initialize(params)
+      @params = params
+      @logger = Seedify::Logger.new(self)
+    end
+
+    def log(message, &block)
+      @logger.line(message, &block)
+    end
+
+    def log_each(array, message, &block)
+      @logger.each(array, message, &block)
+    end
+
+    def log_times(count, message, &block)
+      @logger.times(count, message, &block)
+    end
+  end
+end

data/lib/seedify/call_stack.rb

@@ -0,0 +1,21 @@
+module Seedify
+  class CallStack
+    class << self
+      def call(proc)
+        stack.push(proc)
+        proc.call
+        stack.pop
+      end
+
+      def last
+        stack.last
+      end
+
+      private
+
+      def stack
+        Thread.current[:seedify_call_stack] ||= []
+      end
+    end
+  end
+end

data/lib/seedify/logger.rb

@@ -0,0 +1,82 @@
+module Seedify
+  class Logger
+    attr_reader :context
+
+    def initialize(context)
+      @context = context
+    end
+
+    def line(message, &block)
+      print "#{name} #{formatted_message message}"
+      yield if block_given?
+      print "\n"
+    end
+
+    def each(array, message, &block)
+      process_items(array, array.length, message, &block)
+    end
+
+    def times(count, message, &block)
+      process_items(count.times.to_a, count, message, &block)
+    end
+
+    private
+
+    def process_items(array, count, message, &block)
+      if count > 0
+        done_count = yield_with_count(array, count, message, &block)
+        all_done   = done_count == count
+        eraser     = ' ' * (count.to_s.length - done_count.to_s.length)
+
+        print "\r#{name} #{formatted_message message} " +
+          colorize("#{done_count}/#{count}", all_done ? 35 : 31) + eraser
+      else
+        print "\r#{name} #{formatted_message message} #{colorize 'NONE', 31}"
+      end
+
+      print "\n"
+    end
+
+    def yield_with_count(array, count, message)
+      done_count = 0
+      array.each_with_index do |item, index|
+        percent = (index * 100) / count
+        print "\r#{name} #{formatted_message message} #{colorize "#{index + 1}/#{count}", 35}"
+
+        done_count += 1 if yield(item) != false
+      end
+
+      done_count
+    end
+
+    def formatted_message(message)
+      message = colorize_pairs message, '*', 93
+      message = colorize_pairs message, "'", 92
+      message = colorize_pairs message, '"', 96
+
+      message
+    end
+
+    def colorize(message, code)
+      "\033[#{code}m#{message}\033[0m"
+    end
+
+    def colorize_pairs(message, quote, code)
+      quote = '\\' + quote
+      message.gsub(/#{quote}(.*?)#{quote}/) do |match|
+        colorize(match.sub(/^#{quote}/, '').sub(/#{quote}$/, ''), code)
+      end
+    end
+
+    def print(message)
+      Kernel.print(message) if context.log?
+    end
+
+    def name
+      text = context.class.name
+      text = (' ' * [0, Seedify::Storage.max_seed_name_length - text.length].max) + text
+
+      colorize(text, 32)
+    end
+  end
+end

data/lib/seedify/param_reader.rb

@@ -0,0 +1,23 @@
+module Seedify
+  module ParamReader
+    def inherited(subclass)
+      get_param_readers.each do |param_name, options|
+        subclass.param_reader param_name, options
+      end
+    end
+
+    def param_reader(param_name, options = {})
+      param_name = param_name.to_sym
+      getter_name = options[:type] == :boolean ? "#{param_name}?" : param_name
+
+      @params ||= {}
+      @params[param_name] = options
+
+      define_method(getter_name) { params[param_name] }
+    end
+
+    def get_param_readers
+      @params || {}
+    end
+  end
+end

data/lib/seedify/param_value.rb

@@ -0,0 +1,37 @@
+module Seedify
+  class ParamValue
+    class << self
+      def get(param_name, options)
+        value = get_env_value(param_name) || get_default_value(options[:default])
+        value = get_type_casted_value(value, options[:type])
+
+        value
+      end
+
+      private
+
+      def get_env_value(param_name)
+        ENV[param_name.to_s]
+      end
+
+      def get_default_value(default)
+        if default.respond_to?(:call)
+          default.call
+        else
+          default
+        end
+      end
+
+      def get_type_casted_value(value, type)
+        case type.to_s
+        when 'boolean'
+          value.to_s.in?(%{1 true})
+        when 'integer'
+          (value || 0).to_i
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/seedify/railtie.rb

@@ -0,0 +1,9 @@
+module Seedify
+  class Railtie < Rails::Railtie
+    railtie_name :seedify
+
+    rake_tasks do
+      load 'tasks/seedify.rake'
+    end
+  end
+end

data/lib/seedify/storage.rb

@@ -0,0 +1,19 @@
+module Seedify
+  module Storage
+    class << self
+      def seed_directory
+        Rails.root.join('app', 'seeds')
+      end
+
+      def seed_list
+        @all_seeds ||= Dir[seed_directory.join('**', '*_seed.rb')].map do |file|
+          file.sub(/^#{seed_directory.to_s + "/"}/, '').sub(/#{".rb"}$/, '').classify
+        end
+      end
+
+      def max_seed_name_length
+        @max_seed_name_length ||= seed_list.map(&:length).max
+      end
+    end
+  end
+end

data/lib/seedify/version.rb

@@ -0,0 +1,3 @@
+module Seedify
+  VERSION = '0.1.0'
+end

data/lib/tasks/seedify.rake

@@ -0,0 +1,21 @@
+require 'seedify'
+
+seed_list = Seedify::Storage.seed_list
+
+if seed_list.include?('ApplicationSeed')
+  desc 'Call the Application seed'
+  task seedify: :environment do
+    ApplicationSeed.call(task: true)
+  end
+end
+
+namespace :seedify do
+  seed_list.each do |seed|
+    next if seed == 'ApplicationSeed'
+
+    desc "Call the #{seed.underscore.humanize}"
+    task seed.underscore.gsub('/', ':').sub(/_seed$/, '') => :environment do
+      seed.constantize.call(task: true)
+    end
+  end
+end

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: seedify
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Karol Słuszniak
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: scrutinizer-ocular
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Let your seed code become a first-class member of the Rails app and put
+  it into seed objects in "app/seeds" alongside the controllers, models etc. Invoke
+  seeds as rake tasks or from within the app/console, with or without the parameters.
+  Progress logging included.
+email: k.sluszniak@visuality.pl
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- README.md
+- lib/seedify.rb
+- lib/seedify/base.rb
+- lib/seedify/call_stack.rb
+- lib/seedify/logger.rb
+- lib/seedify/param_reader.rb
+- lib/seedify/param_value.rb
+- lib/seedify/railtie.rb
+- lib/seedify/storage.rb
+- lib/seedify/version.rb
+- lib/tasks/seedify.rake
+homepage: http://github.com/visualitypl/seedify
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Implement and organize seeds in Rail-ish, object-oriented fashion. Handy
+  syntax for command line parameters and progress logging.
+test_files: []