json_schema-faker 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4fe0bd03f8a005b3e787b728ce7287db41612d36
-  data.tar.gz: ab3c402bb39c68ee5c3c9102b5dcbc5dccc370d4
+  metadata.gz: 9a48c2a0057da8ee6de1652e93757976bda7579f
+  data.tar.gz: ce9fba20b0e52dfb882311a2c6959b10f6c7431d
 SHA512:
-  metadata.gz: 8cfdfcb77c087e913d4d555a6793a948a847f7dae5b4fe9722cc3f844a10a1f5f1b6b14b54ef20db7909faef0e59263bc71e32f0aba1d95af0f5f23f1c8005c7
-  data.tar.gz: 25b74a451865ab813ed00c2575fe8b43eab4775a6503dbf984baefbb4a794236c828d5a2e0b620115cc8af055e5c2caa470b3e0f91643e48eadea7d6fe787bed
+  metadata.gz: f2aa83f9038c66b9c569b35b1fafac65b08638c99b00635c3daf24119ec26c43094e7e8607c9678de66ead6eefde411eca0ed94dd77b0d7374be9b0f290df82b
+  data.tar.gz: '0558dcd25334eda4711868fd89e7d291195ccc32013bb37aabaebdf90cd05d430fd61e6b0f55558d2eab33f4f52f749c1604db8f42b3e54595d163f37bfef7ec'

data/.circleci/config.yml

@@ -0,0 +1,37 @@
+# Ruby CircleCI 2.0 configuration file
+#
+# Check https://circleci.com/docs/2.0/language-ruby/ for more details
+#
+version: 2
+jobs:
+  build:
+    docker:
+       - image: circleci/ruby:2.4.1
+
+    working_directory: ~/repo
+
+    steps:
+      - checkout
+
+      # Download and cache dependencies
+      - restore_cache:
+          keys:
+          - v1-dependencies-{{ checksum "Gemfile.lock" }}
+          # fallback to using the latest cache if no exact match is found
+          - v1-dependencies-
+
+      - run:
+          name: install dependencies
+          command: |
+            bundle install --jobs=4 --retry=3 --path vendor/bundle
+
+      - save_cache:
+          paths:
+            - ./venv
+          key: v1-dependencies-{{ checksum "Gemfile.lock" }}
+
+      # run tests!
+      - run:
+          name: run tests
+          command: |
+            bundle exec danger

data/.travis.yml

@@ -1,6 +1,8 @@
 sudo: false
 language: ruby
 rvm:
+  - ruby-head
+  - 2.4.1
   - 2.3.1
   - 2.2.5
 before_install: gem install bundler -v 1.12.3

data/CHANGELOG.md

@@ -1,22 +1,29 @@
+## 0.5.0
+
+* Added
+  * ::JsonSchema::Faker::Util. utility for json_schema
+* Removed
+  * ::JsonSchema::Faker::Strategy::Simple.merge_schema! is removed. use ::JsonSchema::Faker::Util.take_logical_and_of_schema instead.
+
 ## 0.4.0
 
-* ADDED
- * Greedy strategy to use properties as much as possible (suitable to response generation)
+* Added
+  * Greedy strategy to use properties as much as possible (suitable to response generation)
 
 ## 0.3.0
 
-* ENHANCEMENT
- * can add faker to format
+* Added
+  * can add faker to format
 
 ## 0.2.0
 
-* ENHANCEMENT
- * support example as hint
+* Added
+  * support example as hint
 
 ## 0.1.1
 
-* IMPROVEMENT
- * refactor and improve generation
+* Added
+  * refactor and improve generation
 
 ## 0.1.0
 

data/Dangerfile

@@ -0,0 +1 @@
+rspec_no_filter.warn_for_rspec_filter

data/README.md

@@ -28,7 +28,7 @@ raw_schema = {
   "required"   => [ "a" ],
 }
 
