nrser 0.0.25 → 0.0.26

data/lib/nrser/types/symbols.rb

@@ -0,0 +1,39 @@
+require 'nrser/refinements'
+require 'nrser/types/is'
+require 'nrser/types/is_a'
+
+require 'nrser/refinements'
+using NRSER
+  
+module NRSER::Types
+
+  def self.sym **options
+    if options.empty?
+      # if there are no options can point to the constant for efficiency
+      SYM
+    else
+      IsA.new(
+        Symbol,
+        from_s: :to_sym.to_proc,
+        **options
+      )
+    end
+  end # sym
+  
+  singleton_class.send :alias_method, :symbol, :sym
+  
+  SYM = sym( name: 'SymType' ).freeze
+  
+  
+  def self.non_empty_sym **options
+    return NON_EMPTY_SYM if options.empty?
+    
+    intersection \
+      SYM,
+      attrs( {to_s: non_empty_str} ),
+      **options
+  end
+  
+  NON_EMPTY_SYM = non_empty_sym( name: 'NonEmptySym' ).freeze
+  
+end # NRSER::Types

data/lib/nrser/types/trees.rb

@@ -0,0 +1,93 @@
+# Requirements
+# =======================================================================
+
+# Stdlib
+# -----------------------------------------------------------------------
+
+# Deps
+# -----------------------------------------------------------------------
+
+# Project / Package
+# -----------------------------------------------------------------------
+require_relative './combinators'
+require_relative './responds'
+
+
+# Refinements
+# =======================================================================
+
+require 'nrser/refinements'
+using NRSER
+
+
+# Definitions
+# =======================================================================
+
+module NRSER::Types
+  
+  # @todo Document array_like method.
+  # 
+  # @param [type] arg_name
+  #   @todo Add name param description.
+  # 
+  # @return [return_type]
+  #   @todo Document return value.
+  # 
+  def self.array_like **options
+    if options.empty?
+      ARRAY_LIKE
+    else
+      intersection \
+        is_a( Enumerable ),
+        respond_to( :each_index ),
+        **options
+    end
+  end # .array_like
+  
+  ARRAY_LIKE = array_like( name: 'ArrayLikeType' ).freeze
+  
+  
+  # @todo Document hash_like method.
+  # 
+  # @param [type] arg_name
+  #   @todo Add name param description.
+  # 
+  # @return [return_type]
+  #   @todo Document return value.
+  # 
+  def self.hash_like **options
+    if options.empty?
+      HASH_LIKE
+    else
+      intersection \
+        is_a( Enumerable ),
+        respond_to( :each_pair ),
+        **options
+    end
+  end # .hash_like
+  
+  HASH_LIKE = hash_like( name: 'HashLikeType' ).freeze
+  
+  
+  # @todo Document tree method.
+  # 
+  # @param [type] arg_name
+  #   @todo Add name param description.
+  # 
+  # @return [return_type]
+  #   @todo Document return value.
+  # 
+  def self.tree **options
+    if options.empty?
+      TREE
+    else
+      union \
+        array_like,
+        hash_like,
+        **options
+    end
+  end # .tree
+  
+  TREE = tree( name: 'TreeType' ).freeze
+  
+end # module NRSER::Types

data/lib/nrser/types/tuples.rb

