hash_mangler 0.2.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cfc06b7c06365d662bcdad2368dff79f50dfc8e3
-  data.tar.gz: c9bfd8626aafcdbeae1502078eb6da1cd8da5a70
+  metadata.gz: 035249bf5d64b998b482081c145889b8631b4a41
+  data.tar.gz: 6ea2dcf26bb6fa926811d4ff751c871c0bc1e8f5
 SHA512:
-  metadata.gz: 890d86ec18d079d1e21c646bf68d7ba88f5cabda369eac76b48092b6050fc2760eb3ad081645551551d11141d8ff4cf9b50aab849f24b68c101cdb7edc5d2163
-  data.tar.gz: fdd854a130baf3b73dd56f75550d1ab35b343861fc8ca75d30976e3f8cfefbb90bd0f0e0f5c6cad7d3fe6b640d79651e3b16a3cde6abb2d3e07e0dcc0cdeba5a
+  metadata.gz: 65ffd3c1d0db077659beb1b61db8ab389d9766e036fbe508d2aee8a4978fb0c36e6d63911c566577947b58acb59c01d2a41443bcff33f7989db118f816d1a28e
+  data.tar.gz: 6964318e0595e3a05fad54c4699ed859808350326a7559431dfd234cce32c5e0c76af610c8fe8ff44d0da46dcf4738b15cdf9210bccab53f0aa70d314a6f8a8b

data/README.md

@@ -1,14 +1,19 @@
 # HashMangler
 
 A simple gem which converts nested hash into a struct allowing data access with method calls like:
+
 ```
   mangled_hash.users[0].name # => John
 ```
+
 instead of doing:
+
 ```
   users_hash[:users][0].fetch(:name) # => John
 ```
+
 for a hash:
+
 ```
   users_hash = {
     users: [
@@ -38,26 +43,54 @@ Or install it yourself as:
 ## Usage
 
 For a basic convertion from Hash to a nested object:
+
+
 ```
 hm = HashMangler::Mangler.new.mangle(hash)
 hm.some_method_name
 ```
 
 You can also perform operations on argument hash values by passing a proc to the `initialize` method:
+
 ```
 value_mangler = proc { |o| o.to_s.downcase }  
-hm = HashMangler::Mangler.new(value_mangler: value_mangler).mangle(hash)
+options = { value_mangler: value_mangler }
+hm = HashMangler::Mangler.new(options).mangle(hash)
 hm.some_method_name
 ```
 
-If you want you can use `HashMangler::SimpleStruct` instead of `OpenStruct` when using `JSON.parse(json, object_class: OpenStruct)`. This way a `NoMethodError` will be raised instead of returning `nil` when method name does not comply with
 
-By default method names are in snake case, to leave them the same as input hash keys `snake_case_method_names: false` option needs to be passed into `initialize`:
+By default method names are in snake case, to leave them the same as input hash keys:
+
+```
+snake_case_method_names: false
+```
+
+option needs to be passed into `initialize` like:
+
 ```
-hm = HashMangler::Mangler.new(snake_case_method_names: false).mangle(hash)
+options = { snake_case_method_names: false } 
+hm = HashMangler::Mangler.new(options).mangle(hash)
 hm.someMethodName
 ```
 
+Hash can also be mangled with `OpenStruct` or `Hash` using `struct_class` option:
+
+```
+options = { struct_class: OpenStruct }
+hm = HashMangler::Mangler.new(options).mangle(hash)
+hm.some_method_name
+```
+
+`HashMangler::SimpleStruct` can also be used instead of `OpenStruct` when using:
+
+```
+JSON.parse(json, object_class: OpenStruct)
+```
+
+This way a `NoMethodError` will be raised instead of returning `nil` when method name does not comply with
+
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/smnkrt/hash_mangler.

data/lib/hash_mangler.rb

@@ -1,53 +1,5 @@
 require 'hash_mangler/version'
+require 'hash_mangler/mangler'
 
 module HashMangler
-  class SimpleStruct
-    def initialize(snake_case_method_names = true)
-      @snake_case_method_names = snake_case_method_names
-      @hash = {}
-    end
-
-    def []=(key, val)
-      key = format_key(key)
-      @hash[key] = val
-      define_singleton_method(key) { @hash[key] }
-    end
-
-    def [](key)
-      @hash[format_key(key)]
-    end
-
-    private
-
-    def format_key(key)
-      return key unless @snake_case_method_names
-      key_to_snake_case(key)
-    end
-
-    def key_to_snake_case(key)
-      key
-        .to_s
-        .gsub(/::/, '/')
-        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-        .tr('-', '_')
-        .downcase
-        .to_sym
-    end
-  end
-
-  class Mangler
-    def initialize(options = {})
-      @snake_case_method_names = options.fetch(:snake_case_method_names, true)
-      @value_mangler = options.fetch(:value_mangler, proc { |o| o })
-    end
-
-    def mangle(a)
-      return @value_mangler.(a) unless a.is_a?(Hash) || a.is_a?(Array)
-      return a.map { |v| mangle(v) } if a.is_a?(Array)
-      r = HashMangler::SimpleStruct.new(@snake_case_method_names)
-      a.each { |k, v| r[k] = mangle(v) }
-      r
-    end
-  end
 end

data/lib/hash_mangler/mangler.rb

@@ -0,0 +1,35 @@
+require_relative 'mangler/key_mangler'
+require_relative 'simple_struct'
+
+module HashMangler
+  class Mangler
+    #
+    # @param options [Hash]
+    # @option options [Boolean] :snake_case_method_names specifies if generated method
+    #  names should be formatted to snake case, defaults to: true
+    # @option options [Proc] :value_mangler optional proc called for each leaf value
+    #   defaults to: proc { |o| o }
+    # @option options [Class] :struct_class optional class which will be used to convert
+    #   hash data into object, defaults to: HashMangler::SimpleStruct
+    #   any class with [](key) and []=(key, value) accessor methods
+    #
+    def initialize(options = {})
+      @value_mangler           = options.fetch(:value_mangler, proc { |o| o })
+      @struct_class            = options.fetch(:struct_class , HashMangler::SimpleStruct)
+      @key_mangler             = KeyMangler.new(options)
+    end
+
+    #
+    # @param obj (Object) for which mangling should be performed
+    #  it should respond to []= and [] methods
+    # @return [struct_class]
+    #
+    def mangle(obj)
+      return @value_mangler.call(obj) unless obj.is_a?(Hash) || obj.is_a?(Array)
+      return obj.map { |v| mangle(v) } if obj.is_a?(Array)
+      r = @struct_class.new()
+      obj.each { |k, v| r[@key_mangler.format(k)] = mangle(v) }
+      r
+    end
+  end
+end

data/lib/hash_mangler/mangler/key_mangler.rb

@@ -0,0 +1,44 @@
+module HashMangler
+  class Mangler
+    class KeyMangler
+      #
+      # @param options [Hash]
+      # @option options [Boolean] :snake_case_method_names specifies if generated method
+      #  names should be formatted to snake case, defaults to: true
+      #
+      def initialize(options)
+        @snake_case_method_names = options.fetch(:snake_case_method_names, true)
+      end
+
+      #
+      # formats key to snake case if @snake_case_method_names is true,
+      #  otherwise returns key as a symbol
+      # @param key [Symbol/String]
+      # @return [Symbol]
+      #
+      def format(key)
+        return key.to_sym unless @snake_case_method_names
+        key_to_snake_case(key)
+      end
+
+      private
+
+      #
+      # @params key
+      # @return [Symbol] key in snake case
+      #
+      def key_to_snake_case(key)
+        key
+          .to_s
+          .gsub(/::/, '/')
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .tr('-', '_')
+          .downcase
+          .to_sym
+      end
+    end
+
+    private_constant :KeyMangler
+  end
+end

data/lib/hash_mangler/simple_struct.rb

@@ -0,0 +1,30 @@
+module HashMangler
+  #
+  # Simple object defining singleton methods for each (key, value) pair
+  #  passed into []=(key, val) method.
+  #
+  class SimpleStruct
+    def initialize
+      @hash = {}
+    end
+
+    #
+    # sets value for provided key and generates a singleton method
+    # @param key [String/Symbol]
+    #  a passed value (val) will be available
+    # @param val [Object]
+    #
+    def []=(key, val)
+      @hash[key] = val
+      define_singleton_method(key) { @hash[key] }
+    end
+
+    #
+    # retrieves value for provided key
+    # @param key [String/Symbol]
+    #
+    def [](key)
+      @hash[key]
+    end
+  end
+end

data/lib/hash_mangler/version.rb

@@ -1,3 +1,3 @@
 module HashMangler
-  VERSION = "0.2.0"
+  VERSION = '0.3.2'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hash_mangler
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.2
 platform: ruby
 authors:
 - smnkrt
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-13 00:00:00.000000000 Z
+date: 2017-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -83,6 +83,9 @@ files:
 - Rakefile
 - hash_mangler.gemspec
 - lib/hash_mangler.rb
+- lib/hash_mangler/mangler.rb
+- lib/hash_mangler/mangler/key_mangler.rb
+- lib/hash_mangler/simple_struct.rb
 - lib/hash_mangler/version.rb
 homepage: https://github.com/smnkrt/hash_mangler
 licenses: