json-schema-serializer 1.5.2 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6ac2c2fbbc49625b87c22bba8061ef8aacff924a4e1bfa19faedbeeb3d6fcb7
-  data.tar.gz: 4071e3b87030dc4bff3f5800a650618619b703121094afea5b9cae8b1f584689
+  metadata.gz: 688a9d9a5604e822768c5427964b4b63a4bc1e4a909709672a4ba091c9afd309
+  data.tar.gz: 842ed003063daf2b04c14cee4239d8b2b31c4bdc77426adbc3c231ac80922576
 SHA512:
-  metadata.gz: c5372d62cecbea2832b93c09b4c3c7336a54d52e342f23d7c8689266d2b848d94ffb218cb19464ba16d74464da6ccc69c4706127f85acfa383f24cbb209d9cf0
-  data.tar.gz: 5426726b5f922839c4e21b0172a1f9281167bc2c5f41ef18baa81995d2395949624627f6b786f2c764715fabef7ba299f21d316a40d4b456543755b9b68eb3e3
+  metadata.gz: 88ede4a87f75b6f176d177cb078d7336ba67f25923d890a95c727106a14e2c673f6a02593056a3f069b30d517b6b48f344075df7b30e0edac76e1bab58f4fb15
+  data.tar.gz: f797603f80e47cced28a52bddabf61cef290064339d8b25c32b89fd7ebafd2093c46eeaa9b79f6436b557d8315ec23c5153060058f364067f98243cf3222d924

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # CHANGELOG
 
+## 2.0.0
+
+- fix: Non-primitive (arrays, objects, etc.) "default" schemas and injections have strange results.
+    - If you were using a non-primitive (array, object, etc.) "default" schema with injection, it could be a breaking change!
+
+## 1.7.0
+
+- add: `with_context!` api
+- add: `:inject_by_keyword` option
+
+## 1.6.0
+
+- add: inject context
+
 ## 1.5.0
 
 - add: many options

data/README.md

