sd_struct 0.0.3 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7b543501f8aa5ae85ede78790fe9322e02329912
-  data.tar.gz: 307b9ffef98af9acd6bfb3220ecefac8d1b593b3
+  metadata.gz: db8247a8652fb98a73e935ce9c0737d3bcb60aeb
+  data.tar.gz: e681ebbbe672b041dbe2d84e7e819123c7bfd966
 SHA512:
-  metadata.gz: 5677a893ed42b6c60dadd6d411931174a7b39ff6303452a3418961bc304cc9948ad01f60d886eaad2109162c1952e76f166e69a484fdd71d67e39339348aef61
-  data.tar.gz: cc7349a61ce9c5af6c9038a930e0e1fc13ea30091c2a546a02848b16c2461fdd9641413dfcae883d51fc88d31e601ff548a23d9234e879bf2b020178db05b877
+  metadata.gz: a46da494946f552eca4dc1912c1d6f96667f933539b9fe4f66d37f530600f52e6e508c7a9c26a4d541f71c433af85dd890008bef1b231af98fe8d30878027b03
+  data.tar.gz: 3987632b1425ef16c1535a740ac68183170a644b9b1122e14ac3e2eab9c9d24c6745c357e957e5fe2266ef452f9a8a172e7bd097afeb9f8c5b2ab96b7c942837

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+0.1.0 / 2017-04-19
+==================
+  * Added warning when changing value to different type and
+  * Added conversion of value assigned to struct if it's a Hash or an Array and deep option is set to true
+  * Improved `find` to be more like xpath with its root and non-root search
+  * Upgraded Bundler
+  * Prepared to use Rspec (no specs yet)
+  * Added changelog
+
+0.0.3 / 2017-04-09
+==================
+
+  * Initial working version

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at adrian.setyadi@reebonz.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/README.md

@@ -1,7 +1,7 @@
 # SDStruct
 
-An alternative to OpenStruct that is stricter in assigning values and deeper in
-consuming the passed Hash and transforming it back to Hash or JSON, equipped
+An alternative to OpenStruct that is more strict in assigning values and deeper
+in consuming the passed Hash and transforming it back to Hash or JSON, equipped
 with deep digging capabilities.
 
 ## Usage
@@ -48,6 +48,11 @@ sd_struct = JSON.parse(response.body, object_class: SDStruct)
 
 sd_struct["two words"]
 # => "Foo bar"
+
+# By the way, you can also use `send` method to access spaced key/field
+o_struct.send("two words")
+sd_struct.send("two words")
+# => "Foo bar"
 ```
 
 
@@ -103,26 +108,26 @@ sd_struct
 sd_struct.find('object/a')
 # => "bau bau"
 
-sd_struct.find('array/0/one')
+sd_struct.find('/array/0/one')
 # => 1
 
 sd_struct.find('object->a', separator: '->')
 # => "bau bau"
 
-sd_struct.find('array.0.one', separator: '.')
+sd_struct.find('.array..one', separator: '.')
 # => 1
 
 # You can push it to find deeper. It will return the first occurrence of the matched field
-sd_struct.find('a')
+sd_struct.find('//a')
 # => "bau bau"
 
-sd_struct.find('0/one')
+sd_struct.find('//0/one')
 # => 1
 
-sd_struct.find('one')
+sd_struct.find('//one')
 # => 1
 
-sd_struct.find('four')
+sd_struct.find('//four')
 # => nil
 
 sd_struct.dig_deep(0, :one)
@@ -147,8 +152,8 @@ sd_struct
 # => #<SDStruct .object=#<SDStruct .a="bau bau", .c="boo boo">,
 # .array=[#<SDStruct .one=1, .two=2, .three=3>], ['two words']="Foo bar">
 
-sd_struct.find('0').one = 0
-sd_struct.find('0').three = 0
+sd_struct.find('//0').one = 0
+sd_struct.find('//0').three = 0
 sd_struct['two words'] = ""
 sd_struct
 # => #<SDStruct .object=#<SDStruct .a="bau bau", .c="boo boo">,
@@ -162,7 +167,7 @@ Therefore, keys with those values are excluded from the generated JSON string.
 sd_struct.to_json
 # => "{\"object\":{\"a\":\"bau bau\",\"c\":\"boo boo\"},\"array\":[{\"two\":2}]}"
 
-sd_struct.find('0').two = 0
+sd_struct.find('///0').two = 0
 sd_struct.to_json
 # => "{\"object\":{\"a\":\"bau bau\",\"c\":\"boo boo\"}}"
 ```
@@ -215,8 +220,9 @@ sd_struct = SDStruct.new(hash)
 
 ## Reserved Field Names
 
-`dig`, `to_h`, `find`, `keys`, `marshal_dump`, `marshal_load`, `table`, `delete_field`,
-`fields`, `dig_deep`, `new_member`, `spaced_keys`, `non_spaced_keys`, `delete_key`
+`delete_field`, `delete_key`, `dig`, `dig_deep`, `each_pair`, `fields`, `find`,
+`keys`, `marshal_dump`, `marshal_load`, `new_struct_member`, `non_spaced_keys`,
+`spaced_keys`, `structurize`, `table`, `to_h`, `to_json`
 
 ## Dependencies
 
@@ -238,6 +244,12 @@ Or install it yourself as:
 
     $ gem install activesupport
 
+In your code:
+
+```ruby
+require 'active_support/all'
+```
+
 
 ## Installation
 
@@ -255,6 +267,13 @@ Or install it yourself as:
 
     $ gem install sd_struct
 
+If you're not using rails, you can choose to only require the minimal version
+that doesn't have deep search and deep convert capabilities.
+
+```ruby
+require 'sd_struct/base'
+```
+
 ## Contributing
 
 1. Fork it ( https://github.com/styd/sd_struct/fork )

data/Rakefile

@@ -1,2 +1,2 @@
 require "bundler/gem_tasks"
-
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "sd_struct"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/sd_struct/base.rb

@@ -0,0 +1,225 @@
+# Alternative to OpenStruct that is more strict and go deeper.
+#
+# @author Adrian Setyadi
+#
+class SDStruct
+  using Module.new {
+    refine Hash do
+      #
+      # Change current Hash object to SDStruct object
+      #
+      # @return [SDStruct] SDStruct object
+      #
+      def to_struct
+        SDStruct.new(to_h.dup)
+      end
+    end
+
+    refine Array do
+
+      #
+      # Call `to_struct` to an Array to go deeper or to a Hash to change it to SDStruct
+      #
+      # @return [Array<SDStruct,Object>] array of SDStruct or any other objects
+      #
+      def to_struct
+        map{|x| ( x.is_a?(Hash) || x.is_a?(Array) ) ? x.to_struct : x }
+      end
+    end
+  }
+
+  #
+  # Creates a new SDStruct object. By default, the resulting SDStruct object
+  # will have no attributes.
+  #
+  # The optional +hash+, if given, will generate attributes and values (can be
+  # a Hash, an SDStruct or a Struct).
+  # For example:
+  #
+  #   require 'sd_struct' # or require 'sd_struct/base'
+  #   hash = { "name" => "Matz", "coding language" => :ruby, :age => "old" }
+  #   data = SDStruct.new(hash)
+  #
+  #   p data # -> #<SDStruct .name="Matz", ['coding language']=:ruby, .age="old">
+  #
+  def initialize(hash = nil, deep = true)
+    @deep = deep
+    @table = {}
+    if hash
+      hash.each_pair do |k, v|
+        @table[new_struct_member(k)] = structurize(v) # @deep is used in this method
+      end
+    end
+  end
+
+  #
+  # Duplicate an SDStruct object members.
+  #
+  def initialize_copy(orig)
+    super
+    @table = @table.dup
+  end
+
+  #
+  # Provides marshalling support for use by the Marshal library.
+  #
+  def marshal_dump
+    to_h
+  end
+
+  #
+  # Provides marshalling support for use by the Marshal library.
+  #
+  def marshal_load(x)
+    @table = x.map{|a| structurize(a) }.original_to_h
+  end
+
+  #
+  # Yields all attributes (as a symbol) along with the corresponding values
+  # or returns an enumerator if not block is given.
+  # Example:
+  #
+  #   require 'sd_struct'
+  #   data = SDStruct.new("name" => "Matz", "coding language" => :ruby)
+  #   data.each_pair.to_a  # => [[:name, "Matz"], ["coding language", :ruby]]
+  #
+  def each_pair
+    return to_enum(__method__) { @table.size } unless block_given?
+    @table.each_pair{|p| yield p}
+  end
+
+  #
+  # Used internally to define field properties
+  #
+  def new_struct_member(name)
+    name = name.to_s.underscore.to_sym unless name[/^[A-Z]|\s+/]
+    unless respond_to?(name)
+      define_singleton_method(name) { @table[name] }
+      define_singleton_method("#{name}=") { |x| @table[name] = x }
+    end
+    name
+  end
+
+  #
+  # Call to struct to a value if it is an Array or a Hash and @deep is true
+  #
+  def structurize(value)
+    ( @deep && (value.is_a?(Hash) || value.is_a?(Array)) ) ? value.to_struct : value
+  end
+
+  protected :new_struct_member, :structurize
+
+
+  #
+  # Returns the value of a member.
+  #
+  #   person = SDStruct.new('name' => 'Matz', 'lang' => 'ruby')
+  #   person[:lang] # => ruby, same as person.lang
+  #
+  def [](name)
+    @table.has_key?(name) ? @table[name] : @table[name.to_s.underscore.to_sym]
+  end
+
+  #
+  # Sets the value of a member.
+  #
+  #   person = SDStruct.new('name' => 'Matz', 'lang' => 'python')
+  #   person[:lang] = 'ruby' # => equivalent to person.lang = 'ruby'
+  #   person.lang # => ruby
+  #
+  def []=(name, value)
+    unless self.[](name).nil? || value.is_a?(self.[](name).class)
+      warn("You're assigning a value with different type as the previous value.")
+    end
+    @table[new_struct_member(name)] = structurize(value)
+  end
+
+  InspectKey = :__inspect_key__ # :nodoc:
+
+  #
+  # Returns a string containing a detailed summary of the keys and values.
+  #
+  def inspect
+    str = "#<#{self.class}"
+
+    ids = (Thread.current[InspectKey] ||= [])
+    if ids.include?(object_id)
+      return str << ' ...>'
+    end
+
+    ids << object_id
+    begin
+      first = true
+      for k,v in @table
+        str << "," unless first
+        first = false
+        str << " #{k[/\s+/] ? "['#{k}']" : ".#{k}"}=#{v.inspect}"
+      end
+      return str << '>'
+    ensure
+      ids.pop
+    end
+  end
+  alias :to_s :inspect
+
+  attr_reader :table
+  protected :table
+
+  def ==(other)
+    return false unless other.kind_of?(self.class)
+    @table == other.table
+  end
+
+  #
+  # Compares this object and +other+ for equality.  An SDStruct is eql? to
+  # +other+ when +other+ is an SDStruct and the two objects' Hash tables are
+  # eql?.
+  #
+  def eql?(other)
+    return false unless other.kind_of?(self.class)
+    @table.eql?(other.table)
+  end
+
+  #
+  # Compute a hash-code for this SDStruct.
+  # Two hashes with the same content will have the same hash code
+  # (and will be eql?).
+  #
+  def hash
+    @table.hash
+  end
+
+  #
+  # Expose keys with space(s)
+  #
+  def spaced_keys
+    @table.keys - non_spaced_keys
+  end
+
+  #
+  # Expose keys without space(s)
+  #
+  def non_spaced_keys
+    methods(false).select{|x| x[/^\S+[^=]$/]}
+  end
+  alias :fields :non_spaced_keys
+
+  #
+  # Expose all keys
+  #
+  def keys
+    @table.keys
+  end
+
+  #
+  # Delete specified field or key
+  #
+  def delete_field(name)
+    sym = name.to_sym
+    @table.delete(sym) do
+      raise NameError.new("no field `#{sym}' in #{self}", sym)
+    end
+    singleton_class.__send__(:remove_method, sym, "#{sym}=")
+  end
+  alias :delete_key :delete_field
+end

data/lib/sd_struct/deep_convert.rb

@@ -0,0 +1,37 @@
+class SDStruct
+  using Module.new {
+    refine Array do
+      alias :original_to_h :to_h
+
+      def to_h(camelize_keys = false)
+        map{|x| x.respond_to?(:to_h) ? x.to_h(camelize_keys) : x }
+      end
+    end
+  }
+
+  def to_h(opts = {})
+    opts = {
+      camelize_keys: false,
+      exclude_blank_values: false,
+      values_to_exclude: []
+    }.merge(opts)
+
+    @table.map do |k, v|
+      v = v.to_h(opts) if v.is_a?(self.class) || v.is_a?(Array)
+      k = k.to_s.camelize(:lower) if opts[:camelize_keys] && !k[/\s+/]
+      [k, v]
+    end.original_to_h
+       .select{|_,v| opts[:exclude_blank_values] ? v.present? : !v.nil? }
+       .select{|_,v| !v.in?(opts[:values_to_exclude]) }
+  end
+
+  def to_json(opts = {})
+    opts = {
+      camelize_keys: true,
+      exclude_blank_values: true,
+      values_to_exclude: [0, [""], [{}]]
+    }.merge(opts)
+
+    to_h(opts).to_json
+  end
+end

data/lib/sd_struct/deep_search.rb

@@ -0,0 +1,112 @@
+class SDStruct
+  using Module.new {
+    refine Array do
+
+      #
+      # Dig deep into array until non-Array and non-Hash primitive data is found
+      #
+      # @param [Symbol] multiple symbols
+      # @return [String,Integer,Float,Boolean,nil] first matched result
+      #
+      def dig_deep(*args)
+        full_args = args.dup
+        parent_key = args.shift
+        result = nil
+        if parent_key.is_a?(Integer)
+          result = dig(parent_key)
+          unless result.nil? || args.length.zero?
+            result = result.dig_deep(*args)
+          end
+        end
+        if result.nil?
+          each do |x|
+            if x.respond_to?(:dig_deep) || x.is_a?(Array)
+              result = x.dig_deep(*full_args)
+            end
+            return result unless result.nil?
+          end
+        end
+        return result
+      end
+    end
+  }
+
+  #
+  # Dig deep into Hash until non-Array and non-Hash primitive data is found
+  #
+  # @param [Symbol] multiple symbols
+  # @return [SDStruct,Hash,Array,String,Integer,Float,Boolean,nil] first matched result
+  #
+  def dig_deep(*args)
+    full_args = args.dup
+    parent_key = args.shift
+    result = dig(parent_key)
+    unless result.nil? || args.length.zero?
+      if result.respond_to?(:dig)
+        result = result.dig(*args)
+      end
+    end
+    if result.nil?
+      @table.values
+            .select{|v| v.respond_to?(:dig) }
+            .each do |v|
+              if v.respond_to?(:dig_deep) || v.is_a?(Array)
+                result = v.dig_deep(*full_args)
+              end
+              return result unless result.nil?
+            end
+    end
+    return result
+  end
+
+  #
+  # Dig the content of @table which is a hash
+  #
+  # @param [Symbol] multiple symbols
+  # @return [SDStruct,Hash,Array,String,Integer,Float,Boolean,nil] first matched result
+  #
+  def dig(*args)
+    @table.dig(*args)
+  end
+
+  def find(key_str, opts = {})
+    opts = {
+      separator: "/"
+    }.merge(opts)
+
+    sep = Regexp.quote(opts[:separator])
+
+    args = begin
+      key_str.gsub(/^#{sep}(?!#{sep})|#{sep}+$/, '')
+             .split(/#{sep}{2,}/)
+             .map do |ks|
+               ks.split(/#{sep}/)
+                 .map do |x|
+                   x.strip!
+                   if !!x[/\A[-+]?\d+\z/]
+                     x.to_i
+                   else
+                     if x[/^$|\s+/]
+                       x
+                     else
+                       x.underscore.to_sym
+                     end
+                   end
+                 end
+             end
+    end
+
+    if !(parent_key = args.shift) # args == [], key_str == ""
+      return
+    else # e.g. args == [[], ..] or [[.., ..], [..]]
+      result = dig(*parent_key) unless parent_key.empty?
+
+      unless args.length.zero?
+        args.each do |a|
+          result = result.dig_deep(*a) rescue result = dig_deep(*a)
+        end
+      end
+    end
+    return result
+  end
+end

data/lib/sd_struct/version.rb

@@ -1,3 +1,3 @@
 class SDStruct
-  VERSION = "0.0.3"
+  VERSION = "0.1.0"
 end

data/lib/sd_struct.rb

@@ -1,234 +1,4 @@
 require "sd_struct/version"
-
-
-# Alternative to OpenStruct that is more strict and go deeper.
-#
-# @author Adrian Setyadi
-#
-class SDStruct
-  using Module.new {
-    refine Hash do
-      def to_struct
-        SDStruct.new(to_h.dup)
-      end
-    end
-
-    refine Array do
-      alias :original_to_h :to_h
-
-      def to_h(camelize_keys = false)
-        map{|x| x.respond_to?(:to_h) ? x.to_h(camelize_keys) : x }
-      end
-
-      # Call `to_struct` to an Array to go deeper or to a Hash to change it to SDStruct
-      #
-      # @return [Array<SDStruct,Object>] array of SDStruct or any other objects
-      #
-      def to_struct
-        map{|x| ( x.is_a?(Hash) || x.is_a?(Array) ) ? x.to_struct : x }
-      end
-
-      def dig_deep(*args)
-        full_args = args.dup
-        parent_key = args.shift
-        result = nil
-        if parent_key.is_a?(Integer)
-          result = dig(parent_key)
-          unless result.nil? || args.length.zero?
-            result = result.dig_deep(*args)
-          end
-        end
-        if result.nil?
-          each do |x|
-            if x.respond_to?(:dig_deep) || x.is_a?(Array)
-              result = x.dig_deep(*full_args)
-            end
-            return result unless result.nil?
-          end
-        end
-        return result
-      end
-    end
-  }
-
-  def initialize(hash = nil, deep = true)
-    @table = {}
-    if hash
-      hash.each_pair do |k, v|
-        v = v.to_struct if deep && ( v.is_a?(Hash) || v.is_a?(Array) )
-        @table[new_member(k)] = v
-      end
-    end
-  end
-
-  def initialize_copy(orig)
-    super
-    @table = @table.dup
-  end
-
-  def marshal_dump
-    to_h
-  end
-
-  def marshal_load(x)
-    @table = x.map{|a| ( a.is_a?(Hash) || a.is_a?(Array) ) ? a.to_struct : a }
-              .original_to_h
-  end
-
-  def to_h(opt = {})
-    opt = {
-      camelize_keys: false,
-      exclude_blank_values: false,
-      values_to_exclude: []
-    }.merge(opt)
-
-    @table.map do |k, v|
-      v = v.to_h(opt) if v.is_a?(self.class) || v.is_a?(Array)
-      k = k.to_s.camelize(:lower) if opt[:camelize_keys] && !k[/\s+/]
-      [k, v]
-    end.original_to_h
-       .select{|_,v| opt[:exclude_blank_values] ? v.present? : !v.nil? }
-       .select{|_,v| !v.in?(opt[:values_to_exclude]) }
-  end
-
-  def to_json(opt = {})
-    opt = {
-      camelize_keys: true,
-      exclude_blank_values: true,
-      values_to_exclude: [0, [""], [{}]]
-    }.merge(opt)
-
-    to_h(opt).to_json
-  end
-
-  def new_member(name)
-    name = name.to_s.underscore.to_sym unless name[/\s+/] # contains whitespace
-    unless respond_to?(name)
-      define_singleton_method(name) { @table[name] }
-      define_singleton_method("#{name}=") { |x| @table[name] = x }
-    end
-    name
-  end
-  protected :new_member
-
-  def [](name)
-    @table.has_key?(name) ? @table[name] : @table[name.to_s.underscore.to_sym]
-  end
-
-  def []=(name, value)
-    @table[new_member(name)] = value
-  end
-
-  InspectKey = :__inspect_key__ # :nodoc:
-
-  def inspect
-    str = "#<#{self.class}"
-
-    ids = (Thread.current[InspectKey] ||= [])
-    if ids.include?(object_id)
-      return str << ' ...>'
-    end
-
-    ids << object_id
-    begin
-      first = true
-      for k,v in @table
-        str << "," unless first
-        first = false
-        str << " #{k[/\s+/] ? "['#{k}']" : ".#{k}"}=#{v.inspect}"
-      end
-      return str << '>'
-    ensure
-      ids.pop
-    end
-  end
-  alias :to_s :inspect
-
-  def dig_deep(*args)
-    full_args = args.dup
-    parent_key = args.shift
-    result = dig(parent_key)
-    unless result.nil? || args.length.zero?
-      if result.respond_to?(:dig)
-        result = result.dig(*args)
-      end
-    end
-    if result.nil?
-      @table.values
-            .select{|v| v.respond_to?(:dig) }
-            .each do |v|
-              if v.respond_to?(:dig_deep) || v.is_a?(Array)
-                result = v.dig_deep(*full_args)
-              end
-              return result unless result.nil?
-            end
-    end
-    return result
-  end
-
-  def dig(*args)
-    @table.dig(*args)
-  end
-
-  def find(key_str, opt = {})
-    opt = {
-      separator: "/"
-    }.merge(opt)
-
-    args = key_str.split(opt[:separator])
-                  .map do |x|
-                    x.strip!
-                    if !!(x =~ /\A[-+]?\d+\z/)
-                      x.to_i
-                    else
-                      if x[/\s+/]
-                        x
-                      else
-                        x.underscore.to_sym
-                      end
-                    end
-                  end
-
-    result = dig_deep(*args) rescue nil
-    return result
-  end
-
-  attr_reader :table
-  protected :table
-
-  def ==(other)
-    return false unless other.kind_of?(self.class)
-    @table == other.table
-  end
-
-  def eql?(other)
-    return false unless other.kind_of?(self.class)
-    @table.eql?(other.table)
-  end
-
-  def hash
-    @table.hash
-  end
-
-  def spaced_keys
-    @table.keys - non_spaced_keys
-  end
-
-  def non_spaced_keys
-    methods(false).select{|x| x[/^\S+[^=]$/]}
-  end
-  alias :fields :non_spaced_keys
-
-  def keys
-    @table.keys
-  end
-
-  def delete_field(name)
-    sym = name.to_sym
-    @table.delete(sym) do
-      raise NameError.new("no field `#{sym}' in #{self}", sym)
-    end
-    singleton_class.__send__(:remove_method, sym, "#{sym}=")
-  end
-  alias :delete_key :delete_field
-end
+require "sd_struct/base"
+require "sd_struct/deep_convert"
+require "sd_struct/deep_search"

data/sd_struct.gemspec

@@ -8,20 +8,20 @@ Gem::Specification.new do |spec|
   spec.version       = SDStruct::VERSION
   spec.authors       = ["Adrian Setyadi"]
   spec.email         = ["a.styd@yahoo.com"]
-  spec.summary       = %q{Stricter and Deeper Struct}
-  spec.description   = %q{An alternative to OpenStruct that stricter in assigning values and deeper in
+  spec.summary       = %q{Strict and Deep Struct}
+  spec.description   = %q{An alternative to OpenStruct that more strict in assigning values and deeper in
 consuming the passed Hash and transforming it back to Hash or JSON, equipped
 with deep digging capabilities.}
-  spec.homepage      = ""
   spec.license       = "MIT"
 
-  spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "activesupport", "~> 4", "> 4"
+  spec.add_runtime_dependency "activesupport", "> 4"
 
-  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "bundler", "~> 1.14"
   spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.5"
 end

metadata

@@ -1,22 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: sd_struct
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors:
 - Adrian Setyadi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-09 00:00:00.000000000 Z
+date: 2017-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4'
     - - ">"
       - !ruby/object:Gem::Version
         version: '4'
@@ -24,9 +21,6 @@ dependencies:
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4'
     - - ">"
       - !ruby/object:Gem::Version
         version: '4'
@@ -36,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '1.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '1.14'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -58,8 +52,22 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
 description: |-
-  An alternative to OpenStruct that stricter in assigning values and deeper in
+  An alternative to OpenStruct that more strict in assigning values and deeper in
   consuming the passed Hash and transforming it back to Hash or JSON, equipped
   with deep digging capabilities.
 email:
@@ -69,14 +77,22 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rspec"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/console
+- bin/setup
 - lib/sd_struct.rb
+- lib/sd_struct/base.rb
+- lib/sd_struct/deep_convert.rb
+- lib/sd_struct/deep_search.rb
 - lib/sd_struct/version.rb
 - sd_struct.gemspec
-homepage: ''
+homepage: 
 licenses:
 - MIT
 metadata: {}
@@ -99,5 +115,5 @@ rubyforge_project:
 rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: Stricter and Deeper Struct
+summary: Strict and Deep Struct
 test_files: []