nrser 0.2.2 → 0.3.0

data/lib/nrser/types/{array.rb → arrays.rb}

@@ -1,29 +1,13 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 # Requirements
 # =======================================================================
 
-# Stdlib
-# -----------------------------------------------------------------------
-
-# Deps
-# -----------------------------------------------------------------------
-
 # Project / Package
 # -----------------------------------------------------------------------
-require 'nrser/types/type'
-require 'nrser/types/is_a'
-
-
-# Refinements
-# =======================================================================
-
-require 'nrser/refinements'
-using NRSER
 
-
-# Declarations
-# =======================================================================
-
-module NRSER; end
+require_relative './is_a'
 
 
 # Definitions
@@ -36,25 +20,16 @@ module NRSER::Types
     # does is not recognized as an encoding format (as of writing, JSON is
     # the only format we attempt to detect).
     # 
-    # Splits 
+    # Splits
     DEFAULT_SPLIT_WITH = /\,\s*/m
     
-    attr_reader :item_type
-    
     def initialize split_with: DEFAULT_SPLIT_WITH, **options
       super ::Array, **options
       @split_with = split_with
     end
     
     
-    def default_name
-      self.class.short_name
-    end
-    
-    
-    def item_type
-      NRSER::Types.any
-    end
+    def item_type; NRSER::Types.any; end
     
     
     # Called on an array of string items that have been split
@@ -73,40 +48,29 @@ module NRSER::Types
     end
     
     
-    def from_s s
-      # Use custom {@from_s} if we have one.
-      return check( @from_s.call s ) unless @from_s.nil?
-      
+    def custom_from_s string
       # Does it looks like a JSON array?
-      if NRSER.looks_like_json_array? s
+      if NRSER.looks_like_json_array? string
         # It does! Load it
         begin
-          array = JSON.load( s )
+          return JSON.load( string )
         rescue
           # pass - if we failed to load as JSON, it may just not be JSON, and
           # we can try the split approach below.
-        else
-          # Check value and return. If we fail the check here let the error
-          # bubble up
-          return check array
         end
       end
       
       # Split it with the splitter and check that
-      check items_from_strings( s.split( @split_with ) )
+      items_from_strings( string.split( @split_with ) )
     end
     
   end # ArrayType
   
   
-  # Static instance that is satisfied by anything that is an {Array}.
-  ARRAY = ArrayType.new.freeze
-  
-  
   # Type for arrays where every entry satisfies a specific type.
   # 
   # Broken out from {ArrayType} so that {TupleType} can inherit from
-  # {ArrayType} and get share it's string handling functionality without 
+  # {ArrayType} and get share it's string handling functionality without
   # receiving the entry type stuff (which it handles differently).
   # 
   class ArrayOfType < ArrayType
@@ -135,12 +99,12 @@ module NRSER::Types
     # Instance Methods
     # ======================================================================
     
-    def default_name
-      "#{ super() }<#{ @item_type }>"
+    def explain
+      "#{ super() }<#{ item_type.explain }>"
     end
     
     
-    def test value
+    def test? value
       # Check the super method first, which will test if `value` is an Array
       # instance, and return `false` if it's not.
       return false unless super( value )
@@ -156,7 +120,7 @@ module NRSER::Types
     # @return [Boolean]
     # 
     def has_from_s?
-      @item_type.has_from_s?
+      @from_s || @item_type.has_from_s?
     end
     
     
@@ -168,7 +132,7 @@ module NRSER::Types
     # @todo
     #   I'm not even sure why this is implemented... was it used somewhere?
     #   
-    #   It doesn't seems too well thought out... seems like the reality of 
+    #   It doesn't seems too well thought out... seems like the reality of
     #   comparing types is much more complicated?
     # 
     def == other
@@ -180,35 +144,22 @@ module NRSER::Types
   end # class ArrayOfType
   
   
-  # Eigenclass (Singleton Class)
-  # ========================================================================
+  # {NRSER::Types::ArrayType} / {NRSER::Types::ArrayOfType} factory function.
   # 
-  class << self
-    
-    # @!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 = any, **options
-      if item_type == any
-        if options.empty?
-          ARRAY
-        else
-          ArrayType.new **options
-        end
-      else
-        ArrayOfType.new item_type, **options
-      end
-    end # #array
-    
-    alias_method :list, :array
-    
-  end # class << self (Eigenclass)
-  
+  # @param [Type | Object] item_type
+  #   Optional type of items.
+  # 
+  # @return [NRSER::Types::Type]
+  # 
+  def_factory(
+    :array,
+    aliases: [:list],
+  ) do |item_type = any, **options|
+    if item_type == any
+      ArrayType.new **options
+    else
+      ArrayOfType.new item_type, **options
+    end
+  end # #array
   
 end # NRSER::Types

