hashlation 0.1.4 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4749821b8641ec38d5873ef319710ea86068b57dde8691fd2c9ea4d588f5a1f
-  data.tar.gz: 1f1ba4280c4b9970fc9e6222712d630309d63c8ed1645746cf4a2abff1b56119
+  metadata.gz: 1ea79a7925cc1bbb74a610f5a501cda5bd7e75fce4ef3cf07769e16bd7182bd6
+  data.tar.gz: 89dd89bbe44300fc32075c695b412719a357da34862cc16ed88e6b68914f3bcf
 SHA512:
-  metadata.gz: faabb932c886ab678c0387150cbfecac339de828cbbbdc1532460baf7883a86ed9273b52930e7aa84a1b8c83d0449280e25914bb010aba1e054445b383ab7492
-  data.tar.gz: ced1723b25e56f8426f0cdf1927c12f24b5eae62d4a399821276a572d81495f96509340677a858b57b7b152bd9106b12b1fe02431f69646d25f343eb4c1e7834
+  metadata.gz: dd5bf21e523ba96bfb500461e12fba4c8d27c590df9fcd1fcc5bf4808f7f36470242bb41d318cb8f41579ee64ad0abb980d5df4267ffe53becf6f634e875a017
+  data.tar.gz: 9bbec94a8480565dbd3153cb14e6a7023b065bea688b63b1db4406f533634e2bf440210be10e65d3ffd35c1804bfb1a11b5d46a9305e5999fb8c7ff4bdefce44

data/lib/hashlation/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hashlation
-  VERSION = "0.1.4"
+  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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hashlation
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  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: Lightweight parser for cleaner navigation of large or deeply nested hashes.
 email:
@@ -40,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:

data/lib/hashlation/complex.rb

@@ -1,77 +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
-      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,75 +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
-      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