much-factory 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+--- 
+SHA512: 
+  metadata.gz: ce3cb7efa49ac5ee256b00d1753f72c15ac20e91a24b51d8f4c178150e587baa6d25ca74ebd01a87d1d2abc6675708c2d3737254df9bddb1c808a806ad1db783
+  data.tar.gz: 52ebb73ac36e7bd3a2238bb8e16f772aaa85c0a2365bf27dfa6f90d720095411db18e2b79be63423d6d67fd7440543ab374a2590eb684c12c3d44104f17bdd0e
+SHA1: 
+  metadata.gz: 444f3b8521b9c5caa52a3ee6eff9075f6f955ac5
+  data.tar.gz: 26af4aec07d3cbfd2c2c4c3cd265f7dd116e3828

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.log
+*.rbc
+.rbx/
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem 'pry', "~> 0.9.0"

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2018-Present Kelly Redding and Collin Redding
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,73 @@
+# MuchFactory
+
+MuchFactory is an API for generating randomized data.  This is intended to be brought into testing environments and used in test runs to help generate randomized test data.
+
+Note: this was originally implemented in and extracted from [Assert](https://github.com/redding/assert).
+
+## Usage
+
+```ruby
+require 'much-factory'
+
+MuchFactory.integer    #=> 15742
+MuchFactory.integer(3) #=> 2
+MuchFactory.float      #=> 87.2716908041922
+MuchFactory.float(3)   #=> 2.5466638138805
+
+MuchFactory.date       #=> #<Date: 4915123/2,0,2299161>
+MuchFactory.time       #=> Wed Sep 07 10:37:22 -0500 2016
+MuchFactory.datetime   #=> #<DateTime: 302518290593/43200,0,2299161>
+
+MuchFactory.string     #=> "boxsrbazeq"
+MuchFactory.string(3)  #=> "rja"
+MuchFactory.text       #=> "khcwyizmymajfzzxlfwz"
+MuchFactory.text(3)    #=> "qcy"
+MuchFactory.slug       #=> "licia"
+MuchFactory.slug(3)    #=> "luu"
+MuchFactory.hex        #=> "48797adb33"
+MuchFactory.hex(3)     #=> "2fe"
+MuchFactory.url        #=> "/cdqz/hqeq/zbsl"
+MuchFactory.email      #=> "vyojvtxght@gmrin.com"
+
+MuchFactory.file_name  #=> "kagahm.ybb"
+MuchFactory.path       #=> "jbzf/omyk/vbha"
+MuchFactory.dir_path   #=> "fxai/lwnq/urqu"
+MuchFactory.file_path  #=> "bcno/pzxg/gois/mpvlfo.wdr"
+
+MuchFactory.binary     #=> "\000\000\003S"
+MuchFactory.boolean    #=> false
+```
+
+You can also extend on your own factory class:
+
+```ruby
+module Factory
+  extend MuchFactory
+
+  def self.data
+    { Factory.string => Factory.string }
+  end
+end
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'much-factory'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install much-factory
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/lib/much-factory.rb

@@ -0,0 +1,161 @@
+require "much-factory/version"
+
+require 'date'
+require 'time'
+
+module MuchFactory
+  extend self
+
+  def integer(max = nil)
+    self.type_cast(Random.integer(max), :integer)
+  end
+
+  def float(max = nil)
+    self.type_cast(Random.float(max), :float)
+  end
+
+  DAYS_IN_A_YEAR = 365
+  SECONDS_IN_DAY = 24 * 60 * 60
+
+  def date
+    @date ||= self.type_cast(Random.date_string, :date)
+    @date + Random.integer(DAYS_IN_A_YEAR)
+  end
+
+  def time
+    @time ||= self.type_cast(Random.time_string, :time)
+    @time + (Random.float(DAYS_IN_A_YEAR) * SECONDS_IN_DAY).to_i
+  end
+
+  def datetime
+    @datetime ||= self.type_cast(Random.datetime_string, :datetime)
+    @datetime + (Random.float(DAYS_IN_A_YEAR) * SECONDS_IN_DAY).to_i
+  end
+
+  def string(length = nil)
+    self.type_cast(Random.string(length || 10), :string)
+  end
+
+  def text(length = nil)
+    self.type_cast(Random.string(length || 20), :string)
+  end
+
+  def slug(length = nil)
+    self.type_cast(Random.string(length || 5), :string)
+  end
+
+  def hex(length = nil)
+    self.type_cast(Random.hex_string(length), :string)
+  end
+
+  def file_name(length = nil)
+    self.type_cast(Random.file_name_string(length), :string)
+  end
+
+  def dir_path(length = nil)
+    self.type_cast(Random.dir_path_string(length), :string)
+  end
+
+  def file_path
+    self.type_cast(Random.file_path_string, :string)
+  end
+
+  alias_method :path, :dir_path
+
+  def url(host = nil, length = nil)
+    self.type_cast(Random.url_string(host, length), :string)
+  end
+
+  def email(domain = nil, length = nil)
+    self.type_cast(Random.email_string(domain, length), :string)
+  end
+
+  def binary
+    self.type_cast(Random.binary, :binary)
+  end
+
+  def boolean
+    self.type_cast(Random.integer.even?, :boolean)
+  end
+
+  def type_cast(value, type)
+    self.type_converter.send(type, value)
+  end
+
+  def type_converter; TypeConverter; end
+
+  module TypeConverter
+    def self.string(input);    input.to_s;                 end
+    def self.integer(input);   input.to_i;                 end
+    def self.float(input);     input.to_f;                 end
+    def self.datetime(input);  DateTime.parse(input.to_s); end
+    def self.time(input);      Time.parse(input.to_s);     end
+    def self.date(input);      Date.parse(input.to_s);     end
+    def self.boolean(input);   !!input;                    end
+    def self.binary(input);    input;                      end
+  end
+
+  module Random
+
+    # rand given a max int value returns integers between 0 and max-1
+    def self.integer(max = nil)
+      rand(max || 32_766) + 1
+    end
+
+    # `rand` with no args gives a float between 0 and 1
+    def self.float(max = nil)
+      (max || 100).to_f * rand
+    end
+
+    def self.date_string
+      Time.now.strftime("%Y-%m-%d")
+    end
+
+    def self.datetime_string
+      Time.now.strftime("%Y-%m-%d %H:%M:%S")
+    end
+
+    def self.time_string
+      Time.now.strftime("%H:%M:%S")
+    end
+
+    DICTIONARY = [*'a'..'z'].freeze
+    def self.string(length = nil)
+      [*0..((length || 10) - 1)].map{ |n| DICTIONARY[rand(DICTIONARY.size)] }.join
+    end
+
+    def self.hex_string(length = nil)
+      length ||= 10
+      self.integer(("f" * length).hex - 1).to_s(16).rjust(length, '0')
+    end
+
+    def self.file_name_string(length = nil)
+      length ||= 6
+      "#{self.string(length)}.#{self.string(3)}"
+    end
+
+    def self.dir_path_string(length = nil)
+      length ||= 12
+      File.join(*self.string(length).scan(/.{1,4}/))
+    end
+
+    def self.file_path_string
+      File.join(self.dir_path_string, self.file_name_string)
+    end
+
+    def self.url_string(host = nil, length = nil)
+      File.join(host.to_s, self.dir_path_string(length))
+    end
+
+    def self.email_string(domain = nil, length = nil)
+      domain ||= "#{self.string(5)}.com"
+      "#{self.string(length)}@#{domain}"
+    end
+
+    def self.binary
+      [ self.integer(10000) ].pack('N*')
+    end
+
+  end
+
+end

data/lib/much-factory/version.rb

@@ -0,0 +1,3 @@
+module MuchFactory
+  VERSION = "0.1.0"
+end

data/much-factory.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "much-factory/version"
+
+Gem::Specification.new do |gem|
+  gem.name        = "much-factory"
+  gem.version     = MuchFactory::VERSION
+  gem.authors     = ["Kelly Redding", "Collin Redding"]
+  gem.email       = ["kelly@kellyredding.com", "collin.redding@me.com"]
+  gem.summary     = "An API for generating randomized data."
+  gem.description = "An API for generating randomized data."
+  gem.homepage    = "https://github.com/redding/much-factory"
+  gem.license     = 'MIT'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency("assert", ["~> 2.16.4"])
+
+end

data/test/helper.rb

@@ -0,0 +1,19 @@
+# this file is automatically required when you run `assert`
+# put any test helpers here
+
+# add the root dir to the load path
+$LOAD_PATH.unshift(File.expand_path("../..", __FILE__))
+
+# require pry for debugging (`binding.pry`)
+require 'pry'
+
+require 'test/support/factory'
+
+# 1.8.7 backfills
+
+# Array#sample
+if !(a = Array.new).respond_to?(:sample) && a.respond_to?(:choice)
+  class Array
+    alias_method :sample, :choice
+  end
+end

data/test/support/factory.rb

@@ -0,0 +1,6 @@
+require 'assert/factory'
+
+module Factory
+  extend Assert::Factory
+
+end

data/test/unit/much-factory_tests.rb

@@ -0,0 +1,170 @@
+require 'assert'
+require 'much-factory'
+
+require 'test/support/factory'
+
+module MuchFactory
+
+  class UnitTests < Assert::Context
+    desc "MuchFactory"
+    subject{ MuchFactory }
+
+    should have_imeths :integer, :float
+    should have_imeths :date, :time, :datetime
+    should have_imeths :string, :text, :slug, :hex
+    should have_imeths :file_name, :dir_path, :file_path
+    should have_imeths :path, :url, :email
+    should have_imeths :binary, :boolean
+    should have_imeths :type_cast, :type_converter
+
+    should "return a random integer using `integer`" do
+      assert_kind_of Integer, subject.integer
+    end
+
+    should "allow passing a maximum value using `integer`" do
+      assert_includes subject.integer(2), [1, 2]
+    end
+
+    should "return a random float using `float`" do
+      assert_kind_of Float, subject.float
+    end
+
+    should "allow passing a maximum value using `float`" do
+      float = subject.float(2)
+      assert float <= 2
+      assert float >= 0
+
+      float = subject.float(0)
+      assert_equal 0.0, float
+    end
+
+    should "return a random date using `date`" do
+      assert_kind_of Date, subject.date
+    end
+
+    should "return a random time object using `time`" do
+      assert_kind_of Time, subject.time
+    end
+
+    should "return a random time object using `datetime`" do
+      assert_kind_of DateTime, subject.datetime
+    end
+
+    should "return a random string using `string`" do
+      assert_kind_of String, subject.string
+      assert_equal 10, subject.string.length
+    end
+
+    should "allow passing a maximum length using `string`" do
+      assert_equal 1, subject.string(1).length
+    end
+
+    should "return a random string using `text`" do
+      assert_kind_of String, subject.text
+      assert_equal 20, subject.text.length
+    end
+
+    should "allow passing a maximum length using `text`" do
+      assert_equal 1, subject.text(1).length
+    end
+
+    should "return a random string using `slug`" do
+      assert_kind_of String, subject.slug
+      assert_equal 5, subject.slug.length
+    end
+
+    should "allow passing a maximum length using `slug`" do
+      assert_equal 1, subject.slug(1).length
+    end
+
+    should "return a random hex string using `hex`" do
+      assert_kind_of String, subject.hex
+      assert_match /\A[0-9a-f]{10}\Z/, subject.hex
+    end
+
+    should "allow passing a maximum length using `hex`" do
+      assert_equal 1, subject.hex(1).length
+    end
+
+    should "return a random file name string using `file_name`" do
+      assert_kind_of String, subject.file_name
+      assert_match /\A[a-z]{6}\.[a-z]{3}\Z/, subject.file_name
+    end
+
+    should "allow passing a name length using `file_name`" do
+      assert_match /\A[a-z]{1}.[a-z]{3}\Z/, subject.file_name(1)
+    end
+
+    should "return a random folder path string using `dir_path`" do
+      assert_kind_of String, subject.dir_path
+      path_segments = subject.dir_path.split('/')
+      assert_equal 3, path_segments.size
+      path_segments.each{ |s| assert_match /\A[a-z]{4}\Z/, s }
+    end
+
+    should "allow passing a maximum length using `dir_path`" do
+      assert_equal 1, subject.dir_path(1).length
+    end
+
+    should "return a random folder path and file name using `file_path`" do
+      assert_kind_of String, subject.file_path
+      segments = subject.file_path.split('/')
+      assert_equal 4, segments.size
+      segments[0..-2].each{ |s| assert_match /\A[a-z]{4}\Z/, s }
+      assert_match /\A[a-z]{6}\.[a-z]{3}\Z/, segments.last
+    end
+
+    should "return a random url string using `url`" do
+      u = subject.url
+      segments = u.split('/')
+
+      assert_kind_of String, u
+      assert_match /\A\//, u
+      assert_equal 4, segments.size
+      segments[1..-1].each{ |s| assert_match /\A[a-z]{4}\Z/, s }
+    end
+
+    should "allow passing a host string using `url`" do
+      host = "example.com"
+      assert_match /\A#{host}\//, subject.url(host)
+    end
+
+    should "allow passing a maximum length using `url`" do
+      assert_equal 2, subject.url('', 1).length # plus leading '/'
+    end
+
+    should "return a random email string using `email`" do
+      e = subject.email
+      assert_kind_of String, e
+      assert_match /\A\w+@\w+\.com\Z/, e
+    end
+
+    should "allow passing a custom domain to `email`" do
+      e = subject.email('example.org')
+      assert_match /@example\.org\Z/, e
+    end
+
+    should "allow passing a mailbox length using `email`" do
+      assert_equal 2, subject.email(nil, 2).split('@').first.size
+    end
+
+    should "return a random binary string using `binary`" do
+      assert_kind_of String, subject.binary
+    end
+
+    should "return a random boolean using `boolean`" do
+      assert_includes subject.boolean.class, [ TrueClass, FalseClass ]
+    end
+
+    should "type cast values to a specified type using `type_cast`" do
+      expected = Date.parse('2013-01-01')
+      assert_equal expected, subject.type_cast('2013-01-01', :date)
+    end
+
+    should "use `TypedConverter` for the default type converter" do
+      assert_equal TypeConverter, subject.type_converter
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: much-factory
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Kelly Redding
+- Collin Redding
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2018-06-06 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: assert
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.16.4
+  type: :development
+  version_requirements: *id001
+description: An API for generating randomized data.
+email: 
+- kelly@kellyredding.com
+- collin.redding@me.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- lib/much-factory.rb
+- lib/much-factory/version.rb
+- log/.gitkeep
+- much-factory.gemspec
+- test/helper.rb
+- test/support/factory.rb
+- test/unit/much-factory_tests.rb
+- tmp/.gitkeep
+homepage: https://github.com/redding/much-factory
+licenses: 
+- MIT
+metadata: {}
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - &id002 
+    - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id002
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 2.6.6
+signing_key: 
+specification_version: 4
+summary: An API for generating randomized data.
+test_files: 
+- test/helper.rb
+- test/support/factory.rb
+- test/unit/much-factory_tests.rb