iteraptor 0.5.2 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fc9af3898925670c691fd396f57a315f73ca71e5
-  data.tar.gz: 2a34471621ddb6cabfaa0f9c4c77af2feecef7de
+  metadata.gz: 51a190bd902813b3f2831501f2e2c8c8fd9cf555
+  data.tar.gz: fc10ba4bb1997340931716bea23d10dc8b8f0587
 SHA512:
-  metadata.gz: 3cdef9589e987494eb07b316cac128d196ebe087d60ccd483aaa39d38334f16ddc283a8bbd8a18b3c5305a045ff3b9ad163c0b358d6a062665fb8203d906c6cb
-  data.tar.gz: f656e2dcebaa9788a93eda98c8be6e05ff01decef8e25d284fb2aff810772be744622f2c036aa15141e2457f0f0296e80f94c89f7070c85dee5f76635e6484d9
+  metadata.gz: 7804c4da0e00f7077fca99af258e0bec1cfee7c4170926682492b8cda5d76192485bc3ee7e4d945dd55dced7e7ee77ba979a0cc608598333d6e7474450020876
+  data.tar.gz: 8afc7e6932c32412e97b1f95fe84d413a89dd4d9fdc174809e2a2cf7574c721434b5907b3a2186d1efeae51a1835a849668faa9ad01417650a9169561cc2d0af

data/README.md

@@ -190,7 +190,9 @@ Or install it yourself as:
 
 ## Changelog
 
-#### 0.4.0 `aplanar` and `plana_mapa`
+- **`0.6.0`** — experimental support for `full_parent: true` param
+- **`0.5.0`** — `rechazar` and `escoger`
+- **`0.4.0`** — `aplanar` and `plana_mapa`
 
 ## Development
 

data/lib/iteraptor/version.rb

@@ -1,3 +1,3 @@
 module Iteraptor
-  VERSION = '0.5.2'
+  VERSION = '0.6.0'
 end

data/lib/iteraptor.rb

@@ -14,7 +14,7 @@ module Iteraptor
       return enum_for(m, key, value, **params) unless λ
       return self if empty?
 
-      send_to = [Hash, Array, Enumerable].detect(&method(:is_a?))
+      send_to = enumerable_parent?
       send_to && send("#{m}_in_#{send_to.name.downcase}", key || self, value, **params, &λ)
     end
   end
@@ -36,6 +36,7 @@ module Iteraptor
   def aplanar **params
     return self if empty?
     cada(**params).with_object({}) do |(key, value), acc|
+      key = key.join(iteraptor_delimiter(params)) if params[:full_parent]
       key = key.to_sym if params[:symbolize_keys]
       acc[key] = value unless value.is_a?(Enumerable)
       yield key, value if block_given?
@@ -48,7 +49,7 @@ module Iteraptor
     aplanar(**params).each_with_object(
       Hash.new { |h, k| h[k] = h.clone.clear }
     ) do |(k, v), acc|
-      keys = k.to_s.split(params[:delimiter] || DELIMITER)
+      keys = k.to_s.split(iteraptor_delimiter(params))
       parent = keys[0..-2].reduce(acc){ |h, kk| h[kk] }
       parent[keys.last] = v
     end.mapa(yield_all: true, **params) do |_parent, (k, v)|
@@ -62,6 +63,7 @@ module Iteraptor
     return self if empty?
 
     cada(**params).with_object([]) do |(key, value), acc|
+      key = key.join(iteraptor_delimiter(params)) if params[:full_parent]
       key = key.to_sym if params[:symbolize_keys]
       acc << yield(key, value) unless value.is_a?(Enumerable)
     end
@@ -78,21 +80,21 @@ module Iteraptor
     end
   end
 
-  def cada_in_array root = nil, parent = nil, **params
-    λ = Proc.new
-    each.with_index do |e, idx|
-      [parent, idx].compact.join(params[:delimiter] || DELIMITER).tap do |p|
-        yield p, e
-        CADA_PROC.call(e, root, p, **params, &λ)
-      end
-    end
+  def cada_in_array root = nil, parent = nil, **params, &λ
+    cada_in_array_or_hash true, root, parent, **params, &λ
   end
   alias cada_in_enumerable cada_in_array
 
