much-factory 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
---- 
-SHA512: 
-  metadata.gz: ce3cb7efa49ac5ee256b00d1753f72c15ac20e91a24b51d8f4c178150e587baa6d25ca74ebd01a87d1d2abc6675708c2d3737254df9bddb1c808a806ad1db783
-  data.tar.gz: 52ebb73ac36e7bd3a2238bb8e16f772aaa85c0a2365bf27dfa6f90d720095411db18e2b79be63423d6d67fd7440543ab374a2590eb684c12c3d44104f17bdd0e
-SHA1: 
-  metadata.gz: 444f3b8521b9c5caa52a3ee6eff9075f6f955ac5
-  data.tar.gz: 26af4aec07d3cbfd2c2c4c3cd265f7dd116e3828
+---
+SHA256:
+  metadata.gz: 724bcba5bca34b1c458a9a96a63e3b2f5add77642cc6bdb10c68636a8c2f2e3e
+  data.tar.gz: 1619a18b41368f44345ae3cfd91f28003aa9ffd035eb1840d2d4bcc953100b89
+SHA512:
+  metadata.gz: 7205c437919dcd3f1cc9b203ca81b53887a8a2c87a6c5c64821c901b09ccd453ded45fff8279df3c4bb6eca343909f2e8f70884477d54c4893fd333469121114
+  data.tar.gz: f4109ebebecb364f1b41da0038bb71ad7dc787a334d612d5d368eb8684dfc4f64b20f28b7d52c2e32250e3e0b8ed2b9746ae1901aa952b2f6d669a9c58e35780

data/Gemfile

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

data/README.md

@@ -7,7 +7,7 @@ Note: this was originally implemented in and extracted from [Assert](https://git
 ## Usage
 
 ```ruby
-require 'much-factory'
+require "much-factory"
 
 MuchFactory.integer    #=> 15742
 MuchFactory.integer(3) #=> 2
@@ -20,6 +20,8 @@ MuchFactory.datetime   #=> #<DateTime: 302518290593/43200,0,2299161>
 
 MuchFactory.string     #=> "boxsrbazeq"
 MuchFactory.string(3)  #=> "rja"
+MuchFactory.symbol     #=> :sfdhortksj
+MuchFactory.symbol(3)  #=> :emh
 MuchFactory.text       #=> "khcwyizmymajfzzxlfwz"
 MuchFactory.text(3)    #=> "qcy"
 MuchFactory.slug       #=> "licia"
@@ -54,7 +56,7 @@ end
 
 Add this line to your application's Gemfile:
 
-    gem 'much-factory'
+    gem "much-factory"
 
 And then execute:
 

data/lib/much-factory.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require "much-factory/version"
 
-require 'date'
-require 'time'
+require "date"
+require "time"
 
 module MuchFactory
   extend self
@@ -36,6 +38,10 @@ module MuchFactory
     self.type_cast(Random.string(length || 10), :string)
   end
 
+  def symbol(*args)
+    self.string(*args).to_sym
+  end
+
   def text(length = nil)
     self.type_cast(Random.string(length || 20), :string)
   end
@@ -82,21 +88,22 @@ module MuchFactory
     self.type_converter.send(type, value)
   end
 
-  def type_converter; TypeConverter; 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
+    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
@@ -119,14 +126,14 @@ module MuchFactory
       Time.now.strftime("%H:%M:%S")
     end
 
-    DICTIONARY = [*'a'..'z'].freeze
+    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')
+      self.integer(("f" * length).hex - 1).to_s(16).rjust(length, "0")
     end
 
     def self.file_name_string(length = nil)
@@ -153,9 +160,7 @@ module MuchFactory
     end
 
     def self.binary
-      [ self.integer(10000) ].pack('N*')
+      [ self.integer(10000) ].pack("N*")
     end
-
   end
-
 end

data/lib/much-factory/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MuchFactory
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/much-factory.gemspec

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 # -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "much-factory/version"
 
@@ -11,13 +13,14 @@ Gem::Specification.new do |gem|
   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.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"])
+  gem.required_ruby_version = "~> 2.5"
 
+  gem.add_development_dependency("assert", ["~> 2.19.0"])
 end

data/test/helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # this file is automatically required when you run `assert`
 # put any test helpers here
 
@@ -5,15 +7,6 @@
 $LOAD_PATH.unshift(File.expand_path("../..", __FILE__))
 
 # require pry for debugging (`binding.pry`)
-require 'pry'
-
-require 'test/support/factory'
-
-# 1.8.7 backfills
+require "pry"
 
-# Array#sample
-if !(a = Array.new).respond_to?(:sample) && a.respond_to?(:choice)
-  class Array
-    alias_method :sample, :choice
-  end
-end
+require "test/support/factory"

data/test/support/factory.rb

@@ -1,4 +1,6 @@
-require 'assert/factory'
+# frozen_string_literal: true
+
+require "assert/factory"
 
 module Factory
   extend Assert::Factory

data/test/unit/much-factory_tests.rb

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

metadata

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