data/lib/nrser/types/attrs.rb

@@ -1,11 +1,37 @@
-require 'nrser/refinements'
-require 'nrser/types/type'
-require 'nrser/types/combinators'
+# encoding: UTF-8
+# frozen_string_literal: true
 
-using NRSER
+
+# Requirements
+# ========================================================================
+
+# Project / Package
+# ------------------------------------------------------------------------
+
+require 'nrser/core_ext/hash'
+
+require_relative './type'
+require_relative './combinators'
+require_relative './is'
+
+
+# Definitions
+# ========================================================================
   
 module NRSER::Types
-  class Attrs < NRSER::Types::Type
+  
+  # Specify types for value attributes.
+  # 
+  class AttrsType < NRSER::Types::Type
+    
+    # Construct an `AttrsType`.
+    # 
+    # @param [Hash<Symbol, TYPE>] attrs
+    #   Map of attribute names to their types (`TYPE` values will be passed
+    #   through {NRSER::Types.make} to get a type instance).
+    #   
+    #   May not be empty.
+    # 
     def initialize attrs, **options
       super **options
       
@@ -14,12 +40,15 @@ module NRSER::Types
           "Must provide at least one attribute name/type pair"
       end
       
-      @attrs = NRSER.map_values(attrs) { |name, type|
-        NRSER::Types.make type
-      }
+      @attrs = attrs.transform_values &NRSER::Types.maker
     end
     
-    def default_name
+    
+    # @see NRSER::Types::Type#explain
+    # 
+    # @return [String]
+    # 
+    def explain
       attrs_str = @attrs.map { |name, type|
         "##{ name }#{ RESPONDS_WITH }#{ type.name }"
       }.join(', ')
@@ -31,12 +60,19 @@ module NRSER::Types
       end
     end
     
-    def test value
+    
+    # @see NRSER::Types::Type#test
+    # 
+    # @return [Boolean]
+    # 
+    def test? value
       @attrs.all? { |name, type|
-        value.respond_to?(name) && type.test(value.method(name).call)
+        value.respond_to?( name ) &&
+          type.test?( value.method( name ).call )
       }
     end
-  end # Attrs
+    
+  end # AttrsType
   
   
   # @!group Type Factory Functions
@@ -46,8 +82,20 @@ module NRSER::Types
   # @example Type where first element of an Enumerable is a String
   #   string_first = intersection Enumerable, attrs(first: String)
   # 
-  def_factory :attrs do |attrs, **options|
-    Attrs.new attrs, **options
+  def_factory :attrs do |*args|
+    case args.length
+    when 0
+      raise NRSER::ArgumentError.new \
+        "requires at least one argument"
+    when 1
+      attrs = args[0]
+      options = {}
+    when 2
+      attrs = args[0]
+      options = args[1]
+    end
+    
+    AttrsType.new attrs, **options
   end
   
   
@@ -114,11 +162,16 @@ module NRSER::Types
     case args[0]
     when ::Integer
       # It's just a length
+      return attrs(
+        { length: is( non_neg_int.check!( args[0] ) ) },
+        **options
+      )
+      
       bounds[:min] = bounds[:max] = non_neg_int.check args[0]
       
     when ::Hash
       # It's keyword args
-      kwds = NRSER.symbolize_keys args[0]
+      kwds = args[0].sym_keys
       
       # Pull any :min and :max in the keywords
       bounds[:min] = kwds.delete :min

data/lib/nrser/types/booleans.rb

@@ -1,47 +1,108 @@
-require 'nrser/refinements'
-require 'nrser/types/type'
-require 'nrser/types/is'
-require 'nrser/types/combinators'
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Need truthy and falsy parse values
+require 'nrser/functions/object/truthy'
+
+require_relative './type'
+require_relative './is'
+require_relative './combinators'
 
-using NRSER
   
 module NRSER::Types
-  # booleans
-  # ========
-  
-  TRUE = is true, name: 'true', from_s: ->(string) {
-    if ['true', 't', '1', 'yes', 'y', 'on'].include? string.downcase
-      true
-    else
-      raise TypeError, "can not convert to true: #{ string.inspect }"
-    end
-  }
-  
-  def self.true
-    TRUE
-  end
   
-  FALSE = is false, name: 'false', from_s: ->(string) {
-    if ['false', 'f', '0', 'no', 'n', 'off'].include? string.downcase
-      false
-    else
-      raise TypeError, "can not convert to true: #{ string.inspect }"
-    end
-  }
+  # Abstract base class for {TrueType} and {FalseType}.
+  # 
+  class BooleanType < Is
+    
+    # Instantiate a new `BooleanType`.
+    # 
+    def initialize value, **options
+      # Check it's a boolean
+      unless true.equal?( value ) || false.equal?( value )
+        raise ArgumentError.new \
+          "`value` arg must be `true` or `false`, found #{ value.inspect }"
+      end
+      
+      super value, **options
+    end # #initialize
+    
+    
+    protected
+    # ========================================================================
+      
+      def custom_from_s string
+        return value if self::STRINGS.include?( string.downcase )
+        
+        raise NRSER::Types::FromStringError.new \
+          type: self,
+          string: string,
+          binding: binding,
+          details: -> {
+            <<~END
+              Down-cased `string` must be one of:
+              
+                  <%= self::STRINGS.to_a %>
+            END
+          }
+      end
+      
+    public # end protected *****************************************************
+    
+  end # class TrueType
+  
+  
+  # A type for only the `true`.
+  # 
+  # Provides a {#custom_from_s} to load from CLI options and ENV var-like
+  # string values.
+  # 
+  class TrueType < BooleanType
+    
+    STRINGS = NRSER::TRUTHY_STRINGS
+    
+    # Instantiate a new `TrueType`.
+    # 
+    def initialize **options
+      super true, **options
+    end # #initialize
+    
+  end # class TrueType
   
-  def self.false
-    FALSE
+  
+  # A type for only `false`.
+  # 
+  # Provides a {#custom_from_s} to load from CLI options and ENV var-like
+  # string values.
+  # 
+  class FalseType < BooleanType
+    
+    STRINGS = NRSER::FALSY_STRINGS
+    
+    # Instantiate a new `TrueType`.
+    # 
+    def initialize **options
+      super false, **options
+    end # #initialize
+    
+  end # class FalseType
+  
+  
+  def_factory :true do |**options|
+    TrueType.new **options
   end
   
-  BOOL = union TRUE, FALSE
   
-  # true or false
-  def self.bool
-    BOOL
+  def_factory :false do |**options|
+    FalseType.new **options
   end
   
-  def self.boolean
-    bool
+  
+  def_factory(
+    :bool,
+    aliases: [ :boolean ],
+  ) do |**options|
+    union self.true, self.false, **options
   end
   
 end # NRSER::Types

data/lib/nrser/types/bounded.rb

@@ -6,15 +6,17 @@ using NRSER
 module NRSER::Types
   class Bounded < NRSER::Types::Type
     
-    # @!attribute [r] min
-    #   @return [Number]
-    #     Minimum value.
+    # Minimum value.
+    # 
+    # @return [Number]
+    #     
     attr_reader :min
     
     
-    # @!attribute [r] max
-    #   @return [Number]
-    #     Minimum value.
+    # Minimum value.
+    # 
+    # @return [Number]
+    # 
     attr_reader :max
     
     
@@ -27,13 +29,13 @@ module NRSER::Types
       @max = max
     end
     
-    def test value
+    def test? value
       return false if @min && value < @min
       return false if @max && value > @max
       true
     end
     
-    def default_name
+    def explain
       attrs_str = ['min', 'max'].map {|name|
         [name, instance_variable_get("@#{ name }")]
       }.reject {|name, value|
@@ -42,12 +44,12 @@ module NRSER::Types
         "#{ name }=#{ value }"
       }.join(', ')
       
-      "#{ self.class.short_name } #{ attrs_str }"
+      "#{ self.class.demod_name }<#{ attrs_str }>"
     end
     
   end # Bounded
   
-  def self.bounded **options
+  def_factory :bounded do |**options|
     Bounded.new **options
   end
    

data/lib/nrser/types/combinators.rb

@@ -1,31 +1,37 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
-require 'nrser/refinements'
 require 'nrser/types/type'
 
-using NRSER
-
 # base class for Union and Intersection which combine over a set of types.
 module NRSER::Types
+  
+  # Abstract base class for logically combining types to create new ones.
+  # 
   class Combinator < NRSER::Types::Type
+    
+    # The parametrized types, in the order they will be tested.
+    # 
+    # @return [Array<NRSER::Types::Type>]
+    # 
     attr_reader :types
     
     
     def initialize *types, **options
       super **options
