recursive_case_indifferent_ostruct 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b398b7f98e4169257f4811888715dd82fd43b4b2
+  data.tar.gz: f44fee346580aec8bc67449f40223967852f3bc6
+SHA512:
+  metadata.gz: e23e8daeca037f194a719201a486c509462c0e0abaa5bb52f8eb8e392075e885b96e2229195860b1bfc63338ff44202124cab26d8cc2d232bb4f1255cca5c399
+  data.tar.gz: fde5b277fe47328995e2f6d762f2ea14c11ed1bb41f1b63566807b032541d16673c454737140c1a088773397b527bccf98c65b764aa54221882f5a28433ddc7e

data/README.md

@@ -0,0 +1,110 @@
+# Recursive Case Indifferent Ostruct
+
+Takes a hash of snake, camel, train, or kabab case and make its
+attributes accessible with any other case.
+
+The main application is for working with JSON from an API and standardizing
+to a Ruby-centric underscore/snake case interface.
+
+##Usage
+
+Gemfile
+
+```ruby
+gem "recursive_case_indifferent_ostruct"
+````
+
+
+## Examples
+```ruby
+user = RecursiveCaseIndifferentOstruct.new({
+  "firstName"   => "Tommy",
+  "first-name"  => "Bobby",
+  "LAST_NAME"   => "Johnson",
+  "Birth-Place" => "Springfield",
+  "father"      => {
+    "age"     72
+  },
+  "siblings"    => [
+    {relation: "brother", age: 12}
+  ]
+}, :lower_camel)
+
+# access attributes like so
+user.first_name # "Tommy"
+user.last_name # "Johnson"
+user.father.age # 72
+user.siblings[0].age # 12
+
+user.birth_place    = "New York" # set fields
+user.first_name     = "Ken" # sets {"firstName" => "Ken", "first-name" => "Ken"}
+user.mothers_maiden = "Woods" # Since case is mixed in that hash, use default :lower_camel
+
+
+user.to_h
+# {
+#   "firstName"   => "Ken",
+#   "first-name"  => "Bobby",
+#   "LAST_NAME"   => "Johnson",
+#   "Birth-Place" => "New York",
+#   "father"      => {
+#     "age"     72
+#   },
+#   "siblings"    => [
+#     {relation: "brother", age: 12}
+#   ],
+#   "mothersMaiden" => "Woods",
+# }
+```
+
+
+### Case Matching
+Since the key matching is fuzzy, should there be two attributes with
+the same name but different case (`first-name` and `firstName`), the
+library will return first value that it finds. For an assignment it
+will assign all matching attributes to the new value.
+
+### Default Case
+Should you assign an attribute to the hash that does not already exist
+the library will try to figure out which case to use based on other
+keys in the hash. If it cannot determine which case is being used
+it will fall back to `RecursiveCaseIndifferentOstruct::DEFAULT_CASE=:snake`
+which you could set to override. Another option is to pass the default
+case on initialization `RecursiveCaseIndifferentOstruct.new(hash, :snake)`.
+
+Available options:
+  * `:snake` *this_is_snake*
+  * `:lower_camel` *thisIsLowerCamel*
+  * `:upper_camel` *ThisIsUpperCamel*
+  * `:kabab` *this-is-kabab*
+  * `:train` *This-Is-Train*
+
+If you need to assign a value to a key that has an odd case you can
+use a string with the bracket syntax like so: `json["PI:Value"] = 3.14`.
+The value can still be accessed via `json.pi_value`.
+
+
+### Hash Methods
+`RecursiveCaseIndifferentOstruct` will pass methods along to the hash
+if the method is not defined and there is not attribute matching that
+name. However, all the hash methods operate on the original hash, so
+`#has_key?`, `#each`, `#fetch`, etc, will not be case-indifferent.
+
+```ruby
+json = RecursiveCaseIndifferentOstruct.new({
+  ID: 123,
+  userName: "pax"
+})
+
+json.has_key?(:user_name) # false
+json.has_key?("userName") # true
+json.fetch(:id) # nil
+json.keys # [:ID, :userName]
+
+```
+
+
+## Tests
+`rake test`
+
+

data/lib/recursive_case_indifferent_ostruct.rb

