randrizer 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: be06076a3c75b00ab51471e44ef3f7b6794423f9c5dbe4f9ff9b01efb4493fb6
+  data.tar.gz: cea424a0ca6abd167ec418afbb7952c346304252f1da937f13d5eb85373ade6c
+SHA512:
+  metadata.gz: 656b7243cc9ac2be824c6060a27ed88940316f57a5acd93140b3a99043283443130bc34b774c9ed0e43867beb6b54cf941dbebf46b1509b114dad37b4d30be41
+  data.tar.gz: c5ca2206521f575429fbf281d45072f3025ba3ec5c367d971c55663209db339b7f7f0d8b173f3db1a0ceac4b6b3c6058bf162457523761138227d2ba1030b7ba

data/.gitignore

@@ -0,0 +1,12 @@
+.DS_Store
+
+.data/
+.bundle/
+log/
+tmp/
+.idea/
+
+.rspec_status
+
+.local_files
+Gemfile.lock

data/.rubocop.yml

@@ -0,0 +1,107 @@
+require: rubocop-rspec
+
+AllCops:
+  TargetRubyVersion: 2.6.5
+  DisplayCopNames: true
+  DisplayStyleGuide: true
+  ExtraDetails: true
+  Exclude:
+    - .*/**/*
+    - vendor/**/*
+    - bin/**/*
+
+Lint/UnneededCopDisableDirective:
+  Severity: error
+
+Lint/AmbiguousBlockAssociation:
+  Exclude:
+    - "spec/**/*"
+
+Metrics/AbcSize:
+  Max: 59
+
+Metrics/CyclomaticComplexity:
+  Max: 10
+
+Metrics/PerceivedComplexity:
+  Max: 9
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Max: 58
+
+Metrics/LineLength:
+  Max: 90
+  Exclude:
+    - 'Gemfile'
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/ParameterLists:
+  Max: 10
+  CountKeywordArgs: false
+
+Naming/FileName:
+  Exclude:
+    - 'Gemfile'
+
+Style/Documentation:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: "double_quotes"
+  Exclude:
+    - Gemfile
+
+Layout/IndentFirstArrayElement:
+  EnforcedStyle: consistent
+
+Layout/IndentFirstHashElement:
+  EnforcedStyle: consistent
+
+Style/YodaCondition:
+  Enabled: true
+
+RSpec/ExampleLength:
+  Enabled: false
+
+RSpec/MultipleExpectations:
+  Max: 10
+
+RSpec/NestedGroups:
+  Max: 8
+
+RSpec/ImplicitSubject:
+  Enabled: false
+
+RSpec/NamedSubject:
+  Enabled: false
+
+RSpec/LetSetup:
+  Enabled: false
+
+RSpec/ContextWording:
+  Prefixes:
+    - when
+    - with
+    - without
+    - if
+    - unless
+    - for
+    - and
+
+Naming/UncommunicativeMethodParamName:
+  AllowedNames:
+    # These are the default allowed names, set by Rubocop
+    - io
+    - id
+    # These are some custom names that we want to allow, since they aren't
+    # uncommunicative - they're actually rather meaningful!
+    - to
+    - "_"

data/.ruby-version

@@ -0,0 +1 @@
+2.7.0

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec

data/LICENCE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Vito Giuliani
+
+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,82 @@
+# Randrizer
+
+Randrizer is a small library that allows consumers to generate random data
+for testing.
+
+```ruby
+irb(main):001:0> definition = Randrizer::Types::Dict[{
+  Randrizer::Types::Const["hello"] => Randrizer::Types::String[],
+  Randrizer::Types::Const["world"] => Randrizer::Types::Int[min: 5, max: 10],
+  Randrizer::Types::Const["nested"] => Randrizer::Types::Dict[
+    {
+      Randrizer::Types::Const["nested1"] => Randrizer::Types::Float[],
+      Randrizer::Types::Optional[inner_type: Randrizer::Types::Const["nested2"]] =>
+        Randrizer::Types::Int[]
+    }
+  ]
+}]
+
+irb(main):002:0> definition.eval
+=> {"hello"=>"XN3#tQd1%5#HWXI*p9zJD!tV^\\e%Wgais]vJQRNp$Z60FymI[=8~xy0IdVrmSb)me59zbqJjTbgZsv1NQA",
+ "world"=>6,
+ "nested"=>{"nested1"=>2274302953.724733}}
+```
+
+## Use cases
+
+* Fuzzy testing: create massive amounts of random data for your application
+  to consume. Are the inputs sanitised correctly? Are invalid inputs accepted?
+* Performance testing: generate random data to be fed to your application to
+  measure throughput and performance
+* Anonymisation: replace your production data with random values 
+
+## Drivers
+
+Currently there's a single driver out of the box for simple JSON schema files.
+
+```json
+$ cat json_schema.json
+{
+  "$schema": "http://json-schema.org/draft-06/schema#",
+  "properties": {
+    "resource": {
+      "description": "A type",
+      "type": "string",
+      "enum": ["type 1", "type 2"]
+    },
+    "amount": {
+      "description": "Amount in cents",
+      "type": "integer",
+      "minimum": 0
+    },
+    "the_date": {
+      "description": "Birthday",
+      "type": "string",
+      "format": "date"
+    },
+    "country": {
+      "description": "Country code",
+      "type": "string",
+      "minLength": 2,
+      "maxLength": 2
+    }
+  },
+  "type": "object",
+  "required": [
+    "resource",
+    "amount",
+    "the_date",
+    "country"
+  ]
+}
+```
+
+```json
+$ randrizer-json-schema json_schema.json
+{
+  "resource": "type 1",
+  "amount": 302365828,
+  "the_date": "2157-09-13",
+  "country": "g-"
+}
+```

data/exe/randrizer-json-schema

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "randrizer"
+require "randrizer/cli"
+
+Randrizer::Cli.run
+exit 0

data/lib/randrizer/cli.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "randrizer/version"
+require "randrizer"
+
+module Randrizer
+  class Cli
+    def self.run
+      return help if ARGV.empty?
+
+      fname = ARGV[0]
+      unless File.exist?(fname)
+        raise ArgumentError, "#{fname} does not exist or cannot be accessed"
+      end
+
+      input_json = File.read(fname)
+      type_tree = Drivers::JSONSchema::Driver.for(content: input_json).type_tree
+      output = type_tree.eval
+      puts JSON.pretty_generate(output)
+    end
+
+    def self.help
+      STDOUT.write("Randrizer #{Randrizer::VERSION}\n")
+    end
+  end
+end