@@ -0,0 +1,116 @@
+# Requirements
+# =======================================================================
+
+# Stdlib
+# -----------------------------------------------------------------------
+
+# Deps
+# -----------------------------------------------------------------------
+
+# Project / Package
+# -----------------------------------------------------------------------
+
+
+# Refinements
+# =======================================================================
+
+require 'nrser/refinements'
+using NRSER
+
+
+# Definitions
+# =======================================================================
+
+module NRSER::Types
+  
+  # Tuple type - array of fixed length and types (though those could be
+  # {NRSER::Types::ANY}).
+  # 
+  class TupleType < NRSER::Types::ArrayType
+    
+    # Constants
+    # ======================================================================
+    
+    
+    # Class Methods
+    # ======================================================================
+    
+    
+    # Attributes
+    # ======================================================================
+    
+    
+    # Constructor
+    # ======================================================================
+    
+    # Instantiate a new `TupleType`.
+    def initialize *types, **options
+      super **options
+      @types = types.map &NRSER::Types.method(:make)
+    end # #initialize
+    
+    
+    # Instance Methods
+    # ======================================================================
+    
+    # @todo Document test method.
+    # 
+    # @param [type] arg_name
+    #   @todo Add name param description.
+    # 
+    # @return [return_type]
+    #   @todo Document return value.
+    # 
+    def test value
+      # Test the super class first
+      return false unless super( value )
+      
+      # If it's not the right length then it doesn't pass
+      return false unless value.length == @types.length
+      
+      # Test each item type
+      @types.each_with_index.all? { |type, index|
+        type.test value[index]
+      }
+    end # #test
+    
+    
+    # @return [Boolean]
+    #   `true` if this type can load values from a string, which is true if
+    #   *all* it's types can load values from strings.
+    # 
+    def has_from_s?
+      @types.all? &:has_from_s?
+    end # #has_from_s?
+    
+    
+    # Load each value in an array of strings split out by
+    # {NRSER::Types::ArrayType#from_s} by passing each value to `#from_s` in
+    # the type of the corresponding index.
+    # 
+    # @param [Array<String>] strings
+    # 
+    # @return [Array]
+    # 
+    def items_from_strings strings
+      @types.each_with_index.map { |type, index|
+        type.from_s strings[index]
+      }
+    end
+    
+  end # class TupleType
+  
+
+  # @todo Document tuple method.
+  # 
+  # @param [type] arg_name
+  #   @todo Add name param description.
+  # 
+  # @return [return_type]
+  #   @todo Document return value.
+  # 
+  def self.tuple *types, **options
+    TupleType.new *types, **options
+  end # .tuple
+  
+end # module NRSER::Types

data/lib/nrser/types/type.rb

@@ -194,12 +194,36 @@ module NRSER::Types
     end # #to_data
     
     
+    # Language Inter-Op
+    # =====================================================================
+    
+    
     # @return [String]
-    #   a brief string description of the type.
+    #   a brief string description of the type - just it's {#name} surrounded
+    #   by some back-ticks to make it easy to see where it starts and stops.
     # 
     def to_s
-      "`Type: #{ name }`"
+      "`#{ name }`"
     end
     
+    
+    # Inspecting
+    # ---------------------------------------------------------------------
+    # 
+    # Due to their combinatoric nature, types can quickly become large data
+    # hierarchies, and the built-in {#inspect} will produce a massive dump
+    # that's distracting and hard to decipher.
+    # 
+    # {#inspect} is readily used in tools like `pry` and `rspec`, significantly
+    # impacting their usefulness when working with types.
+    # 
+    # As a solution, we alias the built-in `#inspect` as {#builtin_inspect},
+    # so it's available in situations where you really want all those gory
+    # details, and point {#inspect} to {#to_s}.
+    # 
+    
+    alias_method :builtin_inspect, :inspect
+    alias_method :inspect, :to_s
+    
   end # Type
 end # NRSER::Types

data/lib/nrser/version.rb

@@ -1,5 +1,5 @@
 module NRSER
-  VERSION = "0.0.25"
+  VERSION = "0.0.26"
   
   module Version
     

data/spec/nrser/hash/{guess_name_type_spec.rb → guess_label_key_type_spec.rb}

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe "NRSER.guess_name_type" do
-  subject { NRSER.method :guess_name_type }
+describe "NRSER.guess_label_key_type" do
+  subject { NRSER.method :guess_label_key_type }
   
   it "can't guess about an empty hash" do
     expect( subject.call( {} ) ).to be nil
@@ -44,4 +44,4 @@ describe "NRSER.guess_name_type" do
     ).to be nil
   end
   
-end # NRSER.guess_name_type
+end # NRSER.guess_label_key_type

data/spec/nrser/hash_spec.rb

@@ -5,26 +5,6 @@ require 'spec_helper'
 
 using NRSER
 
-describe NRSER.method(:leaves) do
-  it do
-    expect(NRSER.leaves({a: 1, b: 2})).to eq ({[:a] => 1, [:b] => 2})
-    expect(
-      NRSER.leaves({
-        a: {
-          x: 'ex',
-          y: {
-            z: 'zee'
-          }
-        },
-        b: 'bee',
-      })
-    ).to eq({
-      [:a, :x] => 'ex',
-      [:a, :y, :z] => 'zee',
-      [:b] => 'bee',
-    })
-  end
-end # NRSER.leaves
 
 describe NRSER.method(:map_values) do
   

data/spec/nrser/merge_by_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+require 'nrser/refinements'
+using NRSER
+
+
+# NRSER.merge_by
+# ========================================================================
+# 
+describe "NRSER.merge_by" do
+  subject { NRSER.method :merge_by }
+  
+  context "line items example" do
+    let( :current ) {
+      [
+        {
+          line_item_id: 123,
+          item_id: 1,
+          quantity: 1,
+        },
+        
+        {
+          line_item_id: 456,
+          item_id: 2,
+          quantity: 4,
+        },
+      ]
+    }
+    
+    let( :update ) {
+      [
+        {
+          item_id: 1,
+          quantity: 4,
+        },
+        
+        {
+          item_id: 3,
+          quantity: 1,
+        }
+      ]
+    }
+    
+    subject {
+      super().call current, update, &[:item_id].digger
+    }
+    
+    it {
+      is_expected.to include(
+        {
+          line_item_id: 123,
+          item_id: 1,
+          quantity: 4,
+        },
+        
+        {
+          line_item_id: 456,
+          item_id: 2,
+          quantity: 4,
+        },
+        
+        {
+          item_id: 3,
+          quantity: 1,
+        }
+      )
+    }
+    
+  end # line items example
+  
+end # NRSER.merge_by
+
+# ************************************************************************

data/spec/nrser/meta/props_spec.rb

@@ -1,67 +1,160 @@
 require 'spec_helper'
 
+require 'nrser/refinements'
+using NRSER
+
+require 'nrser/refinements/types'
 using NRSER::Types
 
+
 describe NRSER::Meta::Props do
   
-  # Setup
-  # =====================================================================
-  
-  let(:point) {
-    Class.new(NRSER::Meta::Props::Base) do
-      # include NRSER::Meta::Props
-      
-      prop :x, type: t.int
-      prop :y, type: t.int
-      prop :blah, type: t.str, source: :blah
-      
-      def blah
-        "blah!"
+  context "simple Point class" do
+    
+    # Setup
+    # =====================================================================
+    
+    let(:point_class) {
+      Class.new(NRSER::Meta::Props::Base) do
+        # include NRSER::Meta::Props
+        
+        prop :x, type: t.int
+        prop :y, type: t.int
+        prop :blah, type: t.str, source: :blah
+        
+        def blah
+          "blah!"
+        end
       end
-    end
-  }
-  
-  it "has the props" do
-    props = point.props
+    }
     
-    expect(props).to be_a Hash
     
-    [:x, :y, :blah].each do |name|
-      expect(props[name]).to be_a NRSER::Meta::Props::Prop
-    end
+    describe ".props" do
+    # ========================================================================
+      
+      subject { point_class.props }
+      
+      it {
+        is_expected.to be_a( Hash ).and have_attributes \
+          keys: eq( [:x, :y, :blah] ),
+          values: all( be_a NRSER::Meta::Props::Prop )
+      }
+      
+      describe 'primary props `x` and `y`' do
+        [:x, :y].each do |name|
+          describe "prop `#{ name }`" do
+            subject { super()[name] }
+            
+            include_examples "expect subject", to: {
+              be_a: NRSER::Meta::Props::Prop,
+              have_attributes: {
+                source?: false,
+                primary?: true,
+              }
+            }
+          end
+        end
+      end # primary props `x` and `y`'
+      
+      describe "derived (sourced) prop `blah`" do        
+        subject { super()[:blah] }
+        
+        include_examples "expect subject", to: {
+          be_a: NRSER::Meta::Props::Prop,
+          have_attributes: {
+            source?: true,
+            primary?: false,
+          }
+        }
+      end # derived (sourced) prop :blah
+      
+    end # .props
+    
+    # ************************************************************************
     
