hashlation 0.1.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68d3645838c4821d08458fc685b7ea0e0e4a6c849ca43d8c3008915e5dd40a91
-  data.tar.gz: eb99e52cf5a8c7831b1f3136aac4457d97214db84af6575f544667146fb28585
+  metadata.gz: 1ea79a7925cc1bbb74a610f5a501cda5bd7e75fce4ef3cf07769e16bd7182bd6
+  data.tar.gz: 89dd89bbe44300fc32075c695b412719a357da34862cc16ed88e6b68914f3bcf
 SHA512:
-  metadata.gz: 7af40ef344bbda534fc05cdc7b6a55a064d3124a1e0c9da4c73dd7a61f95366370ce73955ec9cb83e30dd899c391b7178236ef61e637f6075fd8b23147aa0726
-  data.tar.gz: 3eb70282efe7e2ade0017ebd919729b918bc5004cc8843871fbc8c73e1801c4aa19d19f86e80bef2fbae9a264bc8982eb751b585a2b3bc0a7a107e99eccb9ca3
+  metadata.gz: dd5bf21e523ba96bfb500461e12fba4c8d27c590df9fcd1fcc5bf4808f7f36470242bb41d318cb8f41579ee64ad0abb980d5df4267ffe53becf6f634e875a017
+  data.tar.gz: 9bbec94a8480565dbd3153cb14e6a7023b065bea688b63b1db4406f533634e2bf440210be10e65d3ffd35c1804bfb1a11b5d46a9305e5999fb8c7ff4bdefce44

data/README.md

@@ -17,13 +17,9 @@ Or install it yourself as:
     $ gem install hashlation
 
 
-    Hashlation::Complex -> Hashlation::Complex.new(hash) 
-    
-    
     
     
-
-##Methods
+## Methods
 
 The returned `obj` includes the method `.keys` to list the keys on the object at every level.
 
@@ -50,7 +46,21 @@ Usage:
 
 ---
 
-**If `Complex` fails due to inability to read key, please report in Issues. Thanks! **
+** If `Complex` fails due to inability to read a key, please report in GitHub Issues. Thanks! **
+
+---
+
+## Translated Keys Format:
+
+Keys that cannot be set as-is by attr_accessor will be transformed.
+
+### Simple:
+
+- `'Test-Name' -> obj.test_name`
+
+### Complex:
+
+- `'11123:12312' -> obj._11123_12312`
 
 ## Development
 
@@ -65,3 +75,7 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/rharri
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+---
+
+*Naming credit belongs to my wife, who bales out my inability to name stuff..*

data/hashlation.gemspec

@@ -8,11 +8,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ["rharris389"]
   spec.email         = ["56176404+rharris389@users.noreply.github.com"]
 
-  spec.summary       = "Simple/Lightweight hash parsing gem."
-  spec.description   = "Quickly parses hashes into objects for cleaner navigation of large response objects.
-                         Hashlation::Simple.new(hash_object) will handle most common string and symbol keys.
-                         Certain characters in a key, such as a leading Integer or a ':' will not translate with Simple.
-                         These must be processed with the Hashlation::Complex.new(hash_object) method. Name credit to my wife."
+  spec.summary       = "Lightweight response parsing"
+  spec.description   = "Lightweight parser for cleaner navigation of large or 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.2"
+  VERSION = "1.0.0"
 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.class.to_s.to_sym
+                   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
+
+    def handle_complex_key(key, value)
+      # If this is to be responses may contain improper keys, uncomment and implement for all attr names
+      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
+
+    def keys
+      instance_variables
+    end
+  end
+
 end

metadata

@@ -1,20 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: hashlation
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 1.0.0
 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: |-
-  Quickly parses hashes into objects for cleaner navigation of large response objects.
-                           Hashlation::Simple.new(hash_object) will handle most common string and symbol keys.
-                           Certain characters in a key, such as a leading Integer or a ':' will not translate with Simple.
-                           These must be processed with the Hashlation::Complex.new(hash_object) method. Name credit to my wife.
+description: Lightweight parser for cleaner navigation of large or deeply nested hashes.
 email:
 - 56176404+rharris389@users.noreply.github.com
 executables: []
@@ -44,8 +40,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:
@@ -73,5 +67,5 @@ requirements: []
 rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
-summary: Simple/Lightweight hash parsing gem.
+summary: Lightweight response parsing
 test_files: []

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