nrser 0.0.30 → 0.1.0

data/lib/nrser/tree/map_leaves.rb

@@ -1,63 +0,0 @@
-module NRSER
-  
-  # Eigenclass (Singleton Class)
-  # ========================================================================
-  # 
-  class << self
-    
-    def map_leaves tree, &block
-      NRSER::Types.tree.check tree
-      
-      _internal_map_leaves tree, key_path: [], &block
-    end # #map_leaves
-    
-    private
-    # ========================================================================
-      
-      # Internal recursive implementation for {NRSER.leaves}.
-      # 
-      # @param [#each_pair | (#each_index & #each_with_index)] tree
-      #   Tree to walk.
-      # 
-      # @param [Array] path
-      #   Key path down to `tree`.
-      # 
-      # @param [Hash<Array, Object>] results
-      #   New hash to stick results in.
-      # 
-      # @return [nil]
-      # 
-      def _internal_map_leaves tree, key_path:, &block
-        NRSER::Types.match tree,
-          NRSER::Types.hash_like, ->( hash_like ) {
-            hash_like.map { |key, value|
-              new_key_path = [*key_path, key]
-              
-              new_value = if NRSER::Types.tree.test( value )
-                _internal_map_leaves value, key_path: new_key_path, &block
-              else
-                block.call new_key_path, value
-              end
-              
-              [key, new_value]
-            }.to_h
-          },
-          
-          NRSER::Types.array_like, ->( array_like ) {
-            array_like.each_with_index.map { |value, index|
-              new_key_path = [*key_path, index]
-              
-              if NRSER::Types.tree.test( value )
-                _internal_map_leaves value, key_path: new_key_path, &block
-              else
-                block.call new_key_path, value
-              end
-            }
-          }
-      end # #_internal_leaves
-      
-    # end private
-    
-  end # class << self (Eigenclass)
-  
-end # module NRSER

data/spec/nrser/enumerable_spec.rb

@@ -1,111 +0,0 @@
-require 'spec_helper'
-
-describe "NRSER Enumerable Methods" do
-  
-  describe NRSER.method(:find_bounded) do
-    
-    context "when just :length bounds arg is provided" do
-      it "returns found elements when length is correct" do
-        expect(
-          subject.([1, 2, 3], length: 1) { |i| i == 2 }
-        ).to eq [2]
-      end
-      
-      it "raises TypeError when length in incorrect" do
-        expect {
-          subject.([1, 2, 3], length: 2) { |i| i == 2 }
-        }.to raise_error TypeError
-      end
-    end # when just :length bounds arg is provided
-    
-    context "when just :min bounds arg is provided" do
-      it "returns found elements when min is correct" do
-        expect(
-          subject.([1, 2, 3], min: 1) { |i| i == 2 }
-        ).to eq [2]
-      end
-      
-      it "raises TypeError when min in incorrect" do
-        expect {
-          subject.([1, 2, 3], min: 2) { |i| i == 2 }
-        }.to raise_error TypeError
-      end
-    end # when just :min bounds arg is provided
-
-    context "when just :max bounds arg is provided" do
-      it "returns found elements when max is correct" do
-        expect(
-          subject.([1, 2, 3], max: 2) { |i| i >= 2 }
-        ).to eq [2, 3]
-      end
-      
-      it "raises TypeError when max in incorrect" do
-        expect {
-          subject.([1, 2, 3], max: 1) { |i| i >= 2 }
-        }.to raise_error TypeError
-      end
-    end # when just :max bounds arg is provided
-    
-    
-    context "when :min and :max bounds args are both provided" do
-      it "returns found elements when min and max are correct" do
-        expect(
-          subject.([1, 2, 3], min: 1, max: 2) { |i| i >= 2 }
-        ).to eq [2, 3]
-      end
-      
-      it "raises TypeError when min is incorrect" do
-        expect {
-          subject.([1, 2, 3], min: 1, max: 2) { |i| false }
-        }.to raise_error TypeError
-      end
-      
-      it "raises TypeError when max is incorrect" do
-        expect {
-          subject.([1, 2, 3], min: 1, max: 2) { |i| true }
-        }.to raise_error TypeError
-      end
-    end # when :min and :max bounds args are both provided
-    
-  end # NRSER.method(:find_bounded)
-  
-  
-  describe NRSER.method(:find_only) do
-    
-    it "returns the element when only one is found" do
-      expect(
-        subject.call [1, 2, 3] { |i| i == 2 }
-      ).to be 2
-    end
-    
-    it "raises TypeError when more than one element is found" do
-      expect {
-        subject.call [1, 2, 3] { |i| i >= 2 }
-      }.to raise_error TypeError
-    end
-    
-    it "raises TypeError when no elements are found" do
-      expect {
-        subject.call [1, 2, 3] { |i| false }
-      }.to raise_error TypeError
-    end
-    
-  end # NRSER.method(:find_only)
-  
-  
-  describe NRSER.method(:to_h_by) do
-    
-    context "Duplicate keys" do
-      it "raises NRSER::ConflictError" do
-        expect {
-          NRSER.to_h_by([1, 2, 3]) { |i| i % 2 }
-        }.to raise_error NRSER::ConflictError
-      end
-    end # Duplicate keys
-    
-    
-  end # NRSER.to_h_by
-  
-  
-end # NRSER Enumerable Methods
-