@@ -0,0 +1,167 @@
+
+class RecursiveCaseIndifferentOstruct
+  DEFAULT_CASE=:snake
+  attr_accessor :default_case
+  
+  def initialize(hash={}, casing=nil)
+    @default_case = casing || DEFAULT_CASE
+    @hash         = hash
+  end
+  
+  def to_h
+    @hash
+  end
+  
+  def [](key)
+    handle_get(key)
+  end
+
+  def []=(key, value)
+    handle_assignment(key, value, true)
+  end
+  
+  def method_missing(method_sym, *args, &block)
+    method_name   = method_sym.to_s
+    is_assignment = method_name.slice(-1) == '='
+    is_get        = !is_assignment && args.length == 0 && !@hash.respond_to?(method_name)
+    
+    # remove = if an assignment
+    if is_assignment
+      method_name = method_name.slice(0, method_name.length - 1)
+    end
+    
+    if is_assignment
+      return handle_assignment(method_name, args.first)
+    elsif is_get
+      return handle_get(method_name)
+    else
+      @hash.send(method_name, *args, &block)
+    end
+    
+    # if they called a function and passed some args, then
+    # raise no method error
+    #super
+  end
+  
+  def case_being_used
+    # TODO: If all nil then scan for keys in nested hashes
+    cases_found = @hash.keys.map do |key|
+      if !key.to_s.match(/^[a-z]+\-[a-z]/).nil? # kabab
+        :kabab
+      elsif key.to_s.include?('_')# snake
+        :snake
+      elsif !key.to_s.match(/^[a-z]+[A-Z]/).nil? # lower camel
+        :lower_camel
+      elsif !key.to_s.match(/^[A-Z][a-z]+[A-Z]/).nil? # upper camel
+        :upper_camel
+      elsif !key.to_s.match(/^[A-Z][a-z]+\-[A-Z]/).nil? # Train-Case
+        :train
+      else
+        # Could just be one word in that case who knows what case it is
+        nil
+      end
+    end
+    
+    if cases_found.compact.uniq.size == 1
+      cases_found.compact.first
+    else
+      return @default_case
+    end
+    
+  end
+
+  def find_matching_keys(to_find)
+    @hash.keys.select do |key|
+      self.class.clean_key(to_find) == self.class.clean_key(key)
+    end
+  end
+
+  # string for comparison
+  def self.clean_key(key)
+    key.to_s.downcase.gsub(/[\W_]/, '')
+  end
+
+  private
+  def handle_assignment(method_name, value, allow_override=false)
+    # assign all matching keys
+    keys = find_matching_keys(method_name)
+
+    # assigning a new value
+    if keys.empty?
+      # allow custom case via []=
+      if method_name.is_a?(String) && allow_override
+        @hash[method_name] = value
+      else
+        @hash[ensure_default_case(method_name)] = value
+      end
+      
+    end
+    
+    keys.each do |key|
+      @hash[key] = value
+    end
+    
+    value
+  end
+  
+  def handle_get(method_name)
+    keys = find_matching_keys(method_name)
+    
+    value = @hash[keys.first]
+
+    if value.is_a?(Array)
+      # Make any hashes in the array an ostruct
+      value.map do |item|
+        item.is_a?(Hash) ? RecursiveCaseIndifferentOstruct.new(item, @default_case) : item
+      end
+    elsif value.is_a?(Hash)
+      RecursiveCaseIndifferentOstruct.new(value, @default_case)
+    else
+      value
+    end
+  end
+  
+  
+  def ensure_default_case(key)
+    # Pull out the words/numbers from the key name
+    # find:     lower          camel             UPCASE       numbers
+    re = /( (?:[a-z]+) | (?:[A-Z][a-z]+) | (?:[A-Z]+) |   [0-9]+  )/x
+    words = key.to_s.scan(re).map do |word|
+      word = word.first
+      if word.scan(/[A-Z]/).size < 2
+        word.downcase
+      else
+        word # it's an acronym in whichcase lets leave it.
+      end
+    end
+    
+    if @default_case == :snake
+      words.join('_')
+      
+    elsif @default_case == :kabab
+      words.join('-')
+      
+    elsif @default_case == :lower_camel
+      words.map.with_index do |w, i|
+        if i > 0
+          w[0] = w[0].upcase
+          w
+        else
+          w
+        end
+      end.join      
+      
+    elsif @default_case == :upper_camel
+      words.map do |w|
+        w[0] = w[0].upcase
+      end.join
+      
+    elsif @default_case == :train
+      words.map do |w|
+        w[0] = w[0].upcase
+      end.join('-')
+    end
+    
+  end
+  
+end

metadata

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification
+name: recursive_case_indifferent_ostruct
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Tyler Roberts
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-15 00:00:00.000000000 Z
+dependencies: []
+description: See github.
+email: code@polar-concepts.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/recursive_case_indifferent_ostruct.rb
+homepage: http://github.com/bdevel/recursive_case_indifferent_ostruct
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Access JSON or Hashes attributes without regards to snake_case, camelCase,
+  or kabab-case.
+test_files: []