data/lib/randrizer/drivers/json_schema/driver.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "json"
+
+require "randrizer/drivers/json_schema/typegen"
+
+module Randrizer
+  module Drivers
+    module JSONSchema
+      class Driver
+        # JSON Schemas are much more complex than one would initially imagine. This is a
+        # very simple driver for basic schemas, but not all the attributes and properties
+        # of types are respected.
+        # TODO: support for list and dict datatypes
+
+        attr_reader :path
+
+        def self.for(content:)
+          parsed_content = JSON.parse(content)
+          new(parsed_content)
+        end
+
+        def initialize(parsed_schema)
+          @json = parsed_schema
+        end
+
+        def type_tree
+          dict_items = []
+
+          required_keys = json.fetch("required", [])
+          json.fetch("properties", []).map do |key, attrs|
+            key_type = Types::Const[key]
+            root_type = attrs["type"]
+            value_type = gen_value_type(root_type, attrs)
+
+            unless required_keys.include?(key_type)
+              key_type = Types::Optional[inner_type: key_type]
+            end
+
+            dict_items.append([key_type, value_type])
+          end
+
+          Types::Dict[dict_items]
+        end
+
+        private
+
+        attr_reader :json
+
+        def gen_value_type(type, attrs)
+          case type
+          when "integer"
+            Typegen.t_integer(attrs)
+          when "number"
+            Typegen.t_number(attrs)
+          when "boolean"
+            Typegen.t_boolean(attrs)
+          when "string"
+            Typegen.t_string(attrs)
+          when "null"
+            Typegen.t_null(attrs)
+          when Array
+            Types::OneOf.build(type.map { |sub_t| gen_value_type(sub_t, attrs) })
+          else
+            raise "Unsupported type: #{type}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/randrizer/drivers/json_schema/typegen.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "randrizer/types"
+
+module Randrizer
+  module Drivers
+    module JSONSchema
+      class Typegen
+        class << self
+          MONTH_INT_TYPE =
+            Types::OneOf[(1..12).map { |i| Types::Const.build(i.to_s.rjust(2, "0")) }]
+          DAY_INT_TYPE =
+            Types::OneOf[(1..31).map { |i| Types::Const.build(i.to_s.rjust(2, "0")) }]
+          HOUR_INT_TYPE =
+            Types::OneOf[(0..23).map { |i| Types::Const.build(i.to_s.rjust(2, "0")) }]
+          MIN_SEC_INT_TYPE =
+            Types::OneOf[(0..59).map { |i| Types::Const.build(i.to_s.rjust(2, "0")) }]
+
+          DATE_SEQUENCE = [
+            Types::Int.build(min: 1970, max: 2200),
+            Types::Const["-"],
+            MONTH_INT_TYPE,
+            Types::Const["-"],
+            DAY_INT_TYPE
+          ].freeze
+
+          TIMEZONE_SEQUENCE = Types::OneOf.build([
+            Types::Const["Z"],
+            Types::StringSequence.build([
+              Types::OneOf.build([Types::Const["+"], Types::Const["-"]]),
+              HOUR_INT_TYPE,
+              Types::Const[":"],
+              MIN_SEC_INT_TYPE
+            ])
+          ])
+
+          TIME_SEQUENCE = [
+            HOUR_INT_TYPE,
+            Types::Const[":"],
+            MIN_SEC_INT_TYPE,
+            Types::Const[":"],
+            MIN_SEC_INT_TYPE,
+            Types::Optional.build(inner_type: TIMEZONE_SEQUENCE)
+          ].freeze
+
+          EMAIL_SEQUENCE = [
+            Types::String.build(valid_chars: Types::String::CHARS_ALL_LETTERS + "._+"),
+            Types::Const["@"],
+            Types::String.build(valid_chars: Types::String::CHARS_ALL_LETTERS + "._")
+          ].freeze
+
+          def t_null(_attrs)
+            # `Types::Nullable` would require an inner type, as this will never change
+            # we can just return a constant null value.
+            Types::Const[nil]
+          end
+
+          def t_boolean(_attrs)
+            Types::Bool[]
+          end
+
+          def t_number(attrs)
+            # TODO: support multipleOf
+
+            restrictions = {}
+            restrictions[:min] = attrs.fetch("minimum", -999_999_999)
+            restrictions[:max] = attrs.fetch("maximum", 999_999_999)
+
+            restrictions[:min] += 1 if attrs.fetch("exclusiveMinimum", false)
+            restrictions[:max] -= 1 if attrs.fetch("exclusiveMaximum", false)
+
+            Types::Int.build(**restrictions)
+          end
+
+          def t_integer(attrs)
+            t_number(attrs)
+          end
+
+          def t_string_with_format(_attrs, format)
+            # https://json-schema.org/understanding-json-schema/reference/string.html#built-in-formats
+
+            case format
+            when "date"
+              Types::StringSequence.build(DATE_SEQUENCE)
+            when "time"
+              Types::StringSequence.build(TIME_SEQUENCE)
+            when "date-time"
+              Types::StringSequence.build([
+                DATE_SEQUENCE,
+                Types::Const["T"],
+                TIME_SEQUENCE
+              ].flatten)
+            when "email"
+              Types::StringSequence.build(EMAIL_SEQUENCE)
+            else
+              raise "Format not supported: #{format}"
+            end
+          end
+
+          def t_string(attrs)
+            # TODO: support String patterns format specs
+
+            if attrs.include?("enum")
+              return Types::OneOf[
+                attrs["enum"].map { |e| Types::Const[e] }
+              ]
+            end
+
+            if attrs.include?("format")
+              return t_string_with_format(attrs, attrs["format"])
+            end
+
+            props = {}
+            props[:min_length] = attrs["minLength"].to_i if attrs.include?("minLength")
+            props[:max_length] = attrs["maxLength"].to_i if attrs.include?("maxLength")
+
+            Types::String.build(**props)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/randrizer/drivers/json_schema.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "randrizer/drivers/json_schema/driver"

data/lib/randrizer/generator.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "randrizer/types"
+
+module Randrizer
+  class Generator
+    def self.generate(type)
+      type.validate!
+      type.eval
+    end
+  end
+end

data/lib/randrizer/types/bool.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "randrizer/types/type_builder"
+
+module Randrizer
+  module Types
+    class Bool
+      include TypeBuilder
+
+      PRESENCE_MAYBE = 0.5
+
+      def initialize(true_prob: PRESENCE_MAYBE)
+        @true_prob = true_prob
+      end
+
+      def validate!
+        raise ValidationError("true_prob must be < 1.0") if @true_prob > 1.0
+        raise ValidationError("true_prob must be > 0.0") if @true_prob < 0.0
+      end
+
+      def eval
+        rand > (1.0 - @true_prob)
+      end
+    end
+  end
+end

data/lib/randrizer/types/const.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "randrizer/types/type_builder"
+
+module Randrizer
+  module Types
+    class Const
+      include TypeBuilder
+
+      def initialize(params)
+        @params = params
+      end
+
+      def validate!; end
+
+      def eval
+        @params
+      end
+    end
+  end
+end

data/lib/randrizer/types/dict.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "randrizer/types/skip"
+require "randrizer/types/type_builder"
+
+module Randrizer
+  module Types
+    class Dict
+      include TypeBuilder
+
+      def initialize(keys_def)
+        @keys_def = keys_def
+      end
+
+      def validate!; end
+
+      def eval
+        @keys_def.each_with_object({}) do |(key_type, value_type), hash|
+          key = key_type.eval
+          value = value_type.eval
+
+          next if key == SKIP || value == SKIP
+
+          hash[key] = value
+        end
+      end
+
+      def empty?
+        @keys_def.empty?
+      end
+    end
+  end
+end

data/lib/randrizer/types/float.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "randrizer/types/type_builder"
+
+module Randrizer
+  module Types
+    class Float
+      include TypeBuilder
+
+      DEFAULT_MIN = 0.0
+      DEFAULT_MAX = 9_999_999_999.0
+
+      def initialize(min: DEFAULT_MIN, max: DEFAULT_MAX)
+        @min = min
+        @max = max
+      end
+
+      def validate!
+        return if @max >= @min
+
+        raise ValidationError("invalid min/max configuration")
+      end
+
+      def eval
+        return @min if @min == @max
+
+        rand * (@max - @min) + @min
+      end
+    end
+  end
+end

data/lib/randrizer/types/int.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "randrizer/types/type_builder"
+
+module Randrizer
+  module Types
+    class Int
+      include TypeBuilder
+
+      DEFAULT_MIN = 0
+      DEFAULT_MAX = 9_999_999_999
+
+      def initialize(min: DEFAULT_MIN, max: DEFAULT_MAX)
+        @min = min
+        @max = max
+      end
+
+      def validate!
+        return if @max >= @min
+
+        raise ValidationError("invalid min/max configuration")
+      end
+
+      def eval
+        return @min if @min == @max
+
+        rand(@min..@max)
+      end
+    end
+  end
+end

data/lib/randrizer/types/list.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "randrizer/types/skip"
+require "randrizer/types/type_builder"
+
+module Randrizer
+  module Types
+    class List
+      include TypeBuilder
+
+      def initialize(list_def)
+        @list_def = list_def
+      end
+
+      def validate!
+        !@list_def.nil?
+      end
+
+      def eval
+        @list_def.map(&:eval).reject { |evaluated| evaluated == SKIP }
+      end
+
+      def empty?
+        @list_def.empty?
+      end
+    end
+  end
+end

data/lib/randrizer/types/nullable.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "randrizer/types/type_builder"
+
+module Randrizer
+  module Types
+    class Nullable
+      include TypeBuilder
+
+      def initialize(null_prob:, inner_type:)
+        @null_prob = null_prob
+        @inner_type = inner_type
+      end
+
+      def validate!
+        raise ValidationError("null_prob must be < 1.0") if @null_prob > 1.0
+        raise ValidationError("null_prob must be > 0.0") if @null_prob < 0.0
+      end
+
+      def eval
+        return nil if rand > (1.0 - @null_prob)
+
+        @inner_type.eval
+      end
+    end
+  end
+end

data/lib/randrizer/types/one_of.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "randrizer/types/type_builder"
+
+module Randrizer
+  module Types
+    class OneOf
+      include TypeBuilder
+
+      def initialize(list_def)
+        @list_def = list_def
+      end
+
+      def validate!
+        !@list_def.nil?
+      end
+
+      def eval
+        @list_def.sample.eval
+      end
+
+      def length
+        @list_def.length
+      end
+
+      alias count length
+    end
+  end
+end

data/lib/randrizer/types/optional.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "randrizer/types/skip"
+require "randrizer/types/type_builder"
+
+module Randrizer
+  module Types
+    class Optional
+      include TypeBuilder
+
+      PRESENCE_MAYBE = 0.5
+
+      def initialize(inner_type:, presence_prob: PRESENCE_MAYBE)
+        @inner_type = inner_type
+        @presence_prob = presence_prob
+      end
+
+      def validate!
+        raise ValidationError("presence_prob must be < 1.0") if @presence_prob > 1.0
+        raise ValidationError("presence_prob must be > 0.0") if @presence_prob < 0.0
+      end
+
+      def eval
+        return SKIP if rand > @presence_prob
+
+        @inner_type.eval
+      end
+    end
+  end
+end

data/lib/randrizer/types/skip.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Randrizer
+  module Types
+    class Skip
+      def ==(other)
+        other.class == Skip
+      end
+
+      def eval
+        self
+      end
+    end
+
+    SKIP = Skip.new
+  end
+end

data/lib/randrizer/types/string.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "randrizer/types/type_builder"
+
+module Randrizer
+  module Types
+    class String
+      include TypeBuilder
+
+      CHARS_NUMBERS = "0123456789"
+      CHARS_SYMBOLS = " !\"£$%^&()=-*/[]#\\~"
+      CHARS_LOWERCASE_LETTERS = "abcdfeghijklmnopqrstuvwxyz"
+      CHARS_UPPERCASE_LETTERS = CHARS_LOWERCASE_LETTERS.upcase
+      CHARS_ALL_LETTERS = CHARS_LOWERCASE_LETTERS + CHARS_UPPERCASE_LETTERS
+
+      DEFAULT_VALID_CHARS =
+        CHARS_NUMBERS +
+        CHARS_ALL_LETTERS +
+        CHARS_SYMBOLS
+
+      DEFAULT_MIN_LENGTH = 0
+      DEFAULT_MAX_LENGTH = 99
+
+      def initialize(min_length: DEFAULT_MIN_LENGTH,
+                     max_length: DEFAULT_MAX_LENGTH,
+                     valid_chars: DEFAULT_VALID_CHARS)
+        @min_length = min_length
+        @max_length = max_length
+        @valid_chars = valid_chars
+      end
+
+      def validate!
+        return if @max_length >= @min_length
+
+        raise ValidationError("invalid length configuration")
+      end
+
+      def eval
+        chars_split = @valid_chars.split("")
+        string_length = rand(@min_length..@max_length)
+        string_length.times.map { chars_split.sample }.join
+      end
+    end
+  end
+end

data/lib/randrizer/types/string_sequence.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "randrizer/types/type_builder"
+
+module Randrizer
+  module Types
+    class StringSequence
+      include TypeBuilder
+
+      ALLOWED_TYPES = [
+        Types::Int,
+        Types::String,
+        Types::Const,
+        Types::Nullable,
+        Types::Optional,
+        Types::OneOf
+      ].freeze
+
+      def initialize(sequence_def)
+        @sequence_def = sequence_def
+      end
+
+      def validate!
+        disallowed = @sequence_def.reject { |item| ALLOWED_TYPES.include?(item.class) }
+
+        raise ValidationError("types not allowed in a string sequence: #{disallowed}")
+      end
+
+      def eval
+        @sequence_def.map(&:eval).reject { |evaluated| evaluated == SKIP }.compact.join
+      end
+
+      def empty?
+        @sequence_def.empty?
+      end
+    end
+  end
+end

data/lib/randrizer/types/type_builder.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Randrizer
+  module Types
+    module TypeBuilder
+      class ValidationError < StandardError; end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      def validate!
+        raise NotImplementedError
+      end
+
+      module ClassMethods
+        def build(*args, **params)
+          new(*args, **params)
+        end
+
+        alias [] build
+      end
+    end
+  end
+end

data/lib/randrizer/types.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# Primitive types. They should not depend on each other.
+require "randrizer/types/const"
+require "randrizer/types/bool"
+require "randrizer/types/int"
+require "randrizer/types/float"
+require "randrizer/types/string"
+require "randrizer/types/one_of"
+require "randrizer/types/skip"
+require "randrizer/types/optional"
+require "randrizer/types/nullable"
+
+# Iterable types. They might inspect the internal types to special case behaviour and
+# as such must be declared after the primitive types.
+require "randrizer/types/list"
+require "randrizer/types/dict"
+require "randrizer/types/string_sequence"

data/lib/randrizer/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Randrizer
+  VERSION = "0.0.1"
+end

data/lib/randrizer.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "randrizer/version"
+require "randrizer/types"
+require "randrizer/drivers/json_schema"

data/randrizer.gemspec

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "randrizer/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "randrizer"
+  spec.homepage      = "https://github.com/ivgiuliani/randrizer"
+  spec.version       = Randrizer::VERSION
+  spec.authors       = ["Ivan Giuliani"]
+  spec.email         = ["giuliani.v@gmail.com"]
+
+  spec.summary       = "Generate random data for testing"
+  spec.description   = "Random data generator with type composition"
+  spec.license       = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "pry-byebug", "~> 3.7.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rubocop", "~> 0.75.0"
+  spec.add_development_dependency "rubocop-rspec", "~> 1.36.0"
+end

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: randrizer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ivan Giuliani
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-02-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.7.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.7.0
+- !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.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.75.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.75.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.36.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.36.0
+description: Random data generator with type composition
+email:
+- giuliani.v@gmail.com
+executables:
+- randrizer-json-schema
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- ".ruby-version"
+- Gemfile
+- LICENCE.txt
+- README.md
+- exe/randrizer-json-schema
+- lib/randrizer.rb
+- lib/randrizer/cli.rb
+- lib/randrizer/drivers/json_schema.rb
+- lib/randrizer/drivers/json_schema/driver.rb
+- lib/randrizer/drivers/json_schema/typegen.rb
+- lib/randrizer/generator.rb
+- lib/randrizer/types.rb
+- lib/randrizer/types/bool.rb
+- lib/randrizer/types/const.rb
+- lib/randrizer/types/dict.rb
+- lib/randrizer/types/float.rb
+- lib/randrizer/types/int.rb
+- lib/randrizer/types/list.rb
+- lib/randrizer/types/nullable.rb
+- lib/randrizer/types/one_of.rb
+- lib/randrizer/types/optional.rb
+- lib/randrizer/types/skip.rb
+- lib/randrizer/types/string.rb
+- lib/randrizer/types/string_sequence.rb
+- lib/randrizer/types/type_builder.rb
+- lib/randrizer/version.rb
+- randrizer.gemspec
+homepage: https://github.com/ivgiuliani/randrizer
+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: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Generate random data for testing
+test_files: []