deep-hash-struct 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1aa824e97416264b19d1bc4436292c26cfc62aab
-  data.tar.gz: 8df3bff21c7c12ff5c690fa01c22d84126a739e0
+  metadata.gz: d75b9bdee86a1e833867d5f5c09a39af09dbe262
+  data.tar.gz: a9b9534aeb425c24a0cabc04f03ce417876c344f
 SHA512:
-  metadata.gz: 8d9353d008e6f32345e64233d8841c23eb4f0a2b2786eebeeb46e53322b123ff551be42cbe9b71542ce7225dce02b0c5314ba60976cb88cacb2946da35d2dbb7
-  data.tar.gz: 659123eb11918ca7ea2926a72baf2b0ddc0e9cee02c5206e7da39b7044700dd50eabf0615f5ba94c39cdb299890fd0b41e233e6666c3cc871078a2d6c8cdbdb4
+  metadata.gz: 5d3676edb4c79c1dfcd232c9c550b00afd1acba038c39b389f719239c2948fb843c34be45e70ffb0e7d1389c01aa81c96026e158cd18668362955e48702d46bf
+  data.tar.gz: c882419641decdce45a9bbb6a6ae139ef8ca76730785b8c1b449e02da0b78f56a21a403dc36f867635e54da9257ad5b65425161a2f0967716b4ba1078d767ae9

data/.travis.yml

@@ -1,5 +1,5 @@
 sudo: false
 language: ruby
 rvm:
-  - 2.3.1
-before_install: gem install bundler -v 1.13.6
+  - 2.4.1
+before_install: gem install bundler -v 1.14.6

data/README.md

@@ -1,6 +1,7 @@
 # Deep::Hash::Struct
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/deep/hash/struct`. To experiment with that code, run `bin/console` for an interactive prompt.
+Struct copes with the operation that is Deep.
+Because the data maintenance of many hierarchies became possible, I can treat it like Hash.
 
 ## Installation
 
@@ -20,18 +21,14 @@ Or install it yourself as:
 
 ## Usage
 
+```ruby
 wrapper         = Deep::Hash::Struct::Wrapper.new
 wrapper.a       = 1
 wrapper.b.a     = 2
 wrapper[:c][:a] = 3
 wrapper[:c].b   = 4
-wrapper.to_h        # => => {:a=>1, :b=>{:a=>2}, :c=>{:a=>3, :b=>4}}
-
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+wrapper.to_h # => {:a=>1, :b=>{:a=>2}, :c=>{:a=>3, :b=>4}}
+```
 
 ## Contributing
 
@@ -41,4 +38,3 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/etiopi
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-

data/lib/deep/hash/struct.rb

@@ -5,17 +5,25 @@ module Deep
   module Hash
     module Struct
       class Wrapper
+        attr_accessor :default
+
         def initialize(h = {})
           return if h.nil? || h.count.zero?
           wrap h, self
         end
 
         def keys
-          instance_variables.map do |k|
+          instance_variables.select { |k| k !~ /default/ }.map do |k|
             k.to_s[1..-1].to_sym
           end
         end
 
+        def values
+          keys.map do |k|
+            self[k]
+          end
+        end
+
         def [](k)
           __send__ k
         end
@@ -24,16 +32,53 @@ module Deep
           __send__ "#{k}=", v
         end
 
+        def ==(hash)
+          if hash.class == self.class
+            to_h == hash.to_h
+          else
+            to_h == hash
+          end
+        end
+
+        def ===(klass)
+          self.class == klass
+        end
+
         def each
+          if block_given?
+            keys.each do |k|
+              yield k, self[k]
+            end
+          else
+            to_h.each
+          end
+        end
+
+        def each_with_index
+          index = 0
           keys.each do |k|
-            yield k, self[k]
+            yield [k, self[k]], index
+            index += 1
           end
         end
 
-        def each_with_index(i = 0)
+        def each_with_object(init)
+          each do |k, v|
+            yield [k, v], init
+          end
+
+          init
+        end
+
+        def each_key
           keys.each do |k|
-            yield [k, self[k]], i
-            i += 1
+            yield k
+          end
+        end
+
+        def each_value
+          values.each do |v|
+            yield v
           end
         end
 
@@ -42,12 +87,6 @@ module Deep
         end
         alias size count
 
-        def values
-          keys.map do |k|
-            self[k]
-          end
-        end
-
         def blank?
           keys.size.zero?
         end
@@ -57,15 +96,15 @@ module Deep
         end
 
         def dig(*syms)
-          syms.reduce(self) do |h, k|
-            h[k] if h.keys.include? k
+          syms.inject(self) do |h, k|
+            h[k]
           end
         rescue
           nil
         end
 
         def merge(hash)
-          klass = self.dup
+          klass = dup
 
           hash.each do |k, v|
             klass[k] = v
@@ -80,12 +119,13 @@ module Deep
           end
           self
         end
+        alias update merge!
 
-        def deep_merge(hash)
-          klass = self.dup
+        def deep_merge(hash, klass = self)
+          klass = klass.dup
 
           hash.each do |k , v|
-            klass[k] = hash?(v) ? deep_merge(v) : v
+            klass[k] = hash?(v) ? klass.deep_merge(v, klass[k]) : v
           end
 
           klass
@@ -99,6 +139,44 @@ module Deep
           klass
         end
 
+        def reverse_merge(hash)
+          klass = dup
+
+          hash.each do |k, v|
+            klass[k] = v if klass.exclude?(k)
+          end
+
+          klass
+        end
+
+        def reverse_merge!(hash)
+          hash.each do |k, v|
+            self[k] = v if exclude?(k)
+          end
+
+          self
+        end
+
+        def reverse_deep_merge(hash, klass = self)
+          klass = klass.dup
+
+          hash.each do |k , v|
+            next if !hash?(v) && klass.include?(k)
+            klass[k] = hash?(v) ? klass.reverse_deep_merge(v, klass[k]) : v
+          end
+
+          klass
+        end
+
+        def reverse_deep_merge!(hash)
+          hash.each do |k, v|
+            next if !hash?(v) && include?(k)
+            self[k] = hash?(v) ? reverse_deep_merge(v, self[k]) : v
+          end
+
+          self
+        end
+
         def fetch(k, msg = nil)
           v = self[k]
           if block_given?
@@ -123,6 +201,252 @@ module Deep
           end
         end
 
+        def map
+          vs = []
+
+          each do |k, v|
+            vs << yield(k, v)
+          end
+
+          vs
+        end
+        alias collect map
+
+        def map_key
+          vs = []
+
+          keys.each do |k|
+            vs << yield(k)
+          end
+
+          vs
+        end
+
+        def map_value
+          vs = []
+
+          values.each do |v|
+            vs << yield(v)
+          end
+
+          vs
+        end
+
+        def fetch_values(*syms)
+          syms.map do |sym|
+            if block_given?
+              if keys.include?(sym)
+                self[sym]
+              else
+                yield sym
+              end
+            else
+              raise KeyError, "key not found: :#{sym}" unless keys.include?(sym)
+              self[sym]
+            end
+          end
+        end
+
+        def values_at(*syms)
+          syms.map do |sym|
+            v = self[sym]
+            (v.nil? || (v.class == self.class && v.blank?)) ? nil : v
+          end
+        end
+
+        def invert
+          each_with_object({}) do |(k, v), h|
+            h[v] = k
+          end
+        end
+
+        def delete(k)
+          remove_instance_variable "@#{k}"
+        end
+
+        def delete_if
+          each do |k, v|
+            remove_instance_variable "@#{k}" if yield(k, v)
+          end
+          self
+        end
+
+        def find
+          klass = self.class.new
+
+          each do |k, v|
+            if yield(k, v)
+              klass[k] = v
+              break
+            end
+          end
+
+          klass
+        end
+
+        def select
+          klass = self.class.new
+
+          each do |k, v|
+            klass[k] = v if yield(k, v)
+          end
+
+          klass
+        end
+        alias find_all select
+
+        def reject
+          klass = self.class.new
+
+          each do |k, v|
+            klass[k] = v unless yield(k, v)
+          end
+
+          klass
+        end
+
+        def reject!
+          each do |k, v|
+            remove_instance_variable "@#{k}" if yield(k, v)
+          end
+          self
+        end
+
+        def inject(init = 0)
+          value = init.dup
+          each do |k, v|
+            val = yield init.dup, [k, v]
+            next if val.nil?
+            value += val
+          end
+          value
+        end
+        alias reduce inject
+
+        def clear
+          each_key do |k|
+            remove_instance_variable "@#{k}"
+          end
+          self
+        end
+
+        def replace(other)
+          h = if other.class == self.class
+                other.to_hash
+              elsif hash? other
+                other
+              else
+                other.to_hash
+              end
+
+          clear
+          wrap h, self
+        end
+
+        def flatten
+          to_h.flatten
+        end
+
+        def has_key?(k)
+          keys.include? k
+        end
+        alias include? has_key?
+
+        def has_keys?(*syms)
+          syms.inject(self) do |klass, sym|
+            val = klass[sym]
+            return false if val.class == self.class && val.blank?
+            klass[sym]
+          end
+          true
+        end
+
+        def exclude?(k)
+          !include? k
+        end
+
+        def sort
+          to_h.sort
+        end
+
+        def shift
+          k = keys.first
+          [k, remove_instance_variable("@#{k}")]
+        end
+
+        def to_a
+          to_h.to_a
+        end
+        alias to_ary to_a
+
+        def compact
+          klass = dup
+
+          klass.each do |k, v|
+            klass.remove_instance_variable("@#{k}") if (v.class == self.class && v.blank?) || v.nil?
+          end
+
+          klass
+        end
+
+        def compact!
+          each do |k, v|
+            remove_instance_variable("@#{k}") if (v.class == self.class && v.blank?) || v.nil?
+          end
+
+          self
+        end
+
+        def deep_compact
+          klass = dup
+
+          klass.each do |k, v|
+            flag  = if v.class == self.class
+                      klass[k] = v.deep_compact
+                      klass[k].present?
+                    else
+                      !v.nil?
+                    end
+            next if flag
+            klass.remove_instance_variable("@#{k}")
+          end
+
+          klass
+        end
+
+        def deep_compact!
+          each do |k, v|
+            flag  = if v.class == self.class
+                      self[k] = v.deep_compact
+                      self[k].present?
+                    else
+                      !v.nil?
+                    end
+            next if flag
+            remove_instance_variable("@#{k}")
+          end
+
+          self
+        end
+
+        def slice(*syms)
+          klass = self.class.new
+
+          each_key do |k|
+            klass[k] = self[k] if syms.map(&:to_sym).include?(k)
+          end
+
+          klass
+        end
+
+        def slice!(*syms)
+          each_key do |k|
+            remove_instance_variable("@#{k}") unless syms.map(&:to_sym).include?(k)
+          end
+
+          self
+        end
+
         def to_hash
           deep_hash self
         end
@@ -132,23 +456,24 @@ module Deep
           to_h.to_json
         end
 
+        private
+
         def method_missing(method_name, arg = nil)
           name = method_name.to_s.delete("=")
 
           if method_name.to_s.end_with? "="
-            keys << name.to_sym unless keys.include? name.to_sym
             instance_variable_set "@#{name}", hash?(arg) ? wrap(arg) : arg
+          elsif block_given?
+            __send__ "#{name}=", yield
           else
             val = instance_variable_get "@#{name}"
             return val unless val.nil?
-            instance_variable_set "@#{name}", self.class.new
+            instance_variable_set "@#{name}", default.dup || self.class.new
           end
         rescue => e
           super
         end
 
-        private
-
         def deep_hash(klass)
           h = {}
 

data/lib/deep/hash/struct/version.rb

@@ -1,7 +1,7 @@
 module Deep
   module Hash
     module Struct
-      VERSION = "0.1.1"
+      VERSION = "0.1.2"
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: deep-hash-struct
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - adachi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-26 00:00:00.000000000 Z
+date: 2017-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -92,7 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Convenient hash.