-  def cada_in_hash root = nil, parent = nil, **params
-    λ = Proc.new
-    each do |k, v|
-      [parent, k].compact.join(params[:delimiter] || DELIMITER).tap do |p|
+  def cada_in_hash root = nil, parent = nil, **params, &λ
+    cada_in_array_or_hash false, root, parent, **params, &λ
+  end
+
+  def cada_in_array_or_hash in_array, root = nil, parent = nil, **params, &λ
+    (in_array ? each_with_index : each).each do |k, v|
+      k, v = v, k if in_array
+      result = [parent, k].flatten.compact
+      result = result.join(iteraptor_delimiter(params)) unless params[:full_parent]
+      result.tap do |p|
         yield p, v
         CADA_PROC.call(v, root, p, **params, &λ)
       end
@@ -106,18 +108,26 @@ module Iteraptor
   #  - with_index
   #  - yield_all
   #  - symbolize_keys
-  def mapa_in_array root = nil, parent = nil, **params
-    λ = Proc.new
-
+  def mapa_in_array root = nil, parent = nil, **params, &λ
     map.with_index do |e, idx|
-      p = [parent, idx].compact.join(params[:delimiter] || DELIMITER)
-
-      e = yield p, (params[:with_index] ? [idx.to_s, e] : e) if !e.is_a?(Enumerable) || params[:yield_all]
-
-      case e
-      when Iteraptor then e.mapa(root, p, **params, &λ)
-      when Enumerable then e.map(&λ.curry[p])
-      else e
+      p = [parent, idx].flatten.compact
+      p = p.join(iteraptor_delimiter(params)) unless params[:full_parent]
+
+      yielded =
+        if !enumerable_parent?(e) || params[:yield_all]
+          yield p, (params[:with_index] ? [idx.to_s, e] : e)
+        else
+          e
+        end
+      # allow blindly return [k, v] instead of check for an array instance
+      #  when block arguments are matched as (k, v)
+      yielded = yielded.last || yielded.first if
+        yielded.is_a?(Array) && yielded.size == 2 && (yielded.last.nil? || yielded.first == e)
+
+      case yielded
+      when Iteraptor then yielded.mapa(root, p, **params, &λ)
+      when Enumerable then yielded.map(&λ.curry[p])
+      else yielded
       end
     end
   end
@@ -126,11 +136,10 @@ module Iteraptor
   # Params:
   #  - yield_all
   #  - symbolize_keys
-  def mapa_in_hash root = nil, parent = nil, **params
-    λ = Proc.new
-
+  def mapa_in_hash root = nil, parent = nil, **params, &λ
     map do |k, v|
-      p = [parent, k].compact.join(params[:delimiter] || DELIMITER)
+      p = [parent, k].flatten.compact
+      p = p.join(iteraptor_delimiter(params)) unless params[:full_parent]
 
       k, v = yield p, [k, v] if !v.is_a?(Enumerable) || params[:yield_all]
 
@@ -176,8 +185,8 @@ module Iteraptor
     raise ArgumentError, "no filter given in call to #{method ? :escoger : :rechazar}" if filter.empty?
 
     plough = method ? :none? : :any?
-    aplanar.each_with_object({}) do |(key, value), acc|
-      to_match = key.split(params[:delimiter] || DELIMITER)
+    aplanar(**params).each_with_object({}) do |(key, value), acc|
+      to_match = key.to_s.split(iteraptor_delimiter(params)) unless params[:full_parent]
       to_match = to_match.flat_map { |k| [k.to_s, k.to_s.to_sym] } if params[:soft_keys]
 
       next if filter.public_send(plough, &->(f){ to_match.any?(&f.method(:===)) })
@@ -189,6 +198,12 @@ module Iteraptor
 
   ##############################################################################
   ### helpers
+  def enumerable_parent?(receiver = self)
+    [Hash, Array, Enumerable].detect(&receiver.method(:is_a?))
+  end
+  def iteraptor_delimiter(params)
+    params[:delimiter] || DELIMITER
+  end
   def leaf? e
     [Iteraptor, Enumerable].none?(&e.method(:is_a?))
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iteraptor
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.6.0
 platform: ruby
 authors:
 - Aleksei Matiushkin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-29 00:00:00.000000000 Z
+date: 2018-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -127,7 +127,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: 'Iterator on steroids: allows thorough iteration through nested Enumerables'