nrser 0.0.26 → 0.0.27

data/lib/nrser/types.rb

@@ -24,6 +24,7 @@ require 'pp'
 # 
 require_relative './types/type'
 require_relative './types/is'
+require_relative './types/nil'
 require_relative './types/is_a'
 require_relative './types/where'
 require_relative './types/combinators'

data/lib/nrser/types/array.rb

@@ -30,6 +30,7 @@ module NRSER; end
 # =======================================================================
   
 module NRSER::Types
+  
   class ArrayType < IsA
     # Default value to split strings with in {#from_s} if the string provided
     # does is not recognized as an encoding format (as of writing, JSON is
@@ -51,6 +52,11 @@ module NRSER::Types
     end
     
     
+    def item_type
+      NRSER::Types.any
+    end
+    
+    
     # Called on an array of string items that have been split
     # from a single string by {#from_s} to convert each individual item before
     # {#check} is called on the value.
@@ -179,12 +185,17 @@ module NRSER::Types
   # 
   class << self
     
-    # array
+    # @!group Type Factory Functions
+    
+    # {NRSER::Types::ArrayType} / {NRSER::Types::ArrayOfType} factory function.
+    # 
+    # @param [Type | Object] item_type
+    #   Optional type of items.
     # 
     # @return [NRSER::Types::Type]
     # 
-    def array item_type = NRSER::NO_ARG, **options
-      if item_type == NRSER::NO_ARG
+    def array item_type = any, **options
+      if item_type == any
         if options.empty?
           ARRAY
         else
@@ -199,4 +210,5 @@ module NRSER::Types
     
   end # class << self (Eigenclass)
   
+  
 end # NRSER::Types

data/lib/nrser/types/is_a.rb

@@ -7,19 +7,58 @@ module NRSER::Types
     attr_reader :klass
     
     def initialize klass, **options
+      unless klass.is_a?( Class ) || klass.is_a?( Module )
+        raise ArgumentError.new binding.erb <<-ERB
+          `klass` argument must be a Class or Module, found:
+          
+              <%= klass.pretty_inspect %>
+          
+        ERB
+      end
+      
       super **options
       @klass = klass
     end
     
     def default_name
-      "#{ self.class.short_name }(#{ @klass })"
+      "#{ self.class.short_name }(#{ @klass.name })"
     end
     
     def test value
       value.is_a? @klass
     end
+    
+    
+    # If {#klass} responds to `#from_data`, call that and check results.
+    # 
+    # Otherwise, forward up to {NRSER::Types::Type#from_data}.
+    # 
+    # @param [Object] data
+    #   Data to create the value from that will satisfy the type.
+    # 
+    # @return [Object]
+    #   Instance of {#klass}.
+    # 
+    def from_data data
+      if @from_data.nil?
+        if @klass.respond_to? :from_data
+          check @klass.from_data( data )
+        else
+          super data
+        end
+      else
+        @from_data.call data
+      end
+    end
+    
+    
+    def has_from_data?
+      @from_data || @klass.respond_to?( :from_data )
+    end
+    
   end # IsA
   
+  
   # class membership
   def self.is_a klass, **options
     IsA.new klass, **options

data/lib/nrser/types/nil.rb

@@ -0,0 +1,17 @@
+require 'nrser/types/is'
+  
+module NRSER::Types
+
+  NIL_TYPE = is(
+    nil,
+    name: 'NilType',
+    # from_s: ->( s ) {
+    #   
+    # }
+  ).freeze
+  
+  # nothing
+  def self.nil
+    NIL_TYPE
+  end
+end # NRSER::Types

data/lib/nrser/types/paths.rb

@@ -45,7 +45,6 @@ module NRSER::Types
     where { |value| value.to_s.length > 0 },
     name: 'NonEmptyPathnameType'
   
-  
   PATH = union non_empty_str, NON_EMPTY_PATHNAME, name: 'Path'
   
   
@@ -53,9 +52,10 @@ module NRSER::Types
   # ========================================================================
   # 
   class << self
+    # @!group Type Factory Functions
     
     def pathname to_data: :to_s, **options
-      if options.empty?
+      if options.empty? && to_data == :to_s
         PATHNAME
       else
         is_a \
@@ -82,6 +82,19 @@ module NRSER::Types
     end # #path
     
     
+    def path_segment **options
+      if options.empty?
+        POSIX_PATH_SEGMENT
+      else
+        intersection  non_empty_str,
+                      where { |string| ! string.include?( '/' ) },
+                      name: 'POSIXPathSegment'
+      end
+    end
+    
+    alias_method :path_seg, :path_segment
+    
+    
     # An absolute {#path}.
     # 
     # @param **options see NRSER::Types::Type#initialize