-schema = JsonSchema::Schema.parse(raw_schema)
+schema = JsonSchema.parse!(raw_schema)
 
 JsonSchema::Faker.new(schema).generate #=> { "a" => "e" }
 ```

data/VERSION

@@ -1 +1 @@
-0.4.0
+0.5.0

data/json_schema-faker.gemspec

@@ -24,6 +24,11 @@ Gem::Specification.new do |spec|
   # test
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "activesupport"
+
+  # check pr
+  spec.add_development_dependency "danger"
+  spec.add_development_dependency "danger-rspec_no_filter"
 
   # debug
   spec.add_development_dependency "pry"

data/lib/json_schema/faker/strategy/greedy.rb

@@ -21,22 +21,27 @@ module JsonSchema::Faker::Strategy
         {}
       end
 
-      # http://json-schema.org/latest/json-schema-validation.html#anchor53
-      required_length = schema.max_properties || [ schema.properties.size, (schema.min_properties || 0) ].max
-
-      keys = ((schema.required || [])+ (schema.properties || {}).keys).uniq - object.keys
-      keys -= hint[:not_have_keys] if hint && hint[:not_have_keys]
+      if hint && hint[:not_have_keys]
+        candidates      = schema.properties.keys - object.keys - hint[:not_have_keys]
+        required_length = schema.max_properties || [ (schema.properties.keys - hint[:not_have_keys]).size, (schema.min_properties || 0) ].max
+      else
+        candidates      = schema.properties.keys - object.keys
+        required_length = schema.max_properties || [ schema.properties.keys.size, (schema.min_properties || 0) ].max
+      end
 
-      keys.first(required_length).each.with_object(object) do |key, hash|
+      # http://json-schema.org/latest/json-schema-validation.html#anchor53
+      # TODO: candidates.shift(required_length)
+      candidates.first(required_length).each.with_object(object) do |key, hash|
         hash[key] = generate(schema.properties[key], hint: hint, position: "#{position}/#{key}")
       end
+      candidates = candidates - object.keys
 
       # if length is not enough
       if schema.additional_properties === false
         (required_length - object.keys.length).times.each.with_object(object) do |i, hash|
           if schema.pattern_properties.empty?
-            key = (schema.properties.keys - object.keys).first
-            hash[key] = generate(schema.properties[key], hint: hint, position: "#{position}/#{key}")
+            key = candidates.pop
+            hash[key] = generate(schema.properties[key], hint: hint, position: "#{position}/#{key}") if key
           else
             name = ::Pxeger.new(schema.pattern_properties.keys.first).generate
             hash[name] = generate(schema.pattern_properties.values.first, hint: hint, position: "#{position}/#{name}")
@@ -51,7 +56,6 @@ module JsonSchema::Faker::Strategy
 
       # consider dependency
       depended_keys = object.keys & schema.dependencies.keys
-
       # FIXME: circular dependency is not supported
       depended_keys.each.with_object(object) do |key, hash|
         dependency = schema.dependencies[key]
@@ -61,7 +65,7 @@ module JsonSchema::Faker::Strategy
           hash.update(generate(schema.dependencies[key], hint: nil, position: "#{position}/dependencies/#{key}"))
         else
           dependency.each do |additional_key|
-            object[additional_key] = generate(schema.properties[additional_key], hint: hint, position: "#{position}/dependencies/#{key}/#{additional_key}") unless object.has_key?(additional_key)
+            hash[additional_key] = generate(schema.properties[additional_key], hint: hint, position: "#{position}/dependencies/#{key}/#{additional_key}") unless object.has_key?(additional_key)
           end
         end
       end

data/lib/json_schema/faker/strategy/simple.rb

@@ -1,5 +1,9 @@
+require "json_schema/faker/util"
+
 module JsonSchema::Faker::Strategy
   class Simple
+    include ::JsonSchema::Faker::Util
+
     class << self
       def formats
         @formats ||= {}
@@ -171,7 +175,7 @@ module JsonSchema::Faker::Strategy
         if schema.items.is_a?(Array)
           items = schema.items.map.with_index {|e, i| generate(e, hint: hint, position: "#{position}/items[#{i}]") }
 
-          items + (length - items.size).map.with_index {|i| schema.additional_items === false ? i : generate(schema.additional_items, hint: hint, position: "#{position}/additional_items[#{i}]") }
+          items + (length - items.size).times.map.with_index {|i| schema.additional_items === false ? i : generate(schema.additional_items, hint: hint, position: "#{position}/additional_items[#{i}]") }
         else
           length.times.map.with_index {|i| generate(schema.items, hint: hint, position: "#{position}/items[#{i}]") }
         end
@@ -218,15 +222,7 @@ module JsonSchema::Faker::Strategy
       end
     end
 
-    def compact_and_merge_schema(a, b, a_position:, b_position:)
-      merge_schema!(
-        compact_schema(a, position: a_position),
-        compact_schema(b, position: b_position),
-        a_position: a_position,
-        b_position: b_position
-      )
-    end
-
+    # TODO: compacting all_of and one_of/any_of at once will not work
     def compact_schema(schema, position:)
       return schema if schema.one_of.empty? && schema.any_of.empty? && schema.all_of.empty?
 
@@ -241,108 +237,57 @@ module JsonSchema::Faker::Strategy
       merged_schema.any_of = []
       merged_schema.all_of = []
 
-      unless schema.one_of.empty?
-        ::JsonSchema::Faker::Configuration.logger.info "compact one_of" if ::JsonSchema::Faker::Configuration.logger
-        compact_and_merge_schema(merged_schema, schema.one_of.first, a_position: position, b_position: "#{position}/one_of[0]")
-      end
-
-      unless schema.any_of.empty?
-        ::JsonSchema::Faker::Configuration.logger.info "compact any_of" if ::JsonSchema::Faker::Configuration.logger
-        compact_and_merge_schema(merged_schema, schema.any_of.first, a_position: position, b_position: "#{position}/any_of[0]")
-      end
-
       unless schema.all_of.empty?
         ::JsonSchema::Faker::Configuration.logger.info "compact all_of" if ::JsonSchema::Faker::Configuration.logger
-        all_of = ::JsonSchema::Schema.new
-        all_of.copy_from(schema.all_of.first)
 
-        all_of = schema.all_of[1..-1].each.with_index.inject(all_of) do |(a, _), (b, i)|
-          compact_and_merge_schema(a, b, a_position: "#{position}/all_of", b_position: "#{position}/all_of[#{i+1}]")
+        all_of = schema.all_of.each.with_index.inject(nil) do |(a, _), (b, i)|
+          if a
+            take_logical_and_of_schema(a, b, a_position: "#{position}/all_of", b_position: "#{position}/all_of[#{i+1}]")
+          else
+            b
+          end
         end
 
-        merge_schema!(merged_schema, all_of, a_position: position, b_position: "#{position}/all_of")
-      end
-
-      ::JsonSchema::Faker::Configuration.logger.debug "compacted: #{merged_schema.inspect_schema}" if ::JsonSchema::Faker::Configuration.logger
-
-      merged_schema
-    end
-
-    def merge_schema!(a, b, a_position:, b_position:)
-      if ::JsonSchema::Faker::Configuration.logger
-        ::JsonSchema::Faker::Configuration.logger.info "start to merge at #{a_position} with #{b_position}"
-        ::JsonSchema::Faker::Configuration.logger.debug "a: #{a.inspect_schema}"
-        ::JsonSchema::Faker::Configuration.logger.debug "b: #{b.inspect_schema}"
-      end
-      # attr not supported now
-      # not:        too difficult (if `not` is not wrapped by all_of wrap it?)
-      # multiple_of TODO: least common multiple
-      # format      TODO: just override
-
-      # array properties
-      a.any_of = (a.any_of.empty? ? b.any_of : a.any_of) # XXX: actually impossible
-      a.enum = (a.enum    ? (a.enum & b.enum) : b.enum) if b.enum
-
-      %i[ type one_of all_of ].each do |attr|
-        a.__send__("#{attr}=", a.__send__(attr) + b.__send__(attr))
-      end
-      a.required = (a.required ? (a.required + b.required).uniq : b.required) if b.required
-
-      # object properties
-      # XXX: key conflict
-      %i[ properties pattern_properties dependencies ].each do |attr|
-        a.__send__("#{attr}=", a.__send__(attr).merge(b.__send__(attr)))
-      end
+        merged_schema = unless schema.one_of.empty? && schema.any_of.empty?
+          ::JsonSchema::Faker::Configuration.logger.info "find from one_of and any_of which satiffy all_of" if ::JsonSchema::Faker::Configuration.logger
+          one_of_candidate = schema.one_of.find do |s|
+            s2 = take_logical_and_of_schema(s, all_of)
+            compare_schema(s, s2) # FIXME: check s2 > s
+          end
 
-      # array of object
-      if a.items && b.items
-        if a.items.is_a?(Array) && b.items.is_a?(Array)
-          # TODO: zip and merge it
-        elsif a.items.is_a?(Array) && b.items.is_a?(::JsonSchema::Schema)
-          a.items = a.items.map.with_index do |e, i|
-            compact_and_merge_schema(e, b.items, a_position: "#{a_position}/items[#{i}]", b_position: "#{b_position}/items")
+          any_of_candidate = schema.any_of.find do |s|
+            s2 = take_logical_and_of_schema(s, all_of)
+            compare_schema(s, s2) # FIXME: check s2 > s
           end
-        elsif a.items.is_a?(::JsonSchema::Schema) && a.items.is_a?(Array)
-          a.items = b.items.map.with_index do |e, i|
-            compact_and_merge_schema(a.items, e, a_position: "#{a_position}/items", b_position: "#{b_position}/items[#{i}]")
+
+          unless one_of_candidate || any_of_candidate
+            ::JsonSchema::Faker::Configuration.logger.error "failed to find condition which satfisfy all_of in one_of and any_of" if ::JsonSchema::Faker::Configuration.logger
+            take_logical_and_of_schema(merged_schema, all_of, a_position: position, b_position: "#{position}/all_of")
+          else
+            take_logical_and_of_schema(merged_schema, one_of_candidate, a_position: position, b_position: "#{position}/one_of") if one_of_candidate
+            take_logical_and_of_schema(merged_schema, any_of_candidate, a_position: position, b_position: "#{position}/any_of") if any_of_candidate
           end
         else
-          compact_and_merge_schema(a.items, b.items, a_position: "#{a_position}/items", b_position: "#{b_position}/items")
+          take_logical_and_of_schema(merged_schema, all_of, a_position: position, b_position: "#{position}/all_of")
         end
       else
-        a.items ||= b.items
-      end
-
-      # override to stronger validation
-      %i[ additional_items additional_properties ].each do |attr|
-        a.__send__("#{attr}=", false) unless a.__send__(attr) && b.__send__(attr)
-      end
-      %i[ min_exclusive max_exclusive unique_items ].each do |attr|
-        a.__send__("#{attr}=", a.__send__(attr) & b.__send__(attr))
-      end
-      %i[ min min_length min_properties min_items ].each do |attr|
-        if b.__send__(attr)
-          if a.__send__(attr)
-            a.__send__("#{attr}=", b.__send__(attr)) if b.__send__(attr) < a.__send__(attr)
-          else
-            a.__send__("#{attr}=", b.__send__(attr))
-          end
+        unless schema.one_of.empty?
+          ::JsonSchema::Faker::Configuration.logger.info "compact one_of" if ::JsonSchema::Faker::Configuration.logger
+          merged_schema = take_logical_and_of_schema(merged_schema, schema.one_of.first, a_position: position, b_position: "#{position}/one_of[0]")
         end
-      end
-      %i[ max max_length max_properties max_items ].each do |attr|
-        if b.__send__(attr)
-          if a.__send__(attr)
-            a.__send__("#{attr}=", b.__send__(attr)) if b.__send__(attr) > a.__send__(attr)
-          else
-            a.__send__("#{attr}=", b.__send__(attr))
-          end
+
+        unless schema.any_of.empty?
+          ::JsonSchema::Faker::Configuration.logger.info "compact any_of" if ::JsonSchema::Faker::Configuration.logger
+          merged_schema = take_logical_and_of_schema(merged_schema, schema.any_of.first, a_position: position, b_position: "#{position}/any_of[0]")
         end
       end
-      a.pattern = (a.pattern && b.pattern) ? "(?:#{a.pattern})(?=#{b.pattern})" : (a.pattern || b.pattern)
 
-      ::JsonSchema::Faker::Configuration.logger.debug "merged: #{a.inspect_schema}" if ::JsonSchema::Faker::Configuration.logger
+      # compact recursively
+      merged_schema = compact_schema(merged_schema, position: position)
 
-      a
+      ::JsonSchema::Faker::Configuration.logger.debug "compacted: #{merged_schema.inspect_schema}" if ::JsonSchema::Faker::Configuration.logger
+
+      merged_schema
     end
   end
 end

data/lib/json_schema/faker/util.rb

@@ -0,0 +1,235 @@
+require "json_schema/faker"
+
+class JsonSchema::Faker
+  module Util
+    # umhhh maybe we don't need this...
+    def compare_schema(a, b)
+      if a.is_a?(::JsonSchema::Schema) && b.is_a?(::JsonSchema::Schema)
+        %i[ multiple_of min max min_exclusive max_exclusive
+          max_length min_length pattern
+          additional_items items max_items min_items unique_items
+          max_properties min_properties required additional_properties properties pattern_properties
+          enum type all_of any_of one_of not
+        ].all? {|k| compare_schema(a.__send__(k), b.__send__(k)) }
+      elsif a.is_a?(::Array) && b.is_a?(::Array)
+        return false unless a.size == b.size
+        a.zip(b).all? {|ai, bi| compare_schema(ai, bi) }
+      elsif a.is_a?(::Hash) && b.is_a?(::Hash)
+        return false unless a.keys.sort == b.keys.sort
+        a.keys.all? {|key| compare_schema(a[key], b[key]) }
+      else
+        a == b
+      end
+    end
+
+    def take_unique_items(a, b)
+      a.select do |ae|
+        b.any? {|be| compare_schema(ae, be) }
+      end
+    end
+
+    def take_logical_and_of_schema(a, b, a_position: nil, b_position: nil)
+      return a || b if a.nil? || b.nil?
+
+      # deep copy and modify it
+      a = ::JsonSchema::Schema.new.tap {|s| s.copy_from(a) }
+
+      # for numeric
+      if a.multiple_of && b.multiple_of
+        # TODO: multipleOf it seems easy
+        ::JsonSchema::Faker::Configuration.logger.warn "not support merging multipleOf" if ::JsonSchema::Faker::Configuration.logger
+      end
+
+      # maximum minimum exclusiveMinimum exclusiveMinimum
+      if b.max
+        if !a.max || a.max > b.max
+          a.max = b.max
+        end
+        a.max_exclusive = b.max_exclusive if b.max_exclusive
+      end
+      if b.min
+        if !a.min || a.min < b.min
+          a.min = b.min
+        end
+        a.min_exclusive = b.min_exclusive if b.min_exclusive
+      end
+
+      # for string
+      # maxLength minLength
+      if b.max_length
+        if !a.max_length || a.max_length > b.max_length
+          a.max_length = b.max_length
+        end
+      end
+      if b.min_length
+        if !a.min_length || a.min_length < b.min_length
+          a.min_length = b.min_length
+        end
+      end
+      # pattern
+      if a.pattern && b.pattern
+        # TODO: pexeger does not support generated one
+        ::JsonSchema::Faker::Configuration.logger.warn "not support merging pattern" if ::JsonSchema::Faker::Configuration.logger
+      end
+      #if b.pattern
+      #  a.pattern = (a.pattern ? "/^(?=.*#{a.pattern.inspect.gsub("/\\/", "").gsub("\\//", "")})(?=.*#{b.pattern.inspect.gsub("/\\/", "").gsub("\\//", "")})/" : b.pattern)
+      #end
+
+      # for array
+      # items and aditionalItems
+      if b.items
+        if a.items
+          if a.items.is_a?(Array) && b.items.is_a?(Array)
+            [ a.items.size, b.items.size ].max.times do |i|
+              ai, bi = a.items[i], b.items[i]
+              if ai && bi
+                a.items[i] = take_logical_and_of_schema(ai, bi)
+              else
+                # XXX: consider aditionalItems
+                a.items[i] = ai || bi
+              end
+            end
+          elsif a.items.is_a?(::JsonSchema::Schema) && b.items.is_a?(::JsonSchema::Schema)
+            a.items = take_logical_and_of_schema(a.items, b.items)
+          end
+        else
+          a.items = b.items
+        end
+      end
+      if a.additional_items === false || b.additional_items === false
+        a.additonal_items = false
+      else
+        if b.additional_items.is_a?(::JsonSchema::Schema)
+          if a.additional_items.is_a?(::JsonSchem::Schema)
+            ::JsonSchema::Faker::Configuration.logger.warn "not support merging additionalItems" if ::JsonSchema::Faker::Configuration.logger
+          else
+            a.additional_items = b.additional_items
+          end
+        end
+      end
+      # maxItems, minItems
+      if b.max_items
+        if !a.max_items || a.max_items > b.max_items
+          a.max_items = b.max_items
+        end
+      end
+      if b.min_items
+        if !a.min_items || a.min_items < b.min_items
+          a.min_items = b.min_items
+        end
+      end
+      # uniqueItems
+      if a.unique_items || b.unique_items
+        a.unique_items = true
+      end
+
+      # for object
+      # maxProperties, minProperties
+      if b.max_properties
+        if !a.max_properties || a.max_properties > b.max_properties
+          a.max_properties = b.max_properties
+        end
+      end
+      if b.min_properties
+        if !a.min_properties || a.min_properties < b.min_properties
+          a.min_properties = b.min_properties
+        end
+      end
+      # required
+      if b.required
+        a.required = a.required ? (a.required + b.required).uniq : b.required
+      end
+      # properties
+      if !b.properties.empty?
+        ( a.properties.keys + b.properties.keys ).uniq.each do |key|
+          a.properties[key] = take_logical_and_of_schema(a.properties[key], b.properties[key])
+        end
+      end
+      # additionalProperties, patternProperties, dependencies
+      if a.additional_properties === false || b.additional_properties === false
+        a.additional_properties = false
+      else
+        if b.additional_properties.is_a?(::JsonSchema::Schema)
+          if a.additional_properties.is_a?(::JsonSchem::Schema)
+            ::JsonSchema::Faker::Configuration.logger.warn "not support merging additionalProperties" if ::JsonSchema::Faker::Configuration.logger
+          else
+            a.additional_properties = b.additional_properties
+          end
+        end
+      end
+      if !b.pattern_properties.empty?
+        if !a.pattern_properties.empty?
+          ::JsonSchema::Faker::Configuration.logger.warn "not support merging patternProperties" if ::JsonSchema::Faker::Configuration.logger
+        else
+          a.pattern_properties = b.pattern_properties
+        end
+      end
+      if !b.dependencies.empty?
+        if !a.dependencies.empty?
+          ::JsonSchema::Faker::Configuration.logger.warn "not support merging dependencies" if ::JsonSchema::Faker::Configuration.logger
+        else
+          a.dependencies = b.dependencies
+        end
+      end
+      # for any
+      # enum
+      if b.enum
+        if a.enum
+          a.enum = a.enum & b.enum
+        else
+          a.enum = b.enum
+        end
+      end
+      # type
+      if !b.type.empty?
+        if !a.type.empty?
+          a.type = a.type & b.type
+        else
+          a.type = b.type
+        end
+      end
+      # allOf
+      if !b.all_of.empty?
+        if !a.all_of.empty?
+          a.all_of = [
+            [ *a.all_of, *b.all_of ].inject(nil) {|res, c| res ? take_logical_and_of_schema(res, c) : c }
+          ]
+        else
+          a.all_of = b.all_of
+        end
+      end
+      # anyOf
+      if !b.any_of.empty?
+        if !a.any_of.empty?
+          # XXX: it is difficult to find logically and of any_of
+          # like "anyOf": { "minimum": 5 }, { "multipleOf": 3 } and { "maximum": 6 }, { "multipleOf": 2 }
+          a.any_of = take_unique_items(a.any_of, b.any_of)
+        else
+          a.any_of = b.any_of
+        end
+      end
+      # oneOf
+      if !b.one_of.empty?
+        if !a.one_of.empty?
+          # XXX: it is difficult to find logically and of one_of
+          a.one_of = take_unique_items(a.one_of, b.one_of)
+        else
+          a.one_of = b.one_of
+        end
+      end
+      # not
+      if b.not
+        if a.not
+          ::JsonSchema::Faker::Configuration.logger.warn "not support merging not" if ::JsonSchema::Faker::Configuration.logger
+        else
+          a.not = b.not
+        end
+      end
+
+      a
+    end
+
+
+    module_function *instance_methods
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json_schema-faker
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - okitan
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-07-11 00:00:00.000000000 Z
+date: 2017-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json_schema
@@ -94,6 +94,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  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: danger
+  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: danger-rspec_no_filter
+  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: pry
   requirement: !ruby/object:Gem::Requirement
@@ -115,12 +157,14 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".circleci/config.yml"
 - ".gitignore"
 - ".gitmodules"
 - ".rspec"
 - ".travis.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
+- Dangerfile
 - Gemfile
 - Guardfile
 - LICENSE.txt
@@ -133,6 +177,7 @@ files:
 - lib/json_schema/faker.rb
 - lib/json_schema/faker/strategy/greedy.rb
 - lib/json_schema/faker/strategy/simple.rb
+- lib/json_schema/faker/util.rb
 homepage: https://github.com/okitan/json_schema-faker
 licenses:
 - MIT
@@ -153,7 +198,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: generate fake data from json schema