hashlation 0.1.3 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f73fbcd96c1c7beeedd568b29102b4931a8d2425aaa9dada4fede99d1c0aa88
-  data.tar.gz: 8a7624e52ea1880b35e5df71d10d704fa8d25dd83205cac334faec748f4b4716
+  metadata.gz: 52fc04f602d14cd91c6c7f9041b1fe49700e522b4dee867334d646e2961ba3ec
+  data.tar.gz: e018fc8740c10f9cf02f5fab2b4e5c7439df395e7ef0fd18aa362dad2b15667c
 SHA512:
-  metadata.gz: 467cbaa9f2c43460c61266487f8f3aece0ef1af931a01f2bfe279608cbef2c38e3f6dfeabebfb93c4c9602509727135457e4eacfd5c097c7804f667ddf9ede8c
-  data.tar.gz: f95861a090051ccf724bc7cc10f7b43b45a15427847a7070487723c5cdac453545a0e83ac6a21a77f2d86111f77220a908dd63961da75c29364a26f4f398d29f
+  metadata.gz: ffc0fb90dd2edd7d3188e4b4f080a53f28189a4a3605384db2077878048af9453e62fd702e815a48094c8d091517d24c328a08d909e501d2b09336d571941991
+  data.tar.gz: 7c091b00481934e018c8af726dd0a6b1e9d34a981b263667884892da6de0e3bf80ec58349fcbb982e1f98aad87ed9e730bc18edfc4d882de7a11c66b39656e7a

data/README.md

@@ -1,5 +1,7 @@
 # Hashlation
 
+FAST and VERSATILE hash transformer. Born of the need to more easily read and traverse deeply nested response objects. Faster at 1 to 1 comparisons and more versatile than both OpenStruct and Hashie.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -19,49 +21,28 @@ Or install it yourself as:
 
     
     
-## Methods
+## Usage
 
 The returned `obj` includes the method `.keys` to list the keys on the object at every level.
 
----
-
-### Simple 
-
-Handles simple string/symbol keys in conversion as well as singleton_methods. Very fast, but cannot handle edge cases in keys.
-
-Usage:
-
-`obj = Hashlation::Simple.new(hash)`
-
-
----
-
-### Complex
+`obj = Hashlation::Any.new(hash)`
 
-Handles MOST key types in conversion. If you know that your keys will contain leading Integer characters, or ':' use this method.
-
-Usage:
-
-`obj = Hashlation::Complex.new(hash)`
-
----
-
-** If `Complex` fails due to inability to read a key, please report in GitHub Issues. Thanks! **
+Handles both simple and complex string/symbol keys in translation. Defines singleton_methods for keys ending in '?'.
 
 ---
 
 ## Translated Keys Format:
 
-Keys that cannot be set as-is by attr_accessor will be transformed.
-
-### Simple:
+Keys that cannot be set as-is by attr_accessor will be transformed. For example:
 
 - `'Test-Name' -> obj.test_name`
 
-### Complex:
-
 - `'11123:12312' -> obj._11123_12312`
 
+** If `Any` fails due to inability to read a key, please report in GitHub Issues. Thanks! **
+
+---
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/hashlation.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.email         = ["56176404+rharris389@users.noreply.github.com"]
 
   spec.summary       = "Lightweight response parsing"
-  spec.description   = "Lightweight hash parser for cleaner navigation of large response objects."
+  spec.description   = "Lightweight parser for cleaner navigation of large and deeply nested hashes."
   spec.homepage      = "https://github.com/rharris389/hashlation"
   spec.license       = "MIT"
   spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")

data/lib/hashlation/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hashlation
-  VERSION = "0.1.3"
+  VERSION = "1.1.1"
 end

data/lib/hashlation.rb

@@ -1,9 +1,95 @@
 # frozen_string_literal: true
 
 require_relative "hashlation/version"
-require_relative "hashlation/complex"
-require_relative "hashlation/simple"
 
 module Hashlation
-  class Error < StandardError; end
+  # SHOULD process ANY Hash object return, if object if failing it is likely that a key is not getting transformed correctly.
+  # Add that character to the transformation string to process correctly.
+  class Any
+    # Only Assumption is that base level object is a Hash Array or Hash Object
+    def initialize(i, key: nil)
+      case i
+      when Array
+        process_array(i, key: key)
+      when Hash
+        process_hash(i)
+      else
+        puts 'Base object must be Hash Object or Array'
+      end
+    end
+
+    def process_array(i, key: nil)
+      attr_key = key ? key.underscore : 'array'
+      array = []
+      unless i.empty?
+        i.each do |array_item|
+          array << case array_item
+                   when Hash || Array
+                     Any.new(array_item)
+                   else
+                     array_item
+                   end
+        end
+      end
+      begin
+        self.class.attr_accessor(attr_key)
+        send("#{attr_key}=", array)
+        instance_variable_set("@#{attr_key}", array)
+      rescue NameError
+        handle_complex_key(attr_key, value)
+      end
+    end
+
+    def process_hash(i)
+      i.each do |key, value|
+        if key[-1, 1] == '?'
+          handle_method(key: key, value: value)
+        else
+          k_underscore = (key.instance_of? Symbol) ? key : key.underscore
+          case value
+          when Hash
+            res = Any.new(value, key: k_underscore)
+            begin
+              self.class.attr_accessor(k_underscore)
+              send("#{k_underscore}=", res)
+              instance_variable_set("@#{k_underscore}", res)
+            rescue NameError
+              handle_complex_key(k_underscore, res)
+            end
+          when Array
+            process_array(value, key: k_underscore)
+          else
+            begin
+              self.class.attr_accessor(k_underscore)
+              send("#{k_underscore}=", value)
+              instance_variable_set("@#{k_underscore}", value)
+            rescue NameError
+              handle_complex_key(k_underscore, value)
+            end
+          end
+        end
+      end
+    end
+
+    # Use Begin/Rescue to submit complex keys be sanitized and written to attr_accessor without needlessly checking keys.
+    def handle_complex_key(key, value)
+      k_special_underscore = key[0,1] =~ /^[0-9].*/ ? "_#{key.tr(':', '_').underscore}" : key.tr(':', '_').underscore
+      self.class.attr_accessor(k_special_underscore)
+      send("#{k_special_underscore}=", value)
+      instance_variable_set("@#{k_special_underscore}", value)
+    end
+
+    # Allows us to handle methods ending with '?' as Singleton Methods
+    def handle_method(key:, value:)
+      define_singleton_method(key) do
+        return value
+      end
+    end
+
+    # Get keys at this object level.
+    def keys
+      instance_variables
+    end
+  end
+
 end

metadata

@@ -1,16 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: hashlation
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 1.1.1
 platform: ruby
 authors:
 - rharris389
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-05-16 00:00:00.000000000 Z
+date: 2022-05-17 00:00:00.000000000 Z
 dependencies: []
-description: Lightweight hash parser for cleaner navigation of large response objects.
+description: Lightweight parser for cleaner navigation of large and deeply nested
+  hashes.
 email:
 - 56176404+rharris389@users.noreply.github.com
 executables: []
@@ -40,8 +41,6 @@ files:
 - bin/setup
 - hashlation.gemspec
 - lib/hashlation.rb
-- lib/hashlation/complex.rb
-- lib/hashlation/simple.rb
 - lib/hashlation/version.rb
 homepage: https://github.com/rharris389/hashlation
 licenses:

data/lib/hashlation/complex.rb

@@ -1,78 +0,0 @@
-module Hashlation
-  # ---------------------------------------COMPLEX PARSER-----------------------------------------
-  # SHOULD process ANY Hash object return, if object if failing, it is likely that a key is not getting transformed
-  # correctly, add that character to the transformation string to process correctly.
-  class Complex
-    # Only Assumption is that base level object is a Hash Array or Hash Object
-    def initialize(i, key: nil)
-      case i
-      when Array
-        process_array(i, key: key)
-      when Hash
-        process_hash(i)
-      else
-        puts 'Base object must be Hash Object or Array'
-      end
-    end
-
-    def process_array(i, key: nil)
-      attr_key = key ? sanatize_key(key) : 'array'
-      array = []
-      unless i.empty?
-        i.each do |array_item|
-          array << case array_item.class.to_s.to_sym
-                   when :Hash || :Array
-                     Complex.new(array_item)
-                   else
-                     array_item
-                   end
-        end
-      end
-      self.class.attr_accessor(attr_key)
-      send("#{attr_key}=", array)
-      instance_variable_set("@#{attr_key}", array)
-    end
-
-    def process_hash(i)
-      i.each do |key, value|
-        if key[-1, 1] == '?'
-          handle_method(key: key, value: value)
-        else
-          k_underscore = (key.instance_of? Symbol) ? key : sanatize_key(key)
-          case value
-          when Hash
-            res = Complex.new(value, key: k_underscore)
-            self.class.attr_accessor
-            self.class.attr_accessor(k_underscore)
-            send("#{k_underscore}=", res)
-            instance_variable_set("@#{k_underscore}", res)
-          when Array
-            process_array(value, key: k_underscore)
-          else
-            self.class.attr_accessor(k_underscore)
-            send("#{k_underscore}=", value)
-            instance_variable_set("@#{k_underscore}", value)
-          end
-        end
-      end
-    end
-
-
-    def sanatize_key(key)
-      # If this is to be responses may contain improper keys, uncomment and implement for all attr names
-      # the PrimeTrust API responses only need to be underscored as they do not contain leading integers or dis-allowed characters
-      key[0,1] =~ /^[0-9].*/ ? "_#{key.tr(':', '_').underscore}" : key.tr(':', '_').underscore
-    end
-
-    # Allows us to handle methods ending with '?' as Singleton Methods
-    def handle_method(key:, value:)
-      define_singleton_method(key) do
-        return value
-      end
-    end
-
-    def keys
-      instance_variables
-    end
-  end
-end

data/lib/hashlation/simple.rb

@@ -1,76 +0,0 @@
-module Hashlation
-  # ---------------------------------------SIMPLE PARSER-----------------------------------------
-  # SHOULD process MOST common hash keys quickly. Will fail on Leading integers on keys and inclusion of ':' characters
-  class Simple
-    # Only Assumption is that base level object is a Hash Array or Hash Object
-    def initialize(i, key: nil)
-      case i
-      when Array
-        process_array(i, key: key)
-      when Hash
-        process_hash(i)
-      else
-        puts 'Base object must be Hash Object or Array'
-      end
-    end
-
-    def process_array(i, key: nil)
-      attr_key = key ? sanatize_key(key) : 'array'
-      array = []
-      unless i.empty?
-        i.each do |array_item|
-          array << case array_item.class.to_s.to_sym
-                   when :Hash || :Array
-                     Simple.new(array_item)
-                   else
-                     array_item
-                   end
-        end
-      end
-      self.class.attr_accessor(attr_key)
-      send("#{attr_key}=", array)
-      instance_variable_set("@#{attr_key}", array)
-    end
-
-    def process_hash(i)
-      i.each do |key, value|
-        if key[-1, 1] == '?'
-          handle_method(key: key, value: value)
-        else
-          k_underscore = (key.instance_of? Symbol) ? key : sanatize_key(key)
-          case value
-          when Hash
-            res = Simple.new(value, key: k_underscore)
-            self.class.attr_accessor
-            self.class.attr_accessor(k_underscore)
-            send("#{k_underscore}=", res)
-            instance_variable_set("@#{k_underscore}", res)
-          when Array
-            process_array(value, key: k_underscore)
-          else
-            self.class.attr_accessor(k_underscore)
-            send("#{k_underscore}=", value)
-            instance_variable_set("@#{k_underscore}", value)
-          end
-        end
-      end
-    end
-
-    def sanatize_key(key)
-      # If this is to be responses may contain improper keys, uncomment and implement for all attr names
-      # the PrimeTrust API responses only need to be underscored as they do not contain leading integers or dis-allowed characters
-      key.underscore
-    end
-
-    # Allows us to handle methods ending with '?' as Singleton Methods
-    def handle_method(key:, value:)
-      define_singleton_method(key) do
-        return value
-      end
-    end
-
-    def keys
-      instance_variables
-    end
-  end
-end