sd_struct 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7b543501f8aa5ae85ede78790fe9322e02329912
+  data.tar.gz: 307b9ffef98af9acd6bfb3220ecefac8d1b593b3
+SHA512:
+  metadata.gz: 5677a893ed42b6c60dadd6d411931174a7b39ff6303452a3418961bc304cc9948ad01f60d886eaad2109162c1952e76f166e69a484fdd71d67e39339348aef61
+  data.tar.gz: cc7349a61ce9c5af6c9038a930e0e1fc13ea30091c2a546a02848b16c2461fdd9641413dfcae883d51fc88d31e601ff548a23d9234e879bf2b020178db05b877

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in sd_struct.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2017 Adrian Setyadi
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,264 @@
+# 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
+with deep digging capabilities.
+
+## Usage
+
+### From JSON
+
+Example of a response body in JSON.
+
+```JSON
+{
+  "object": {
+    "a": "bau bau",
+    "c": "boo boo"
+  },
+  "array": [
+    {
+      "one": 1,
+      "two": 2,
+      "three": 3
+    }
+  ],
+  "two words": "Foo bar"
+}
+```
+
+
+> In OpenStruct, it's not obvious how to get a value with fields that contain spaces.
+> Some people don't even know that it can be accessed.
+
+```ruby
+## with OpenStruct
+o_struct = JSON.parse(response.body, object_class: OpenStruct)
+# => #<OpenStruct object=#<OpenStruct a="bau bau", c="boo boo">,
+# array=[#<OpenStruct one=1, two=2, three=3>], two words="Foo bar">
+
+o_struct["two words"]
+# => "Foo bar"
+
+
+## with SDStruct
+sd_struct = JSON.parse(response.body, object_class: SDStruct)
+# => #<SDStruct .object=#<SDStruct .a="bau bau", .c="boo boo">,
+# .array=[#<SDStruct .one=1, .two=2, .three=3>], ['two words']="Foo bar">
+
+sd_struct["two words"]
+# => "Foo bar"
+```
+
+
+> OpenStruct's `to_h` doesn't return a hash deeply.
+
+```ruby
+## OpenStruct
+o_struct.to_h
+# => {:object=>#<OpenStruct a="bau bau", c="boo boo">,
+# :array=>[#<OpenStruct one=1, two=2, three=3>], :"two words"=>"Foo bar"}
+
+## SDStruct
+sd_struct.to_h
+# => {:object=>{:a=>"bau bau", :c=>"boo boo"},
+# :array=>[{:one=>1, :two=>2, :three=>3}], "two words"=>"Foo bar"}
+```
+
+
+> OpenStruct uses `method_missing` to create new field, while SDStruct prevent creation
+> of new field using dot notation.
+
+SDStruct prevent creation of new field using dot notation once it is initialized
+to prevent assigning unintended field when you mistyped the key/field. SDStruct
+is stricter in that way. However, SDStruct can also be lenient. You can use
+square brackets when you want to assign a new field.
+
+```ruby
+## OpenStruct
+o_struct.book = "title"
+# => "title"
+
+o_struct
+# => #<OpenStruct object=#<OpenStruct a="bau bau", c="boo boo">,
+# array=[#<OpenStruct one=1, two=2, three=3>], two words="Foo bar", book="title">
+
+
+## SDStruct
+sd_struct.book = "title"
+# => NoMethodError: undefined method `book=' for #<SDStruct:0x007ffa65b10a28>
+
+sd_struct["book"] = "title"
+# => "title"
+
+sd_struct
+# => #<SDStruct .object=#<SDStruct .a="bau bau", .c="boo boo">,
+# .array=[#<SDStruct .one=1, .two=2, .three=3>], ['two words']="Foo bar", .book="title">
+```
+
+
+> OpenStruct doesn't have search or deep digging functionalities
+
+```ruby
+sd_struct.find('object/a')
+# => "bau bau"
+
+sd_struct.find('array/0/one')
+# => 1
+
+sd_struct.find('object->a', separator: '->')
+# => "bau bau"
+
+sd_struct.find('array.0.one', separator: '.')
+# => 1
+
+# You can push it to find deeper. It will return the first occurrence of the matched field
+sd_struct.find('a')
+# => "bau bau"
+
+sd_struct.find('0/one')
+# => 1
+
+sd_struct.find('one')
+# => 1
+
+sd_struct.find('four')
+# => nil
+
+sd_struct.dig_deep(0, :one)
+# => 1
+
+sd_struct.dig_deep(:one)
+# => 1
+```
+
+
+> SDStruct is suitable for building JSON request body
+
+You can parse a default JSON file for request body, fill it in, and only send
+parts that are not empty.
+
+```ruby
+# SDStruct also has `delete_field` method
+sd_struct.delete_field(:book)
+# => #<Class:#<SDStruct:0x007ffa65b10a28>>
+
+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['two words'] = ""
+sd_struct
+# => #<SDStruct .object=#<SDStruct .a="bau bau", .c="boo boo">,
+# .array=[#<SDStruct .one=0, .two=2, .three=0>], ['two words']="">
+```
+
+By default, blank value, 0, [""], and [{}] are considered not important.
+Therefore, keys with those values are excluded from the generated JSON string.
+
+```ruby
+sd_struct.to_json
+# => "{\"object\":{\"a\":\"bau bau\",\"c\":\"boo boo\"},\"array\":[{\"two\":2}]}"
+
+sd_struct.find('0').two = 0
+sd_struct.to_json
+# => "{\"object\":{\"a\":\"bau bau\",\"c\":\"boo boo\"}}"
+```
+
+However, you can include them if you want to by removing them from `:values_to_exclude` option.
+
+```ruby
+sd_struct.to_json values_to_exclude: [[""], [{}]] # default to [0, [""], [{}]]
+# => "{\"object\":{\"a\":\"bau bau\",\"c\":\"boo boo\"},\"array\":[{\"one\":0,\"two\":0,\"three\":0}]}"
+
+sd_struct.to_json values_to_exclude: [[""], [{}]], exclude_blank_values: false # default to true
+# => "{\"object\":{\"a\":\"bau bau\",\"c\":\"boo boo\"},\"array\":[{\"one\":0,\"two\":0,\"three\":0}],\"two words\":\"\"}"
+```
+
+### From Hash
+
+Example of a Hash.
+
+```ruby
+{
+  :object => {
+    :a => "bau bau",
+    :c => "boo boo"
+  },
+  :array => [
+    {
+      :one => 1,
+      :two => 2,
+      :three => 3
+    }
+  ],
+  "two words" => "Foo bar"
+}
+```
+
+
+> OpensStruct doesn't consume a hash deeply
+
+```ruby
+## with OpenStruct
+o_struct = OpenStruct.new(hash)
+# => #<OpenStruct object={:a=>"bau bau", :c=>"boo boo"},
+# array=[{:one=>1, :two=>2, :three=>3}], two words="Foo bar">
+
+## with SDStruct
+sd_struct = SDStruct.new(hash)
+# => #<SDStruct .object=#<SDStruct .a="bau bau", .c="boo boo">,
+# .array=[#<SDStruct .one=1, .two=2, .three=3>], ['two words']="Foo bar">
+```
+
+## 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`
+
+## Dependencies
+
+ActiveSupport (if you use Rails, this should already be installed)
+
+### ActiveSupport Installation (for when you don't use Rails)
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'activesupport'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install activesupport
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sd_struct'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sd_struct
+
+## Contributing
+
+1. Fork it ( https://github.com/styd/sd_struct/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/sd_struct.rb

@@ -0,0 +1,234 @@
+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

data/lib/sd_struct/version.rb

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

data/sd_struct.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sd_struct/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sd_struct"
+  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
+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.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "activesupport", "~> 4", "> 4"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: sd_struct
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Adrian Setyadi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-04-09 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'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: |-
+  An alternative to OpenStruct that stricter in assigning values and deeper in
+  consuming the passed Hash and transforming it back to Hash or JSON, equipped
+  with deep digging capabilities.
+email:
+- a.styd@yahoo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/sd_struct.rb
+- lib/sd_struct/version.rb
+- sd_struct.gemspec
+homepage: ''
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Stricter and Deeper Struct
+test_files: []