@@ -139,5 +152,7 @@ module NRSER::Types
     
   end # class << self (Eigenclass)
   
+  POSIX_PATH_SEGMENT = path_segment name: 'POSIXPathSegment'
+  
 end # module NRSER::Types
 

data/lib/nrser/types/strings.rb

@@ -6,33 +6,68 @@ require 'nrser/types/attrs'
 using NRSER
   
 module NRSER::Types
-  def self.str length: nil, **options
-    if length.nil? && options.empty?
-      # if there are no options can point to the constant for efficiency
-      STR
-    else
-      if length.nil?
-        IsA.new String, from_s: ->(s) { s }, **options
+  
+  # Eigenclass (Singleton Class)
+  # ========================================================================
+  # 
+  class << self
+    # @!group Type Factory Functions
+    
+    def str length: nil, **options
+      if length.nil? && options.empty?
+        # if there are no options can point to the constant for efficiency
+        STR
       else
-        intersection \
-          IsA.new( String, from_s: ->(s) { s } ),
-          NRSER::Types.length( length ),
-          **options
+        if length.nil?
+          IsA.new String, from_s: ->(s) { s }, **options
+        else
+          intersection \
+            IsA.new( String, from_s: ->(s) { s } ),
+            NRSER::Types.length( length ),
+            **options
+        end
       end
+    end # string
+    
+    alias_method :string, :str
+    
+    
+    def empty_str
+      EMPTY_STR
     end
-  end # string
-  
-  singleton_class.send :alias_method, :string, :str
-  
-  STR = str( name: 'StrType' ).freeze
+    
+    
+    def non_empty_str **options
+      return NON_EMPTY_STR if options.empty?
+      
+      str( length: {min: 1}, **options )
+    end # .non_empty_str
+    
+    
+    private
+    # ========================================================================
+      
+      
+      # @todo Document make_string_type method.
+      # 
+      # @param [type] arg_name
+      #   @todo Add name param description.
+      # 
+      # @return [return_type]
+      #   @todo Document return value.
+      # 
+      def make_string_type length: nil, match: nil
+        # method body...
+      end # #make_string_type
+      
+      
+    # end private
+    
+  end # class << self (Eigenclass)
   
-  EMPTY_STR = Is.new( '' ).freeze
+  STR = str( name: 'StringType' ).freeze
   
-  def self.non_empty_str **options
-    return NON_EMPTY_STR if options.empty?
-    
-    str( length: {min: 1}, **options )
-  end # .non_empty_str
+  EMPTY_STR = str( name: 'EmptyStringType', length: 0 ).freeze
   
   NON_EMPTY_STR = non_empty_str( name: 'NonEmptyStr' ).freeze
   

data/lib/nrser/types/tuples.rb

@@ -50,6 +50,11 @@ module NRSER::Types
     end # #initialize
     
     
+    def default_name
+      '[' + @types.map( &:name ).join( ', ' ) + ']'
+    end
+    
+    
     # Instance Methods
     # ======================================================================
     

data/lib/nrser/types/type.rb

@@ -35,7 +35,7 @@ module NRSER::Types
     # @param [nil | #call | #to_proc] to_data:
     #   
     # 
-    def initialize name: nil, from_s: nil, to_data: nil
+    def initialize name: nil, from_s: nil, to_data: nil, from_data: nil
       @name = name
       @from_s = from_s
       
@@ -46,10 +46,37 @@ module NRSER::Types
       elsif to_data.respond_to?( :to_proc )
         to_data.to_proc
       else
-        raise TypeError.squished <<-END
-          `to_data:` keyword arg must be `nil`, respond to `:call` or respond
-          to `:to_proc`; found #{ to_data.inspect }
-        END
+        raise TypeError.new binding.erb <<-ERB
+          `to_data:` keyword arg must be `nil`, respond to `#call` or respond
+          to `#to_proc`.
+          
+          Found value:
+          
+              <%= to_data.pretty_inspect %>
+          
+          (type <%= to_data.class %>)
+          
+        ERB
+      end
+      
+      @from_data = if from_data.nil?
+        nil
+      elsif from_data.respond_to?( :call )
+        from_data
+      elsif from_data.respond_to?( :to_proc )
+        from_data.to_proc
+      else
+        raise TypeError.new binding.erb <<-ERB
+          `to_data:` keyword arg must be `nil`, respond to `#call` or respond
+          to `#to_proc`.
+          
+          Found value:
+          
+              <%= from_data.pretty_inspect %>
+          
+          (type <%= from_data.class %>)
+          
+        ERB
       end
     end # #initialize
     
@@ -152,6 +179,15 @@ module NRSER::Types
     end
     
     
+    def from_data data
+      if @from_data.nil?
+        raise NoMethodError, "#from_data not defined"
+      end
+      
+      check @from_data.call( data )
+    end
+    
+    
     # Test if the type knows how to load values from strings.
     # 
     # If this method returns `true`, then we expect {#from_s} to succeed.
@@ -176,6 +212,11 @@ module NRSER::Types
     end # #has_to_data?
     
     
+    def has_from_data?
+      ! @from_data.nil?
+    end
+    
+    
     # Dumps a value of this type to "data" - structures and values suitable
     # for transport and storage, such as dumping to JSON or YAML, etc.
     # 
@@ -186,7 +227,7 @@ module NRSER::Types
     #   The data representation of the value.
     # 
     def to_data value
-      if @from_s.nil?
+      if @to_data.nil?
         raise NoMethodError, "#to_data not defined"
       end
       

data/lib/nrser/version.rb

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

data/spec/nrser/errors/abstract_method_error_spec.rb

@@ -0,0 +1,46 @@
+
+module NRSER::TestFixtures::AbstractMethodError
+  
+  class Base
+    def f
+      raise NRSER::AbstractMethodError.new( self, __method__ )
+    end
+  end
+  
+  class Sub < Base; end
+  
+end # module NRSER::TestFixtures::AbstractMethodError
+
+
+describe_class NRSER::AbstractMethodError do
+  
+  context(
+    "when raising method is invoked through instance of defining class"
+  ) do
+    
+    it "explains that the instance's class is abstract" do
+      expect {
+        NRSER::TestFixtures::AbstractMethodError::Base.new.f
+      }.to raise_error(
+        NRSER::AbstractMethodError,
+        /Base is an abstract class/
+      )
+    end
+    
+  end # when raising method is invoked through instance of defining class
+  
+  context "when raising method is invoked through instance of a subclass" do
+    
+    it "explains that an implementing class needs to be found or written" do
+      expect {
+        NRSER::TestFixtures::AbstractMethodError::Sub.new.f
+      }.to raise_error(
+        NRSER::AbstractMethodError,
+        /find a subclass of .*Sub to instantiate or write your own/
+      )
+    end
+    
+  end # when raising method is invoked through instance of a subclass
+  
+  
+end # Class NRSER::AbstractMethodError Description

data/spec/nrser/meta/props/to_and_from_data_spec.rb

@@ -0,0 +1,74 @@
+require 'nrser/meta/props'
+
+require 'nrser/refinements'
+using NRSER
+
+require 'nrser/refinements/types'
+using NRSER::Types
+
+
+describe NRSER::Meta::Props do
+  
+  describe_section "to and from data" do
+  # ========================================================================
+    
+    before( :all ) {
+      @cat_class = Class.new( NRSER::Meta::Props::Base ) do
+        prop :name, type: t.non_empty_str
+        prop :breed, type: t.non_empty_str
+        prop :age, type: t.unsigned
+        
+        def self.name; 'Cat'; end
+      end
+    }
+    
+    describe_group "simple nesting" do
+      
+      before( :all ) {
+        # IMPORTANT!!!  must bind *outside* the class declaration; can't use
+        #               @cat_class in there because it resolves to a (nil)
+        #               instance variable of the new class.
+        cat_class = @cat_class
+        
+        @owner_class = Class.new( NRSER::Meta::Props::Base ) do
+          prop :name, type: t.non_empty_str
+          
+          prop :cat, type: cat_class
+          
+          def self.name; 'Owner'; end
+        end
+        
+        @cat = @cat_class.new name: "Hooty", breed: "American Shorthair", age: 2
+        
+        @owner = @owner_class.new name: "Neil", cat: @cat
+      }
+      
+      it "is setup correctly" do
+        expect( @cat_class ).to be_a Class
+        expect( @cat_class.is_a? ::Class ).to be true
+        expect( @cat_class.name ).to eq "Cat"
+        expect( t.make @cat_class ).to be_a NRSER::Types::IsA
+        
+        name_prop = @owner_class.props[:name]
+        expect( name_prop.type ).to be t.non_empty_str
+        
+        cat_prop = @owner_class.props[:cat]
+        expect( cat_prop.type ).to be_a NRSER::Types::IsA
+        expect( cat_prop.type.klass ).to be @cat_class
+        expect( @cat_class.respond_to? :from_data ).to be true
+        expect( cat_prop.type.has_from_data? ).to be true
+      end
+      
+      it "dumps to and loads from data" do
+        data = @owner.to_data        
+        restored = @owner_class.from_data data
+        expect( restored.to_data ).to eq data
+      end
+      
+    end # Group "simple nesting" Description
+    
+    
+  end # section to and from data
+  # ************************************************************************
+  
+end