nrser 0.3.9 → 0.3.10

data/lib/nrser/types/pairs.rb

@@ -1,109 +1,133 @@
-# Requirements
-# =======================================================================
-
-# Stdlib
-# -----------------------------------------------------------------------
+# encoding: UTF-8
+# frozen_string_literal: true
 
-# Deps
-# -----------------------------------------------------------------------
+# Requirements
+# ========================================================================
 
 # Project / Package
-# -----------------------------------------------------------------------
+# ------------------------------------------------------------------------
+
 require 'nrser/core_ext/hash'
 
 require_relative './combinators'
+require_relative './attributes'
 require_relative './tuples'
 
 
-# Refinements
-# =======================================================================
+# Namespace
+# ========================================================================
 
+module  NRSER
+module  Types
 
-# Declarations
+
+# Definitions
 # =======================================================================
 
-module NRSER; end
+# @!group Pairs Type Factories
+# ----------------------------------------------------------------------------
 
 
-# Definitions
-# =======================================================================
+#@!method self.ArrayPair key: self.Top, value: self.Top, **options
+#   Type for key/value pairs encoded as a {.Tuple} ({::Array}) of length 2.
+#   
+#   @param [TYPE] key
+#     Key type. Made into a type by {NRSER::Types.make} if it's not already.
+#   
+#   @param [TYPE] value
+#     Value type. Made into a type by {NRSER::Types.make} if it's not already.
+#   
+#   @param [Hash] options
+#     Passed to {Type#initialize}.
+#   
+#   @return [Type]
+#   
+def_type        :ArrayPair,
+  default_name: false,
+  parameterize: [ :key, :value ],
+&->( key: self.Top, value: self.Top, **options ) do
+  tuple \
+    key,
+    value,
+    **options
+end # .ArrayPair
 
-module NRSER::Types
-  
-  # Type for key/value pairs encoded as a {.tuple} (Array) of length 2.
-  # 
-  def_factory(
-    :array_pair,
-  ) do |name: 'ArrayPair', key: any, value: any, **options|
-    unless options.key? :name
-      options[:name] = if key == any && value == any
-        'ArrayPair'
-      else
-        key = NRSER::Types.make key
-        value = NRSER::Types.make value
-        
-        "ArrayPair<#{ key.name }, #{ value.name }>"
-      end
-    end
-    
-    tuple \
-      key,
-      value,
-      # name: name,
-      **options
-  end # .array_pair
-  
+
+# @!method self.HashPair key: self.Top, value: self.Top, **options
+# 
+#   Type whose members are single a key/value pairs encoded as {::Hash} instances 
+#   with a single entry (`::Hash#length==1`).
+#   
+#   @param [TYPE] key
+#     Key type. Made into a type by {NRSER::Types.make} if it's not already.
+#   
+#   @param [TYPE] value
+#     Value type. Made into a type by {NRSER::Types.make} if it's not already.
+#   
+#   @param [Hash] options
+#     Passed to {Type#initialize}.
+#   
+#   @return [Type]
+# 
+def_type        :HashPair,
+  default_name: false,
+  parameterize: [ :key, :value ],
+&->( key: self.Top, value: self.Top, **options ) do
+  key = self.make key
+  value = self.make value
+
+  options[:name] ||= "Hash<(#{ key.name }, #{ value.name })>"
   
-  # Type for key/value pairs encoded as {Hash} with a single entry.
-  # 
-  # @param [String] name:
-  #   Name to give the new type.
-  # 
-  # @param [Hash] **options
-  #   Other options to pass to
-  # 
-  def_factory(
-    :hash_pair,
-  ) do |key: any, value: any, **options|
-    unless options.key? :name
-      options[:name] = if key == any && value == any
-        'HashPair'
-      else
-        key = NRSER::Types.make key
-        value = NRSER::Types.make value
-        
-        "HashPair<#{ key.name }, #{ value.name }>"
-      end
-    end
-    
-    intersection \
-      hash_type( keys: key, values: value ),
-      length( 1 ),
-      # name: name,
-      **options
-  end # .hash_pair
+  options[:symbolic] ||= "(#{ key.symbolic }=>#{ value.symbolic })"
   
+  intersection \
+    self.Hash( keys: key, values: value ),
+    self.Length( 1 ),
+    **options
+end # .HashPair
+
+
+#@!method self.Pair key: self.Top, value: self.Top, **options
+#   A key/value pair, which can be encoded as an Array of length 2 or a
+#   Hash of length 1.
+#   
+#   @param [TYPE] key
+#     Key type. Made into a type by {NRSER::Types.make} if it's not already.
+#   
+#   @param [TYPE] value
+#     Value type. Made into a type by {NRSER::Types.make} if it's not already.
+# 
+#   @param [Hash] options
+#     Passed to {Type#initialize}.
+#   
+#   @return [Type]
+#   
+def_type        :Pair,
+  default_name: false,
+  parameterize: [ :key, :value ],
+&->( key: self.Top, value: self.Top, **options ) do
+  key = self.make key
+  value = self.make value
 
-  # A key/value pair, which can be encoded as an Array of length 2 or a
-  # Hash of length 1.
-  # 
-  # 
-  def_factory :pair do |key: any, value: any, **options|
-    unless options.key? :name
-      options[:name] = if key == any && value == any
-        'Pair'
-      else
-        key = NRSER::Types.make key
-        value = NRSER::Types.make value
-        
-        "Pair<#{ key.name }, #{ value.name }>"
-      end
-    end
-    
-    union \
-      array_pair( key: key, value: value ),
-      hash_pair( key: key, value: value ),
-      **options
-  end # #pair
+  options[:name] ||= if key == self.Top && value == self.Top
+    "Pair"
+  else
+    "Pair<#{ key.name }, #{ value.name }>"
+  end
+
+  options[:symbolic] ||= "(#{ key.symbolic }, #{ value.symbolic })"
   
-end # module NRSER::Types
+  union \
+    self.ArrayPair( key: key, value: value ),
+    self.HashPair(  key: key, value: value ),
+    **options
+end # .Pair
+
+# @!endgroup Pairs Type Factories # ******************************************
+
+
+# /Namespace
+# ========================================================================
+
+end # module  NRSER
+end #module  Types

data/lib/nrser/types/paths.rb

@@ -1,153 +1,266 @@
 # Requirements
 # =======================================================================
 
-# Stdlib
-# -----------------------------------------------------------------------
-
-# Deps
-# -----------------------------------------------------------------------
-
 # Project / Package
 # -----------------------------------------------------------------------
 
 require 'nrser/core_ext/pathname'
+require 'nrser/functions/path/normalized'
 
 require_relative './is_a'
 require_relative './where'
 require_relative './combinators'
 
 
+# Namespace
+# ========================================================================
+
+module  NRSER
+module  Types
+
+
 # Definitions
 # =======================================================================
 
-module NRSER::Types
-  
-  # @!group Type Factory Functions
-  
-  def_factory :pathname do |to_data: :to_s, **options|
-    is_a \
-      Pathname,
-      from_s: ->( string ) { Pathname.new string },
-      to_data: to_data,
-      **options
-  end
-  
-  
-  # A type satisfied by a {Pathname} instance that's not empty (meaning it's
-  # string representation is not empty).
-  def_factory :non_empty_pathname do |name: 'NonEmptyPathname', **options|
-    all_of \
-      pathname,
-      attrs( to_s: non_empty_str ),
-      name: name,
-      **options
-  end
-  
-  
-  # @!method
-  #   A path is a non-empty {String} or {Pathname}.
-  #   
-  #   @param **options see NRSER::Types::Type#initialize
-  #   
-  #   @return [NRSER::Types::Type]
-  # 
-  def_factory :path do |name: 'Path', **options|
-    one_of \
-      non_empty_str,
-      non_empty_pathname,
-      name: name,
-      **options
-  end # #path
-  
-  
-  def_factory :posix_path_segment,
-              aliases: [:path_segment, :path_seg] \
-  do |name: 'POSIXPathSegment', **options|
-    all_of \
-      non_empty_str,
-      respond( to: [:include?, '/'], with: false ),
-      name: name,
-      **options
-  end
-  
-  
-  # An absolute {#path}.
-  # 
-  # @param **options see NRSER::Types::Type#initialize
-  # 
-  def_factory :abs_path do |name: 'AbsPath', **options|
-    intersection \
-      path,
-      # Weirdly, there is no {File.absolute?}..
-      attrs( to_pn: attrs( absolute?: true ) ),
-      name: name,
-      from_s: ->( s ) { File.expand_path s },
-      **options
-  end
-  
-  
-  # A relative path.
-  # 
-  # @todo
-  #   Quick addition, not sure if it's totally right with regard to tilde
-  #   paths and such.
-  # 
-  def_factory :rel_path do |name: 'RelPath', **options|
-    intersection \
-      path,
-      ~abs_path,
-      name: name,
-      **options
-  end
-  
-  
-  # A {NRSER::Types.path} that is a directory.
-  # 
-  # @param [Hash] **options
-  #   Construction options passed to {NRSER::Types::Type#initialize}.
-  # 
-  # @return [NRSER::Types::Type]
-  # 
-  def_factory :dir_path do |name: 'DirPath', **options|
-    intersection \
-      path,
-      # TODO  How to change this from {.where}?
-      where { |path| File.directory? path },
-      name: name,
-      **options
-  end # #dir_path
-  
-  
-  # Absolute {.path} to a directory (both an {.abs_path} and an {.dir_path}).
-  # 
-  # @param name: (see NRSER::Types::Type#initialize)
-  # 
-  # @param **options
-  #   See {NRSER::Types::Type#initialize}
-  # 
-  def_factory :abs_dir_path do |name: 'AbsDirPath', **options|
-    intersection \
-      abs_path,
-      dir_path,
-      name: name,
-      **options
-  end # .abs_dir_path
-  
-  
-  # A {.path} that is a file (using {File.file?} to test).
-  # 
-  # @param name: (see NRSER::Types::Type#initialize)
-  # 
-  # @param **options
-  #   See {NRSER::Types::Type#initialize}
-  # 
-  def_factory :file_path do |name: 'FilePath', **options|
-    intersection \
-      path,
-      # TODO  How to change this from {.where}?
-      where { |path| File.file? path },
-      name: name,
-      **options
-  end
-  
-end # module NRSER::Types
+# Constants
+# ----------------------------------------------------------------------------
+
+# Regular expression to match "tilde" user-home-relative paths.
+# 
+# @return [Regexp]
+# 
+TILDE_PATH_RE = /\A\~(?:\/|\z)/
+
+
+# @!group Path Type Factories
+# ----------------------------------------------------------------------------
+
+#@!method self.Pathname **options
+#   Just a type for instances of {Pathname}.
+#   
+#   @param [Hash] options
+#     Passed to {Type#initialize}.
+#   
+#   @return [Type]
+#   
+def_type    :Pathname,
+  to_data:  :to_s,
+  from_s:   ->( string ) { Pathname.new string } \
+do |**options|
+  is_a Pathname, **options
+end
+
+
+#@!method self.NonEmptyPathname **options
+#   A {.Pathname} that isn't empty. Because not emptiness is often important.
+#   
+#   @param [Hash] options
+#     Passed to {Type#initialize}.
+#   
+#   @return [Type]
+#   
+def_type        :NonEmptyPathname,
+&->( **options ) do
+  self.Intersection \
+    self.Pathname,
+    self.Attributes( to_s: self.NonEmptyString ),
+    **options
+end # .NonEmptyPathname
+
+
+# @!method self.Path **options
+#   A path is a {.NonEmptyString} or {.NonEmptyPathname}.
+#   
+#   @param [Hash] options
+#     See {Type#initialize}.
+#   
+#   @return [Type]
+# 
+def_type        :Path,
+&->( **options ) do
+  self.Union \
+    self.NonEmptyString,
+    self.NonEmptyPathname,
+    **options
+end # #Path
+
+
+#@!method self.POSIXPathSegment **options
+#   A POSIX path segment (directory, file name) - any {.NonEmptyString} that
+#   doesn't have `/` in it.
+#   
+#   @param [Hash] options
+#     Passed to {Type#initialize}.
+#   
+#   @return [Type]
+#   
+def_type        :POSIXPathSegment,
+  aliases:      [ :path_segment, :path_seg ],
+&->( **options ) do
+  self.Intersection \
+    self.NonEmptyString,
+    self.Respond( to: [:include?, '/'], with: false ),
+    **options
+end # .POSIXPathSegment
+
+
+# @!method self.AbsolutePath **options
+#   An absolute {.Path}.
+#   
+#   @param [Hash] options
+#     Passed to {Type#initialize}.
+#   
+#   @return [Type]
+#   
+def_type        :AbsolutePath,
+  aliases:      [ :AbsPath, :abs_path ],
+  # TODO  IDK how I feel about this...
+  # from_s:       ->( s ) { File.expand_path s },
+&->( **options ) do
+  self.Intersection \
+    self.Path,
+    # Weirdly, there is no {File.absolute?}..
+    self.Attributes( to_pn: attrs( absolute?: true ) ),
+    **options
+end # .AbsolutePath
+
+
+#@!method self.HomePath **options
+#   A path that starts with `~`, meaning it's relative to a user's home 
+#   directory (to Ruby, see note below).
+# 
+#   > ### Note: How Bash and Ruby Think Differently About Home Paths ###
+#   > 
+#   > #### Ruby Always Tries to Go Home ####
+#   > 
+#   > From my understanding and fiddling around Ruby considers *any* path that
+#   > starts with `~` a "home path" for the purpose of expanding, such as in
+#   > {::File.expand_path} and {::Pathname#expand_path}.
+#   > 
+#   > You can see this clearly in the [rb_file_expand_path_internal][] C
+#   > function, which is where those expand methods end up.
+#   > 
+#   > [rb_file_expand_path_internal]: https://github.com/ruby/ruby/blob/61bef8612afae25b912627e69699ddbef81adf93/file.c#L3486
+#   > 
+#   > #### Bash  ####
+#   > 
+#   > However
+#   > 
+#   > However - Bash 4's `cd` - on MacOSX, at least - treats `~some_user` as 
+#   > being a home directory *only if* `some_user` exists... and you may have
+#   > a file or directory in the working dir named `~some_user` that it will 
+#   > correctly fall back on if `some_user` does not exist.
+#   > 
+#   > Paths are complicated, man.
+#   
+#   @param [Hash] options
+#     Passed to {Type#initialize}.
+#   
+#   @return [Type]
+#   
+def_type        :HomePath,
+&->( **options ) do
+  self.Intersection \
+    self.Path,
+    self.Respond( to: [ :start_with?, '~' ], with: self.True ),
+    **options
+end # .HomePath
+
+
+# @!method self.AbsPath **options
+#   A relative {.Path}, which is just a {.Path} that's not {.AbsPath} or
+#   {.TildePath}.
+#   
+#   @param [Hash] options
+#     Passed to {Type#initialize}.
+#   
+#   @return [Type]
+#   
+def_type :RelPath,
+&->( **options ) do
+  self.Intersection \
+    self.Path,
+    !self.AbsPath,
+    !self.TildePath,
+    **options
+end
+
+
+# @method self.DirPath **options
+#   A {.Path} that is a directory. Requires checking the file system.
+#   
+#   @param [Hash] options
+#     Passed to {Type#initialize}.
+#   
+#   @return [Type]
+# 
+def_type :DirPath,
+&->( **options ) do
+  self.Intersection \
+    self.Path,
+    self.Where( File.method :directory? ),
+    **options
+end # .DirPath
+
+
+# @!method self.AbsDirPath **options
+#   Absolute {.Path} to a directory (both an {.AbsPath} and an {.DirPath}).
+#   
+#   @param [Hash] options
+#     Passed to {Type#initialize}.
+#   
+#   @return [Type]
+# 
+def_type :AbsDirPath,
+&->( **options ) do
+  self.Intersection \
+    self.AbsPath,
+    self.DirPath,
+    **options
+end # .AbsDirPath
+
+
+# @!method self.FilePath **options
+#   A {.Path} that is a file (using {File.file?} to test).
+# 
+# @param name: (see NRSER::Types::Type#initialize)
+# 
+# @param [Hash] options
+#   See {NRSER::Types::Type#initialize}
+# 
+def_type :FilePath,
+&->( **options ) do
+  self.Intersection \
+    self.Path,
+    self.Where( File.method :file? ),
+    **options
+end # .FilePath
+
+
+#@!method self.NormalizedPath **options
+#   @todo Document NormalizedPath type factory.
+#   
+#   @param [Hash] options
+#     Passed to {Type#initialize}.
+#   
+#   @return [Type]
+#   
+def_type        :NormalizedPath,
+  aliases:      [ :NormPath, :norm_path ],
+&->( **options ) do
+  self.Intersection \
+    self.Path,
+    self.Where( NRSER.method :normalized_path? ),
+    **options
+end # .NormalizedPath
+
+
+
+# @!endgroup Path Type Factories # *******************************************
+
+
+# /Namespace
+# ========================================================================
+
+end # module Types
+end # module NRSER