surrealist 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cad5fa813b903c8a83c6618f48a8e5f027244346
-  data.tar.gz: 4c65f03f060c4c93ae2dd036f634bcc84ab77d3e
+  metadata.gz: 712012011eaaceb220f8811228de4b07c6e08460
+  data.tar.gz: 5ed1ef86483b6dd864a8769359443c7f760e1ae2
 SHA512:
-  metadata.gz: 85121fc7dd2a504fe51d03337c52d2ea08784eeca7fbb150f43f047bfe9c915cff1cb813051307cff9a552ad3c564f891eadca1e8dd18e412a850b150f85cd23
-  data.tar.gz: 140e6ced9ee0c3e35b77417e12279699ab0468d7c154e9f8cf5bf89e2a73f7bb065303dc5a39013153acd1c5ca9aeea0b3dd0b477cdcde64cfd5a7f295061bd5
+  metadata.gz: b15fda40fbc90382e61703564c4e7a386c521036b60227e902df8e6fd1216c933d1281ac4dc5305f0b641475ebc83187b61354550a603e086026bc0de94d0330
+  data.tar.gz: dc9d2a1a70f6696f5dec95214125b7fe9677ff5c19e6aa9561318127f05b30ea60b0e0dcc694436ac9313879d9fd98e4e23824532ed1f9723534dedc3daa1734

data/CHANGELOG.md

@@ -1,11 +1,19 @@
+# 0.1.4
+## Added
+* Optional `include_root` argument to wrap schema in a root key. [#15](https://github.com/nesaulov/surrealist/pull/15)
+## Fixed
+* Performance of schema cloning.
+## Changed
+* `Boolean` module renamed to `Bool`.
+
 # 0.1.2
 ## Added
-* `Any` module for skipping type checks
-* Optional `camelize` argument to convert keys to camelBacks
+* `Any` module for skipping type checks.
+* Optional `camelize` argument to convert keys to camelBacks.
 
 # 0.1.0
 ## Fixed
-* Fix schema mutability issue
+* Fix schema mutability issue.
 ## Changed
 * Change `schema` class method to `json_schema` due to compatibility issues with other gems.
 

data/README.md

@@ -4,6 +4,8 @@
 [![Inline docs](http://inch-ci.org/github/nesaulov/surrealist.svg?branch=master)](http://inch-ci.org/github/nesaulov/surrealist)
 [![Gem Version](https://badge.fury.io/rb/surrealist.svg)](https://rubygems.org/gems/surrealist)
 
+![Surrealist](surrealist-icon.png)
+ 
 A gem that provides DSL for serialization of plain old Ruby objects to JSON in a declarative style
 by defining a `json_schema`. It also provides a trivial type checking in the runtime before serialization.
 [Yard documentation](http://www.rubydoc.info/github/nesaulov/surrealist/master)
@@ -13,7 +15,7 @@ by defining a `json_schema`. It also provides a trivial type checking in the run
 A typical use case for this gem could be, for example, serializing a (decorated) object outside
 of the view context. The schema is described through a hash, so you can build the structure
 of serialized object independently of its methods and attributes, while also having possibility
-to serialize nested objects and structures.
+to serialize nested objects and structures. [Introductory blogpost.](https://medium.com/@billikota/introducing-surrealist-a-gem-to-serialize-ruby-objects-according-to-a-defined-schema-6ca7e550628d)
 
 * [Installation](#installation)
 * [Usage](#usage)
@@ -23,11 +25,14 @@ to serialize nested objects and structures.
   * [Usage with Dry::Types](#usage-with-drytypes)
   * [Build schema](#build-schema)
   * [Camelization](#camelization)
+  * [Include root](#include-root)
   * [Bool and Any](#bool-and-any)
   * [Type errors](#type-errors)
   * [Undefined methods in schema](#undefined-methods-in-schema)
   * [Other notes](#other-notes)
+* [Roadmap](#roadmap)  
 * [Contributing](#contributing)
+* [Credits](#credits)
 * [License](#license)
 
 
@@ -63,17 +68,14 @@ class Person
   include Surrealist
  
   json_schema do
-    {
-      foo: String,
-      bar: Integer,
-    }
+    { name: String, age: Integer }
   end
  
-  def foo
-    'This is a string'
+  def name
+    'John Doe'
   end
  
-  def bar
+  def age
     42
   end
 end
@@ -83,7 +85,7 @@ end
 
 ``` ruby
 Person.new.surrealize
-# => '{ "foo": "This is a string", "bar" :42 }'
+# => '{ "name": "John Doe", "age": 42 }'
 ```
 
 ### Nested structures
@@ -140,7 +142,7 @@ class User
 end
 
 User.new.surrealize
-# => '{ "name": "John Doe", "credit_card": { "number" :1234, "cvv": 322 } }'
+# => '{ "name": "John Doe", "credit_card": { "number": 1234, "cvv": 322 } }'
 
 ```
 
@@ -149,7 +151,7 @@ You can use `Dry::Types` for type checking. Note that Surrealist does not ship
 with dry-types by default, so you should do the [installation and configuration](http://dry-rb.org/gems/dry-types/)
 by yourself. All built-in features of dry-types work, so if you use, say, `Types::Coercible::String`,
 your data will be coerced if it is able to, otherwise you will get a TypeError.
-Assuming, that you have defined module called `Types`:
+Assuming that you have defined module called `Types`:
 
 ``` ruby
 require 'dry-types'
@@ -169,25 +171,25 @@ class Car
   end
  
   def age;
-    '7';
+    '7'
   end
  
   def previous_owner;
-    'John Doe';
+    'John Doe'
   end
  
   def horsepower;
-    140;
+    140
   end
  
   def brand;
-    'Toyota';
+    'Toyota'
   end
  
   def doors; end
  
   def fuel_system;
-    'Direct injection';
+    'Direct injection'
   end
 end
 
@@ -207,13 +209,54 @@ Car.new.build_schema
 
 ### Camelization
 If you need to have keys in camelBack, you can pass optional `camelize` argument
-to `#surrealize`. From the previous example:
+to `#surrealize or #build_schema`. From the previous example:
 
 ``` ruby
 Car.new.surrealize(camelize: true)
 # => '{ "age": 7, "brand": "Toyota", "doors": null, "horsepower": 140, "fuelSystem": "Direct injection", "previousOwner": "John Doe" }'
 ```
 
+### Include root
+If you want to wrap the resulting JSON into a root key, you can pass optional `include_root` argument
+to `#surrealize` or `#build_schema`. The root key in this case will be taken from the class name of the
+surrealizable object.
+``` ruby
+class Cat
+  include Surrealist
+ 
+  json_schema do
+    { weight: String }
+  end
+ 
+  def weight
+    '3 kilos'
+  end
+end
+ 
+Cat.new.surrealize(include_root: true)
+# => '{ "cat": { "weight": "3 kilos" } }'
+```
+With nested classes the last namespace will be taken as root key:
+``` ruby
+class Animal
+  class Dog
+    include Surrealist
+ 
+    json_schema do
+      { breed: String }
+    end
+ 
+    def breed
+      'Collie'
+    end
+  end
+end
+
+Animal::Dog.new.surrealize(include_root: true)
+# => '{ "dog": { "breed": "Collie" } }'
+```
+Nesting namespaces are [yet to be implemented.](https://github.com/nesaulov/surrealist/issues/14)
+
 ### Bool and Any
 If you have a parameter that is of boolean type, or if you don't care about the type, you
 can use `Bool` and `Any` respectively.
@@ -274,14 +317,22 @@ Car.new.surrealize
 ### Other notes
 * nil values are allowed by default, so if you have, say, `age: String`, but the actual value is nil,
 type check will be passed. If you want to be strict about `nil`s consider using `Dry::Types`.
-* Surrealist requires ruby of version 2.2 and higher.
+* Surrealist requires MRI ruby of version 2.2 and higher.
 
-## Contributing
+## Roadmap
+Here is a list of features that are not implemented yet (contributions are welcome):
+* [ActiveRecord_Relation serialization](https://github.com/nesaulov/surrealist/issues/13)
+* [Collection serialization](https://github.com/nesaulov/surrealist/issues/12)
+* [Delegating serialization to parent class](https://github.com/nesaulov/surrealist/issues/11)
+* [Having nested namespaces being surrealized](https://github.com/nesaulov/surrealist/issues/14)
 
+## Contributing
 Bug reports and pull requests are welcome on GitHub at https://github.com/nesaulov/surrealist.
 This project is intended to be a safe, welcoming space for collaboration, and contributors are expected
 to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
-## License
+## Credits
+The icon was created by [Simon Child from Noun Project](https://thenounproject.com/term/salvador-dali/124566/) and is published under [Creative Commons License](https://creativecommons.org/licenses/by/3.0/us/)
 
+## License
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/lib/surrealist/hash_utils.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Surrealist
+  # A helper class to camelize, wrap and deeply copy hashes.
+  class HashUtils
+    class << self
+      # Deeply copies the schema hash and wraps it if there is a need to.
+      #
+      # @param [Object] hash object to be copied.
+      # @param [Boolean] include_root optional argument for including root in the hash.
+      # @param [Boolean] camelize optional argument for camelizing the root key of the hash.
+      # @param [String] klass instance's class name.
+      #
+      # @return [Object] a copied object
+      def deep_copy(hash:, include_root: false, camelize: false, klass: false)
+        return copy_hash(hash) unless include_root
+        raise_unknown_root! if include_root && !klass
+
+        actual_class = extract_class(klass)
+        root_key = camelize ? camelize(actual_class, false).to_sym : underscore(actual_class).to_sym
+        object = Hash[root_key => {}]
+        copy_hash(hash, wrapper: object[root_key])
+
+        object
+      end
+
+      # Converts hash's keys to camelBack keys.
+      #
+      # @param [Hash] hash a hash to be camelized.
+      #
+      # @return [Hash] camelized hash.
+      def camelize_hash(hash)
+        if hash.is_a?(Hash)
+          Hash[hash.map { |k, v| [camelize_key(k, false), camelize_hash(v)] }]
+        else
+          hash
+        end
+      end
+
+      private
+
+      # 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: {})
+        hash.each_with_object(wrapper) do |(key, value), new|
+          new[key] = value.is_a?(Hash) ? copy_hash(value) : value
+        end
+      end
+
+      # Converts symbol to string and camelizes it.
+      #
+      # @param [String | Symbol] key a key to be camelized.
+      # @param [Boolean] first_upper should the first letter be capitalized.
+      #
+      # @return [String | Symbol] camelized key of a hash.
+      def camelize_key(key, first_upper = true)
+        if key.is_a? Symbol
+          camelize(key.to_s, first_upper).to_sym
+        elsif key.is_a? String
+          camelize(key, first_upper)
+        else
+          key
+        end
+      end
+
+      # Camelizes a string.
+      #
+      # @param [String] snake_string a string to be camelized.
+      # @param [Boolean] first_upper should the first letter be capitalized.
+      #
+      # @return [String] camelized string.
+      def camelize(snake_string, first_upper = true)
+        if first_upper
+          snake_string.to_s
+                    .gsub(/(?:^|_)([^_\s]+)/) { Regexp.last_match[1].capitalize }
+        else
+          parts = snake_string.split('_', 2)
+          parts[0] << camelize(parts[1]) if parts.size > 1
+          parts[0] || ''
+        end
+      end
+
+      # Clones a string and converts first character to lower case.
+      #
+      # @param [String] string a string to be cloned.
+      #
+      # @return [String] new string with lower cased first character.
+      def uncapitalize(string)
+        str = string.dup
+        str[0] = str[0].downcase
+        str
+      end
+
+      # Converts a string to snake_case.
+      #
+      # @param [String] string a string to be underscored.
+      #
+      # @return [String] underscored string.
+      def underscore(string)
+        string.gsub('::', '_')
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .tr('-', '_')
+          .downcase
+      end
+
+      # Extract last class from a namespace.
+      #
+      # @param [String] string full namespace
+      #
+      # @example Extract class
+      #   extract_class('Animal::Dog::Collie') # => 'Collie'
+      #
+      # @return [String] extracted class
+      def extract_class(string)
+        uncapitalize(string.split('::').last)
+      end
+
+      # Raises Surrealist::UnknownRootError if class's name is unknown.
+      #
+      # @raise Surrealist::UnknownRootError
+      def raise_unknown_root!
+        raise Surrealist::UnknownRootError, "Can't wrap schema in root key - class name was not passed"
+      end
+    end
+  end
+end

data/lib/surrealist/instance_methods.rb

@@ -4,13 +4,13 @@ module Surrealist
   # Instance methods that are included to the object's class
   module InstanceMethods
     # Invokes +Surrealist+'s class method +surrealize+
-    def surrealize(camelize: false)
-      Surrealist.surrealize(self, camelize: camelize)
+    def surrealize(camelize: false, include_root: false)
+      Surrealist.surrealize(instance: self, camelize: camelize, include_root: include_root)
     end
 
     # Invokes +Surrealist+'s class method +build_schema+
-    def build_schema(camelize: false)
-      Surrealist.build_schema(self, camelize: camelize)
+    def build_schema(camelize: false, include_root: false)
+      Surrealist.build_schema(instance: self, camelize: camelize, include_root: include_root)
     end
   end
 end

data/lib/surrealist/type_helper.rb

@@ -3,6 +3,7 @@
 module Surrealist
   # Service class for type checking
   class TypeHelper
+    # Dry-types class matcher
     DRY_TYPE_CLASS = 'Dry::Types'
 
     class << self

data/lib/surrealist/version.rb

@@ -2,5 +2,5 @@
 
 module Surrealist
   # Defines the version of Surrealist
-  VERSION = '0.1.2'
+  VERSION = '0.1.4'
 end

data/lib/surrealist.rb

@@ -4,7 +4,7 @@ require 'surrealist/class_methods'
 require 'surrealist/instance_methods'
 require 'surrealist/bool'
 require 'surrealist/any'
-require 'surrealist/utils'
+require 'surrealist/hash_utils'
 require 'surrealist/type_helper'
 require 'json'
 
@@ -22,102 +22,126 @@ module Surrealist
   # Error class for failed type-checks.
   class InvalidTypeError < TypeError; end
 
-  # @param [Class] base class to include/extend +Surrealist+.
-  def self.included(base)
-    base.extend(Surrealist::ClassMethods)
-    base.include(Surrealist::InstanceMethods)
-  end
-
-  # Dumps the object's methods corresponding to the schema
-  # provided in the object's class and type-checks the values.
-  #
-  # @param [Object] instance of a class that has +Surrealist+ included.
-  #
-  # @return [String] a json-formatted string corresponding to the schema
-  #   provided in the object's class. Values will be taken from the return values
-  #   of appropriate methods from the object.
-  #
-  # @raise +Surrealist::UnknownSchemaError+ if no schema was provided in the object's class.
-  #
-  # @raise +Surrealist::InvalidTypeError+ if type-check failed at some point.
-  #
-  # @raise +Surrealist::UndefinedMethodError+ if a key defined in the schema
-  #   does not have a corresponding method on the object.
-  #
-  # @example Define a schema and surrealize the object
-  #   class User
-  #     include Surrealist
-  #
-  #     json_schema do
-  #       {
-  #         name: String,
-  #         age: Integer,
-  #       }
-  #     end
-  #
-  #     def name
-  #       'Nikita'
-  #     end
-  #
-  #     def age
-  #       23
-  #     end
-  #   end
-  #
-  #   User.new.surrealize
-  #   # => "{\"name\":\"Nikita\",\"age\":23}"
-  #   # For more examples see README
-  def self.surrealize(instance, camelize:)
-    ::JSON.dump(build_schema(instance, camelize: camelize))
-  end
+  # Error class for undefined root keys for schema wrapping.
+  class UnknownRootError < RuntimeError; end
 
-  # Builds hash from schema provided in the object's class and type-checks the values.
-  #
-  # @param [Object] instance of a class that has +Surrealist+ included.
-  #
-  # @return [Hash] a hash corresponding to the schema
-  #   provided in the object's class. Values will be taken from the return values
-  #   of appropriate methods from the object.
-  #
-  # @raise +Surrealist::UnknownSchemaError+ if no schema was provided in the object's class.
-  #
-  # @raise +Surrealist::InvalidTypeError+ if type-check failed at some point.
-  #
-  # @raise +Surrealist::UndefinedMethodError+ if a key defined in the schema
-  #   does not have a corresponding method on the object.
-  #
-  # @example Define a schema and surrealize the object
-  #   class User
-  #     include Surrealist
-  #
-  #     json_schema do
-  #       {
-  #         name: String,
-  #         age: Integer,
-  #       }
-  #     end
-  #
-  #     def name
-  #       'Nikita'
-  #     end
-  #
-  #     def age
-  #       23
-  #     end
-  #   end
-  #
-  #   User.new.build_schema
-  #   # => { name: 'Nikita', age: 23 }
-  #   # For more examples see README
-  def self.build_schema(instance, camelize:)
-    schema = instance.class.instance_variable_get('@__surrealist_schema')
+  class << self
+    # @param [Class] base class to include/extend +Surrealist+.
+    def included(base)
+      base.extend(Surrealist::ClassMethods)
+      base.include(Surrealist::InstanceMethods)
+    end
 
-    if schema.nil?
-      raise Surrealist::UnknownSchemaError, "Can't serialize #{instance.class} - no schema was provided."
+    # Dumps the object's methods corresponding to the schema
+    # provided in the object's class and type-checks the values.
+    #
+    # @param [Object] instance of a class that has +Surrealist+ included.
+    # @param [Boolean] camelize optional argument for converting hash to camelBack.
+    # @param [Boolean] include_root optional argument for having the root key of the resulting hash
+    #   as instance's class name.
+    #
+    # @return [String] a json-formatted string corresponding to the schema
+    #   provided in the object's class. Values will be taken from the return values
+    #   of appropriate methods from the object.
+    #
+    # @raise +Surrealist::UnknownSchemaError+ if no schema was provided in the object's class.
+    #
+    # @raise +Surrealist::InvalidTypeError+ if type-check failed at some point.
+    #
+    # @raise +Surrealist::UndefinedMethodError+ if a key defined in the schema
+    #   does not have a corresponding method on the object.
+    #
+    # @example Define a schema and surrealize the object
+    #   class User
+    #     include Surrealist
+    #
+    #     json_schema do
+    #       {
+    #         name: String,
+    #         age: Integer,
+    #       }
+    #     end
+    #
+    #     def name
+    #       'Nikita'
+    #     end
+    #
+    #     def age
+    #       23
+    #     end
+    #   end
+    #
+    #   User.new.surrealize
+    #   # => "{\"name\":\"Nikita\",\"age\":23}"
+    #   # For more examples see README
+    def surrealize(instance:, camelize:, include_root:)
+      ::JSON.dump(build_schema(instance: instance, camelize: camelize, include_root: include_root))
     end
 
-    hash = Builder.call(schema: Surrealist::Utils.deep_copy(schema), instance: instance)
+    # Builds hash from schema provided in the object's class and type-checks the values.
+    #
+    # @param [Object] instance of a class that has +Surrealist+ included.
+    # @param [Boolean] camelize optional argument for converting hash to camelBack.
+    # @param [Boolean] include_root optional argument for having the root key of the resulting hash
+    #   as instance's class name.
+    #
+    # @return [Hash] a hash corresponding to the schema
+    #   provided in the object's class. Values will be taken from the return values
+    #   of appropriate methods from the object.
+    #
+    # @raise +Surrealist::UnknownSchemaError+ if no schema was provided in the object's class.
+    #
+    # @raise +Surrealist::InvalidTypeError+ if type-check failed at some point.
+    #
+    # @raise +Surrealist::UndefinedMethodError+ if a key defined in the schema
+    #   does not have a corresponding method on the object.
+    #
+    # @example Define a schema and surrealize the object
+    #   class User
+    #     include Surrealist
+    #
+    #     json_schema do
+    #       {
+    #         name: String,
+    #         age: Integer,
+    #       }
+    #     end
+    #
+    #     def name
+    #       'Nikita'
+    #     end
+    #
+    #     def age
+    #       23
+    #     end
+    #   end
+    #
+    #   User.new.build_schema
+    #   # => { name: 'Nikita', age: 23 }
+    #   # For more examples see README
+    def build_schema(instance:, camelize:, include_root:)
+      schema = instance.class.instance_variable_get('@__surrealist_schema')
+
+      raise_unknown_schema!(instance) if schema.nil?
 
-    camelize ? Surrealist::Utils.camelize_hash(hash) : hash
+      normalized_schema = Surrealist::HashUtils.deep_copy(
+        hash:         schema,
+        klass:        instance.class.name,
+        camelize:     camelize,
+        include_root: include_root,
+      )
+
+      hash = Builder.call(schema: normalized_schema, instance: instance)
+      camelize ? Surrealist::HashUtils.camelize_hash(hash) : hash
+    end
+
+    # Raises Surrealist::UnknownSchemaError
+    #
+    # @param [Object] instance instance of the class without schema defined.
+    #
+    # @raise Surrealist::UnknownSchemaError
+    def raise_unknown_schema!(instance)
+      raise Surrealist::UnknownSchemaError, "Can't serialize #{instance.class} - no schema was provided."
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: surrealist
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Nikita Esaulov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-10-02 00:00:00.000000000 Z
+date: 2017-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -102,11 +102,12 @@ files:
 - lib/surrealist/bool.rb
 - lib/surrealist/builder.rb
 - lib/surrealist/class_methods.rb
+- lib/surrealist/hash_utils.rb
 - lib/surrealist/instance_methods.rb
 - lib/surrealist/schema_definer.rb
 - lib/surrealist/type_helper.rb
-- lib/surrealist/utils.rb
 - lib/surrealist/version.rb
+- surrealist-icon.png
 - surrealist.gemspec
 homepage: https://github.com/nesaulov/surrealist
 licenses:

data/lib/surrealist/utils.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module Surrealist
-  # A helper class to camelize hash keys and deep copy objects
-  class Utils
-    class << self
-      # Deep copies the schema hash.
-      #
-      # @param [Object] hash object to be copied
-      #
-      # @return [Object] a copied object
-      def deep_copy(hash)
-        hash.each_with_object({}) do |(key, value), new|
-          new[key] = value.is_a?(Hash) ? deep_copy(value) : value
-        end
-      end
-
-      # Converts hash's keys to camelCase
-      #
-      # @param [Hash] hash a hash to be camelized
-      #
-      # @return [Hash] camelized hash
-      def camelize_hash(hash)
-        if hash.is_a?(Hash)
-          Hash[hash.map { |k, v| [camelize_key(k, false), camelize_hash(v)] }]
-        else
-          hash
-        end
-      end
-
-      private
-
-      # Converts symbol to string and camelizes it
-      #
-      # @param [String | Symbol] key a key to be camelized
-      #
-      # @param [Boolean] first_upper should the first letter be capitalized
-      #
-      # @return [String | Symbol] camelized key of a hash
-      def camelize_key(key, first_upper = true)
-        if key.is_a? Symbol
-          camelize(key.to_s, first_upper).to_sym
-        elsif key.is_a? String
-          camelize(key, first_upper)
-        else
-          key
-        end
-      end
-
-      # Camelizes a word
-      #
-      # @param [String] snake_word a word to be camelized
-      #
-      # @param [Boolean] first_upper should the first letter be capitalized
-      #
-      # @return [String] camelized string
-      def camelize(snake_word, first_upper = true)
-        if first_upper
-          snake_word.to_s
-                    .gsub(/(?:^|_)([^_\s]+)/) { Regexp.last_match[1].capitalize }
-        else
-          parts = snake_word.split('_', 2)
-          parts[0] << camelize(parts[1]) if parts.size > 1
-          parts[0] || ''
-        end
-      end
-    end
-  end
-end