model_grinder 1.0.0

data/lib/model_grinder.rb

@@ -0,0 +1,133 @@
+module ModelGrinder; end
+
+require 'model_grinder/class_methods'
+
+##
+# = Introduction
+# Model Grinder is a library to make the generation of data for use in tests. It is inspired by dm-sweatshop and is
+# intended for use in all ORMs, not just DataMapper.
+#
+# == Setup
+# To use with one ORM, pass the name of the ORM to ModelGrinder.integrate via a symbol. Like so:
+#    ModelGrinder.integrate(:datamapper)
+# Currently the options are :datamapper, :activerecord, and :mongoid. I'm still trying to get Mongoid to work
+# properly, so be patient. If you wish to simply have it load for all available ORMs, pass the argument of :all instead
+# of the ORM name.
+#
+# Note that you do not have to integrate if you wish to use the ModelGrinder to make all the calls instead of calling
+# directly on the models.
+#
+# == Usage
+# === Templates
+# An example is worth ten million words and two examples are worth twenty million, I suppose. Both are identical -
+# the second sets up and calls the same methods the first one does.
+#
+#  ModelGrinder.template(YourModel, :valid ) {{
+#    name: /\w+/.gen,
+#    some_text: /[:sentence]/.gen
+#    some_number: rand(5938571234)
+#  }}
+#
+#  YourModel.template(:valid) {{
+#    name: /\w+/.gen,
+#    some_text: /[:sentence]/.gen
+#    some_number: rand(5938571234) + 6
+#  }}
+#
+# Your first question might be: "what the crap is up with the double curly braces??" Well, the first curly brace is
+# the beginning of the block, the second curly brace is the beginning of the hash. You pass a hash inside a block so
+# that the library can call this block multiple times and get different results. Anything you want to stay the same
+# you pass in as a static value, anything you want to be different you pass in some sort of random generator.
+#
+# This library includes the randexp gem, which is used in these examples to generate random data. You can read more about
+# it here at https://github.com/benburkert/randexp. However, you can use whatever libraries or methods you would like
+# to generate the data.
+#
+# === Using The Templates
+# If you'd like to get the hash by itself:
+#  ModelGrinder.gen_hash(YourModel, :valid, name: "Your mom" )
+# or
+#  YourModel.gen_hash(:valid, name: "Your mom")
+# Anything you pass in the last hash will override the values in the hash generated by the template.
+#
+# If you'd like to have them assigned to a model instance, use:
+#  ModelGrinder.generate(YourModel, :valid, name: "Your mom")
+# or
+#  YourModel.generate(:valid, name: "Your mom")
+#
+# If you'd like to persist the model to the data store (by calling "save" on the instance), use the build method instead
+# with the same arguments. It will return the instance for you to manipulate later.
+#
+module ModelGrinder
+
+  extend ActiveSupport::Concern if const_defined?(:ActiveSupport)
+
+  # List of supported ORMs
+  # TODO: get Mongoid working!
+  ORMS = {
+      datamapper: lambda { |obj| DataMapper::Model.append_extensions obj },
+      activerecord: lambda { |obj| ActiveRecord::Base.extend obj },
+      mongoid: lambda { |obj|
+        if Mongoid.respond_to?(:models)
+          Mongoid.models.each { |o| o.extend obj}
+        else
+          # Find all the mongoids, find them all!
+          ObjectSpace.each_object(Class) { |o|
+            next unless o.ancestors.include?(Mongoid::Components)
+            o.extend obj
+          }
+        end
+      },
+      all: nil
+  }
+
+  extend ClassMethods
+
+  def self.extended(klass) # :nodoc:
+    klass.send(:extend,  ModelGrinder::ClassMethods)
+  end
+
+  # Integrate Model Grinder into an ORM, or to all available ORMs
+  #
+  # @param [Symbol] orm can either be :datamapper, :activerecord, :mongoid, or :all
+  #
+  def self.integrate(orm)
+    if orm == :all
+      ORMS.each { |k,v|
+        next if v.nil?
+        begin
+          v.call(self)
+        rescue
+          puts "Unable to extend #{k}"
+        end
+      }
+    else
+      if ORMS[orm]
+        ORMS[orm].call(self)
+      else
+        raise ArgumentError.new(
+          "Unsupported argument: #{orm.inspect}. Valid options: #{ORMS.keys.map { |v| v.inspect }.join(', ')}"
+        )
+      end
+    end
+  end
+
+  # Clears all currently defined templates
+  #
+  def self.clear_templates!
+    @_mg_templates = {}
+  end
+
+  # The templates currently defined
+  #
+  # @return [Hash]
+  #
+  def self.templates
+    @_mg_templates ||= {}
+  end
+
+  def self._generated
+    @_mg_generated ||= {}
+  end
+
+end

data/lib/model_grinder/class_methods.rb

@@ -0,0 +1,148 @@
+module ModelGrinder
+  ##
+  # Please see the documentation for the module ModelGrinder for full documentation.
+  #
+  module ClassMethods
+
+    # Sets up a template that's a block which contains a hash (for pseudo-random generation later). A bit of magic is
+    # used to make the first argument optional on all methods.
+    #
+    # @param [Class] klass The class that's attached to the template (optional)
+    # @param [Symbol] name The name of the template (optional, defaults to :default)
+    # @raise [ArgumentError] on no block passed
+    # @return [Proc] The passed block
+    #
+    def template(*args, &blk)
+      #TODO: check to make sure block returns hash
+      raise ArgumentError.new('A block that contains a hash must be passed to template.') unless block_given?
+      klass, name = parse_args(args)
+      _mg_templates[klass] ||= {}
+      _mg_templates[klass][name] = blk
+    end
+
+    alias :fix :template
+    alias :fixture :template
+    alias :t :template
+
+
+    # Generates a new hash from a template found by the Class and name passed. A bit of magic is used to make the first
+    # argument optional on all methods.
+    #
+    # @param [Class] klass The class that's attached to the template (optional)
+    # @param [Symbol] name The name of the template (optional, defaults to :default)
+    # @param [Hash] override_attrs Values to assign to the hash irrespective of the template
+    # @raise [ArgumentError] if template does not exist.
+    #
+    def gen_hash(*args)
+      klass, name, override_attrs = parse_args(args)
+      raise ArgumentError.new("The template `#{name}` for `#{klass}` does not exist.") unless _mg_templates[klass] && _mg_templates[klass][name]
+      attrs = _mg_templates[klass][name].call
+      attrs.merge!(override_attrs) if override_attrs
+      attrs
+    end
+
+    alias :genh :gen_hash
+
+    # Generates a new hash from a template on a class and creates a new object. Class must respond to new and accept
+    # a hash as the first and only argument.
+    #
+    # @param (see #gen_hash)
+    # @return [Class]
+    #
+    def generate(*args)
+      klass, name, attrs = parse_args(args)
+      # This returns the model instance
+      _mg_store_generated(
+          klass,
+          name,
+          klass.new(gen_hash(*args) || {})
+      )
+    end
+
+    alias :gen :generate
+    alias :make :generate
+
+
+    # Picks a specified number of already generated models
+    #
+    # @param [Class] klass The class that's attached to the template (optional)
+    # @param [Symbol] name The name of the template (optional, defaults to :default)
+    # @param [Hash] options Currently the only option is number of models returned (e.g. number: 3)
+    # @return [Array] An array of the number of generated models, up to the number actually generated.
+    def pick(*args)
+      klass, name, hash = parse_args(args)
+      hash[:number] ||= 1
+      return [] unless _mg_generated[klass].is_a?(Hash) && _mg_generated[klass][name].is_a?(Array)
+      _mg_generated[klass][name].sample hash[:number]
+    end
+
+    # Generates a new hash from a template on a class, creates a new object, and persists it to the datastore. Class must
+    # respond to new, accept a hash as the first and only argument, and respond to save.
+    #
+    # @param (see #gen_hash)
+    # @return [Class]
+    #
+    def build(*args)
+      model = generate(*args)
+      model.save
+      model
+    end
+
+    private
+
+    # Parses out the class, fixture name, and override attributes from the arguments
+    #
+    # @param [Array] args The array of arguments passed to the calling method.
+    # @raise  [ArgumentError] if invalid/out of order arguments are passed
+    # @return [Class/Module, Symbol, Hash]
+    #
+    def parse_args(args)
+      error = false
+      new_args = []
+      args.each { |arg|
+        case arg
+          when Class, Module
+            new_args[0] = arg
+          when Symbol, String
+            new_args[1] = arg.to_sym
+          when Hash
+            new_args[2] = arg
+        end
+      }
+      args = new_args
+      case args.size
+        when 3,2,1 # do nothing
+        else error = true
+      end
+      args[0] ||= self
+      args[1] ||= :default
+      args[2] ||= {}
+      error = true unless args[0].is_a?(Class) || args[0].is_a?(Module)
+      error = true unless args[1].is_a?(Symbol)
+      error = true unless args[2].is_a?(Hash)
+      raise ArgumentError.new(
+                'Invalid arguments passed. Valid syntax: class(opt), fixture_name (symbol, required), hash (opt)'
+            ) if error == true
+      return *args
+    end
+
+  private
+
+    # References the global template hash
+    def _mg_templates
+      @_mg_templates ||= ModelGrinder.templates
+    end
+
+    def _mg_generated
+      @_mg_generated ||= ModelGrinder._generated
+    end
+
+    def _mg_store_generated(klass, name, instance)
+      _mg_generated[klass] ||= {}
+      _mg_generated[klass][name] ||= []
+      _mg_generated[klass][name] << instance
+      instance
+    end
+
+  end
+end

data/lib/model_grinder/ruby_hacks.rb

@@ -0,0 +1,18 @@
+unless Array.respond_to?(:sample)
+  class Array
+    def sample(num = 1)
+      ret = []
+      already_picked = []
+      (1..num).each { |i|
+        break if i > length
+        i2 = rand(length - 1)
+        while already_picked.include?(i2)
+          i2 = rand(length - 1)
+        end
+        already_picked << i2
+        ret << self[i2]
+      }
+      ret
+    end
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: model_grinder
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Jeremy Nicoll
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: randexp
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: An ORM agnostic way to generate models for testing
+email: jrnicoll@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/model_grinder/class_methods.rb
+- lib/model_grinder/ruby_hacks.rb
+- lib/model_grinder.rb
+homepage: http://rubygems.org/gems/model_grinder
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Grind out model data
+test_files: []
+has_rdoc: