json_schema-faker 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7137b715285867fea6d5ecc696dfe0aac42a38f1
-  data.tar.gz: 220a678a7049bf935b3d7b71aecb2a69045fac37
+  metadata.gz: 6d295d3dfb065608b9af8b1bfcd4336ea16a7de1
+  data.tar.gz: 08969d39f4b51f7c4fc07fd0c7ec3cb9408d3995
 SHA512:
-  metadata.gz: 29ca21c97466107c9a71bd8253ba919350a0a005e534a784f9c62b75fcff3a64e9cc54364019fe575b2baad59b9b9248c54fb1d68ab1d6ee8a8d774dd0fedb67
-  data.tar.gz: 3f9c593277208bc7ca82d8ccb07254680c81d45f7bce4ad9176959c6bd64d641eb3a1c16e8437cd823d536d9d8ef889bb28d3ba988089734b519dab438d9008d
+  metadata.gz: 9a3360dae5813be93b1c4aa5ac9cdd04c5c1e7c5151d90529811d4e5530c48a022c187967a2d1e92bd5d395c3660c2978dedcabbd46114d7d37d7dc3823698e3
+  data.tar.gz: b07858fa1b121b06e58d3dd27342a76e2cc03e27fde3137ffd73d6a50c1ec15a9bf0c8cb9289795d08cd4f525ae86800022a1cfce2c456478f954bef5881d312

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+## 0.1.1
+
+* IMPROVEMENT
+ * refactor and improve generation
+
+## 0.1.0
+
+* initial release

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.1

data/lib/json_schema/faker.rb

@@ -10,293 +10,26 @@ module JsonSchema
       module_function :logger, :logger=
     end
 
-    # TODO:
-    # strategy to use for faker
-    def initialize(schema, options = {})
-      @schema  = schema
+    module Strategy
+      require "json_schema/faker/strategy/simple"
+    end
 
+    def initialize(schema, options = {})
+      @schema   = schema
       @options = options
     end
 
     def generate(hint: nil)
-      generated = _generate(@schema, hint: nil, position: "")
+      strategy  = @options[:strategy] || Strategy::Simple.new
 
       Configuration.logger.debug "to generate against #{@schema.inspect_schema}" if Configuration.logger
+
+      generated = strategy.call(@schema, hint: nil, position: "")
       Configuration.logger.debug "generated: #{generated.inspect}" if Configuration.logger
 
       generated
     end
 
     protected
