ree_lib 1.0.33 → 1.0.34

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0cfd5b894f0d131e04b5432aa8c02956929f5bd44fbd37dc8e929857ea029b1b
-  data.tar.gz: 6e83f29eeb2490db79e57b9c66700979b45aac51ce9274e6993eda80780c2e11
+  metadata.gz: 4791b1d4665fb6529a0eac40ce9cec637a08bc95896466d97bd2b23dece953ff
+  data.tar.gz: d698530862a8ae9d812efe51592eb0f06ab050547be07a23e600411d9398564f
 SHA512:
-  metadata.gz: 45dc1bdac618816fdc22bad5451de79d3e84e010a8a2e2968abd30683afe4a3b3de17bfaf2360211f885387133399b26dd892efe136a8c0d86014b395e70b16c
-  data.tar.gz: ae491406a6207a00b48928e604555f482686e1c25f0b94a07524c3783d4963d63a1282e2ff0c425c6d397c4135513e8ab4c91d9fa3f2946bf726ea97b9915cff
+  metadata.gz: ca10f0b35282bc9113376f0f18cdc7e06b5d9da80b4a0bba45e53f0f64bb17cd0d8f6a1f108a79a13067c7642d4ff97d69b86a3bf687d453d9ff9642a4331941
+  data.tar.gz: 79d127c9a1104ff11b21a6ddacdfcbfe126f467fb6f1b508dfd1910ab230d7d571d4ac92d33b44eb919b24b524b86088c9b0bc866818ba21bf41880ea4cdc331

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ree_lib (1.0.33)
+    ree_lib (1.0.34)
       binding_of_caller (~> 1.0.0)
       i18n (~> 1.12.0)
       loofah (~> 2.18.0)
@@ -36,8 +36,6 @@ GEM
       crass (~> 1.0.2)
       nokogiri (>= 1.5.9)
     msgpack (1.6.0)
-    nokogiri (1.14.2-x86_64-darwin)
-      racc (~> 1.4)
     nokogiri (1.14.2-x86_64-linux)
       racc (~> 1.4)
     oj (3.13.23)

data/lib/ree_lib/packages/ree_logger/package/ree_logger/multi_logger.rb

@@ -1,7 +1,7 @@
 class ReeLogger::MultiLogger < Logger
   include Ree::LinkDSL
 
-  link :as_json, from: :ree_object
+  link :to_hash, from: :ree_object
   link :transform_values, from: :ree_hash
   link 'ree_logger/log_event', -> { LogEvent }
   link 'ree_logger/rate_limiter', -> { RateLimiter }
@@ -149,7 +149,7 @@ class ReeLogger::MultiLogger < Logger
           args[name] = method_binding.local_variable_get(name)
         end
 
-        args = transform_values(as_json(args)) do |k, v|
+        args = transform_values(to_hash(args)) do |k, v|
           if @filter_words.any? { k.to_s.include?(_1) }
             'FILTERED'
           else

data/lib/ree_lib/packages/ree_object/Package.schema.json

@@ -15,13 +15,6 @@
 
   ],
   "objects": [
-    {
-      "name": "as_json",
-      "schema": "packages/ree_object/schemas/ree_object/functions/as_json.schema.json",
-      "tags": [
-        "fn"
-      ]
-    },
     {
       "name": "deep_dup",
       "schema": "packages/ree_object/schemas/ree_object/functions/deep_dup.schema.json",
@@ -64,6 +57,13 @@
         "fn"
       ]
     },
+    {
+      "name": "to_hash",
+      "schema": "packages/ree_object/schemas/ree_object/functions/to_hash.schema.json",
+      "tags": [
+        "fn"
+      ]
+    },
     {
       "name": "to_obj",
       "schema": "packages/ree_object/schemas/ree_object/functions/to_obj.schema.json",

data/lib/ree_lib/packages/ree_object/package/ree_object/functions/{as_json.rb → to_hash.rb}

@@ -1,74 +1,74 @@
-# frozen_string_literal: true
-
-class ReeObject::AsJson
-  include Ree::FnDSL
-
-  fn :as_json do
-    def_error { RecursiveObjectErr }
-  end
-  
-  BASIC_TYPES = [
-    Date, Time, Numeric, String, FalseClass, TrueClass, NilClass, Symbol,
-    Module, Class
-  ].freeze
-
-  contract(
-    Any => Or[Hash, ArrayOf[Any], *BASIC_TYPES]
-  ).throws(RecursiveObjectErr)
-  def call(obj)
-    recursively_convert(obj, {}, {})
-  end
-
-  private
-
-  def recursively_convert(obj, acc, cache)
-    ancestors = obj.class.ancestors
-
-    if ancestors.intersection(BASIC_TYPES).size > 0
-      obj
-    elsif obj.is_a?(Array)
-      convert_array(obj, acc, cache)
-    elsif obj.is_a?(Hash)
-      convert_hash(obj, acc, cache)
-    elsif obj.respond_to?(:to_h)
-      convert_hash(obj.to_h, acc, cache)
-    else
-      convert_object(obj, acc, cache)
-    end
-  end
-
-  def convert_array(obj, acc, cache)
-    obj.map { |el| recursively_convert(el, {}, cache) }
-  end
-
-  def convert_hash(obj, acc, cache)
-    obj.each do |k, v|
-      key_sym = k.to_sym
-      acc[key_sym] = recursively_convert(v, {}, cache)
-    end
-
-    acc
-  end
-
-  def convert_object(obj, acc, cache)
-    return obj if obj.is_a?(Class) || obj.is_a?(Module)
-
-    if cache.key?(obj.object_id)
-      raise RecursiveObjectErr, "Recursive object found: #{obj}"
-    end
-
-    cache[obj.object_id] = acc
-    
-    obj.instance_variables.each do |var|
-      key_name = var.to_s.delete("@")
-      key_sym = key_name.to_sym
-
-      key = key_sym
-      value = obj.instance_variable_get(var)
-
-      acc[key] = recursively_convert(value, {}, cache)
-    end
-
-    acc
-  end
+# frozen_string_literal: true
+
+class ReeObject::ToHash
+  include Ree::FnDSL
+
+  fn :to_hash do
+    def_error { RecursiveObjectErr }
+  end
+  
+  BASIC_TYPES = [
+    Date, Time, Numeric, String, FalseClass, TrueClass, NilClass, Symbol,
+    Module, Class
+  ].freeze
+
+  contract(
+    Any => Or[Hash, ArrayOf[Any], *BASIC_TYPES]
+  ).throws(RecursiveObjectErr)
+  def call(obj)
+    recursively_convert(obj, {}, {})
+  end
+
+  private
+
+  def recursively_convert(obj, acc, cache)
+    ancestors = obj.class.ancestors
+
+    if ancestors.intersection(BASIC_TYPES).size > 0
+      obj
+    elsif obj.is_a?(Array)
+      convert_array(obj, acc, cache)
+    elsif obj.is_a?(Hash)
+      convert_hash(obj, acc, cache)
+    elsif obj.respond_to?(:to_h)
+      convert_hash(obj.to_h, acc, cache)
+    else
+      convert_object(obj, acc, cache)
+    end
+  end
+
+  def convert_array(obj, acc, cache)
+    obj.map { |el| recursively_convert(el, {}, cache) }
+  end
+
+  def convert_hash(obj, acc, cache)
+    obj.each do |k, v|
+      key_sym = k.to_sym
+      acc[key_sym] = recursively_convert(v, {}, cache)
+    end
+
+    acc
+  end
+
+  def convert_object(obj, acc, cache)
+    return obj if obj.is_a?(Class) || obj.is_a?(Module)
+
+    if cache.key?(obj.object_id)
+      raise RecursiveObjectErr, "Recursive object found: #{obj}"
+    end
+
+    cache[obj.object_id] = acc
+    
+    obj.instance_variables.each do |var|
+      key_name = var.to_s.delete("@")
+      key_sym = key_name.to_sym
+
+      key = key_sym
+      value = obj.instance_variable_get(var)
+
+      acc[key] = recursively_convert(value, {}, cache)
+    end
+
+    acc
+  end
 end

data/lib/ree_lib/packages/ree_object/package/ree_object/functions/to_obj.rb

@@ -1,97 +1,97 @@
-# frozen_string_literal: true
-
-class ReeObject::ToObj
-  include Ree::FnDSL
-
-  fn :to_obj do
-    link :as_json, import: -> { BASIC_TYPES }
-    link :slice, from: :ree_hash
+# frozen_string_literal: true
+
+class ReeObject::ToObj
+  include Ree::FnDSL
+
+  fn :to_obj do
     link :except, from: :ree_hash
+    link :slice, from: :ree_hash
+    link :to_hash, import: -> { BASIC_TYPES }
     link 'ree_hash/contracts/hash_keys_contract', -> { HashKeysContract }
-  end
-
-  contract(
-    Any,
-    Ksplat[
-      include?: HashKeysContract,
-      exclude?: HashKeysContract,
-      global_exclude?: ArrayOf[Symbol]
-    ] => Or[Object, ArrayOf[Object], *BASIC_TYPES]
-  ).throws(ArgumentError)
-  def call(obj, **opts)
-    dump = as_json(obj)
-
-    options = prepare_options(opts)
-
-    if opts[:include]
-      dump = slice(dump, options[:include])
-    end
-
-    if opts[:exclude]
-      dump = except(dump, options[:exclude])
-    end
-
-    if opts[:global_exclude]
-      dump = except(dump, global_except: options[:global_exclude])
-    end
-
-    ancestors = dump.class.ancestors
-    return dump if ancestors.intersection(BASIC_TYPES).size > 0
-      
-    if dump.is_a?(Array)
-      build_array(dump)
-    else
-      recursively_assign(Object.new, dump)
-    end
-  end
-
-  private
-
-  def build_array(array)
-    array.map do |value|
-      if value.is_a?(Array)
-        build_array(value)
-      elsif value.is_a?(Hash)
-        recursively_assign(Object.new, value)
-      else
-        value
-      end
-    end
-  end
-
-  def recursively_assign(obj, hash)
-    hash.each do |key, value|
-      var = :"@#{key}"
-
-      obj.define_singleton_method key do 
-        instance_variable_get(var)
-      end
-
-      if value.is_a?(Array)
-        obj.instance_variable_set(var, build_array(value))
-      elsif value.is_a?(Hash)
-        obj.instance_variable_set(var, recursively_assign(Object.new, value))
-      else
-        obj.instance_variable_set(var, value)
-      end
-    end
-    
-    obj
-  end
-
-  def prepare_options(opts)
-    if opts[:include] && (opts[:exclude] || opts[:global_exclude])
-      intersection = opts_keys(opts[:include]).intersection(opts_keys(opts[:exclude] || opts[:global_exclude]))
-
-      if intersection.length > 0
-        raise ArgumentError, "Exclude and include have the same values: #{intersection}"
-      end
-    end
-
-    opts
-  end
-
-  def opts_keys(arr)
-    arr.reject { |e| e.is_a?(Hash) }
-  end
+  end
+
+  contract(
+    Any,
+    Ksplat[
+      include?: HashKeysContract,
+      exclude?: HashKeysContract,
+      global_exclude?: ArrayOf[Symbol]
+    ] => Or[Object, ArrayOf[Object], *BASIC_TYPES]
+  ).throws(ArgumentError)
+  def call(obj, **opts)
+    dump = to_hash(obj)
+
+    options = prepare_options(opts)
+
+    if opts[:include]
+      dump = slice(dump, options[:include])
+    end
+
+    if opts[:exclude]
+      dump = except(dump, options[:exclude])
+    end
+
+    if opts[:global_exclude]
+      dump = except(dump, global_except: options[:global_exclude])
+    end
+
+    ancestors = dump.class.ancestors
+    return dump if ancestors.intersection(BASIC_TYPES).size > 0
+
+    if dump.is_a?(Array)
+      build_array(dump)
+    else
+      recursively_assign(Object.new, dump)
+    end
+  end
+
+  private
+
+  def build_array(array)
+    array.map do |value|
+      if value.is_a?(Array)
+        build_array(value)
+      elsif value.is_a?(Hash)
+        recursively_assign(Object.new, value)
+      else
+        value
+      end
+    end
+  end
+
+  def recursively_assign(obj, hash)
+    hash.each do |key, value|
+      var = :"@#{key}"
+
+      obj.define_singleton_method key do
+        instance_variable_get(var)
+      end
+
+      if value.is_a?(Array)
+        obj.instance_variable_set(var, build_array(value))
+      elsif value.is_a?(Hash)
+        obj.instance_variable_set(var, recursively_assign(Object.new, value))
+      else
+        obj.instance_variable_set(var, value)
+      end
+    end
+
+    obj
+  end
+
+  def prepare_options(opts)
+    if opts[:include] && (opts[:exclude] || opts[:global_exclude])
+      intersection = opts_keys(opts[:include]).intersection(opts_keys(opts[:exclude] || opts[:global_exclude]))
+
+      if intersection.length > 0
+        raise ArgumentError, "Exclude and include have the same values: #{intersection}"
+      end
+    end
+
+    opts
+  end
+
+  def opts_keys(arr)
+    arr.reject { |e| e.is_a?(Hash) }
+  end
 end

data/lib/ree_lib/packages/ree_object/schemas/ree_object/functions/dump_as_json.schema.json

@@ -10,7 +10,7 @@
     {
       "doc": "",
       "throws": [
-        "ReeObject::DumpAsJson::RecursiveObjectErr"
+
       ],
       "return": "Or[Hash, ArrayOf[Any], Date, Time, Numeric, String, FalseClass, TrueClass, NilClass, Symbol, Module, Class]",
       "args": [

data/lib/ree_lib/packages/ree_object/schemas/ree_object/functions/{as_json.schema.json → to_hash.schema.json}

@@ -1,16 +1,16 @@
 {
   "schema_type": "object",
   "schema_version": "1.1",
-  "name": "as_json",
-  "path": "packages/ree_object/package/ree_object/functions/as_json.rb",
+  "name": "to_hash",
+  "path": "packages/ree_object/package/ree_object/functions/to_hash.rb",
   "mount_as": "fn",
-  "class": "ReeObject::AsJson",
+  "class": "ReeObject::ToHash",
   "factory": null,
   "methods": [
     {
       "doc": "",
       "throws": [
-        "ReeObject::AsJson::RecursiveObjectErr"
+        "ReeObject::ToHash::RecursiveObjectErr"
       ],
       "return": "Or[Hash, ArrayOf[Any], Date, Time, Numeric, String, FalseClass, TrueClass, NilClass, Symbol, Module, Class]",
       "args": [

data/lib/ree_lib/packages/ree_object/schemas/ree_object/functions/to_obj.schema.json

@@ -28,14 +28,6 @@
     }
   ],
   "links": [
-    {
-      "target": "as_json",
-      "package_name": "ree_object",
-      "as": "as_json",
-      "imports": [
-        "BASIC_TYPES"
-      ]
-    },
     {
       "target": "except",
       "package_name": "ree_hash",
@@ -51,6 +43,14 @@
       "imports": [
 
       ]
+    },
+    {
+      "target": "to_hash",
+      "package_name": "ree_object",
+      "as": "to_hash",
+      "imports": [
+        "BASIC_TYPES"
+      ]
     }
   ]
 }

data/lib/ree_lib/packages/ree_object/spec/ree_object/functions/{as_json_spec.rb → to_hash_spec.rb}

@@ -1,172 +1,172 @@
-# frozen_string_literal = true
-
-RSpec.describe :as_json do
-  link :as_json, from: :ree_object
-
-  context "object" do
-    let(:klass) {
-      Class.new do
-        attr_reader :integer, :string, :array, :hash, :object
-
-        def initialize
-          @integer = 1
-          @string = 'string'
-          @array = [1, 'string', 3, { 'name' => 'John'}]
-
-          @hash = {
-            id: 1,
-            'test' => 2,
-            nested: {
-              some_value: 1,
-              another_value: 2
-            },
-            name: 'name'
-          }
-
-          @object = Object.new
-          @klass = Object
-          @module = Module
-          @object.instance_exec do
-            @name = 'John'
-            @last_name = 'Doe'
-          end
-        end 
-      end
-    }
-
-    context "Struct" do
-      it {
-        klass = Struct.new(:id, :name)
-        result = as_json(klass.new(1, 'John'))
-
-        expect(result).to eq({id: 1, name: 'John'})
-      }  
-    end
-
-    context "OpenStruct" do
-      it {
-        require 'ostruct'
-        obj = OpenStruct.new(id: 1, name: 'John')
-        result = as_json(obj)
-
-        expect(result).to eq({id: 1, name: 'John'})
-      }
-    end
-
-    context "basic types" do
-      it {
-        obj = Date.new
-        result = as_json(obj)
-        expect(result).to eq(obj)
-      }
-
-      it {
-        obj = Time.new
-        result = as_json(obj)
-        expect(result).to eq(obj)
-      }
-
-      it {
-        obj = 1
-        result = as_json(obj)
-        expect(result).to eq(obj)
-      }
-
-      it {
-        obj = "string"
-        result = as_json(obj)
-        expect(result).to eq(obj)
-      }
-
-      it {
-        obj = true
-        result = as_json(obj)
-        expect(result).to eq(obj)
-      }
-
-      it {
-        obj = false
-        result = as_json(obj)
-        expect(result).to eq(obj)
-      }
-
-      it {
-        obj = nil
-        result = as_json(obj)
-        expect(result).to eq(obj)
-      }
-
-      it {
-        obj = :symbol
-        result = as_json(obj)
-        expect(result).to eq(obj)
-      }
-
-      it {
-        obj = Object.new
-        result = as_json(obj)
-        expect(result).to eq({})
-      }
-
-      it {
-        obj = Class
-        result = as_json(obj)
-        expect(result).to eq(obj)
-      }
-
-      it {
-        obj = Module
-        result = as_json(obj)
-        expect(result).to eq(obj)
-      }
-    end
-
-    context "object" do
-      it {
-        result = as_json(klass.new)
-  
-        expected = {
-          integer: 1,
-          string: 'string',
-          array: [1, 'string', 3, { name: 'John'}],
-          hash: {
-            id: 1,
-            test: 2,
-            nested: {
-              some_value: 1,
-              another_value: 2
-            },
-            name: 'name'
-          },
-          klass: Object,
-          module: Module,
-          object: {
-            name: 'John',
-            last_name: 'Doe'
-          }
-        }
-  
-        expect(result).to eq(expected)
-      }
-    end
-
-    context "check for recursion" do
-      let(:obj_klass) {
-        Class.new do
-          def set(v)
-            @value = v
-          end
-        end
-      }
-  
-      it {
-        obj = obj_klass.new
-        obj.set([obj])
-  
-        expect {
-          as_json(obj)
-        }.to raise_error(ReeObject::AsJson::RecursiveObjectErr, /Recursive object found: /)
-      }
-    end
-  end
+# frozen_string_literal = true
+
+RSpec.describe :to_hash do
+  link :to_hash, from: :ree_object
+
+  context "object" do
+    let(:klass) {
+      Class.new do
+        attr_reader :integer, :string, :array, :hash, :object
+
+        def initialize
+          @integer = 1
+          @string = 'string'
+          @array = [1, 'string', 3, { 'name' => 'John'}]
+
+          @hash = {
+            id: 1,
+            'test' => 2,
+            nested: {
+              some_value: 1,
+              another_value: 2
+            },
+            name: 'name'
+          }
+
+          @object = Object.new
+          @klass = Object
+          @module = Module
+          @object.instance_exec do
+            @name = 'John'
+            @last_name = 'Doe'
+          end
+        end
+      end
+    }
+
+    context "Struct" do
+      it {
+        klass = Struct.new(:id, :name)
+        result = to_hash(klass.new(1, 'John'))
+
+        expect(result).to eq({id: 1, name: 'John'})
+      }
+    end
+
+    context "OpenStruct" do
+      it {
+        require 'ostruct'
+        obj = OpenStruct.new(id: 1, name: 'John')
+        result = to_hash(obj)
+
+        expect(result).to eq({id: 1, name: 'John'})
+      }
+    end
+
+    context "basic types" do
+      it {
+        obj = Date.new
+        result = to_hash(obj)
+        expect(result).to eq(obj)
+      }
+
+      it {
+        obj = Time.new
+        result = to_hash(obj)
+        expect(result).to eq(obj)
+      }
+
+      it {
+        obj = 1
+        result = to_hash(obj)
+        expect(result).to eq(obj)
+      }
+
+      it {
+        obj = "string"
+        result = to_hash(obj)
+        expect(result).to eq(obj)
+      }
+
+      it {
+        obj = true
+        result = to_hash(obj)
+        expect(result).to eq(obj)
+      }
+
+      it {
+        obj = false
+        result = to_hash(obj)
+        expect(result).to eq(obj)
+      }
+
+      it {
+        obj = nil
+        result = to_hash(obj)
+        expect(result).to eq(obj)
+      }
+
+      it {
+        obj = :symbol
+        result = to_hash(obj)
+        expect(result).to eq(obj)
+      }
+
+      it {
+        obj = Object.new
+        result = to_hash(obj)
+        expect(result).to eq({})
+      }
+
+      it {
+        obj = Class
+        result = to_hash(obj)
+        expect(result).to eq(obj)
+      }
+
+      it {
+        obj = Module
+        result = to_hash(obj)
+        expect(result).to eq(obj)
+      }
+    end
+
+    context "object" do
+      it {
+        result = to_hash(klass.new)
+
+        expected = {
+          integer: 1,
+          string: 'string',
+          array: [1, 'string', 3, { name: 'John'}],
+          hash: {
+            id: 1,
+            test: 2,
+            nested: {
+              some_value: 1,
+              another_value: 2
+            },
+            name: 'name'
+          },
+          klass: Object,
+          module: Module,
+          object: {
+            name: 'John',
+            last_name: 'Doe'
+          }
+        }
+
+        expect(result).to eq(expected)
+      }
+    end
+
+    context "check for recursion" do
+      let(:obj_klass) {
+        Class.new do
+          def set(v)
+            @value = v
+          end
+        end
+      }
+
+      it {
+        obj = obj_klass.new
+        obj.set([obj])
+
+        expect {
+          to_hash(obj)
+        }.to raise_error(ReeObject::ToHash::RecursiveObjectErr, /Recursive object found: /)
+      }
+    end
+  end
 end

data/lib/ree_lib/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ReeLib
-  VERSION = "1.0.33"
+  VERSION = "1.0.34"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ree_lib
 version: !ruby/object:Gem::Version
-  version: 1.0.33
+  version: 1.0.34
 platform: ruby
 authors:
 - Ruslan Gatiyatov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-02-28 00:00:00.000000000 Z
+date: 2023-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ree
@@ -1020,29 +1020,29 @@ files:
 - lib/ree_lib/packages/ree_object/Package.schema.json
 - lib/ree_lib/packages/ree_object/bin/console
 - lib/ree_lib/packages/ree_object/package/ree_object.rb
-- lib/ree_lib/packages/ree_object/package/ree_object/functions/as_json.rb
 - lib/ree_lib/packages/ree_object/package/ree_object/functions/deep_dup.rb
 - lib/ree_lib/packages/ree_object/package/ree_object/functions/deep_freeze.rb
 - lib/ree_lib/packages/ree_object/package/ree_object/functions/dump_as_json.rb
 - lib/ree_lib/packages/ree_object/package/ree_object/functions/is_blank.rb
 - lib/ree_lib/packages/ree_object/package/ree_object/functions/load_json_dump.rb
 - lib/ree_lib/packages/ree_object/package/ree_object/functions/not_blank.rb
+- lib/ree_lib/packages/ree_object/package/ree_object/functions/to_hash.rb
 - lib/ree_lib/packages/ree_object/package/ree_object/functions/to_obj.rb
-- lib/ree_lib/packages/ree_object/schemas/ree_object/functions/as_json.schema.json
 - lib/ree_lib/packages/ree_object/schemas/ree_object/functions/deep_dup.schema.json
 - lib/ree_lib/packages/ree_object/schemas/ree_object/functions/deep_freeze.schema.json
 - lib/ree_lib/packages/ree_object/schemas/ree_object/functions/dump_as_json.schema.json
 - lib/ree_lib/packages/ree_object/schemas/ree_object/functions/is_blank.schema.json
 - lib/ree_lib/packages/ree_object/schemas/ree_object/functions/load_json_dump.schema.json
 - lib/ree_lib/packages/ree_object/schemas/ree_object/functions/not_blank.schema.json
+- lib/ree_lib/packages/ree_object/schemas/ree_object/functions/to_hash.schema.json
 - lib/ree_lib/packages/ree_object/schemas/ree_object/functions/to_obj.schema.json
 - lib/ree_lib/packages/ree_object/spec/package_schema_spec.rb
-- lib/ree_lib/packages/ree_object/spec/ree_object/functions/as_json_spec.rb
 - lib/ree_lib/packages/ree_object/spec/ree_object/functions/deep_dup_spec.rb
 - lib/ree_lib/packages/ree_object/spec/ree_object/functions/deep_freeze_spec.rb
 - lib/ree_lib/packages/ree_object/spec/ree_object/functions/dump_as_json_spec.rb
 - lib/ree_lib/packages/ree_object/spec/ree_object/functions/is_blank_spec.rb
 - lib/ree_lib/packages/ree_object/spec/ree_object/functions/not_blank_spec.rb
+- lib/ree_lib/packages/ree_object/spec/ree_object/functions/to_hash_spec.rb
 - lib/ree_lib/packages/ree_object/spec/ree_object/functions/to_obj_spec.rb
 - lib/ree_lib/packages/ree_object/spec/spec_helper.rb
 - lib/ree_lib/packages/ree_string/.gitignore