nrser 0.3.9 → 0.3.10

data/lib/nrser/functions/string.rb

@@ -112,7 +112,7 @@ module NRSER
   # @param [Fixnum] max
   #   Max length to allow for the output string.
   # 
-  # @param [String] omission:
+  # @param [String] omission
   #   The string to stick in the middle where original contents were
   #   removed. Defaults to the unicode ellipsis since I'm targeting the CLI
   #   at the moment and it saves precious characters.
@@ -128,7 +128,7 @@ module NRSER
   def self.ellipsis source, max, omission: UNICODE_ELLIPSIS
     return source unless source.length > max
     
-    trim_to = max - omission.length
+    trim_to = max - ( String === source ? omission.length : 1 )
     middle = trim_to / 2
     remainder = trim_to % 2
     
@@ -175,12 +175,12 @@ module NRSER
   #   Max length to allow for the output string. Result will usually be
   #   *less* than this unless the fallback to {NRSER.ellipsis} kicks in.
   # 
-  # @param [String] omission:
+  # @param [String] omission
   #   The string to stick in the middle where original contents were
   #   removed. Defaults to the unicode ellipsis since I'm targeting the CLI
   #   at the moment and it saves precious characters.
   # 
-  # @param [String] split:
+  # @param [String] split
   #   The string to tokenize the `string` parameter by. If you pass a
   #   {Regexp} here it might work, it might loop out, maybe.
   # 

data/lib/nrser/functions/text/README.md

@@ -0,0 +1,4 @@
+NRSER Gem `nrser/text` Directory
+========================================================================
+
+Function for working with strings that are blocks of text.

data/lib/nrser/functions/text/format.rb

@@ -0,0 +1,53 @@
+module NRSER
+  
+  # Format a segment of a message.
+  # 
+  # If `segment` responds to `#to_summary`, it will be called and the
+  # result will be returned.
+  # 
+  # Strings are simply returned. Other things are inspected (for now).
+  # 
+  # @param [Object] segment
+  #   The segment.
+  # 
+  # @return [String]
+  #   The formatted string for the segment.
+  # 
+  def self.fmt_msg_segment segment
+    return segment.to_summary.to_s if segment.respond_to?( :to_summary )
+    
+    return segment if String === segment
+    
+    # TODO  Do better!
+    segment.inspect
+  end
+
+  
+  # Provides simple formatting for messages constructed as a list of 
+  # segments.
+  # 
+  # Allows you to do this sort of thing:
+  # 
+  #     NRSER.fmt_msg "Some stuff went wrong with the", thing,
+  #       "and we're figuring it out, sorry. Maybe take a look at",
+  #       something_else
+  # 
+  # Which I find easier than interpolation since you quite often have to split
+  # across lines anyways.
+  # 
+  # See {.fmt_msg_segment} for info about how each segment is formatted.
+  # 
+  # This methods joins the results together 
+  # 
+  # @param [Array] segments
+  #   Message segments.
+  # 
+  # @return [String]
+  #   Formatted and joined message ready to pass up to the built-in
+  #   exception's `#initialize`.
+  # 
+  def self.fmt_msg *segments
+    segments.map { |segment| fmt_msg_segment segment }.join( ' ' )
+  end # .words
+  
+end # module NRSER

data/lib/nrser/functions/text/indentation.rb

@@ -120,11 +120,11 @@ module NRSER
   # @param [String] text
   #   String text to indent tag.
   # 
-  # @param [String] marker:
+  # @param [String] marker
   #   Special string to mark the start of tagged lines. If interpolated text
   #   lines start with this string you're going to have a bad time.
   # 
-  # @param [String] separator:
+  # @param [String] separator
   #   Special string to separate the leading indent from the rest of the line.
   # 
   # @return [String]
@@ -151,10 +151,10 @@ module NRSER
   # @param [String] text
   #   Tagged text string.
   # 
-  # @param [String] marker:
+  # @param [String] marker
   #   Must be the marker used to tag the text.
   # 
-  # @param [String] separator:
+  # @param [String] separator
   #   Must be the separator used to tag the text.
   # 
   # @return [String]
@@ -182,11 +182,11 @@ module NRSER
   # Indent tag a some text via {NRSER.indent_tag}, call the block with it,
   # then pass the result through {NRSER.indent_untag} and return that.
   # 
-  # @param [String] marker:
+  # @param [String] marker
   #   Special string to mark the start of tagged lines. If interpolated text
   #   lines start with this string you're going to have a bad time.
   # 
-  # @param [String] separator:
+  # @param [String] separator
   #   Must be the separator used to tag the text.
   # 
   # @return [String]

data/lib/nrser/functions/text/word_wrap.rb

@@ -9,10 +9,10 @@ module NRSER
   # @param [String] text
   #   Text to word wrap.
   # 
-  # @param [Fixnum] line_width:
+  # @param [Fixnum] line_width
   #   Line with in number of character to wrap at.
   # 
-  # @param [String] break_sequence:
+  # @param [String] break_sequence
   #   String to join lines with.
   # 
   # @return [String]

data/lib/nrser/functions/tree/map_leaves.rb

@@ -14,11 +14,11 @@ module NRSER
   # @param [#each_pair | (#each_index & #each_with_index)] tree
   #   Tree to walk.
   # 
-  # @param [Array] path
+  # @param [Array] key_path
   #   Key path down to `tree`.
   # 
-  # @param [Hash<Array, Object>] results
-  #   New hash to stick results in.
+  # @param [Proc] block
+  #   Called with each `(key_path, value)` pair.
   # 
   # @return [nil]
   # 

data/lib/nrser/functions/tree/map_tree.rb

@@ -23,7 +23,7 @@ module NRSER
   # 
   # @param tree (see NRSER.each_branch)
   # 
-  # @param [Boolean] prune:
+  # @param [Boolean] prune
   #   When `true`, prunes out values whose labels end with `?` and values are
   #   `nil`.
   # 
@@ -57,7 +57,7 @@ module NRSER
         pruned = {}
         
         mapped.each { |key, value|
-          if  Types.label.test( key ) &&
+          if  Types.Label.test( key ) &&
               key.to_s.end_with?( '?' )
             unless value.nil?
               new_key = key.to_s[0..-2]

data/lib/nrser/functions/tree/transform.rb

@@ -1,13 +1,6 @@
 module NRSER
   
-  # @todo Document transform method.
-  # 
-  # @param [type] arg_name
-  #   @todo Add name param description.
-  # 
-  # @return [return_type]
-  #   @todo Document return value.
-  # 
+
   def self.transform tree, source
     map_tree( tree, prune: true ) { |value|
       if value.is_a? Proc
@@ -39,15 +32,6 @@ module NRSER
   end
   
   
-  
-  # @todo Document transformer method.
-  # 
-  # @param [type] arg_name
-  #   @todo Add name param description.
-  # 
-  # @return [return_type]
-  #   @todo Document return value.
-  # 
   def self.transformer &block
     map_tree( block.call SendSerializer.new ) { |value|
       if value.is_a? SendSerializer
@@ -59,5 +43,4 @@ module NRSER
   end # .transformer
   
   
-  
 end # module NRSER

data/lib/nrser/gem_ext/README.md

@@ -0,0 +1,4 @@
+Gem Extensions
+==============================================================================
+
+Monkey-patches to gem dependencies.

data/lib/nrser/labs/README.md

@@ -0,0 +1,8 @@
+`lib/nrser/labs` Directory
+========================================================================
+
+Ideas I'm trying out. No consideration for stability at all. Anything in here may be completely changed or totally disappear at any time with no warning.
+
+**_Don't use if you want any sort of stability._**
+
+Stuff that makes it over the "Ok, this seems like not the worst idea, I'm willing to go with it at least for now" hump will be moved out of here.

data/lib/nrser/labs/config.rb

@@ -0,0 +1,163 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Requirements
+# =======================================================================
+
+# Stdlib
+# -----------------------------------------------------------------------
+
+# Deps
+# -----------------------------------------------------------------------
+
+# Project / Package
+# -----------------------------------------------------------------------
+
+
+# Refinements
+# =======================================================================
+
+
+# Namespace
+# =======================================================================
+
+module  NRSER
+
+
+# Definitions
+# =======================================================================
+
+# @todo document Config class.
+class Config
+  
+  # Constants
+  # ========================================================================
+
+  
+  # Mixins
+  # ========================================================================
+
+  include Hamster::Immutable
+  include Hamster::Enumerable
+  include Hamster::Associable
+  
+  
+  # Class Methods
+  # ========================================================================
+  
+  def self.deep_trie_merge trie, source, &block
+    to_put = {}
+
+    source.each_pair do |key, source_value|
+      _, trie_value = trie.get key
+
+      to_put[ key ] = if [ trie_value, source_value ].all? { |value|
+        NRSER.hash_like?( value ) && value.respond_to?( :deep_merge )
+      }
+        trie_value.deep_merge source_value, &block
+      elsif block
+        block.call key, trie_value, source_value
+      else
+        source_value
+      end
+    end
+
+    trie.bulk_put to_put
+  end # .deep_trie_merge
+
+  
+  # Attributes
+  # ========================================================================
+  
+  
+  # Construction
+  # ========================================================================
+  
+  # Instantiate a new `Config`.
+  def initialize *sources
+    @sources = sources
+    @trie = sources.reduce( Hamster::EmptyTrie ) { |trie, source|
+      self.class.deep_trie_merge trie, source
+    }
+
+  end # #initialize
+  
+  
+  # Instance Methods
+  # ========================================================================
+
+  # Retrieve the value corresponding to the provided key object. If not found,
+  # and this `Hash` has a default block, the default block is called to provide
+  # the value. Otherwise, return `nil`.
+  #
+  # @example
+  #   h = Hamster::Hash["A" => 1, "B" => 2, "C" => 3]
+  #   h["B"]             # => 2
+  #   h.get("B")         # => 2
+  #   h.get("Elephant")  # => nil
+  #
+  #   # Hamster Hash with a default proc:
+  #   h = Hamster::Hash.new("A" => 1, "B" => 2, "C" => 3) { |key| key.size }
+  #   h.get("B")         # => 2
+  #   h.get("Elephant")  # => 8
+  #
+  # @param [Array<Object>] key_path
+  #   The key to look up
+  # @return [Object]
+  # 
+  def get *key_path, type: nil, default: nil
+    first, *rest = key_path
+    entry = @trie.get first
+
+    value = if entry
+      current = entry[ 1 ]
+
+      while !current.nil? && !rest.empty?
+        first, *rest = rest
+
+        current = if current.respond_to? :dig
+          rest = [] # Short-circuit
+          current.dig *rest
+
+        elsif current.respond_to? :[]
+          current[ first ]
+        
+        elsif current.respond_to? :get
+          current.get first
+        
+        else
+          rest = []
+          default
+
+        end
+      end
+
+      current
+
+    else
+      default
+    end
+
+    parse_and_check key_path, value, type: type
+
+  end
+  alias :[] :get
+  alias :dig :get
+
+
+  def parse_and_check key_path, value, type: nil
+    return value if type.nil?
+  end
+
+
+  def each *args, &block
+    @trie.each *args, &block
+  end
+  
+  
+end # class Config
+
+# /Namespace
+# =======================================================================
+
+end # module NRSER

data/lib/nrser/labs/i8.rb

@@ -15,8 +15,6 @@ require 'hamster'
 # Project / Package
 # -----------------------------------------------------------------------
 require 'nrser/errors/type_error'
-require 'nrser/props/immutable/hash'
-require 'nrser/props/immutable/vector'
 
 require 'nrser/refinements/types'
 using NRSER::Types
@@ -33,171 +31,63 @@ module I8
   
   # Easy way to get the class names shorter..?
   class Vector < Hamster::Vector; end
+
+
   class Hash < Hamster::Hash; end
-  class Set < Hamster::Set; end
-  class SortedSet < Hamster::SortedSet; end
-  # class List < Hamster::List; end # Not a class! Ugh...
-  
-  
-  module Struct
-    
-    def self.check_new_args! vector_prop_defs, hash_prop_defs
-      
-      unless  (vector_prop_defs.empty? && !hash_prop_defs.empty?) ||
-              (!vector_prop_defs.empty? && hash_prop_defs.empty?)
-        
-        raise NRSER::ArgumentError.new \
-          "Exactly one of *args or **kwds must be empty",
-          
-          args: vector_prop_defs,
-          
-          kwds: hash_prop_defs,
-          
-          details: -> {%{
-            {I8::Struct.define} proxies to either
-            
-            1.  {I8::Struct::Vector.define}
-            2.  {I8::Struct::Hash.define}
-            
-            depending on *where* the property definitions are passed:
-            
-            1.  Positionally in `*args` -> {I8::Struct::Vector.new}
-            2.  By name in `**kwds` -> {I8::Struct::Hash.new}
-            
-            Examples:
-            
-            1.  Create a Point struct backed by an {I8::Vector}:
-                
-                    Point = I8::Struct.define [x: t.int], [y: t.int]
-                
-            2.  Create a Point struct backed by an {I8::Hash}:
-                
-                    Point = I8::Struct.define x: t.int, y: t.int
-            
-          }}
-        
-      end # unless vector_prop_defs.empty? XOR hash_prop_defs.empty?
-      
-    end # .check_new_args!
-    
-    private_class_method :check_new_args!
-    
-    
-    def self.define *vector_prop_defs, **hash_prop_defs, &body
-      check_new_args! vector_prop_defs, hash_prop_defs
-      
-      if !vector_prop_defs.empty?
-        raise "not implemented"
-        # I8::Struct::Vector.new
-      else
-        I8::Struct::Hash.new **hash_prop_defs, &body
-      end
-    end
-    
-    singleton_class.send :alias_method, :new, :define
-    
-    
-  end # module Struct
-  
+
   
-  class Struct::Hash < I8::Hash
-    include I8::Struct
-    include NRSER::Props::Immutable::Hash
-    
-    def self.define **prop_defs, &body
-      Class.new( I8::Struct::Hash ) do
-        prop_defs.each do |name, settings|
-          kwds = t.match settings,
-            t.type, ->( type ) {{ type: type }},
-            t.hash_, settings
-          
-          prop name, **kwds
-        end
-        
-        class_exec &body if body
-      end
-    end
-    
-    def self.new *args, **kwds, &block
-      if self == I8::Struct::Hash
-        define *args, **kwds, &block
+  class Set < Hamster::Set
+
+    # Get a {I8::Set} containing `items`.
+    #
+    # Overridden to...
+    #
+    # 1.  Return `items` if items is already a {I8::Set}... sort of like a copy
+    #     constructor that doesn't actually copy because the instances are
+    #     immutable.
+    #
+    # 2.  Return an instance of `self` pointing to `items`'s {Hamster::Trie}
+    #     if `items` is a {Hamster::Set}; this way you get an instance of
+    #     the correct class but don't do any additional instantiation.
+    # 
+    # 3.  Returns {.empty} if `items` responds to `#empty?` truthfully.
+    # 
+    # Otherwise, defers to `super`.
+    # 
+    # @param [#each] items
+    #   Items for the new set to contain.
+    # 
+    # @return [I8::Set]
+    #
+    def self.new items = []
+      case items
+      when self
+        items
+      when Hamster::Set
+        alloc items.instance_variable_get( :@trie )
       else
-        # See NOTE in {I8::Struct::Vector.new}
-        if kwds.empty?
-          super( *args, &block )
+        if items.respond_to?( :empty? ) && items.empty?
+          self.empty
         else
-          super( *args, **kwds, &block )
+          super items
         end
       end
     end
-  end
-  
-  
-  class Struct::Vector < I8::Vector
-    include I8::Struct
-    include NRSER::Props::Immutable::Vector
-    
-    def self.define *prop_defs, &body
-      # Unwrap `[name: type]` format
-      prop_defs.map! { |prop_def|
-        if  ::Array === prop_def &&
-            prop_def.length == 1 &&
-            ::Hash === prop_def[0]
-          prop_def[0]
-        else
-          prop_def
-        end
-      }
-      
-      # Check we have a list of pairs with label keys
-      t.array( t.pair( key: t.label ) ).check! prop_defs
-      
-      Class.new( I8::Struct::Vector ) do
-        prop_defs.each_with_index do |pair, index|
-          name, settings = pair.first
-          
-          kwds = t.match settings,
-            t.type, ->( type ) {{ type: type }},
-            t.hash_, settings
-          
-          prop name, **kwds, index: index
-        end
-        
-        class_exec &body if body
-      end
-    end
-    
-    
-    def self.new *args, **kwds, &block
-      if self == I8::Struct::Vector
-        unless kwds.empty?
-          raise NRSER::ArgumentError.new \
-            "Can not supply keyword args",
-            args: args,
-            kwds: kwds
-        end
-    
-        define *args, &block
-      else
-        # NOTE  This is... weird. Just doing the normal
-        #       
-        #           super( *args, **kwds, &block )
-        #       
-        #       results in `*args` becoming `[*args, {}]` up the super chain
-        #       when `kwds` is empty.
-        #       
-        #       I can't say I can understand it, but I seem to be able to fix
-        #       it.
-        # 
-        if kwds.empty?
-          super( *args, &block )
-        else
-          super( *args, **kwds, &block )
-        end
-      end
+
+    # Override to build our empty set through {.alloc} so that we can return
+    # it in {.new}.
+    # 
+    # @return [I8::Set]
+    # 
+    def self.empty
+      @empty ||= alloc Hamster::Trie.new( 0 )
     end
-    
-  end # class Struct::Vector
+
+  end # class Set
+
+
+  class SortedSet < Hamster::SortedSet; end
+  # class List < Hamster::List; end # Not a class! Ugh...
   
   
   def self.[] value