-      @types = types.map {|type| NRSER::Types.make type}
+      @types = types.map { |type| NRSER::Types.make type }
     end
     
     
-    def default_name
+    def explain
       if self.class::JOIN_SYMBOL
-        NRSER::Types::L_PAREN +
-        @types.map { |type| type.name }.join( self.class::JOIN_SYMBOL ) +
+        NRSER::Types::L_PAREN + # ' ' +
+        @types.map { |type| type.explain }.join( self.class::JOIN_SYMBOL ) +
+        # ' ' +
         NRSER::Types::R_PAREN
       else
-        "#{ self.class.short_name }<" +
-        @types.map {|type| type.name }.join(',') +
+        "#{ self.class.demod_name }<" +
+          @types.map { |type| type.explain }.join( ',' ) +
         ">"
       end
     end
@@ -59,7 +65,7 @@ module NRSER::Types
     # @raise [TypeError]
     #   See write up above.
     # 
-    def from_s s
+    def custom_from_s s
       unless @from_s.nil?
         return check @from_s.call( s )
       end
@@ -92,10 +98,39 @@ module NRSER::Types
     # @return [Boolean]
     # 
     def has_from_s?
-      super() || @types.any? { |type| type.has_from_s? }
+      !@from_s.nil? || @types.any? { |type| type.has_from_s? }
     end # has_from_s
     
     
+    def has_from_data?
+      @types.any? { |type| type.has_from_data? }
+    end
+    
+    
+    # Overridden to
+    def from_data data
+      unless has_from_data?
+        raise NoMethodError, "#from_data not defined"
+      end
+      
+      errors = []
+      
+      types.each do |type|
+        if type.has_from_data?
+          begin
+            return check!( type.from_data data )
+          rescue Exception => error
+            errors << error
+          end
+        end
+      end
+      
+      raise NRSER::MultipleErrors.new \
+        errors,
+        headline: "No type successfully loaded data"
+    end
+    
+    
     # Overridden to delegate functionality to the combined types:
     # 
     # A combinator can convert a value to data if *any* of it's types can.
@@ -120,7 +155,7 @@ module NRSER::Types
     # 
     def to_data value
       @types.each { |type|
-        if type.respond_to? :to_data
+        if type.has_to_data?
           return type.to_data value
         end
       }
@@ -134,57 +169,59 @@ module NRSER::Types
         other.class == self.class && other.types == @types
       )
     end
-  end
+  
+  end # class Combinator
+  
   
   class Union < Combinator
-    JOIN_SYMBOL = ' ⋁ '
+    JOIN_SYMBOL = ' | ' # ' ⋁ '
     
-    def test value
-      @types.any? {|type| type.test value}
+    def test? value
+      @types.any? { |type| type.test value }
     end
-  end # Union
+  end # class Union
+  
   
   # match any of the types
-  def self.union *types, **options
-    NRSER::Types::Union.new *types, **options
+  def_factory(
+    :union,
+    aliases: [:one_of, :or],
+  ) do |*types, **options|
+    Union.new *types, **options
   end
   
-  singleton_class.send :alias_method, :one_of, :union
-  singleton_class.send :alias_method, :or, :union
   
   class Intersection < Combinator
-    # JOIN_SYMBOL = ', '
-    JOIN_SYMBOL = ' ⋀ '
+    JOIN_SYMBOL = ' & ' # ' ⋀ '
     
-    def test value
-      @types.all? { |type| type.test value}
+    def test? value
+      @types.all? { |type| type.test? value }
     end
-  end
+  end # class Intersection
+  
   
   # match all of the types
-  def self.intersection *types, **options
+  def_factory(
+    :intersection,
+    aliases: [:all_of, :and],
+  ) do |*types, **options|
     Intersection.new *types, **options
   end
   
-  singleton_class.send :alias_method, :all_of, :intersection
-  singleton_class.send :alias_method, :and, :intersection
-  
   
   class XOR < Combinator
     JOIN_SYMBOL = ' ⊕ '
     
-    def test value
+    def test? value
       @types.count { |type| type === value } == 1
     end
-    
-    # def default_name
-    #   '⊕'
-    #   "( #{ @types.map { |t| t.name }.join ' ⊕ ' } )"
-    # end
   end
   
   
-  def self.xor *types, **options
+  def_factory(
+    :xor,
+    aliases: [ :exclusive_or, :only_one_of ],
+  ) do |*types, **options|
     XOR.new *types, **options
   end