genny 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 775a8ea859c1d9e327238c283dccee5bc11018bf
+  data.tar.gz: 683a7a9a6549e6accbb29e87ab497a55db71d157
+SHA512:
+  metadata.gz: b12781c213a72a7f8ba5fb27a61195162d93f7ff8ee4f3ecbc1a315e975c2aabc134398b42be3c1d64de6098768e28469bdf8ec03c0efae6370857595872196b
+  data.tar.gz: baf4d7cecd6da46d907f45ab14c5e30c08606d9b46d96f30368663d0fe62c282d22c6bdd2e22352794ec50f44ab6c1dce43b55322c881e0d8bff222d29fd312d

data/README.md

@@ -0,0 +1,181 @@
+# Genny
+
+Genny likes making things up. Unlike other faker libraries this one is based around generating whole data structures using JSONSchema as a basis.
+
+This gem can be used without any additional gems. The following gems will be used if they can be loaded, but not having them installed/in your bundle will reduce functionality rather than prevent the library from working:
+
+- [json-schema](https://rubygems.org/gems/json-schema) - for JSONSchema validation
+- [faker](https://rubygems.org/gems/faker) - for better hinted strings
+
+## Examples
+
+### Extending core classes
+
+Extending the core classes to have the `genny` class method is handy, but may not be desired. If you wish to use this style then you must initialise it:
+
+```
+Genny::String.genny
+# =>  "pymliestqk" 
+String.respond_to?(:genny)
+# => false
+
+Genny.extend_core
+# => [NilClass, URI, Time, Date, Array, Float, String, Regexp, Integer, Hash]
+
+String.respond_to?(:genny)
+# => true
+String.genny
+# => "oniqpsxubm"
+```
+
+### Strings
+
+```
+Genny::String.genny
+# => "fusmtzavyi"
+Genny::String.genny(format: "ipv4")
+# => "171.199.220.179"
+
+# You can define your own formats
+Genny::String.format("tla") do |opts|
+  3.times.map { ('A'..'Z').to_a.sample }.join
+end
+Genny::String.genny(format: "tla")
+# => "XSE"
+```
+
+### Objects
+
+```
+# Genny makes JSONSchema a first class... class. It acts like a hash but has a genny instance method.
+# If the json-schema gem can be loaded then the new method will raise an error if it's an invalid schema.
+js = JSONSchema.new(
+  "type" => "object",
+  "properties" => {
+    "key" => {
+      "type" => "string"
+    }
+  }
+)
+# => {"type"=>"object", "properties"=>{"key"=>{"type"=>"string"}}, "definitions"=>{}}
+js.genny
+# => {"key"=>"gcqhsanwzd"}
+```
+
+### Arrays
+
+A generated array will always be empty unless a `:classes` option has been defined. Any class in that array that responds to `genny` may be picked as the prototype for an element of the generated array.
+
+```
+Genny::Array.genny
+# => []
+
+Genny::Array.genny(classes: [Genny::String, Genny::Integer])
+# => ["mcztjgoriq", "nohfcavjyz", 739]
+```
+
+#### Hinting
+
+```
+# Hinting for strings allows you to try and indicate what kind of string you'd like back.
+Genny::String.genny(hint: "first name")
+# => "Dean"
+Genny::String.genny(hint: "name")
+# => "Garrison O'Kon"
+
+# And when an object value type is a string, the key will be used as a hint
+JSONSchema.new(
+  "type" => "object",
+  "properties" => {
+    "name" => {
+      "type" => "string"
+    }
+  }
+).genny
+# => { "name" => "Everett Schmitt" }
+
+# You can define your own hinters. Hints defined earlier will take precidence
+Genny::String.hint do |opts|
+  next unless opts[:hint].include?("answer")
+  "42"
+end
+Genny::String.genny(hint: "the answer")
+# => "42"
+```
+
+### Numbers
+
+```
+Genny::Integer.genny
+# => 5
+Genny::Integer.genny(maximum: 100)
+# => 88
+Genny::Integer.genny(minimum: 90, maximum: 100)
+# => 92
+
+Genny::Float.genny
+# => 234.2934215006394
+Genny::Float.genny(minimum: 90, maximum: 100)
+# => 96.6691946757789 
+```
+
+### Dates & Times
+
+```
+Genny::Date.genny
+# => #<Date: 1987-03-01 ((2446856j,0s,0n),+0s,2299161j)> 
+Genny::Time.genny
+# => 1988-11-23 05:48:04 UTC 
+
+# These are also a format of string (for JSONSchema purposes)
+Genny::String.genny(format: "date")
+# => "1975-07-24"
+Genny::String.genny(format: "date-time")
+# => "1994-10-11T07:32:55Z"
+```
+
+### Boolean
+
+There being no core `Boolean` class this must be called directly even if the core classes have been extended.
+
+```
+Genny::Boolean.genny
+# => false
+Genny::Boolean.genny
+# => true
+```
+
+### URIs
+
+```
+Genny::URI.genny
+# => #<URI::HTTP:0x007f8c1c164f90 URL:http://example.com/erichqlvjx>
+
+# URIs are also a format of string (for JSONSchema purposes)
+Genny::String.genny(format: "uri")
+# => "http://example.com/itgxsewckm"
+```
+
+### Regular expressions
+
+Generating a regular expression is a bit useless (it always returns `/.*/` which matches most strings) but there is also an instance `genny` method defined which will, when I implement it, make a best effort at creating a string which matches the given regular expression.
+
+```
+Genny::Regexp.genny
+# => /.*/
+
+# The following hasn't been implemented yet. But soon!
+/[a-f0-9]{2}/.extend(Genny::Regexp).genny
+# => "a7"
+Genny.extend_core
+/[a-f0-9]{2}/.genny
+# => "5c"
+```
+
+## Contributing
+
+Yes please! Pull requests would be lovely.
+
+## Contact
+
+I am [@jphastings](https://twitter.com/jphastings) and I work at [blinkbox Books](https://github.com/blinkboxbooks), do get in touch.

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/genny/array.rb

@@ -0,0 +1,19 @@
+require "genny/base"
+
+module Genny
+  module Array
+    def self.genny(opts = {})
+      opts = Genny.symbolize(opts)
+      opts[:classes] ||= []
+      raise ArgumentError, "classes must be an array" unless opts[:classes].respond_to?(:select)
+      klasses = [*opts[:classes]].select { |klass| klass.respond_to?(:genny) }
+      return [] if klasses.empty?
+      min_count = opts[:minItems] || 1
+      max_count = opts[:maxItems] || 5
+      count = Random.rand(max_count - min_count + 1) + min_count
+      return count.times.map do
+        klasses.sample.genny(opts[:items] || {})
+      end
+    end
+  end
+end

data/lib/genny/base.rb

@@ -0,0 +1,29 @@
+require "genny/version"
+
+module Genny
+  # Extend all the Ruby bbase classes with the `genny` method.
+  #
+  # @return [Array<klass>] Returns the classes which have been extended
+  def self.extend_core
+    self.constants.map do |k|
+      genny_module = self.const_get(k)
+      if Kernel.const_defined?(k) && genny_module.is_a?(Module) && genny_module.respond_to?(:genny)
+        Kernel.const_get(k).include(genny_module).instance_eval do
+          def genny(opts = {})
+            raise NoMethodError, "#{self.name} isn't supported by Genny" unless Genny.constants.include?(self.name.to_sym)
+            Genny.const_get(self.name).genny(opts)
+          end
+        end
+        Kernel.const_get(k)
+      else
+        nil
+      end
+    end.compact
+  end
+
+  def self.symbolize(hash)
+    ::Hash[hash.map { |key, val|
+      [key.to_sym, val]
+    }]
+  end
+end

data/lib/genny/boolean.rb

@@ -0,0 +1,9 @@
+require "genny/base"
+
+module Genny
+  module Boolean
+    def self.genny(_opts = {})
+      [true, false].sample
+    end
+  end
+end

data/lib/genny/date.rb

@@ -0,0 +1,12 @@
+require "genny/base"
+
+module Genny
+  module Date
+    def self.genny(opts = {})
+      opts = Genny.symbolize(opts)
+      opts[:from] ||= ::Date.new(1970, 1, 1)
+      opts[:until] ||= ::Date.today
+      ::Date.jd(Random.rand(opts[:until].jd - opts[:from].jd) + opts[:from].jd)
+    end
+  end
+end

data/lib/genny/engines/faker.rb

@@ -0,0 +1,35 @@
+begin
+  require "faker"
+
+  module Genny::String
+    # First name
+    hint do |opts|
+      hint = opts[:hint].downcase
+      next unless hint.match("first") && hint.match("name")
+      # TODO: ensure the length limits are met
+      Faker::Name.first_name
+    end
+
+    # Last name
+    hint do |opts|
+      hint = opts[:hint].downcase
+      next unless hint.match("last") && hint.match("name")
+      # TODO: ensure the length limits are met
+      Faker::Name.last_name
+    end
+
+    # Full name
+    hint do |opts|
+      next unless opts[:hint].downcase.match("name")
+      # TODO: ensure the length limits are met
+      Faker::Name.name
+    end
+
+    # Email address
+    hint do |opts|
+      next unless opts[:hint].downcase.match("email")
+      Faker::Internet.safe_email
+    end
+  end
+rescue LoadError
+end

data/lib/genny/float.rb

@@ -0,0 +1,13 @@
+require "genny/base"
+
+module Genny
+  module Float
+    def self.genny(opts = {})
+      opts = Genny.symbolize(opts)
+      min = opts[:minimum] || 10
+      max = opts[:maximum] || 1000
+      # TODO: exclusive minimum/maximum
+      Random.rand * (max - min) + min
+    end
+  end
+end

data/lib/genny/integer.rb

@@ -0,0 +1,12 @@
+require "genny/base"
+
+module Genny
+  module Integer
+    def self.genny(opts = {})
+      opts = Genny.symbolize(opts)
+      min = opts[:minimum] || 10
+      max = opts[:maximum] || 1000
+      Random.rand(max - min + 1) + min
+    end
+  end
+end

data/lib/genny/json_schema.rb

@@ -0,0 +1,85 @@
+require "genny/base"
+require "delegate"
+
+class JSONSchema < SimpleDelegator
+  VALIDATE = begin
+    require "json-schema"
+    true
+  rescue LoadError
+    false
+  end
+
+  def initialize(hash, validate: VALIDATE, definitions: {})
+    # TODO: ensure it's a valid schema if VALIDATE
+    hash['definitions'] = (definitions || {}).merge(hash['definitions'] || {})
+    super(hash)
+  end
+
+  def genny
+    opts = Genny.symbolize(self)
+    return opts[:enum].sample if opts.has_key?(:enum)
+    return schema_from_ref(opts[:'$ref']).genny if opts[:'$ref']
+
+    klass = {
+      "array" => Genny::Array,
+      "boolean" => Genny::Boolean,
+      "number" => Genny::Float,
+      "object" => Genny::Hash,
+      "integer" => Genny::Integer,
+      "null" => Genny::NilClass,
+      "string" => Genny::String,
+      nil => Genny::Hash
+    }[opts[:type]]
+    raise "Cannot generate JSON Schema object of type '#{opts[:type]}'." unless klass.respond_to?(:genny)
+    klass.genny(opts)
+  end
+
+  private
+
+  # Deals with JSON-Schema valid "#/definitions/xyz" style references and Swagger style "Thing" style.
+  def schema_from_ref(name)
+    if self['definitions'][name]
+      subschema = self['definitions'][name]
+    elsif name.match(%r{^#/(.+)$})
+      subschema = self.dup
+      Regexp.last_match[1].split("/").each { |key| subschema = subschema[key] }
+    end
+
+    return JSONSchema.new(
+      subschema,
+      definitions: self['definitions'],
+      validate: false
+    ) if subschema
+    raise "Unknown definition"
+  rescue
+    raise "Cannot find definition #{name}"
+  end
+end
+
+module Genny
+  module Hash
+    @@additional_properties = 1
+
+    def self.additional_properties=(chance)
+      raise ArgumentError, "chance must be a probability between 0 and 1" if chance < 0 || chance > 1
+      @@additional_properties = chance
+    end
+
+    def self.genny(opts = {})
+      opts = Genny.symbolize(opts)
+      ::Hash[(opts[:properties] || {}).map { |key, schema_object|
+        next nil if !(opts[:required] || []).include?(key) && Random.rand > @@additional_properties
+        [
+          key,
+          JSONSchema.new(
+            schema_object.merge(
+              hint: [key, opts[:hint]].compact.join(" ")
+            ),
+            definitions: opts[:definitions],
+            validate: false
+          ).genny
+        ]
+      }.compact]
+    end
+  end
+end

data/lib/genny/nil.rb

@@ -0,0 +1,10 @@
+require "genny/base"
+
+module Genny
+  # This one's a bit useless, but it makes mapping the JsonSchema stuff easier
+  module NilClass
+    def self.genny(_opts = {})
+      nil
+    end
+  end
+end

data/lib/genny/regexp.rb

@@ -0,0 +1,14 @@
+require "genny/base"
+
+module Genny
+  module Regexp
+    # A bit unecessary, but who knows, maybe someone will have use for it
+    def self.genny(_opts = {})
+      %r{.*}
+    end
+
+    def genny(opts = {})
+      raise NotImplementedError, "I gotta get some sleep. Genny can't make strings which fit Regexps... yet."
+    end
+  end
+end

data/lib/genny/string.rb

@@ -0,0 +1,36 @@
+require "genny/base"
+
+module Genny
+  module String
+    @@formats = {}
+    @@hints = []
+
+    def self.format(format, &block)
+      @@formats[format] = block
+    end
+
+    def self.hint(&block)
+      @@hints.push(block)
+    end
+
+    def self.genny(opts = {})
+      opts = Genny.symbolize(opts)
+      viable_formats = @@formats.keys & [*opts[:format]]
+      return @@formats[viable_formats.sample].call(opts) unless viable_formats.empty?
+      guess = @@hints.inject(nil) { |guess, hint|
+        break guess if !(guess = hint.call(opts)).nil?
+      } if opts[:hint]
+      return guess unless guess.nil?
+      opts[:minLength] ||= 10
+      opts[:maxLength] ||= 10
+      length = Random.rand(opts[:maxLength] - opts[:minLength] + 1) + opts[:minLength]
+      ('a'..'z').to_a.sample(length).join
+    end
+
+    format("date-time") { |opts| Genny::Time.genny(opts).iso8601 }
+    format("date")      { |opts| Genny::Date.genny(opts).iso8601 }
+    format("ipv4")      { |opts| 4.times.map { Random.rand(255) }.join(".") }
+    format("ipv6")      { |opts| 8.times.map { Random.rand(65536).to_s(16).rjust(4, "0") }.join(":") }
+    format("uri")       { |opts| Genny::URI.genny(opts).to_s }
+  end
+end

data/lib/genny/time.rb

@@ -0,0 +1,10 @@
+require "genny/base"
+require "time"
+
+module Genny
+  module Time
+    def self.genny(_opts = {})
+      ::Time.at(Random.rand(::Time.now.to_i)).utc
+    end
+  end
+end

data/lib/genny/uri.rb

@@ -0,0 +1,11 @@
+require "genny/base"
+require "uri"
+
+module Genny
+  module URI
+    def self.genny(opts = {})
+      opts = Genny.symbolize(opts)
+      ::URI::HTTP.build(host: opts[:host] || 'example.com', path: "/#{Genny::String.genny}")
+    end
+  end
+end

data/lib/genny/version.rb

@@ -0,0 +1,7 @@
+module Genny
+  VERSION = begin
+    File.read(File.join(__dir__, "../../../VERSION")).strip
+  rescue Errno::ENOENT
+    "0.0.0-unknown"
+  end
+end

data/lib/genny.rb

@@ -0,0 +1,15 @@
+require "genny/base"
+
+require "genny/nil"
+require "genny/uri"
+require "genny/time"
+require "genny/date"
+require "genny/array"
+require "genny/float"
+require "genny/string"
+require "genny/regexp"
+require "genny/integer"
+require "genny/boolean"
+require "genny/json_schema"
+
+require "genny/engines/faker"

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: genny
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- JP Hastings-Spital
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Genny likes to make things up. It generates ruby objects, mainly from
+  JSON Schema.
+email:
+- jphastings@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- README.md
+- VERSION
+- lib/genny.rb
+- lib/genny/array.rb
+- lib/genny/base.rb
+- lib/genny/boolean.rb
+- lib/genny/date.rb
+- lib/genny/engines/faker.rb
+- lib/genny/float.rb
+- lib/genny/integer.rb
+- lib/genny/json_schema.rb
+- lib/genny/nil.rb
+- lib/genny/regexp.rb
+- lib/genny/string.rb
+- lib/genny/time.rb
+- lib/genny/uri.rb
+- lib/genny/version.rb
+homepage: ''
+licenses: []
+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: Genny likes to make things up. It generates ruby objects, mainly from JSON
+  Schema.
+test_files: []