json-schema-serializer 1.4.0 → 1.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b4c5d9d360e8b71d59ffaf2dbaef3a19cb782acdbb4c97548188f4c3339d654
-  data.tar.gz: 180e413608d626170441274fa43c82a20cf62d78a5509cc1cee6b8ade65dbeae
+  metadata.gz: 8520da63406ec92ce27f94214e6377eb0235fa22745c1dd9473fb597bfc2acdd
+  data.tar.gz: 36de8e40ad358955d937e2b46141c0da13e9b7cff328a26194e6e52991c1b2cc
 SHA512:
-  metadata.gz: 6b5e545a90241344d73da7d4a015ba83e0d96ec71df27f98652f755018c2c241b612cdbbcbdcf0b3fc5b10a447e493047a035cdf93c770f42214a41e90935b7b
-  data.tar.gz: 8c875c4c2681df2ef05ae8bde119c6cd1a9cc6621e667616e8df935acfe34c2a4c459cf648730aa9e9439240d805382ff9d8033f2edecd804e8a697def9877e5
+  metadata.gz: a6a9d1927d21adc4c7a499313b195e63465302018e4575a83c9095236c31df86eb1037e5d06618ad07fa0674c620c5cd2b58aad0aae2ae04884f3c0f9b6592c8
+  data.tar.gz: f3d64406270a9b00f816106611cf1327ed5eab8bd9ec5472bb577fbfda8f0ef415404563fda4fd50008441388d03f655d82c0085f9dd8b5aba95438c1d50d9f7

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # CHANGELOG
 
+## 1.7.0
+
+- add: `with_context!` api
+- add: `:inject_by_keyword` option
+
+## 1.6.0
+
+- add: inject context
+
+## 1.5.0
+
+- add: many options
+
 ## 1.4.0
 
 - add: "additionalProperties" support

data/README.md

@@ -1,4 +1,4 @@
-# Json::Schema::Serializer
+# JSON::Schema::Serializer
 
 [![Actions Status](https://github.com/Narazaka/json-schema-serializer/workflows/Ruby/badge.svg)](https://github.com/Narazaka/json-schema-serializer/actions)
 [![Gem Version](https://badge.fury.io/rb/json-schema-serializer.svg)](https://badge.fury.io/rb/json-schema-serializer)
@@ -112,11 +112,183 @@ 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"
 
-"additionalProperties" is allowed but must be a schema object. (not boolean)
+"additionalProperties" is allowed but must be a schema object or `false`. (not `true`)
 
 If "additionalProperties" does not exists, this serializer works as `{ additionalProperties": false }`.
 
@@ -167,6 +339,128 @@ serializer2 = JSON::Schema::Serializer.new(schema["properties"]["bar"], {
 })
 ```
 
+## JSON::Schema::Serializer API
+
+### .new(schema, options = nil)
+
+The initializer.
+
+#### schema [any]
+
+JSON schema object. The serializer tries schema["type"], schema[:type] and schema.type!
+
+#### options [Hash]
+
+options
+
+#### options[:resolver] [Proc]
+
+schema object `$ref` resolver
+
+#### options[:schema_key_transform_for_input] [Proc]
+
+input key transform
+
+```ruby
+new({
+  type: :object,
+  properties: {
+    userCount: { type: :integer },
+  },
+}, { schema_key_transform_for_input: ->(name) { name.underscore } }).serialize({ user_count: 1 }) == { "userCount" => 1 }
+```
+
+#### options[:schema_key_transform_for_output] [Proc]
+
+output key transform
+
+```ruby
+new({
+  type: :object,
+  properties: {
+    userCount: { type: :integer },
+  },
+}, { 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[: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.
+
+```ruby
+new({ type: :string }, { null_through: true }).serialize(nil) == nil
+```
+
+#### options[:empty_string_number_coerce_null] [Boolean]
+
+If data == "" in integer or number schema, returns nil.
+
+```ruby
+new({ type: :integer }, { empty_string_number_coerce_null: true }).serialize("") == nil
+```
+
+#### options[:empty_string_boolean_coerce_null] [Boolean]
+
+If data == "" in boolean schema, returns nil.
+
+```ruby
+new({ type: :boolean }, { empty_string_boolean_coerce_null: true }).serialize("") == nil
+```
+
+#### options[:false_values] [Enumerable]
+
+If specified, boolean schema treats `!false_values.include?(data)`.
+
+```ruby
+new({ type: :boolean }, { false_values: Set.new([false]) }).serialize(nil) == true
+```
+
+#### options[:no_boolean_coerce] [Boolean]
+
+If true, boolean schema treats only `true` to be `true`.
+
+```ruby
+new({ type: :boolean }, { no_boolean_coerce: true }).serialize(1) == false
+```
+
+#### options[:guard_primitive_in_structure] [Boolean]
+
+If true, array or object schema does not accept primitive data and returns empty value.
+
+
+```ruby
+new({ type: :object }, { guard_primitive_in_structure: true }).serialize(1) == {}
+new({ type: :object }, { guard_primitive_in_structure: true, null_through: true }).serialize(1) == nil
+```
+
+### #serialize(data)
+
+Serialize the object data by the schema.
+
+#### data [any]
+
+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/json-schema-serializer.gemspec

@@ -4,7 +4,7 @@ require "json/schema/serializer/version"
 
 Gem::Specification.new do |spec|
   spec.name = "json-schema-serializer"
-  spec.version = Json::Schema::Serializer::VERSION
+  spec.version = JSON::Schema::Serializer::VERSION
   spec.authors = %w[Narazaka]
   spec.email = %w[info@narazaka.net]
   spec.licenses = %w[Zlib]
@@ -28,9 +28,10 @@ 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"

data/lib/json/schema/serializer.rb

@@ -5,13 +5,29 @@ require "set"
 module JSON
   class Schema
     class Serializer
-      def initialize(obj, options = {})
-        @schema = options && options[:resolver] ? options[:resolver].call(obj) : obj
-        @options = options
+      def initialize(schema, options = nil) # rubocop:disable Airbnb/OptArgParameters
+        @schema = options && options[:resolver] ? options[:resolver].call(schema) : schema
+        @options = options || {}
       end
 
-      def serialize(obj)
-        Walker.walk(@schema, obj, true, @options)
+      def serialize(data)
+        Walker.walk(@schema, data, true, @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
@@ -27,7 +43,27 @@ module JSON
             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
+              end
+              if injector
+                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)
           end
@@ -121,7 +157,7 @@ module JSON
             when "string"
               case obj
               when nil
-                ""
+                options[:null_through] ? nil : ""
               when DateTime, Date, Time, TimeWithZone
                 case format.to_s
                 when "date-time"
@@ -134,7 +170,7 @@ module JSON
                   obj.to_s
                 end
               when Regexp
-                obj.inspect.gsub(%r`^/|/[a-z]*$`, '')
+                obj.inspect.gsub(%r{^/|/[a-z]*$}, "")
               else
                 obj.to_s
               end
@@ -144,6 +180,10 @@ module JSON
                 1
               when false
                 0
+              when nil
+                options[:null_through] ? nil : 0
+              when ""
+                options[:empty_string_number_coerce_null] ? nil : 0
               else
                 obj.to_i
               end
@@ -153,28 +193,55 @@ module JSON
                 1.0
               when false
                 0.0
+              when nil
+                options[:null_through] ? nil : 0.0
+              when ""
+                options[:empty_string_number_coerce_null] ? nil : 0.0
               else
                 obj.to_f
               end
             when "boolean"
-              obj == true
+              if obj.nil? && options[:null_through]
+                nil
+              elsif options[:empty_string_boolean_coerce_null] && obj == ""
+                nil
+              elsif options[:false_values]
+                !options[:false_values].include?(obj)
+              elsif options[:no_boolean_coerce]
+                obj == true
+              else
+                obj ? true : false
+              end
             when "array"
               items_schema = try_hash(schema, :items)
-              obj.nil? ? [] : obj.map { |item| walk(items_schema, item, true, options) }
+              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) }
             when "object"
+              return nil if obj.nil? && options[:null_through]
+              return options[:null_through] ? nil : {} if options[:guard_primitive_in_structure] && is_primitive?(obj)
+
               properties_schema = try_hash(schema, :properties)
               additional_properties_schema = try_hash(schema, :additionalProperties)
               required_schema = Set.new(try_hash(schema, :required)&.map(&:to_s))
-              ret = properties_schema.map do |name, property_schema|
-                [name.to_s, walk(property_schema, try_hash(obj, name), required_schema.include?(name.to_s), options)]
-              end.to_h
+              input_key_transform = options[:schema_key_transform_for_input] # schema key -> input obj key
+              output_key_transform = options[:schema_key_transform_for_output] # schema key -> out
+              ret =
+                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)]
+                end.to_h
               if additional_properties_schema
-                not_additional_keys = Set.new(properties_schema.keys.map(&:to_s))
+                not_additional_keys_array = properties_schema.keys.map(&:to_s)
+                not_additional_keys = Set.new(input_key_transform ? not_additional_keys_array.map { |k| input_key_transform.call(k) } : not_additional_keys_array)
                 additional_keys = obj.keys.reject { |key| not_additional_keys.include?(key.to_s) }
                 ret.merge(
                   additional_keys.map do |name|
-                    [name.to_s, walk(additional_properties_schema, try_hash(obj, name), false, options)]
-                  end.to_h
+                    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)]
+                  end.to_h,
                 )
               else
                 ret
@@ -186,11 +253,20 @@ module JSON
 
           def try_hash(obj, name)
             if obj.respond_to?(:"[]")
-              obj[name] || obj[name.is_a?(Symbol) ? name.to_s : name.to_sym]
+              obj[name] || obj[name.is_a?(String) ? name.to_sym : name.to_s]
             elsif obj.respond_to?(name)
               obj.send(name)
             end
           end
+
+          def is_primitive?(obj)
+            case obj
+            when String, Integer, Float, true, false, nil
+              true
+            else
+              false
+            end
+          end
         end
       end
     end

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

@@ -1,7 +1,7 @@
-module Json
-  module Schema
-    module Serializer
-      VERSION = "1.4.0".freeze
+module JSON
+  class Schema
+    class Serializer
+      VERSION = "1.7.1".freeze
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json-schema-serializer
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.7.1
 platform: ruby
 authors:
 - Narazaka
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-12-01 00:00:00.000000000 Z
+date: 2020-11-06 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
@@ -181,7 +195,7 @@ 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.4.0
+  documentation_uri: https://www.rubydoc.info/gems/json-schema-serializer/1.7.1
 post_install_message: 
 rdoc_options: []
 require_paths: