nrser 0.3.9 → 0.3.10

data/lib/nrser/types/attributes.rb

@@ -0,0 +1,269 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+
+# Requirements
+# ========================================================================
+
+# Project / Package
+# ------------------------------------------------------------------------
+
+require 'nrser/core_ext/hash'
+
+require_relative './type'
+require_relative './combinators'
+require_relative './is'
+require_relative './bounded'
+
+
+# Namespace
+# ========================================================================
+
+module  NRSER
+module  Types
+
+
+# Definitions
+# ========================================================================
+
+# Specify types for value attributes.
+# 
+# @note
+#   Construct {Attributes} types using the {.Attributes} factory.
+# 
+class Attributes < Type
+
+  # Attributes
+  # ========================================================================
+
+  # Attribute types by name.
+  # 
+  # @return [Hash<Symbol, Type>]
+  #     
+  attr_reader :types
+
+  
+  # Construct an `AttrsType`.
+  # 
+  # @param [Hash<#to_sym, 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
+    
+    if attrs.empty?
+      raise ArgumentError,
+        "Must provide at least one attribute name/type pair"
+    end
+    
+    @types = attrs.map { |k, v|
+      [ k.to_sym, NRSER::Types.make( v ) ]
+    }.to_h.freeze
+  end
+
+
+  # @!group Display Instance Methods
+  # --------------------------------------------------------------------------
+
+  def type_strings method:
+    types.map { |name, type|
+      "##{ name }#{ RESPONDS_WITH }#{ type.public_send method }"
+    }
+  end
+
+
+  def default_name
+    type_strings = self.type_strings method: :name
+
+    if type_strings.length == 1
+      type_strings[0]
+    else
+      L_PAREN + type_strings.join( " #{ AND } " ) + R_PAREN
+    end
+  end
+
+
+  def default_symbolic
+    type_strings = self.type_strings method: :symbolic
+
+    if type_strings.length == 1
+      type_strings[0]
+    else
+      L_PAREN + type_strings.join( " #{ AND } " ) + R_PAREN
+    end
+  end
+  
+  
+  # @see NRSER::Types::Type#explain
+  # 
+  # @return [String]
+  # 
+  def explain
+    "#{ self.class.demod_name }<" +
+    type_strings( method: :explain ).join( ', ' ) +
+    ">"
+  end
+  
+  
+  # @see NRSER::Types::Type#test
+  # 
+  # @return [Boolean]
+  # 
+  def test? value
+    types.all? { |name, type|
+      value.respond_to?( name ) &&
+        type.test?( value.method( name ).call )
+    }
+  end
+  
+end # Attributes
+
+
+# @!group Attributes Type Factories
+# ----------------------------------------------------------------------------
+
+# @!method self.Attributes attrs, **options
+#   Get a {Type} that checks the types of one or more attributes on values.
+#   
+#   @example Type where first element of an Enumerable is a String
+#     string_first = intersection Enumerable, attrs(first: String)
+#   
+#   @param [Hash<#to_sym, (Type | Object)>] attrs
+#     
+# 
+def_type          :Attributes,
+  parameterize:   :attributes,
+  aliases:      [ :attrs, ],
+&->( attributes, **options ) do
+  Attributes.new attributes, **options
+end
+
+
+# @!method self.Length **options
+#   
+#   @overload length exact, options = {}
+#     Get a length attribute type that specifies an `exact` value.
+#     
+#     @example
+#       only_type = NRSER::Types.length 1
+#       
+#       only_type.test []
+#       # => false
+#       
+#       only_type.test [:x]
+#       # => true
+#       
+#       only_type.test [:x, :y]
+#       # => false
+#     
+#     @param [Integer] exact
+#       Exact non-negative integer that the length must be to satisfy the
+#       type created.
+#     
+#     @param [Hash] options
+#       Options hash passed up to {NRSER::Types::Type} constructor.
+#     
+#     @return [NRSER::Types::Attributes]
+#       Type satisfied by a `#length` attribute that is exactly `exact`.
+#   
+#   
+#   @overload length bounds, options = {}
+#     Get a length attribute type satisfied by values within a `:min` and
+#     `:max` (inclusive).
+#     
+#     @example
+#       three_to_five = NRSER::Types.length( {min: 3, max: 5}, name: '3-5' )
+#       three_to_five.test [1, 2]               # => false
+#       three_to_five.test [1, 2, 3]            # => true
+#       three_to_five.test [1, 2, 3, 4]         # => true
+#       three_to_five.test [1, 2, 3, 4, 5]      # => true
+#       three_to_five.test [1, 2, 3, 4, 5, 6]   # => false
+#   
+#     @param [Hash] bounds
+#     
+#     @option bounds [Integer] :min
+#       An optional minimum value that the `#length` should not be less than.
+#     
+#     @option bounds [Integer] :max
+#       An optional maximum value that the `#length` should not be more than.
+#     
+#     @option bounds [Integer] :length
+#       An optional value for both the minimum and maximum.
+#     
+#     @param [Hash] options
+#       Options hash passed up to {NRSER::Types::Type} constructor.
+#     
+#     @return [NRSER::Types::Attributes]
+#       Type satisfied by a `#length` attribute between the `:min` and `:max`
+#       (inclusive).
+# 
+def_type        :Length,
+  # TODO  This would need special attention if we ever started using the
+  #       `parameterize` data for anything...
+  parameterize: :args,
+&->( *args ) do
+  bounds = {}
+  options = if args[1].is_a?( Hash ) then args[1] else {} end
+  
+  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 = args[0].sym_keys
+    
+    # Pull any :min and :max in the keywords
+    bounds[:min] = kwds.delete :min
+    bounds[:max] = kwds.delete :max
+    
+    # But override with :length if we got it
+    if length = kwds.delete(:length)
+      bounds[:min] = length
+      bounds[:max] = length
+    end
+    
+    # (Reverse) merge anything else into the options (options hash values
+    # take precedence)
+    options = kwds.merge options
+    
+  else
+    raise ArgumentError, <<-END.squish
+      arg must be positive integer or option hash, found:
+      #{ args[0].inspect } of type #{ args[0].class }
+    END
+    
+  end
+  
+  bounded_type = self.Bounded bounds
+  
+  length_type = if !bounded_type.min.nil? && bounded_type.min >= 0
+    # We don't need the non-neg check
+    bounded_type
+  else
+    # We do need the non-neg check
+    intersection(non_neg_int, bounded_type)
+  end
+  
+  options[:name] ||= "Length<#{ bounded_type.name }>"
+  
+  self.Attributes({ length: length_type }, options)
+end # .Length
+
+# @!endgroup Attributes Type Factories # *************************************
+
+
+# /Namespace
+# ========================================================================
+
+end # module Types
+end # module NRSER

data/lib/nrser/types/booleans.rb

@@ -1,6 +1,12 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
+# Requirements
+# ========================================================================
+
+# Project / Package
+# ------------------------------------------------------------------------
+
 # Need truthy and falsy parse values
 require 'nrser/functions/object/truthy'
 
@@ -9,100 +15,145 @@ require_relative './is'
 require_relative './combinators'
 
   
-module NRSER::Types
-  
-  # 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
-  
+# Namespace
+# ========================================================================
+
+module  NRSER
+module  Types
+
+
+# Definitions
+# ========================================================================
+
+# Abstract base class for {True} and {False}.
+# 
+class Boolean < Is
   
-  # A type for only the `true`.
-  # 
-  # Provides a {#custom_from_s} to load from CLI options and ENV var-like
-  # string values.
+  # Instantiate a new `Boolean`.
   # 
-  class TrueType < BooleanType
-    
-    STRINGS = NRSER::TRUTHY_STRINGS
+  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
     
-    # Instantiate a new `TrueType`.
-    # 
-    def initialize **options
-      super true, **options
-    end # #initialize
-    
-  end # class TrueType
+    super value, **options
+  end # #initialize
   
   
-  # 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
+  protected
+  # ========================================================================
     
-    # Instantiate a new `TrueType`.
-    # 
-    def initialize **options
-      super false, **options
-    end # #initialize
+    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
     
-  end # class FalseType
+  public # end protected *****************************************************
   
+end # class Boolean
+
+
+# @!group Boolean Type Factories
+# ----------------------------------------------------------------------------
+
+# A type for only the `true`.
+# 
+# Provides a {#custom_from_s} to load from CLI options and ENV var-like
+# string values.
+# 
+class True < Boolean
   
-  def_factory :true do |**options|
-    TrueType.new **options
-  end
+  STRINGS = NRSER::TRUTHY_STRINGS
   
+  # Instantiate a new `True` type.
+  # 
+  def initialize **options
+    super true, **options
+  end # #initialize
   
-  def_factory :false do |**options|
-    FalseType.new **options
-  end
+end # class True
+
+
+# A type for only `false`.
+# 
+# Provides a {#custom_from_s} to load from CLI options and ENV var-like
+# string values.
+# 
+class False < Boolean
   
+  STRINGS = NRSER::FALSY_STRINGS
   
-  def_factory(
-    :bool,
-    aliases: [ :boolean ],
-  ) do |**options|
-    union self.true, self.false, **options
-  end
+  # Instantiate a new `True` type.
+  # 
+  def initialize **options
+    super false, **options
+  end # #initialize
   
-end # NRSER::Types
+end # class FalseType
+
+
+#@!method self.True **options
+#   A type whose only member is `true` and loads from common CLI and ENV 
+#   var string representations (see {True} and {True::STRINGS}).
+#   
+#   @param [Hash] options
+#     Passed to {Type#initialize}.
+#   
+#   @return [Type]
+#   
+def_type  :True,
+&->( **options ) do
+  True.new **options
+end
+
+
+#@!method self.False **options
+#   A type whose only member is `false` and loads from common CLI and ENV 
+#   var string representations (see {False} and {False::STRINGS}).
+#   
+#   @param [Hash] options
+#     Passed to {Type#initialize}.
+#   
+#   @return [Type]
+#   
+def_type        :False,
+&->( **options ) do
+  False.new **options
+end # .False
+
+
+#@!method self.Boolean **options
+#   {.True} or {.False}.
+#   
+#   @param [Hash] options
+#     Passed to {Type#initialize}.
+#   
+#   @return [Type]
+#   
+def_type        :Boolean,
+  aliases:    [ :bool ],
+&->( **options ) do
+  union self.True, self.False, **options
+end # .Boolean
+
+# @!endgroup Boolean Type Factories # ****************************************
+
+
+# /Namespace
+# ========================================================================
+
+end # module Types
+end # module NRSER