-    def _generate(schema, hint: nil, position:)
-      Configuration.logger.debug "current position: #{position}" if Configuration.logger
-
-      raise "here comes nil for schema at #{position}" unless schema
-
-      return schema.default if schema.default
-
-      if schema.not
-        hint ||= {}
-        # too difficult
-        # TODO: support one_of/any_of/all_of
-        hint[:not_have_keys] = schema.not.required if schema.not.required
-        hint[:not_be_values] = schema.not.enum     if schema.not.enum
-      end
-
-      # TODO: should support the combinations of them
-      # http://json-schema.org/latest/json-schema-validation.html#anchor75
-      # Notes:
-      # one_of, any_of, all_of, properties and type is given default and never be nil
-      if    !schema.one_of.empty?
-        generate_for_one_of(schema, hint: hint, position: position)
-      elsif !schema.any_of.empty?
-        generate_for_any_of(schema, hint: hint, position: position)
-      elsif !schema.all_of.empty?
-        generate_for_all_of(schema, hint: hint, position: position)
-      elsif schema.enum
-        generate_by_enum(schema, hint: hint, position: position)
-      elsif !schema.type.empty?
-        generate_by_type(schema, position: position)
-      else # consider as object
-        generate_for_object(schema, hint: hint, position: position)
-      end
-    end
-
-    def generate_for_one_of(schema, hint: nil, position:)
-      merged_schema = JsonSchema::Schema.new
-      merged_schema.copy_from(schema)
-
-      merged_schema.one_of = []
-
-      # TODO: treat rest as not
-      _generate(merge_schema(merged_schema, schema.one_of.first), hint: hint, position: "position/one_of[0]")
-    end
-
-    def generate_for_any_of(schema, hint: nil, position:)
-      merged_schema = JsonSchema::Schema.new
-      merged_schema.copy_from(schema)
-
-      merged_schema.any_of = []
-
-      _generate(merge_schema(merged_schema, schema.any_of.first), hint: hint, position: "position/any_of[0]")
-    end
-
-    def generate_for_all_of(schema, hint: nil, position:)
-      # deep_merge all_of
-      merged_schema = JsonSchema::Schema.new
-      merged_schema.copy_from(schema)
-
-      merged_schema.all_of = []
-
-      schema.all_of.each do |sub_schema|
-        merge_schema(merged_schema, sub_schema)
-      end
-
-      _generate(merged_schema, hint: hint, position: "position/all_of")
-    end
-
-    def generate_for_object(schema, hint: nil, position:)
-      # http://json-schema.org/latest/json-schema-validation.html#anchor53
-      if schema.required
-        keys   = schema.required
-        required_length = schema.min_properties || keys.length
-
-        object = keys.each.with_object({}) do |key, hash|
-          hash[key] = _generate(schema.properties[key], hint: hint, position: "#{position}/#{key}") # TODO: pass hint
-        end
-      else
-        required_length = schema.min_properties || schema.max_properties || 0
-
-        keys = (schema.properties || {}).keys
-        keys -= (hint[:not_have_keys] || []) if hint
-
-        object = keys.first(required_length).each.with_object({}) do |key, hash|
-          hash[key] = _generate(schema.properties[key], hint: hint, position: "#{position}/#{key}") # TODO: pass hint
-        end
-      end
-
-      # 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}")
-          else
-            name = Pxeger.new(schema.pattern_properties.keys.first).generate
-            hash[name] = _generate(schema.pattern_properties.values.first, hint: hint, position: "#{position}/#{name}")
-          end
-        end
-      else
-        # FIXME: key confilct with properties
-        (required_length - object.keys.length).times.each.with_object(object) do |i, hash|
-          hash[i.to_s] = i
-        end
-      end
-
-      # 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]
-
-        if dependency.is_a?(JsonSchema::Schema)
-          # too difficult we just merge
-          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)
-          end
-        end
-      end
-    end
-
-    def generate_by_enum(schema, hint: nil, position:)
-      black_list = (hint ? hint[:not_be_values] : nil)
-
-      if Configuration.logger
-        Configuration.logger.info "generate by enum at #{position}"
-        Configuration.logger.debug schema.inspect_schema
-        Configuration.logger.debug "black list: #{black_list}" if black_list
-      end
-
-      if black_list
-        (schema.enum - black_list).first
-      else
-        schema.enum.first
-      end
-    end
-
-    def generate_by_type(schema, hint: nil, position:)
-      if Configuration.logger
-        Configuration.logger.info "generate by type at #{position}"
-        Configuration.logger.debug schema.inspect_schema
-      end
-
-      # http://json-schema.org/latest/json-schema-core.html#anchor8
-      # TODO: use include? than first
-      case schema.type.first
-      when "array"
-        generate_for_array(schema, hint: hint, position: position)
-      when "boolean"
-        true
-      when "integer", "number"
-        generate_for_number(schema, hint: hint)
-      when "null"
-        nil
-      when "object"
-        # here comes object without properties
-        generate_for_object(schema, hint: hint, position: position)
-      when "string"
-        generate_for_string(schema, hint: hint)
-      else
-        raise "unknown type for #{schema.inspect_schema}"
-      end
-    end
-
-    def generate_for_array(schema, hint: nil, position:)
-      # http://json-schema.org/latest/json-schema-validation.html#anchor36
-      # additionalItems items maxItems minItems uniqueItems
-      length = schema.min_items || 0
-
-      # if "items" is not present, or its value is an object, validation of the instance always succeeds, regardless of the value of "additionalItems";
-      # if the value of "additionalItems" is boolean value true or an object, validation of the instance always succeeds;
-      item = if (schema.items.nil? || schema.items.is_a?(JsonSchema::Schema)) || ( schema.additional_items === true || schema.additional_items.is_a?(JsonSchema::Schema))
-        length.times.map.with_index {|i| i }
-      else # in case schema.items is array and schema.additional_items is true
-        # if the value of "additionalItems" is boolean value false and the value of "items" is an array
-        # the instance is valid if its size is less than, or equal to, the size of "items".
-        raise "#{position}: item length(#{schema.items.length} is shorter than minItems(#{schema.min_items}))" unless schema.items.length <= length
-
-        # TODO: consider unique items
-        length.times.map.with_index {|i| _generate(schema.items[i], position: position + "[#{i}]") }
-      end
-    end
-
-    def generate_for_number(schema, hint: nil)
-      # http://json-schema.org/latest/json-schema-validation.html#anchor13
-      # TODO: use hint[:not_be_values]
-      min = schema.min
-      max = schema.max
-
-      if schema.multiple_of
-        min = (min + schema.multiple_of - min % schema.multiple_of) if min
-        max = (max - max % schema.multiple_of) if max
-      end
-
-      delta = schema.multiple_of ? schema.multiple_of : 1
-
-      # TODO: more sophisticated caluculation
-      min, max = [ (min || (max ? max - delta * 2 : 0)), (max || (min ? min + delta * 2 : 0)) ]
-
-      # to get average of min and max can avoid exclusive*
-      if schema.type.first == "integer"
-        (min / delta + max / delta) / 2 * delta
-      else
-        (min + max) / 2.0
-      end
-    end
-
-    def generate_for_string(schema, hint: nil)
-      # http://json-schema.org/latest/json-schema-validation.html#anchor25
-      # TODO: use hint[:not_be_values]
-      # TODO: support format
-      if schema.pattern
-        Pxeger.new(schema.pattern).generate
-      else
-        length = schema.min_length || 0
-        "a" * length
-      end
-    end
-
-    def merge_schema(a, b)
-      # attr not supported now
-      # any_of:     too difficult...
-      # enum/items: TODO: just get and of array
-      # not:        too difficult (if `not` is not wrapped by all_of wrap it?)
-      # multiple_of TODO: least common multiple
-      # pattern:    too difficult...
-      # format      TODO: just override
-
-      # array properties
-      %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 : 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
-
-      # 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 ].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
-        end
-      end
-      %i[ max max_length max_properties ].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
-        end
-      end
-
-      a
-    end
   end
 end

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

@@ -0,0 +1,311 @@
+module JsonSchema::Faker::Strategy
+  class Simple
+    def call(schema, hint: nil, position:)
+      ::JsonSchema::Faker::Configuration.logger.debug "current position: #{position}" if ::JsonSchema::Faker::Configuration.logger
+
+      raise "here comes nil for schema at #{position}" unless schema
+
+      # merge one_of/any_of/all_of
+      ::JsonSchema::Faker::Configuration.logger.debug schema.inspect_schema if ::JsonSchema::Faker::Configuration.logger
+      schema = compact_schema(schema, position: position)
+
+      return schema.default if schema.default
+
+      if schema.not
+        hint ||= {}
+        # too difficult
+        # TODO: support one_of/any_of/all_of
+        hint[:not_have_keys] = schema.not.required if schema.not.required
+        hint[:not_be_values] = schema.not.enum     if schema.not.enum
+      end
+
+      # http://json-schema.org/latest/json-schema-validation.html#anchor75
+      if schema.enum
+        generate_by_enum(schema, hint: hint, position: position)
+      else
+        generate_by_type(schema, hint: hint, position: position)
+      end
+    end
+    alias_method :generate, :call
+
+    def generate_for_object(schema, hint: nil, position:)
+      # http://json-schema.org/latest/json-schema-validation.html#anchor53
+      if schema.required
+        keys   = schema.required
+        required_length = schema.min_properties || keys.length
+
+        object = keys.each.with_object({}) do |key, hash|
+          hash[key] = generate(schema.properties[key], hint: hint, position: "#{position}/#{key}") # TODO: pass hint
+        end
+      else
+        required_length = schema.min_properties || schema.max_properties || 0
+
+        keys = (schema.properties || {}).keys
+        keys -= (hint[:not_have_keys] || []) if hint
+
+        object = keys.first(required_length).each.with_object({}) do |key, hash|
+          hash[key] = generate(schema.properties[key], hint: hint, position: "#{position}/#{key}") # TODO: pass hint
+        end
+      end
+
+      # 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}")
+          else
+            name = ::Pxeger.new(schema.pattern_properties.keys.first).generate
+            hash[name] = generate(schema.pattern_properties.values.first, hint: hint, position: "#{position}/#{name}")
+          end
+        end
+      else
+        # FIXME: key confilct with properties
+        (required_length - object.keys.length).times.each.with_object(object) do |i, hash|
+          hash[i.to_s] = i
+        end
+      end
+
+      # 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]
+
+        if dependency.is_a?(::JsonSchema::Schema)
+          # too difficult we just merge
+          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)
+          end
+        end
+      end
+    end
+
+    def generate_by_enum(schema, hint: nil, position:)
+      black_list = (hint ? hint[:not_be_values] : nil)
+
+      if ::JsonSchema::Faker::Configuration.logger
+        ::JsonSchema::Faker::Configuration.logger.info "generate by enum at #{position}"
+        ::JsonSchema::Faker::Configuration.logger.debug schema.inspect_schema
+        ::JsonSchema::Faker::Configuration.logger.debug "black list: #{black_list}" if black_list
+      end
+
+      if black_list
+        (schema.enum - black_list).first
+      else
+        schema.enum.first
+      end
+    end
+
+    def generate_by_type(schema, hint: nil, position:)
+      if ::JsonSchema::Faker::Configuration.logger
+        ::JsonSchema::Faker::Configuration.logger.info "generate by type at #{position}"
+        ::JsonSchema::Faker::Configuration.logger.debug schema.inspect_schema
+      end
+
+      # http://json-schema.org/latest/json-schema-core.html#anchor8
+      # TODO: use include? than first
+      case schema.type.first
+      when "array"
+        generate_for_array(schema, hint: hint, position: position)
+      when "boolean"
+        true
+      when "integer", "number"
+        generate_for_number(schema, hint: hint)
+      when "null"
+        nil
+      when "object", nil
+        # here comes object without properties
+        generate_for_object(schema, hint: hint, position: position)
+      when "string"
+        generate_for_string(schema, hint: hint)
+      else
+        raise "unknown type for #{schema.inspect_schema}"
+      end
+    end
+
+    def generate_for_array(schema, hint: nil, position:)
+      # http://json-schema.org/latest/json-schema-validation.html#anchor36
+      # additionalItems items maxItems minItems uniqueItems
+      length = schema.min_items || 0
+
+      if schema.items.nil?
+        length.times.map.with_index {|i| i }
+      else
+        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}]") }
+        else
+          length.times.map.with_index {|i| generate(schema.items, hint: hint, position: "#{position}/items[#{i}]") }
+        end
+      end
+    end
+
+    def generate_for_number(schema, hint: nil)
+      # http://json-schema.org/latest/json-schema-validation.html#anchor13
+      # TODO: use hint[:not_be_values]
+      min = schema.min
+      max = schema.max
+
+      if schema.multiple_of
+        min = (min + schema.multiple_of - min % schema.multiple_of) if min
+        max = (max - max % schema.multiple_of) if max
+      end
+
+      delta = schema.multiple_of ? schema.multiple_of : 1
+
+      # TODO: more sophisticated caluculation
+      min, max = [ (min || (max ? max - delta * 2 : 0)), (max || (min ? min + delta * 2 : 0)) ]
+
+      # to get average of min and max can avoid exclusive*
+      if schema.type.first == "integer"
+        (min / delta + max / delta) / 2 * delta
+      else
+        (min + max) / 2.0
+      end
+    end
+
+    def generate_for_string(schema, hint: nil)
+      # http://json-schema.org/latest/json-schema-validation.html#anchor25
+      # TODO: use hint[:not_be_values]
+      # TODO: support format
+      if schema.pattern
+        ::Pxeger.new(schema.pattern).generate
+      else
+        length = schema.min_length || 0
+        "a" * length
+      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
+
+    def compact_schema(schema, position:)
+      return schema if schema.one_of.empty? && schema.any_of.empty? && schema.all_of.empty?
+
+      if ::JsonSchema::Faker::Configuration.logger
+        ::JsonSchema::Faker::Configuration.logger.info "start to compact at #{position}"
+        ::JsonSchema::Faker::Configuration.logger.debug schema.inspect_schema
+      end
+
+      merged_schema = ::JsonSchema::Schema.new
+      merged_schema.copy_from(schema)
+      merged_schema.one_of = []
+      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}]")
+        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
+
+      # 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")
+          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}]")
+          end
+        else
+          compact_and_merge_schema(a.items, b.items, a_position: "#{a_position}/items", b_position: "#{b_position}/items")
+        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
+        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
+        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
+
+      a
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json_schema-faker
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - okitan
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-06-01 00:00:00.000000000 Z
+date: 2016-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json_schema
@@ -119,6 +119,7 @@ files:
 - ".gitmodules"
 - ".rspec"
 - ".travis.yml"
+- CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - Guardfile
@@ -130,6 +131,7 @@ files:
 - bin/setup
 - json_schema-faker.gemspec
 - lib/json_schema/faker.rb
+- lib/json_schema/faker/strategy/simple.rb
 homepage: https://github.com/okitan/json_schema-faker
 licenses:
 - MIT