deeply_enumerable 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1c7178af253c0b681770ebf17fd86e9f5d8772f6
+  data.tar.gz: 8d11d2165f7375a08cb708be8d74df017f578030
+SHA512:
+  metadata.gz: 1312ce00f3013e42096bdf5f3d6c02dce1a85388be8eed0357f5fa1cff32e170eb5f9aea8ba16379f07f944587671e33aac81e7360af109858ab35bafb410af5
+  data.tar.gz: 0226e8013d0cb9a753f39827b00588502e215a08c4efdb57b089e570c4fee43892d47866e3d6f75dd1fcc919473997a9f6810a6f7db1c25776748c0d8c2a388c

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2018 chaunce
+
+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,59 @@
+# DeeplyEnumerable
+Extend Enumerable objects with recursive methods
+
+## Usage
+Provides the following methods
+```ruby
+$ DeeplyEnumerable::Hash#reverse_deep_merge(DeeplyEnumerable::Hash)
+$ DeeplyEnumerable::Hash#reverse_deep_merge!(DeeplyEnumerable::Hash)
+$ DeeplyEnumerable::Hash#deep_compact
+$ DeeplyEnumerable::Hash#deep_compact!
+
+$ DeeplyEnumerable::Array#deep_compact
+$ DeeplyEnumerable::Array#deep_compact!
+```
+
+Nested `Enumerable` objects will be converted into `DeeplyEnumerable` type objects during merge or compact operations to allow recursive method calls
+
+Class methods may be used for base ruby enumerable objects, such as `Hash` or `Array` objects
+```ruby
+$ DeeplyEnumerable::Hash.deep_compact(Hash)
+$ DeeplyEnumerable::Array.deep_compact(Array)
+```
+
+These methos will retrun a `DeeplyEnumerable` type object matching the object passed, e.g: `Array` will return a `DeeplyEnumerable::Array`
+
+You may also extend base classes if you `require: 'base_extensions'` as described in *Installation*
+```ruby
+$ Hash#reverse_deep_merge(DeeplyEnumerable::Hash)
+$ Hash#reverse_deep_merge!(DeeplyEnumerable::Hash)
+$ Hash#deep_compact
+$ Hash#deep_compact!
+
+$ Array#deep_compact
+$ Array#deep_compact!
+```
+
+## Installation
+Add this line to your application's Gemfile:
+```ruby
+gem 'deeply_enumerable'
+```
+
+or this line to extend the base `Enumerable` classes:
+```ruby
+gem 'deeply_enumerable', require: 'base_extensions'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install deeply_enumerable
+```
+
+## License
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,33 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'DeeplyEnumerable'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/lib/base_extensions.rb

@@ -0,0 +1,4 @@
+require 'deeply_enumerable'
+
+Hash.send(:include, DeeplyEnumerable::HashExtension)
+Array.send(:include, DeeplyEnumerable::ArrayExtension)

data/lib/deeply_enumerable/array.rb

@@ -0,0 +1,40 @@
+require_relative 'enumerable'
+
+module DeeplyEnumerable
+  module ArrayExtension
+    def self.included klass
+      klass.class_eval do
+        include DeeplyEnumerable::Enumerable
+      end
+    end
+
+    def deep_compact!(remove_emptied_elements = true, remove_empty_elements = remove_emptied_elements)
+      each.with_index do |value, index|
+        value = rebuild(value) unless value.respond_to?(:reverse_deep_merge)
+        compact_method = %i[deep_compact! deep_compact compact! compact].detect{ |m| value.respond_to?(m) }
+        next unless compact_method
+
+        original_empty = value.respond_to?(:empty?) ? value.empty? : value.respond_to?(:none?) ? value.none? : false
+        compact_value = value.send(*[compact_method].concat(value.method(compact_method).parameters.collect { |_,param| binding.local_variable_get(param) } ).compact) || value
+        compact_empty = compact_value.respond_to?(:empty?) ? compact_value.empty? : compact_value.respond_to?(:none?) ? compact_value.none? : false
+
+        if (original_empty && remove_empty_elements) || (!original_empty && compact_empty && remove_emptied_elements)
+          self.delete_at(index)
+        else
+          self[index] = compact_value
+        end
+      end
+      compact!
+
+      self
+    end
+
+    def deep_compact(remove_emptied_elements = true, remove_empty_elements = remove_emptied_elements)
+      dup.deep_compact!(remove_emptied_elements, remove_empty_elements)
+    end
+  end
+
+  class Array < ::Array
+    include DeeplyEnumerable::ArrayExtension
+  end
+end

data/lib/deeply_enumerable/enumerable.rb

@@ -0,0 +1,41 @@
+module DeeplyEnumerable
+  module Enumerable
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def rebuild(object)
+        deeply_enumerable_class_name = DeeplyEnumerable.constants(false).detect do |const|
+          deeply_enumerable_const = DeeplyEnumerable.const_get(const)
+          deeply_enumerable_const.respond_to?(:superclass) ? !!object.is_a?(deeply_enumerable_const.superclass) : false
+        end
+
+        return object if deeply_enumerable_class_name.nil?
+
+        deeply_enumerable_class = DeeplyEnumerable.const_get(deeply_enumerable_class_name)
+        deeply_enumerable_class.respond_to?(:deep_rebuild) ? deeply_enumerable_class.deep_rebuild(object) : object
+      end
+
+      def deep_rebuild(object)
+        check_object_class(object)
+        new.tap { |deeply_enumerable_object| object.each { |value| deeply_enumerable_object.push(rebuild(value)) } }
+      end
+
+      def deep_compact(object, remove_emptied_elements = true, remove_empty_elements = remove_emptied_elements)
+        check_object_class(object)
+        deep_rebuild(object).deep_compact(remove_emptied_elements, remove_empty_elements)
+      end
+
+      private
+
+      def check_object_class(object)
+        raise TypeError, "object must be a #{superclass.name}" unless object.kind_of?(superclass)
+      end
+    end
+
+    def rebuild(object)
+      self.class.rebuild(object)
+    end
+  end
+end

data/lib/deeply_enumerable/hash.rb

@@ -0,0 +1,72 @@
+require_relative 'enumerable'
+
+module DeeplyEnumerable
+  module HashExtension
+    def self.included klass
+      klass.class_eval do
+        include DeeplyEnumerable::Enumerable
+      end
+    end
+
+    def reverse_deep_merge!(other_hash)
+      other_hash.each_pair do |current_key, other_value|
+        this_value = self[current_key]
+
+        self[current_key] = if this_value.is_a?(::Hash) && other_value.is_a?(::Hash)
+          this_value = ebuild(this_value) unless this_value.respond_to?(:reverse_deep_merge)
+          this_value.reverse_deep_merge(other_value)
+        else
+          key?(current_key) ? this_value : other_value
+        end
+      end
+
+      self
+    end
+    alias_method :deep_reverse_merge!, :reverse_deep_merge!
+
+    def reverse_deep_merge(other_hash)
+      dup.reverse_deep_merge!(other_hash)
+    end
+    alias_method :deep_reverse_merge, :reverse_deep_merge
+
+    def deep_compact!(remove_emptied_elements = true, remove_empty_elements = remove_emptied_elements)
+      each do |key, value|
+        value = rebuild(value) unless value.respond_to?(:reverse_deep_merge)
+        compact_method = %i[deep_compact! deep_compact compact! compact].detect{ |m| value.respond_to?(m) }
+        next unless compact_method
+
+        original_empty = value.respond_to?(:empty?) ? value.empty? : value.respond_to?(:none?) ? value.none? : false
+        compact_value = value.send(*[compact_method].concat(value.method(compact_method).parameters.collect { |_,param| binding.local_variable_get(param) } ).compact) || value
+        compact_empty = compact_value.respond_to?(:empty?) ? compact_value.empty? : compact_value.respond_to?(:none?) ? compact_value.none? : false
+
+        self[key] = (original_empty && remove_empty_elements) || (!original_empty && compact_empty && remove_emptied_elements) ? nil : compact_value
+      end
+      compact!
+
+      self
+    end
+
+    def deep_compact(remove_emptied_elements = true, remove_empty_elements = remove_emptied_elements)
+      dup.deep_compact!(remove_emptied_elements, remove_empty_elements)
+    end
+  end
+
+  class Hash < ::Hash
+    include DeeplyEnumerable::HashExtension
+
+    class << self
+      def deep_rebuild(object)
+        check_object_class(object)
+        new.tap { |deeply_enumerable_object| object.each { |key, value| deeply_enumerable_object[key] = rebuild(value) } }
+      end
+
+      def reverse_deep_merge(object)
+        check_object_class(object)
+        deep_rebuild(object).reverse_deep_merge
+      end
+      alias_method :deep_reverse_merge, :reverse_deep_merge
+    end
+  end
+end
+
+

data/lib/deeply_enumerable/version.rb

@@ -0,0 +1,3 @@
+module DeeplyEnumerable
+  VERSION = '0.9.0'
+end

data/lib/deeply_enumerable.rb

@@ -0,0 +1,2 @@
+require 'deeply_enumerable/array'
+require 'deeply_enumerable/hash'

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: deeply_enumerable
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- chaunce
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-10-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: recusrive support for enumerable operations
+email:
+- chaunce.slc@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/base_extensions.rb
+- lib/deeply_enumerable.rb
+- lib/deeply_enumerable/array.rb
+- lib/deeply_enumerable/enumerable.rb
+- lib/deeply_enumerable/hash.rb
+- lib/deeply_enumerable/version.rb
+homepage: https://github.com/chaunce/deeply_enumerable
+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.6.14
+signing_key: 
+specification_version: 4
+summary: recusrive support for enumerable operations
+test_files: []