surrealist 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6470fa2a8f31edfdb08c858e7f74bb92add85aa887bf5a3e968521b88585adec
-  data.tar.gz: 703ce5280e32c246d5c51bd6be1d4a0e0688d01dcaaeb195aa1a5867e762e86e
+  metadata.gz: 4029b143bcc01a58f0b5a38d64a457f9a781ef7da37eaa3bc335be8d2ddafcfa
+  data.tar.gz: 4f88b4c0b4224fddfe8fa7f6d16f2d0d2618609f280a7fdfd7bea2e4f46aa2b8
 SHA512:
-  metadata.gz: 3f95d432d163188e66ae51cea051db55cf9fbfb05ae43b0e8096c0275a3d78f317a1a716fb2dc6900b3dc2deae82216ef2b9f09d062db0c00301c0cd2f2459a6
-  data.tar.gz: 71575656f64a1d6110f56623ecaa04d186478702c46f777967a17478fc180c4b6a326e4221a1c48f0def25036d68f307fd6eba2c62881120444b042808c32514
+  metadata.gz: 369823e9f4d78b1c48aa7878f76e69f7381bfacffd79653ba667f747f8c2c23802dc2126eab7ba3b2e0ab6a3ce04878745b12f42c5dbcdb36ac307e953c9b259
+  data.tar.gz: 8c7f310b4150ce62e568bfb8d0d4c0e5da187fff1fbbb11f338098ca17cf1c4e83646bbb6b05e9c0ff6d5d9790a7bcc59a00d6dd70d07fa1e61014f0dc4be0d9

data/.rubocop.yml

@@ -33,6 +33,9 @@ Layout/MultilineOperationIndentation:
 Layout/SpaceInLambdaLiteral:
   EnforcedStyle: require_space
 
+Layout/ClosingParenthesisIndentation:
+  Enabled: true
+
 # Lint
 Lint/AmbiguousBlockAssociation:
   Enabled: false
@@ -98,6 +101,9 @@ Performance/UnfreezeString:
 Style/AsciiComments:
   Enabled: false
 
+Style/AccessModifierDeclarations:
+  Enabled: false
+
 Style/MixinUsage:
   Exclude:
     - spec/**/*rb
@@ -154,9 +160,15 @@ Style/TrailingCommaInArrayLiteral:
 Style/TrailingCommaInHashLiteral:
   EnforcedStyleForMultiline: comma
 
-Style/MethodMissing:
+Style/MissingRespondToMissing:
+  Enabled: false
+
+Style/MethodMissingSuper:
   Enabled: false
 
 Style/EvalWithLocation:
   Exclude:
     - spec/**/*.rb
+
+Style/AccessModifierDeclarations:
+  Enabled: false

data/.travis.yml

@@ -8,12 +8,12 @@ matrix:
   include:
     - rvm: ruby-head
       gemfile: Gemfile
-    - rvm: 2.5.0
+    - rvm: 2.5
       gemfile: Gemfile
-    - rvm: 2.4.3
+    - rvm: 2.4
       gemfile: Gemfile
-    - rvm: 2.3.6
+    - rvm: 2.3
       gemfile: Gemfile
-    - rvm: 2.2.9
+    - rvm: 2.2
       gemfile: gemfiles/activerecord42.gemfile
 

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+# 1.3.0
+
+## Added
+
+* Hash serialization ([@stefkin][]) [#106](https://github.com/nesaulov/surrealist/pull/106)
+
+## Fixed
+
+* Conflict when root and object property share the same name ([@akxcv][]) [#99](https://github.com/nesaulov/surrealist/pull/99)
+* Precedence was given to object method instead of serializer one ([@gjhenrique][] & [@nesaulov][]) [#110](https://github.com/nesaulov/surrealist/pull/110) & [#111](https://github.com/nesaulov/surrealist/pull/111)
+
 # 1.2.0
 
 ## Added
@@ -102,4 +113,5 @@
 [@azhi]: https://github.com/azhi
 [@chrisatanasian]: https://github.com/chrisatanasian
 [@past-one]: https://github.com/past-one
-
+[@stefkin]: https://github.com/stefkin
+[@gjhenrique]: https://github.com/gjhenrique

data/Gemfile

@@ -10,7 +10,7 @@ group :development, :test do
   gem 'blueprinter'
   gem 'coveralls', require: false
   gem 'dry-struct'
-  gem 'dry-types', '= 0.12.2'
+  gem 'dry-types'
   gem 'rom', '~> 4.0'
   gem 'rom-repository'
   gem 'rom-sql'

data/README.md

@@ -40,6 +40,7 @@ to serialize nested objects and structures. [Introductory blogpost.](https://med
     * [Root](#root)
     * [Include namespaces](#include-namespaces)
   * [Configuration](#configuration)
+  * [Hash serialization](#hash-serialization)
   * [Bool and Any](#bool-and-any)
   * [Type errors](#type-errors)
   * [Undefined methods in schema](#undefined-methods-in-schema)
@@ -687,7 +688,7 @@ withdraws.surrealize(include_namespaces: true, namespaces_nesting_level: 2)
 
 There are two ways of setting default arguments for serialization,
 by passing a block to `Surrealist.configure`:
-```ruby
+``` ruby
 Surrealist.configure do |config|
   config.camelize = true
   config.namespaces_nesting_level = 2
@@ -700,13 +701,28 @@ And by passing a hash:
 These arguments will be applied to all calls of `#build_schema` and `#surrealize`.
 If these methods will be called with arguments, they will be merged with respect to explicitly passed ones:
 
-```ruby
+``` ruby
 Surrealist.configure(camelize: true, include_root: true)
 
 Something.new.surrealize(camelize: false)
 # will result in Something.new.surrealize(camelize: false, include_root: true)
 ```
 
+### Hash serialization
+
+You can pass a hash to serializer and it will use the keys instead of methods.
+
+``` ruby
+class HashSerializer < Surrealist::Serializer
+  json_schema { { string: String, int: Integer } }
+end
+
+HashSerializer.new(string: 'string', int: 4).surrealize
+# => '{ "string": "string", "int": 4}'
+
+HashSerializer.new(string: 'string', int: 'not int').surrealize
+# => Surrealist::InvalidTypeError: Wrong type for key `int`. Expected Integer, got String.
+```
 
 ### Bool and Any
 If you have a parameter that is of boolean type, or if you don't care about the type, you
@@ -769,7 +785,8 @@ type check will be passed. If you want to be strict about `nil`s consider using
 
 ## Roadmap
 Here is a list of features that are not implemented yet (contributions are welcome):
-* Memoization/caching
+* Automatic endpoint documentation
+* API for validating (contracts) without actually serializing to JSON (maybe with deserialization from JSON)
 
 ## Contributing
 Bug reports and pull requests are welcome on GitHub at https://github.com/nesaulov/surrealist.

data/lib/surrealist.rb

@@ -18,6 +18,7 @@ require_relative 'surrealist/string_utils'
 require_relative 'surrealist/type_helper'
 require_relative 'surrealist/value_assigner'
 require_relative 'surrealist/vars_helper'
+require_relative 'surrealist/wrapper'
 
 # Main module that provides the +json_schema+ class method and +surrealize+ instance method.
 module Surrealist
@@ -128,10 +129,13 @@ module Surrealist
       Surrealist::ExceptionRaiser.raise_unknown_schema!(instance) if schema.nil?
 
       parameters = config ? config.merge(args) : args
+
+      # TODO: Refactor (something pipeline-like would do here, perhaps a builder of some sort)
       carrier = Surrealist::Carrier.call(parameters)
-      normalized_schema = Surrealist::Copier.deep_copy(schema, carrier, instance.class.name)
-      hash = Builder.new(carrier, normalized_schema, instance).call
-      carrier.camelize ? Surrealist::HashUtils.camelize_hash(hash) : hash
+      copied_schema = Surrealist::Copier.deep_copy(schema)
+      built_schema = Builder.new(carrier, copied_schema, instance).call
+      wrapped_schema = Surrealist::Wrapper.wrap(built_schema, carrier, instance.class.name)
+      carrier.camelize ? Surrealist::HashUtils.camelize_hash(wrapped_schema) : wrapped_schema
     end
     # rubocop:enable Metrics/AbcSize
 
@@ -139,7 +143,7 @@ module Surrealist
     #
     # @return [Hash] default arguments (@see Surrealist::Carrier)
     def config
-      @default_args || Surrealist::Copier::EMPTY_HASH
+      @default_args || Surrealist::HashUtils::EMPTY_HASH
     end
 
     # Sets default serialization arguments with a block
@@ -158,7 +162,7 @@ module Surrealist
         yield(carrier)
         @default_args = carrier.parameters
       else
-        @default_args = hash.nil? ? Surrealist::Copier::EMPTY_HASH : hash
+        @default_args = hash.nil? ? Surrealist::HashUtils::EMPTY_HASH : hash
       end
     end
 

data/lib/surrealist/builder.rb

@@ -80,7 +80,7 @@ module Surrealist
     # @return [Hash] the schema hash
     def construct_collection(schema, instance, key, value)
       schema[key] = instance.send(key).map do |inst|
-        call(Copier.deep_copy(value, carrier), inst)
+        call(Copier.deep_copy(value), inst)
       end
     end
   end

data/lib/surrealist/copier.rb

@@ -3,113 +3,16 @@
 module Surrealist
   # A helper class for deep copying and wrapping hashes.
   module Copier
-    EMPTY_HASH = {}.freeze
-
     class << self
-      # Deeply copies the schema hash and wraps it if there is a need to.
-      #
-      # @param [Object] hash object to be copied.
-      # @param [String] klass instance's class name.
-      # @param [Object] carrier instance of Carrier class that carries arguments passed to +surrealize+
-      #
-      # @return [Hash] a copied hash.
-      def deep_copy(hash, carrier, klass = false)
-        namespaces_condition = carrier.include_namespaces || carrier.namespaces_nesting_level != DEFAULT_NESTING_LEVEL # rubocop:disable Metrics/LineLength
-
-        if !klass && (carrier.include_root || namespaces_condition)
-          Surrealist::ExceptionRaiser.raise_unknown_root!
-        end
-
-        copied_and_possibly_wrapped_hash(hash, klass, carrier, namespaces_condition)
-      end
-
-      private
-
-      # Deeply copies the schema hash and wraps it if there is a need to.
-      #
-      # @param [Object] hash object to be copied.
-      # @param [String] klass instance's class name.
-      # @param [Object] carrier instance of Carrier class that carries arguments passed to +surrealize+
-      # @param [Bool] namespaces_condition whether to wrap into namespace.
-      #
-      # @return [Hash] deeply copied hash, possibly wrapped.
-      def copied_and_possibly_wrapped_hash(hash, klass, carrier, namespaces_condition)
-        return copy_hash(hash) if carrier.no_args_provided?
-
-        if carrier.root
-          wrap_schema_into_root(hash, carrier, carrier.root.to_s)
-        elsif namespaces_condition
-          wrap_schema_into_namespace(hash, carrier, klass)
-        elsif carrier.include_root
-          actual_class = Surrealist::StringUtils.extract_class(klass)
-          wrap_schema_into_root(hash, carrier, actual_class)
-        else
-          copy_hash(hash)
-        end
-      end
-
       # Goes through the hash recursively and deeply copies it.
       #
       # @param [Hash] hash the hash to be copied.
       # @param [Hash] wrapper the wrapper of the resulting hash.
       #
       # @return [Hash] deeply copied hash.
-      def copy_hash(hash, wrapper = {})
+      def deep_copy(hash, wrapper = {})
         hash.each_with_object(wrapper) do |(key, value), new|
-          new[key] = value.is_a?(Hash) ? copy_hash(value) : value
-        end
-      end
-
-      # Wraps schema into a root key if `include_root` is passed to Surrealist.
-      #
-      # @param [Hash] schema schema hash.
-      # @param [Object] carrier instance of Carrier class that carries arguments passed to +surrealize+
-      # @param [String] root what the schema will be wrapped into
-      #
-      # @return [Hash] a hash with schema wrapped inside a root key.
-      def wrap_schema_into_root(schema, carrier, root)
-        root_key = if carrier.camelize
-                     Surrealist::StringUtils.camelize(root, false).to_sym
-                   else
-                     Surrealist::StringUtils.underscore(root).to_sym
-                   end
-        result = Hash[root_key => {}]
-        copy_hash(schema, result[root_key])
-
-        result
-      end
-
-      # Wraps schema into a nested hash of namespaces.
-      #
-      # @param [Hash] schema main schema.
-      # @param [String] klass name of the class where schema is defined.
-      # @param [Object] carrier instance of Carrier class that carries arguments passed to +surrealize+
-      #
-      # @return [Hash] nested hash (see +inject_schema+)
-      def wrap_schema_into_namespace(schema, carrier, klass)
-        nested_hash = Surrealist::StringUtils.break_namespaces(
-          klass, carrier.camelize, carrier.namespaces_nesting_level
-        )
-
-        inject_schema(nested_hash, copy_hash(schema))
-      end
-
-      # Injects one hash into another nested hash.
-      #
-      # @param [Hash] hash wrapper-hash.
-      # @param [Hash] sub_hash hash to be injected.
-      #
-      # @example wrapping hash
-      #  hash = { one: { two: { three: {} } } }
-      #  sub_hash = { four: '4' }
-      #
-      #  inject_schema(hash, sub_hash)
-      #  # => { one: { two: { three: { four: '4' } } } }
-      #
-      # @return [Hash] resulting hash.
-      def inject_schema(hash, sub_hash)
-        hash.each do |k, v|
-          v == EMPTY_HASH ? hash[k] = sub_hash : inject_schema(v, sub_hash)
+          new[key] = value.is_a?(Hash) ? deep_copy(value) : value
         end
       end
     end

data/lib/surrealist/hash_utils.rb

@@ -3,6 +3,8 @@
 module Surrealist
   # A helper class for hashes transformations.
   module HashUtils
+    EMPTY_HASH = {}.freeze
+
     class << self
       # Converts hash's keys to camelBack keys.
       #

data/lib/surrealist/helper.rb

@@ -16,7 +16,7 @@ module Surrealist
       # 4.2 AR relation object did not include Enumerable (it defined
       # all necessary method through ActiveRecord::Delegation module),
       # so we need to explicitly check for this
-      object.is_a?(Enumerable) || ar_relation?(object)
+      (object.is_a?(Enumerable) && !object.instance_of?(Hash)) || ar_relation?(object)
     end
 
     def self.ar_relation?(object)

data/lib/surrealist/serializer.rb

@@ -54,7 +54,7 @@ module Surrealist
     #   e.g `CatSerializer.new(Cat.new(3), food: CatFood.new)`
     #   And then food will be available inside serializer via `context[:food]`
     def initialize(object, **context)
-      @object = object
+      @object = wrap_hash_into_struct(object)
       @context = context
     end
 
@@ -87,12 +87,16 @@ module Surrealist
 
     # Methods not found inside serializer will be invoked on the object
     def method_missing(method, *args, &block)
-      object.public_send(method, *args, &block)
+      object.public_send(method, *args, &block) || super
     end
 
     # Methods not found inside serializer will be invoked on the object
     def respond_to_missing?(method, include_private = false)
       object.respond_to?(method) || super
     end
+
+    def wrap_hash_into_struct(object)
+      object.instance_of?(Hash) ? OpenStruct.new(object) : object
+    end
   end
 end

data/lib/surrealist/value_assigner.rb

@@ -39,7 +39,7 @@ module Surrealist
       end
 
       # Checks if there is a custom serializer defined for the object and invokes the method
-      #   on it first.
+      #   on it first only if the serializer has not defined the same method.
       #
       # @param [Object] instance an instance of a model or a serializer
       # @param [Symbol] method the schema key that represents the method to be invoked
@@ -47,8 +47,10 @@ module Surrealist
       # @return [Object] the return value of the method
       def invoke_method(instance, method)
         object = instance.instance_variable_get(:@object)
-
-        object && object.respond_to?(method) ? object.send(method) : instance.send(method)
+        instance_method = instance.class.instance_methods(false).include?(method) ||
+          instance.class.private_instance_methods(false).include?(method)
+        invoke_object = !instance_method && object && object.respond_to?(method, true)
+        invoke_object ? object.send(method) : instance.send(method)
       end
 
       # Coerces value if type check is passed

data/lib/surrealist/version.rb

@@ -2,5 +2,5 @@
 
 module Surrealist
   # Defines the version of Surrealist
-  VERSION = '1.2.0'.freeze
+  VERSION = '1.3.0'.freeze
 end

data/lib/surrealist/wrapper.rb

@@ -0,0 +1,102 @@
+module Surrealist
+  # A helper class for wrapphing hashes.
+  module Wrapper
+    class << self
+      # Wraps the schema hash into root/namespaces if there is a need to.
+      #
+      # @param [Object] hash to be wrapped.
+      # @param [Object] carrier instance of Carrier class that carries arguments passed to +surrealize+
+      # @param [String] klass instance's class name.
+      #
+      # @return [Hash] a wrapped hash.
+      def wrap(hash, carrier, klass = false)
+        namespaces_condition = carrier.include_namespaces || carrier.namespaces_nesting_level != DEFAULT_NESTING_LEVEL # rubocop:disable Metrics/LineLength
+
+        if !klass && (carrier.include_root || namespaces_condition)
+          Surrealist::ExceptionRaiser.raise_unknown_root!
+        end
+
+        possibly_wrapped_hash(hash, klass, carrier, namespaces_condition)
+      end
+
+      private
+
+      # Deeply copies the schema hash and wraps it if there is a need to.
+      # TODO: refactor
+      #
+      # @param [Object] hash object to be copied.
+      # @param [String] klass instance's class name.
+      # @param [Object] carrier instance of Carrier class that carries arguments passed to +surrealize+
+      # @param [Bool] namespaces_condition whether to wrap into namespace.
+      #
+      # @return [Hash] deeply copied hash, possibly wrapped.
+      def possibly_wrapped_hash(hash, klass, carrier, namespaces_condition)
+        return hash if carrier.no_args_provided?
+
+        if carrier.root
+          wrap_schema_into_root(hash, carrier, carrier.root.to_s)
+        elsif namespaces_condition
+          wrap_schema_into_namespace(hash, carrier, klass)
+        elsif carrier.include_root
+          actual_class = Surrealist::StringUtils.extract_class(klass)
+          wrap_schema_into_root(hash, carrier, actual_class)
+        else
+          hash
+        end
+      end
+
+      # Wraps schema into a root key if `include_root` is passed to Surrealist.
+      #
+      # @param [Hash] schema schema hash.
+      # @param [Object] carrier instance of Carrier class that carries arguments passed to +surrealize+
+      # @param [String] root what the schema will be wrapped into
+      #
+      # @return [Hash] a hash with schema wrapped inside a root key.
+      def wrap_schema_into_root(schema, carrier, root)
+        root_key = if carrier.camelize
+                     Surrealist::StringUtils.camelize(root, false).to_sym
+                   else
+                     Surrealist::StringUtils.underscore(root).to_sym
+                   end
+        result = Hash[root_key => {}]
+        Surrealist::Copier.deep_copy(schema, result[root_key])
+
+        result
+      end
+
+      # Wraps schema into a nested hash of namespaces.
+      #
+      # @param [Hash] schema main schema.
+      # @param [String] klass name of the class where schema is defined.
+      # @param [Object] carrier instance of Carrier class that carries arguments passed to +surrealize+
+      #
+      # @return [Hash] nested hash (see +inject_schema+)
+      def wrap_schema_into_namespace(schema, carrier, klass)
+        nested_hash = Surrealist::StringUtils.break_namespaces(
+          klass, carrier.camelize, carrier.namespaces_nesting_level
+        )
+
+        inject_schema(nested_hash, Surrealist::Copier.deep_copy(schema))
+      end
+
+      # Injects one hash into another nested hash.
+      #
+      # @param [Hash] hash wrapper-hash.
+      # @param [Hash] sub_hash hash to be injected.
+      #
+      # @example wrapping hash
+      #  hash = { one: { two: { three: {} } } }
+      #  sub_hash = { four: '4' }
+      #
+      #  inject_schema(hash, sub_hash)
+      #  # => { one: { two: { three: { four: '4' } } } }
+      #
+      # @return [Hash] resulting hash.
+      def inject_schema(hash, sub_hash)
+        hash.each do |k, v|
+          v == Surrealist::HashUtils::EMPTY_HASH ? hash[k] = sub_hash : inject_schema(v, sub_hash)
+        end
+      end
+    end
+  end
+end

data/surrealist.gemspec

@@ -30,5 +30,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'pry', '~> 0.11'
   spec.add_development_dependency 'rake', '~> 12.3'
   spec.add_development_dependency 'rspec', '~> 3.7'
-  spec.add_development_dependency 'rubocop', '~> 0.54'
+  spec.add_development_dependency 'rubocop', '~> 0.57'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: surrealist
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Nikita Esaulov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-05-13 00:00:00.000000000 Z
+date: 2018-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj
@@ -86,14 +86,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.54'
+        version: '0.57'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.54'
+        version: '0.57'
 description: A gem that provides DSL for serialization of plain old Ruby objects to
   JSON in a declarative style by defining a `schema`. It also provides a trivial type
   checking in the runtime before serialization.
@@ -136,6 +136,7 @@ files:
 - lib/surrealist/value_assigner.rb
 - lib/surrealist/vars_helper.rb
 - lib/surrealist/version.rb
+- lib/surrealist/wrapper.rb
 - surrealist-icon.png
 - surrealist.gemspec
 homepage: https://github.com/nesaulov/surrealist