-    [:x, :y].each do |name|
-      expect(props[name].source?).to be false
-      expect(props[name].primary?).to be true
-    end
     
-    expect(props[:blah].source?).to be true
-    expect(props[:blah].primary?).to be false
+    describe ".props only_primary: true" do
+    # ========================================================================
+      
+      subject { point_class.props only_primary: true }
+      
+      it {
+        is_expected.to be_a( Hash ).
+          and have_attributes(
+            keys: eq( [:x, :y] ),
+            values: all(
+              be_a( NRSER::Meta::Props::Prop ).
+                and have_attributes source?: false, primary?: true
+            )
+          )
+      }
+      
+    end # .props only_primary: true
     
-    primary_props = point.props only_primary: true
+    # ************************************************************************
     
-    expect(primary_props.key? :blah).to be false
+    describe "Point instance where x=1 and y=2 (default blah)" do
+    # ========================================================================
+      
+      subject { point_class.new x: 1, y: 2 }
+      
+      it { is_expected.to have_attributes x: 1, y: 2, blah: "blah!" }
+      
+      describe "#to_h" do
+        subject { super().to_h }
+        it { is_expected.to eq x: 1, y: 2, blah: 'blah!' }
+      end
+      
+      describe "#to_h only_primary: true" do
+        subject { super().to_h only_primary: true }
+        it { is_expected.to eq x: 1, y: 2 }
+      end
+      
+      # ************************************************************************
+      
+    end # Point instance where x=1 and y=2 (default blah)
     
-    p = point.new x: 1, y: 2
+    # ************************************************************************
     
-    expect(p.x).to be 1
-    expect(p.y).to be 2
     
-    expect(p.to_h).to eq({x: 1, y: 2, blah: "blah!"})
-    expect(p.to_h(only_primary: true)).to eq({x: 1, y: 2})
+    describe "bad constructor args" do
+    # ========================================================================
+      
+      it "rejects string `y: 'why?'` value" do
+        expect { point_class.new x: 1, y: 'why?' }.to raise_error TypeError
+      end
+      
+    end # bad constructor args
     
-    expect { point.new x: 1, y: 'why?' }.to raise_error TypeError
-    expect { p.x = 3 }.to raise_error NoMethodError
     
-    p_hash = p.to_h
+    describe ".new" do
+      subject { point_class.method :new }
+      
+      it_behaves_like "function",
+        mapping: {
+          [{x: 1, y: 2}] => NRSER::Message.new(
+            :have_attributes, x: 1, y: 2, blah: 'blah!'
+          ),
+        },
+        raising: {
+          [{x: 1, y: 'why?'}] => [TypeError, /must be of type `IntType`/],
+        }
+    end # .new
     
-    p2 = point.new p_hash
     
-    expect(p2.x).to be 1
-    expect(p2.y).to be 2
+    describe "dump / load cycle" do
+      context "Point with x=1, y=2" do
+        let( :point ) { point_class.new x: 1, y: 2 }
+        let( :point_hash ) { point.to_h }
+        
+        describe "new Point from old point's #to_h" do
+          subject { point_class.new point_hash }
+          it { is_expected.to have_attributes x: 1, y: 2, blah: 'blah!' }
+        end # new Point from old point's #to_h
+      end
+    end # dump / load cycle
     
-    expect(p2.to_h).to eq({x: 1, y: 2, blah: "blah!"})
-  end
+  end # simple Point class
   
 end # NRSER::Meta::Props