iteraptor 0.5.1 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bfa0333669ac2722234680072c6e4c062c4d66d4
-  data.tar.gz: 193f191b05f778f547627c4b9560d305ef1144f5
+  metadata.gz: fc9af3898925670c691fd396f57a315f73ca71e5
+  data.tar.gz: 2a34471621ddb6cabfaa0f9c4c77af2feecef7de
 SHA512:
-  metadata.gz: d7f4dfab10985de98764a59417c64224b7a21462589e03e4fbeec31460b5b0ec8c03cf611838434f819c881782c0a3f8d180f5b82da5a78820aeae692aa9b1ed
-  data.tar.gz: b64575c124d45e50378c3c33c3a323cd4d3a29e532fecaf4420064ebdb8bec6d3fbfef4f2eae00238f32065dffb8502ae64d3f141c2cefb827ee5b7d10de4fbe
+  metadata.gz: 3cdef9589e987494eb07b316cac128d196ebe087d60ccd483aaa39d38334f16ddc283a8bbd8a18b3c5305a045ff3b9ad163c0b358d6a062665fb8203d906c6cb
+  data.tar.gz: f656e2dcebaa9788a93eda98c8be6e05ff01decef8e25d284fb2aff810772be744622f2c036aa15141e2457f0f0296e80f94c89f7070c85dee5f76635e6484d9

data/README.md

@@ -44,6 +44,50 @@ the nested structure out of flattened hash
 and collect elelements
 * `rechazar` (_sp._ `reject`) allows to filter out and collect elelements.
 
+### Words are cheap, show me the code
+
+```ruby
+▶ require 'iteraptor'
+#⇒ true
+
+▶ hash = {company: {name: "Me", currencies: ["A", "B", "C"],
+▷         password: "12345678",
+▷         details: {another_password: "QWERTYUI"}}}
+#⇒ {:company=>{:name=>"Me", :currencies=>["A", "B", "C"],
+#              :password=>"12345678",
+#              :details=>{:another_password=>"QWERTYUI"}}}
+
+▶ hash.segar(/password/i) { "*" * 8 }
+#⇒ {"company"=>{"password"=>"********",
+#   "details"=>{"another_password"=>"********"}}}
+
+▶ hash.segar(/password/i) { |*args| puts args.inspect }
+["company.password", "12345678"]
+["company.details.another_password", "QWERTYUI"]
+#⇒ {"company"=>{"password"=>nil, "details"=>{"another_password"=>nil}}}
+
+▶ hash.rechazar(/password/)
+#⇒ {"company"=>{"name"=>"Me", "currencies"=>["A", "B", "C"]}}
+
+▶ hash.aplanar
+#⇒ {"company.name"=>"Me",
+#   "company.currencies.0"=>"A",
+#   "company.currencies.1"=>"B",
+#   "company.currencies.2"=>"C",
+#   "company.password"=>"12345678",
+#   "company.details.another_password"=>"QWERTYUI"}
+
+▶ hash.aplanar.recoger
+#⇒ {"company"=>{"name"=>"Me", "currencies"=>["A", "B", "C"],
+#   "password"=>"12345678",
+#   "details"=>{"another_password"=>"QWERTYUI"}}}
+
+▶ hash.aplanar.recoger(symbolize_keys: true)
+#⇒ {:company=>{:name=>"Me", :currencies=>["A", "B", "C"],
+#   :password=>"12345678",
+#   :details=>{:another_password=>"QWERTYUI"}}}
+```
+
 ### Iteration
 
 `Iteraptor#cada` iterates all the `Enumerable` elements, recursively. As it meets

data/lib/iteraptor/version.rb

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

data/lib/iteraptor.rb

@@ -10,12 +10,12 @@ module Iteraptor
   end
 
   %i[cada mapa].each do |m|
-    define_method m do |root = nil, parent = nil, **params, &λ|
-      return enum_for(m, root, parent, **params) unless λ
+    define_method m do |key = nil, value = nil, **params, &λ|
+      return enum_for(m, key, value, **params) unless λ
       return self if empty?
 
       send_to = [Hash, Array, Enumerable].detect(&method(:is_a?))
-      send_to && send("#{m}_in_#{send_to.name.downcase}", root || self, parent, **params, &λ)
+      send_to && send("#{m}_in_#{send_to.name.downcase}", key || self, value, **params, &λ)
     end
   end
 
@@ -33,23 +33,22 @@ module Iteraptor
   alias_method :segar, :escoger
   # rubocop:enable Style/Alias
 
-  def aplanar delimiter: DELIMITER, **params
+  def aplanar **params
     return self if empty?
-    cada.with_object({}) do |(parent, element), acc|
-      key = parent.tr(DELIMITER, delimiter)
+    cada(**params).with_object({}) do |(key, value), acc|
       key = key.to_sym if params[:symbolize_keys]
-      acc[key] = element unless element.is_a?(Enumerable)
-      yield key, element if block_given?
+      acc[key] = value unless value.is_a?(Enumerable)
+      yield key, value if block_given?
     end
   end
 
-  def recoger delimiter: DELIMITER, **params
+  def recoger **params
     return self if empty?
     # rubocop:disable Style/MultilineBlockChain
-    aplanar.each_with_object(
+    aplanar(**params).each_with_object(
       Hash.new { |h, k| h[k] = h.clone.clear }
     ) do |(k, v), acc|
-      keys = k.split(delimiter)
+      keys = k.to_s.split(params[:delimiter] || DELIMITER)
       parent = keys[0..-2].reduce(acc){ |h, kk| h[kk] }
       parent[keys.last] = v
     end.mapa(yield_all: true, **params) do |_parent, (k, v)|
@@ -58,14 +57,13 @@ module Iteraptor
     # rubocop:enable Style/MultilineBlockChain
   end
 
-  def plana_mapa delimiter: DELIMITER, **params
-    return enum_for(:plana_mapa, delimiter: delimiter, **params) unless block_given?
+  def plana_mapa **params
+    return enum_for(:plana_mapa, delimiter: params[:delimiter], **params) unless block_given?
     return self if empty?
 
-    cada.with_object([]) do |(parent, element), acc|
-      key = parent.tr(DELIMITER, delimiter)
+    cada(**params).with_object([]) do |(key, value), acc|
       key = key.to_sym if params[:symbolize_keys]
-      acc << yield(key, element) unless element.is_a?(Enumerable)
+      acc << yield(key, value) unless value.is_a?(Enumerable)
     end
   end
 
@@ -73,30 +71,30 @@ module Iteraptor
 
   ##############################################################################
   ### cada
-  CADA_PROC = lambda do |e, root, p, &λ|
+  CADA_PROC = lambda do |e, root, p, **params, &λ|
     case e
-    when Iteraptor then e.cada(root, p, &λ)
+    when Iteraptor then e.cada(root, p, **params, &λ)
     when Enumerable then e.each(&λ.curry[p])
     end
   end
 
-  def cada_in_array root = nil, parent = nil, **_
+  def cada_in_array root = nil, parent = nil, **params
     λ = Proc.new
     each.with_index do |e, idx|
-      [parent, idx].compact.join(DELIMITER).tap do |p|
+      [parent, idx].compact.join(params[:delimiter] || DELIMITER).tap do |p|
         yield p, e
-        CADA_PROC.call(e, root, p, &λ)
+        CADA_PROC.call(e, root, p, **params, &λ)
       end
     end
   end
   alias cada_in_enumerable cada_in_array
 
-  def cada_in_hash root = nil, parent = nil, **_
+  def cada_in_hash root = nil, parent = nil, **params
     λ = Proc.new
     each do |k, v|
-      [parent, k].compact.join(DELIMITER).tap do |p|
+      [parent, k].compact.join(params[:delimiter] || DELIMITER).tap do |p|
         yield p, v
-        CADA_PROC.call(v, root, p, &λ)
+        CADA_PROC.call(v, root, p, **params, &λ)
       end
     end
   end
@@ -112,7 +110,7 @@ module Iteraptor
     λ = Proc.new
 
     map.with_index do |e, idx|
-      p = [parent, idx].compact.join(DELIMITER)
+      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]
 
@@ -132,7 +130,7 @@ module Iteraptor
     λ = Proc.new
 
     map do |k, v|
-      p = [parent, k].compact.join(DELIMITER)
+      p = [parent, k].compact.join(params[:delimiter] || DELIMITER)
 
       k, v = yield p, [k, v] if !v.is_a?(Enumerable) || params[:yield_all]
 
@@ -179,7 +177,7 @@ module Iteraptor
 
     plough = method ? :none? : :any?
     aplanar.each_with_object({}) do |(key, value), acc|
-      to_match = key.split(DELIMITER)
+      to_match = key.split(params[:delimiter] || DELIMITER)
       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(:===)) })

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: iteraptor
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.2
 platform: ruby
 authors:
 - Aleksei Matiushkin