@@ -112,6 +112,178 @@ serializer_injected = JSON::Schema::Serializer.new(
 
 serializer_injected.serialize([1, 2, 3])
 # => {"first"=>1, "count"=>3}
+
+#
+# object injector with context
+#
+
+class BarSerializer
+  def initialize(model, context = nil)
+    @model = model
+    @context = context
+  end
+
+  def id
+    @model[:id]
+  end
+
+  def score
+    @context[@model[:id]]
+  end
+end
+
+inject_context = {
+  1 => 100,
+  2 => 200,
+}
+
+serializer_injected_with_context = JSON::Schema::Serializer.new(
+  {
+    type: :object,
+    inject: :Bar,
+    properties: {
+      id: { type: :integer },
+      score: { type: :integer },
+    },
+  },
+  {
+    inject_key: :inject,
+    injectors: {
+      Bar: BarSerializer,
+    },
+    inject_context: inject_context,
+  },
+)
+
+serializer_injected_with_context.serialize({ id: 1 })
+# => { "id" => 1, "score" => 100 }
+
+#
+# inject in serializer
+#
+
+class ParentSerializer
+  include JSON::Schema::Serializer::WithContext
+
+  def initialize(model, context = nil)
+    @model = model
+    @context = context
+  end
+
+  def id
+    @model[:id]
+  end
+
+  def score
+    @context[:parent_scores][@model[:id]]
+  end
+
+  def child
+    # it can be
+    # with_context(context) { data }
+    # with_context(data, context)
+    # with_context(data: data, context: context)
+    with_context(@context.merge(child_scores: { 1 => 100, 2 => 200 })) do
+      @model[:child]
+    end
+  end
+end
+
+class ChildSerializer
+  def initialize(model, context = nil)
+    @model = model
+    @context = context
+  end
+
+  def id
+    @model[:id]
+  end
+
+  def score
+    @context[:child_scores][@model[:id]]
+  end
+end
+
+serializer_injected_with_context_in_serializer = JSON::Schema::Serializer.new(
+  {
+    type: :object,
+    inject: :Parent,
+    properties: {
+      id: { type: :integer },
+      score: { type: :integer },
+      child: {
+        type: :object,
+        inject: :Child,
+        properties: {
+          id: { type: :integer },
+          score: { type: :integer },
+        },
+      },
+    },
+  },
+  {
+    inject_key: :inject,
+    injectors: {
+      Parent: ParentSerializer,
+      Child: ChildSerializer,
+    },
+    inject_context: { 1 => 10, 2 => 20 },
+  },
+)
+
+serializer_injected_with_context_in_serializer.serialize({ id: 1, child: { id: 2 } })
+# => { "id" => 1, "score" => 10, "child" => { "id" => 2, "score" => 200 } }
+
+#
+# also you can inject context with arraylike data
+#
+
+class ItemsSerializer
+  include JSON::Schema::Serializer::WithContext
+
+  def initialize(models, context = nil)
+    @models = models
+    @context = context
+  end
+
+  def map(&block)
+    context = (@context || {}).merge(scores: {...})
+    @models.map { |model| block.call(with_context(model, context)) }
+    # CAUTION!
+    # not like below!
+    # with_context(@models.map(&block), context)
+    # with_context(context) { @models.map(&block) }
+  end
+end
+
+#
+# inject model can initialize by keywords
+#
+
+class KeywordSerializer
+  def initialize(data:, context: nil)
+    @data = data
+    @context = context
+  end
+
+  ...
+end
+
+serializer_with_keyword_init_inject = JSON::Schema::Serializer.new(
+  {
+    type: :object,
+    inject: :Keyword,
+    properties: { ... },
+  },
+  {
+    inject_key: :inject,
+    injectors: {
+      Keyword: KeywordSerializer,
+      Child: ChildSerializer,
+    },
+    inject_by_keyword: true, # <- keyword_init!
+  },
+)
 ```
 
 ### "additionalProperties"
@@ -211,12 +383,18 @@ new({
 }, { schema_key_transform_for_output: ->(name) { name.underscore } }).serialize({ userCount: 1 }) == { "user_count" => 1 }
 ```
 
-#### options[:injectors] [Hashlike<String, Class>, Class], options[:inject_key] [String, Symbol]
+#### options[:injectors] [Hashlike<String, Class>, Class], options[:inject_key] [String, Symbol], options[:inject_context] [any], options[:inject_by_keyword] [Boolean]
 
 If schema has inject key, the serializer treats data by `injectors[inject_key].new(data)` (or `injectors.send(inject_key).new(data)`).
 
+And if `inject_context` is present, `injectors[inject_key].new(data, inject_context)` (or `injectors.send(inject_key).new(data, inject_context)`).
+
+And if `inject_by_keyword` is true, `new(data, inject_context)` will be `new(data: data, context: inject_context)`.
+
 See examples in [Usage](#usage).
 
+CAUTION: In many case you should define the `nil?` method in the injector class because Injector always initialized by `Injector.new(obj)` even if obj == nil.
+
 #### options[:null_through] [Boolean]
 
 If data is null, always serialize null.
@@ -275,6 +453,14 @@ Serialize the object data by the schema.
 
 Serialize target object. The serializer tries data["foo"], data[:foo] and data.foo!
 
+## JSON::Schema::Serializer::WithContext API
+
+### #with_context!(data, context), #with_context!(data: data, context: context), #with_context!(context) { data }
+
+If you use `with_context!(data, context)` as the return value of the serializer, then "child" serializer can use that context.
+
+See examples in [Usage](#usage).
+
 ## License
 
 Zlib License

data/Steepfile

@@ -0,0 +1,5 @@
+target :lib do
+  signature "sig"
+
+  check "lib"
+end

data/json-schema-serializer.gemspec

@@ -28,13 +28,15 @@ Gem::Specification.new do |spec|
   spec.require_paths = %w[lib]
 
   spec.add_development_dependency "bundler", "~> 2.0"
-  spec.add_development_dependency "rake", "~> 10.5"
+  spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.9"
   spec.add_development_dependency "rspec-power_assert", "~> 1.1"
+  spec.add_development_dependency "simplecov", ">= 0.18"
   spec.add_development_dependency "rubocop", "~> 0.76"
   spec.add_development_dependency "rubocop-airbnb", "~> 3"
   spec.add_development_dependency "prettier", ">= 0.16"
   spec.add_development_dependency "rubocop-config-prettier", "~> 0.1"
   spec.add_development_dependency "pry-byebug", "~> 3.7"
   spec.add_development_dependency "yard", "~> 0.9"
+  spec.add_development_dependency "steep", ">= 0.39"
 end

data/lib/json/schema/serializer.rb

@@ -5,31 +5,79 @@ require "set"
 module JSON
   class Schema
     class Serializer
-      def initialize(schema, options = nil)
-        @schema = options && options[:resolver] ? options[:resolver].call(schema) : schema
+      def initialize(schema, options = nil) # rubocop:disable Airbnb/OptArgParameters
+        @schema =
+          if options && (resolver = options[:resolver])
+            resolver.call(schema)
+          else
+            schema
+          end
         @options = options || {}
       end
 
       def serialize(data)
-        Walker.walk(@schema, data, true, @options)
+        Walker.walk(@schema, data, true, false, @options)
+      end
+
+      DataWithContext = Struct.new(:data, :context, keyword_init: true)
+
+      module WithContext
+        ARG2_NOT_GIVEN = :__json_schema_serializer_arg2_not_given__
+
+        def with_context!(arg1, arg2 = ARG2_NOT_GIVEN) # rubocop:disable Airbnb/OptArgParameters
+          if block_given?
+            DataWithContext.new(data: yield, context: arg1)
+          elsif arg2 == ARG2_NOT_GIVEN
+            DataWithContext.new(arg1)
+          else
+            DataWithContext.new(data: arg1, context: arg2)
+          end
+        end
       end
 
       class Walker
         class << self
           TimeWithZone = defined?(ActiveSupport::TimeWithZone) ? ActiveSupport::TimeWithZone : nil
 
-          def walk(schema, obj, required, options)
+          def walk(schema, obj, required, using_default, options)
             type = try_hash(schema, :type)
             default = try_hash(schema, :default)
             format = try_hash(schema, :format)
-            obj = default if obj.nil?
+            if obj.nil?
+              using_default = true
+              obj = default
+            end
 
             if options[:inject_key]
               inject_key = try_hash(schema, options[:inject_key])
               injector = try_hash(options[:injectors], inject_key) if inject_key
-              obj = injector.new(obj) if injector
+              if obj.instance_of?(JSON::Schema::Serializer::DataWithContext)
+                options = options.merge(inject_context: obj.context)
+                obj = obj.data
+                if obj.nil?
+                  using_default = true
+                  obj = default
+                end
+              end
+              if injector && !using_default
+                if options[:inject_context]
+                  obj =
+                    if options[:inject_by_keyword]
+                      injector.new(data: obj, context: options[:inject_context])
+                    else
+                      injector.new(obj, options[:inject_context])
+                    end
+                else
+                  obj =
+                    if options[:inject_by_keyword]
+                      injector.new(data: obj)
+                    else
+                      injector.new(obj)
+                    end
+                end
+              end
             end
-            type_coerce(schema, detect_type(type, obj), format, obj, required, options)
+            type_coerce(schema, detect_type(type, obj), format, obj, required, using_default, options)
           end
 
           def detect_type(type, obj)
@@ -112,7 +160,7 @@ module JSON
             end
           end
 
-          def type_coerce(schema, type, format, obj, required, options)
+          def type_coerce(schema, type, format, obj, required, using_default, options)
             return nil if !required && obj.nil?
 
             case type.to_s
@@ -169,8 +217,8 @@ module JSON
                 nil
               elsif options[:empty_string_boolean_coerce_null] && obj == ""
                 nil
-              elsif options[:false_values]
-                !options[:false_values].include?(obj)
+              elsif (false_values = options[:false_values])
+                !false_values.include?(obj)
               elsif options[:no_boolean_coerce]
                 obj == true
               else
@@ -181,7 +229,7 @@ module JSON
               return options[:null_through] ? nil : [] if obj.nil? || !obj.respond_to?(:map)
               return options[:null_through] ? nil : [] if options[:guard_primitive_in_structure] && is_primitive?(obj)
 
-              obj.map { |item| walk(items_schema, item, true, options) }
+              obj.map { |item| walk(items_schema, item, true, using_default, options) }
             when "object"
               return nil if obj.nil? && options[:null_through]
               return options[:null_through] ? nil : {} if options[:guard_primitive_in_structure] && is_primitive?(obj)
@@ -195,7 +243,7 @@ module JSON
                 properties_schema.map do |name, property_schema|
                   input_key = input_key_transform ? input_key_transform.call(name.to_s) : name
                   output_key = output_key_transform ? output_key_transform.call(name.to_s) : name.to_s
-                  [output_key, walk(property_schema, try_hash(obj, input_key), required_schema.include?(name.to_s), options)]
+                  [output_key, walk(property_schema, try_hash(obj, input_key), required_schema.include?(name.to_s), using_default, options)]
                 end.to_h
               if additional_properties_schema
                 not_additional_keys_array = properties_schema.keys.map(&:to_s)
@@ -204,7 +252,7 @@ module JSON
                 ret.merge(
                   additional_keys.map do |name|
                     output_key = output_key_transform ? output_key_transform.call(name.to_s) : name.to_s
-                    [output_key, walk(additional_properties_schema, try_hash(obj, name), false, options)]
+                    [output_key, walk(additional_properties_schema, try_hash(obj, name), false, using_default, options)]
                   end.to_h,
                 )
               else

data/lib/json/schema/serializer/version.rb

@@ -1,7 +1,7 @@
 module JSON
   class Schema
     class Serializer
-      VERSION = "1.5.2".freeze
+      VERSION = "2.1.0".freeze
     end
   end
 end

data/sig/json/schema/serializer.rbs

@@ -0,0 +1,59 @@
+type jsonSchema = untyped
+type jsonData = untyped
+type jsonSchemaContext = untyped
+type jsonSingleType = "null" | "string" | "number" | "integer" | "boolean" | "array" | "object"
+type jsonType = jsonSingleType | Array[jsonSingleType]
+
+# Classes
+module JSON
+  class Schema
+    class Serializer
+      VERSION: String
+
+      type serializerOptions = {
+        inject_key: String | Symbol?,
+        inject_context: jsonSchemaContext?,
+        injectors: Hash[String | Symbol, Class] | Class,
+        inject_by_keyword: bool?,
+        resolver: (^(jsonData data) -> jsonData)?,
+        null_through: bool?,
+        empty_string_number_coerce_null: bool?,
+        empty_string_boolean_coerce_null: bool?,
+        false_values: Enumerable[untyped]?,
+        no_boolean_coerce: bool?,
+        guard_primitive_in_structure: bool?,
+        schema_key_transform_for_input: (^(String name) -> String)?,
+        schema_key_transform_for_output: (^(String name) -> String)?
+      }
+      @schema: jsonSchema
+      @options: serializerOptions
+
+      def initialize: (jsonSchema schema, ?serializerOptions options) -> void
+      def serialize: (jsonData data) -> untyped
+
+      class DataWithContext < Struct[untyped]
+        attr_accessor data(): jsonData
+        attr_accessor context(): jsonSchemaContext
+        def initialize: (data: jsonData, context: jsonSchemaContext) -> void
+      end
+
+      module WithContext
+        ARG2_NOT_GIVEN: :__json_schema_serializer_arg2_not_given__
+
+        def with_context!: (jsonSchemaContext context) { () -> jsonData } -> DataWithContext
+                               | (jsonData data, jsonSchemaContext context) -> DataWithContext
+                               | ({ data: jsonData, context: jsonSchemaContext } arg) -> DataWithContext
+      end
+
+      class Walker
+        TimeWithZone: nil
+
+        def self.walk: (jsonSchema schema, jsonData obj, bool required, bool using_default, serializerOptions options) -> untyped
+        def self.detect_type: (jsonType type_, jsonData obj) -> jsonSingleType
+        def self.type_coerce: (jsonSchema schema, jsonType type_, String format, jsonData obj, bool required, bool using_default, serializerOptions options) -> untyped
+        def self.try_hash: (untyped obj, String | Symbol? name) -> untyped
+        def self.is_primitive?: (untyped obj) -> bool
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json-schema-serializer
 version: !ruby/object:Gem::Version
-  version: 1.5.2
+  version: 2.1.0
 platform: ruby
 authors:
 - Narazaka
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2019-12-03 00:00:00.000000000 Z
+date: 2020-12-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.5'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.5'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.18'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.18'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -150,7 +164,21 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
-description: 
+- !ruby/object:Gem::Dependency
+  name: steep
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.39'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.39'
+description:
 email:
 - info@narazaka.net
 executables: []
@@ -168,12 +196,14 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- Steepfile
 - bin/console
 - bin/fmt
 - bin/setup
 - json-schema-serializer.gemspec
 - lib/json/schema/serializer.rb
 - lib/json/schema/serializer/version.rb
+- sig/json/schema/serializer.rbs
 homepage: https://github.com/Narazaka/json-schema-serializer
 licenses:
 - Zlib
@@ -181,8 +211,8 @@ metadata:
   homepage_uri: https://github.com/Narazaka/json-schema-serializer
   source_code_uri: https://github.com/Narazaka/json-schema-serializer.git
   changelog_uri: https://github.com/Narazaka/json-schema-serializer/blob/master/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/json-schema-serializer/1.5.2
-post_install_message: 
+  documentation_uri: https://www.rubydoc.info/gems/json-schema-serializer/2.1.0
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -197,9 +227,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: JSON Schema based serializer
 test_files: []