nrser 0.0.26 → 0.0.27

data/spec/nrser/meta/props_spec.rb

@@ -16,7 +16,8 @@ describe NRSER::Meta::Props do
     
     let(:point_class) {
       Class.new(NRSER::Meta::Props::Base) do
-        # include NRSER::Meta::Props
+        # So that error messages look right
+        def self.name; 'Point'; end
         
         prop :x, type: t.int
         prop :y, type: t.int
@@ -137,7 +138,10 @@ describe NRSER::Meta::Props do
           ),
         },
         raising: {
-          [{x: 1, y: 'why?'}] => [TypeError, /must be of type `IntType`/],
+          [ {x: 1, y: 'why?'} ] => [
+            TypeError,
+            /Value of type String for prop Point\#y\s+failed type check/m
+          ],
         }
     end # .new
     

data/spec/nrser/refinements/erb_spec.rb

@@ -1,8 +1,13 @@
 require 'spec_helper'
-require 'nrser/refinements'
 
+require 'nrser/refinements'
 using NRSER
 
+require 'nrser/refinements/types'
+using NRSER::Types
+
+require 'nrser/meta/props'
+
 describe 'Binding#erb' do
   it "refines NRSER.erb into Binding" do
     expect(
@@ -25,6 +30,100 @@ describe 'Binding#erb' do
       x is 1
     BLOCK
   end
+  
+  
+  it "dedents before interpolating" do
+    dump = JSON.pretty_generate(
+      {
+        x: 1,
+      }
+    )
+    
+    expected = <<-END
+dump is:
+
+{
+  "x": 1
+}
+
+END
+    
+    expect(
+      binding.erb <<-END
+       dump is:
+       
+       <%= dump %>
+       
+      END
+    ).to eq expected
+  end
+  
+  
+  it "preserves indent" do
+    dump = JSON.pretty_generate(
+      {
+        x: 1,
+      }
+    )
+    
+    expected = <<-END
+dump is:
+
+    {
+      "x": 1
+    }
+
+END
+    
+    expect(
+      binding.erb %{
+        dump is:
+        
+            <%= dump %>
+        
+      }
+    ).to eq expected
+  end
+  
+  
+  it "works on a real-world example" do
+    ERBSpecTester = Class.new( NRSER::Meta::Props::Base ) do
+      prop :x, type: t.int, from_data: {hey: 'ho', lets: 'go!'}
+    end
+    
+    prop = ERBSpecTester.props[:x]
+    
+    error = begin
+      prop.value_from_data "I'M DATA!"
+    rescue TypeError => e
+      e
+    end
+    
+    expect( error.message ).
+      to eq <<-END
+Expected `@from_data` to be Symbol, String or Proc;
+found Hash.
+
+Acceptable types:
+
+-   Symbol or String
+    -   Name of class method on the class this property is defined in
+        (ERBSpecTester) to call with data to convert it to a
+        property value.
+        
+-   Proc
+    -   Procedure to call with data to convert it to a property value.
+
+Found `@from_data`:
+
+    {:hey=>"ho", :lets=>"go!"}
+    
+(type Hash)
+
+END
+    
+  end
+  
 
   it "handles edge cases" do
     expect( binding.erb '' ).to eq ''

data/spec/nrser/{common_prefix_spec.rb → string/common_prefix_spec.rb}

@@ -27,4 +27,13 @@ describe "NRSER.common_prefix" do
       BLOCK
     ).to eq "        "
   end
+  
+  it "finds indents in %-quoted strings" do
+    str = %|
+      hey
+      there
+    |.lines.reject( &NRSER.method( :whitespace? ) ).join
+    
+    expect( NRSER.common_prefix str.lines ).to eq '      '
+  end
 end # common_prefix

data/spec/nrser/text/dedent_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe_method "NRSER.dedent" do
+  subject { NRSER.method :dedent }
+  
+  let( :lines ) {
+    [
+      "def f x",
+      "  x * x",
+      "end",
+      ""
+    ]
+  }
+  
+  let( :joined ) {
+    lines.join("\n")
+  }
+  
+  it "removes indents" do
+    expect(
+      NRSER.dedent <<-BLOCK
+        def f x
+          x * x
+        end
+      BLOCK
+    ).to eq joined
+  end
+
+  it "ignores things it that aren't indented" do
+    expect( NRSER.dedent joined ).to eq joined
+  end
+
+  it "handles edge cases" do
+    expect( NRSER.dedent ''     ).to eq ''
+    expect( NRSER.dedent 'blah' ).to eq 'blah'
+  end
+  
+  
+  context "%-quoted multi-line string" do
+    
+    subject {
+      %|
+        def f x
+          x * x
+        end
+      |
+    }
+    
+    it {
+      is_expected.to eq [
+        "",
+        "        def f x",
+        "          x * x",
+        "        end",
+        "      ",
+      ].join( "\n" )
+    }
+    
+    describe "#lines" do
+      subject { super().lines }
+      it { is_expected.to eq [
+        "\n",
+        "        def f x\n",
+        "          x * x\n",
+        "        end\n",
+        "      ",
+      ] }
+    end # #lines
+    
+    
+    describe "dedent applied" do
+      subject { NRSER.dedent super() }
+      
+      it { is_expected.to eq "\n" + joined }
+    end # "dedent"
+    
+    
+  end # %-quoted multi-line strings
+  
+end

data/spec/nrser/tree/map_branch_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+require 'nrser/refinements'
+using NRSER
+
+describe "NRSER.map_branches" do
+# ========================================================================
+  
+  subject { NRSER.method :map_branches }
+  
+  context "called without a block" do
+  # ========================================================================
+    
+    it "raises an error" do
+      expect { subject.call [1, 2, 3] }.to raise_error ArgumentError
+    end
+    
+  end # called without a block
+  # ************************************************************************
+  
+  
+  context "called with a block" do
+  # ========================================================================
+    
+    context "called with arrays" do
+    # ========================================================================
+      
+      context_where tree: [1, 2, 3] do
+        context "square values" do
+          subject {
+            super().call( [1, 2, 3] ) { |index, value| [index, value * value] }
+          }
+          
+          it { is_expected.to eq [1, 4, 9] }
+        end # [1, 2, 3] => v * v
+      end # tree: [1, 2, 3]
+      
+      
+      context_where tree: [:a, :b] do
+        context "swap values (totally contrived example)" do
+          # Don't actually swap like this, but tests how I think it works
+          
+          subject {
+            super().call( tree) { |index, value|
+              [(index + 1) % 2, value]
+            }
+          }
+          
+          it { is_expected.to eq [:b, :a] }
+        end # [1, 2, 3] => v * v
+      end # tree: [:a, :b]
+      
+      
+    end # called with arrays
+    # ************************************************************************
+    
+    
+    context "called with hashes" do
+    # ========================================================================
+      
+      context_where tree: {x: 'ex', y: 'why?'} do
+        
+        describe "map keys to string #ord" do
+          subject {
+            super().call( tree ) { |key, value|
+              [key.to_s.ord, value]
+            }
+          }
+          
+          it { is_expected.to eq 120 => 'ex', 121 => 'why?' }
+        end
+        
+      end # tree: {x: 'ex', y: 'why?'}
+
+      
+    end # called with hashes
+    # ************************************************************************
+    
+  end # called with a block
+  # ************************************************************************
+  
+end # NRSER.map_branches
+# ************************************************************************

data/spec/nrser/tree/map_tree_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+require 'nrser/refinements'
+using NRSER
+
+describe_method "NRSER.map_tree" do
+# ========================================================================
+  
+  subject { NRSER.method :map_tree }
+  
+  describe_section "Simple Examples" do
+  # ========================================================================
+    
+    context_where(
+      tree: {
+        1 => {
+          name: 'Mr. Neil',
+          fav_color: 'blue',
+          age: 33,
+          likes: [:tacos, :cats],
+        },
+        
+        2 => {
+          name: 'Ms. Mica',
+          fav_color: 'red',
+          age: 32,
+          likes: [:cats, :cookies],
+        },
+      }
+    ) do
+      describe "Convert all Integers to Strings" do
+        
+        subject {
+          super().call( tree ) { |element|
+            if element.is_a? Integer
+              element.to_s
+            else
+              element
+            end
+          }
+        }
+        
+        it {
+          is_expected.to eq \
+            '1' => {
+              name: 'Mr. Neil',
+              fav_color: 'blue',
+              age: '33',
+              likes: [:tacos, :cats],
+            },
+            
+            '2' => {
+              name: 'Ms. Mica',
+              fav_color: 'red',
+              age: '32',
+              likes: [:cats, :cookies],
+            }
+        }
+        
+        
+      end # Convert all Integers to Strings
+    end # context where
+
+  end # section Simple Examples
+  # ************************************************************************
+  
+  
+  describe_section "pruning" do
+  # ========================================================================
+    
+  context_where(
+    tree: {
+      1 => {
+        name: 'Mr. Neil',
+        fav_color?: nil,
+        age: 33,
+        likes: [:tacos, :cats],
+      },
+      
+      2 => {
+        name: 'Ms. Mica',
+        fav_color?: 'red',
+        age: 32,
+        likes: [:cats, :cookies],
+      },
+    }
+  ) do
+    describe "Convert all Integers to Strings and prune" do
+      
+      subject {
+        super().call( tree, prune: true ) { |element|
+          if element.is_a? Integer
+            element.to_s
+          else
+            element
+          end
+        }
+      }
+      
+      it {
+        is_expected.to eq \
+          '1' => {
+            name: 'Mr. Neil',
+            age: '33',
+            likes: [:tacos, :cats],
+          },
+          
+          '2' => {
+            name: 'Ms. Mica',
+            fav_color: 'red',
+            age: '32',
+            likes: [:cats, :cookies],
+          }
+      }
+      
+    end # Convert all Integers to Strings
+  end # context where
+    
+  end # section pruning
+  # ************************************************************************
+  
+  
+end # NRSER.map_tree

data/spec/nrser/tree/transform_spec.rb

@@ -60,35 +60,32 @@ describe "NRSER.transform" do
       
     end # transform in key
     
-    # TODO  doesn't work yet... prob wants a general {NRSER#map_branches} or
-    #       something that converts the map result into a Hash only if the
-    #       tree was hash-like.
-    # 
-    # describe "arrays in tree" do
-    #   let :tree do
-    #     {
-    #       list: [
-    #         { name: :name.rtvr },
-    #         { age: :age.rtvr },
-    #       ]
-    #     }
-    #   end
-    #   
-    #   let :source do
-    #     {
-    #       name: 'Mr. Cat',
-    #       age: 2,
-    #     }
-    #   end
-    #   
-    #   it do
-    #     is_expected.to eq \
-    #       list: [
-    #         { name: 'Mr. Cat' },
-    #         { age: 2 },
-    #       ]
-    #   end
-    # end # arrays in tree
+    
+    describe "arrays in tree" do
+      let :tree do
+        {
+          list: [
+            { name: :name.rtvr },
+            { age: :age.rtvr },
+          ]
+        }
+      end
+      
+      let :source do
+        {
+          name: 'Mr. Cat',
+          age: 2,
+        }
+      end
+      
+      it do
+        is_expected.to eq \
+          list: [
+            { name: 'Mr. Cat' },
+            { age: 2 },
+          ]
+      end
+    end # arrays in tree
     
     
   end # section simple examples