nrser 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1518d7452a93418bee72c151693e9f6499a41d6a
-  data.tar.gz: 5139a61976788fb0bb8c397a40eec24d20c695d7
+  metadata.gz: 10930bb8b3998cc81f95333c8eb86a102262d84e
+  data.tar.gz: ff5057aead5992fe1d053e814afd120278b80a4c
 SHA512:
-  metadata.gz: eb32f1311827dc0190db71434a798953282e3d258b3059aea03b86f6e56b57f871b7c5e8dcfe4b99844db1ec65b8782bf0c7ef3a099f1423ceeddcdf8b5ea16b
-  data.tar.gz: 67aad6c06d72fb6123dc74294e113bd9f2862a9eca317e64277aae9fb68169e9c48dc5e9248788ca475e1d30f2314b7cdd6958ee12792880be4ccc859c5fa6b8
+  metadata.gz: f64f47ddbbb195eb13f072aec1f0beb8ff8299dbf9bc40838a2dcb078fd401fc03509c6566f497041ca0b3d5fc95f4b0baee0e7cb390e7238182a0e14e51ee50
+  data.tar.gz: ba2da8fe57e5d3e9f2c1439fa978957327982624c1a536b1bbf950901783d66808c44042d0f01f4ce7c8ec4333a93fb29904878c3165bc010dd099eddd864265

data/lib/nrser.rb

@@ -17,10 +17,11 @@ require 'yaml'
 require 'logger'
 require 'singleton'
 
-
 # Deps
 # -----------------------------------------------------------------------
 require 'hamster'
+require 'semantic_logger'
+
 
 # Hi there!
 # 
@@ -47,28 +48,25 @@ require 'hamster'
 # Enjoy!
 # 
 module NRSER
-  
-  # Absolute, expanded path to the gem's root directory.
-  # 
-  # @return [Pathname]
-  # 
-  ROOT = ( Pathname.new(__FILE__).dirname / '..' ).expand_path
-  
+  include SemanticLogger::Loggable
 end
 
-# 1.  Load up extension mixins first - they don't invoke anything, just define
+# 1.  Load up version, which has {NRSER::ROOT} in it and depends on nothing
+#     else
+require_relative './nrser/version'
+
+# 2.  Load up extension mixins first - they don't invoke anything, just define
 #     methods
 require_relative './nrser/ext'
 
-# 2.  Then load up the refinements, which either include the extension mixins
+# 3.  Then load up the refinements, which either include the extension mixins
 #     or directly define proxies and methods (but don't execute them).
 #     
 #     This way everything else should be able to use them.
 #     
 require_relative './nrser/refinements'
 
-# 3.  Then everything else...
-require_relative './nrser/version'
+# 4.  Then everything else...
 require_relative './nrser/char'
 require_relative './nrser/errors'
 require_relative './nrser/no_arg'

data/lib/nrser/ext.rb

@@ -3,3 +3,4 @@ module NRSER::Ext; end
 require_relative './ext/enumerable'
 require_relative './ext/tree'
 require_relative './ext/pathname'
+require_relative './ext/string'

data/lib/nrser/ext/enumerable.rb

@@ -64,4 +64,10 @@ module NRSER::Ext::Enumerable
     NRSER.find_map self, *args, &block
   end
   
+  # See {NRSER.slice?}
+  def slice? *args, &block
+    NRSER.slice? self, *args, &block
+  end
+  
+  
 end # module NRSER::Ext::Enumerable

data/lib/nrser/ext/string.rb

@@ -0,0 +1,62 @@
+# Extension methods for {String}
+# 
+module NRSER::Ext::String
+  
+  def squish
+    NRSER.squish self
+  end
+  
+  
+  def unblock
+    NRSER.unblock self
+  end
+  
+  
+  def dedent
+    NRSER.dedent self
+  end
+  
+  
+  def indent *args
+    NRSER.indent self, *args
+  end
+  
+  
+  def truncate *args
+    NRSER.truncate self, *args
+  end
+  
+  
+  # See {NRSER.constantize}
+  def constantize
+    NRSER.constantize self
+  end
+  
+  alias_method :to_const, :constantize
+  
+  
+  # @return [Pathname]
+  #   Convert self into a {Pathname}
+  # 
+  def to_pn
+    Pathname.new self
+  end
+  
+  
+  def whitespace?
+    NRSER.whitespace? self
+  end
+  
+  
+  # Calls {NRSER.ellipsis} on `self`.
+  def ellipsis *args
+    NRSER.ellipsis self, *args
+  end
+  
+  
+  # Calls {NRSER.words} on `self`
+  def words *args, &block
+    NRSER::words self, *args, &block
+  end
+  
+end # module NRSER::Ext::String

data/lib/nrser/functions/enumerable.rb

@@ -1,5 +1,6 @@
 require_relative './enumerable/find_map'
 require_relative './enumerable/find_all_map'
+require_relative './enumerable/include_slice'
 
 module NRSER
   

data/lib/nrser/functions/enumerable/include_slice.rb

@@ -0,0 +1,84 @@
+require_relative './include_slice/array_include_slice'
+
+using NRSER
+
+module NRSER
+  
+  # @!group Enumerable Functions
+  
+  # See if an `enum` includes a `slice`, using an optional block to do custom
+  # matching.
+  # 
+  # @example Order matters
+  #   NRSER.slice? [1, 2, 3], [2, 3]
+  #   # => true
+  #   
+  #   NRSER.slice? [1, 2, 3], [3, 2]
+  #   # => false
+  # 
+  # @example The empty slice is always present
+  #   NRSER.slice? [1, 2, 3], []
+  #   # => true
+  #   
+  #   NRSER.slice? [], []
+  #   # => true
+  # 
+  # @example Custom `&is_match` block to prefix-match
+  #   NRSER.slice?(
+  #     ['neil', 'mica', 'hudie'],
+  #     ['m', 'h']
+  #   ) { |enum_entry, slice_entry|
+  #     enum_entry.start_with? slice_entry
+  #   }
+  #   # => true
+  # 
+  # @note
+  #   Right now, just forwards to {NRSER.array_include_slice?}, which requires
+  #   that the {Enumerable}s support {Array}-like `#length` and `#slice`. I
+  #   took a swing at the general case but it came out messy and only partially
+  #   correct.
+  # 
+  # @param [Enumerable] enum
+  #   Sequence to search in.
+  # 
+  # @param [Enumerable] slice
+  #   Slice to search for.
+  # 
+  # @return [Boolean]
+  #   `true` if `enum` has a slice matching `slice`.
+  # 
+  def self.include_slice? enum, slice, &is_match
+    # Check that both args are {Enumerable}
+    unless  Enumerable === enum &&
+            Enumerable === slice
+      raise TypeError.new binding.erb <<-END
+        Both `enum` and `slice` must be {Enumerable}
+        
+        enum (<%= enum.class.name %>):
+        
+            <%= enum.pretty_inspect %>
+        
+        slice (<%= slice.class.name %>):
+        
+            <%= slice.pretty_inspect %>
+        
+      END
+    end
+    
+    if [enum, slice].all? { |e|
+      e.respond_to?( :length ) && e.respond_to?( :slice )
+    }
+      return array_include_slice? enum, slice, &is_match
+    end
+    
+    raise NotImplementedError.new binding.erb <<-END
+      Sorry, but general {Enumerable} slice include has not been implemented
+      
+      It's kinda complicated, or at least seems that way at first, so I'm
+      going to punt for now...
+    END
+  end
+  
+  singleton_class.send :alias_method, :slice?, :include_slice?
+  
+end # module NRSER

data/lib/nrser/functions/enumerable/include_slice/array_include_slice.rb

@@ -0,0 +1,80 @@
+
+module NRSER
+  
+  # @!group Enumerable Functions
+  
+  # Test slice inclusion when both the `slice` and the `enum` that we're
+  # going to look for it in support `#length` and `#slice`
+  # in the same manner that {Array} does (hence the name).
+  # 
+  # This is much simpler and more efficient than the "general" {Enumerable}
+  # case where we can't necessarily find out how many entries are in the
+  # enumerables or really do much of anything with them except iterate through
+  # (at least, with my current grasp of {Enumerable} and {Enumerator} it
+  # seems painfully complex... in fact it may never terminate for infinite
+  # enumerables).
+  # 
+  # @param [Enumerable<E> & #length & #slice] enum
+  #   The {Enumerable} that we want test for `slice` inclusion. Must
+  #   support `#length` and `#slice` like {Array} does.
+  # 
+  # @param [Enumerable<S> & #length & #slice] slice
+  #   The {Enumerable} slice that we want to see if `enum` includes. Must
+  #   support `#length` and `#slice` like {Array} does.
+  # 
+  # @param [Proc<(E, S)=>Boolean>] &is_match
+  #   Optional {Proc} that accepts an entry from `enum` and an entry from
+  #   `slice` and returns if they match.
+  # 
+  # @return [Boolean]
+  #   `true` if there is a slice of `enum` for which each entry matches the
+  #   corresponding entry in `slice` according to `&is_match`.
+  # 
+  def self.array_include_slice? enum, slice, &is_match
+    slice_length = slice.length
+    
+    # Short-circuit on empty slice - it's *always* present
+    return true if slice_length == 0
+    
+    enum_length = enum.length
+    
+    # Short-circuit if slice is longer than enum since we can't possibly
+    # match
+    return false if slice_length > enum_length
+    
+    # Create a default `#==` matcher if we weren't provided one.
+    if is_match.nil?
+      is_match = ->(enum_entry, slice_entry) {
+        enum_entry == slice_entry
+      }
+    end
+    
+    enum.each_with_index do |enum_entry, enum_start_index|
+      # Compute index in `enum` that we would need to match up to
+      enum_end_index = enum_start_index + slice_length - 1
+      
+      # Short-circuit if can't match (more slice entries than enum ones left)
+      return false if enum_end_index >= enum_length
+      
+      # Create the slice to test against
+      enum_slice = enum[enum_start_index..enum_end_index]
+      
+      # See if every entry in the slice from `enum` matches the corresponding
+      # one in `slice`
+      return true if enum_slice.zip( slice ).all?( &is_match )
+      
+      # Otherwise, just continue on through `enum` looking for that first
+      # match until the number of `enum` entries left is too few for `slice`
+      # to possibly match
+    end
+    
+    # We never matched the first `slice` entry to a `enum` entry (and `slice`
+    # had to be of length 1 so that the "too long" short-circuit never fired).
+    # 
+    # So, we don't have a match.
+    false
+  end
+  
+  singleton_class.send :alias_method, :array_slice?, :array_include_slice?
+  
+end # module NRSER

data/lib/nrser/functions/text.rb

@@ -1,3 +1,4 @@
 require_relative './text/lines'
 require_relative './text/word_wrap'
 require_relative './text/indentation'
+require_relative './text/words'

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

@@ -0,0 +1,23 @@
+module NRSER
+  
+  # Regexp {NRSER.words} uses to split strings. Probably not great but it's
+  # what I have for the moment.
+  # 
+  # @return {Regexp}
+  # 
+  SPLIT_WORDS_RE = /[\W_\-\/]+/
+  
+  
+  # Split a string into 'words' for word-based matching.
+  # 
+  # @param [String] string
+  #   Input string.
+  # 
+  # @return [Array<String>]
+  #   Array of non-empty words in `string`.
+  # 
+  def self.words string
+    string.split(/[\W_\-\/]+/).reject { |w| w.empty? }
+  end # .words
+  
+end # module NRSER

data/lib/nrser/labs.rb

@@ -0,0 +1,13 @@
+# Namespace for new ideas I'm trying out. Totally unstable. May be gone
+# completely tomorrow, etc.
+# 
+# While, yes, the entire package is alpha, and there is no guarantee against
+# change and breakage, I'm generally at a point where I'm trying to keep
+# things that work mostly working.
+# 
+# Stuff in here has no such consideration.
+# 
+# There may be some tests for it, but they are going to be skipped by default
+# and certainly won't prevent releases, if they're even run at all.
+# 
+module NRSER::Labs; end

data/lib/nrser/labs/globlin.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+# Requirements
+# =======================================================================
+
+# Stdlib
+# -----------------------------------------------------------------------
+
+# Deps
+# -----------------------------------------------------------------------
+
+# Project / Package
+# -----------------------------------------------------------------------
+
+
+# Refinements
+# =======================================================================
+
+
+# Declarations
+# =======================================================================
+
+module NRSER::Labs; end
+
+
+# Definitions
+# =======================================================================
+
+
+# @todo document NRSER::Labs::Globlin class.
+class NRSER::Labs::Globlin
+  
+  
+  # @todo document Matcher class.
+  class Matcher
+    def match entry
+      if entry.is_a?( NRSER::Globlin )
+        
+      else
+        
+      end
+    end
+  end # class Matcher
+  
+  
+  # Constants
+  # ======================================================================
+  
+  
+  # Class Methods
+  # ======================================================================
+  
+  
+  # Attributes
+  # ======================================================================
+  
+  
+  # Constructor
+  # ======================================================================
+  
+  # Instantiate a new `NRSER:Globlin`.
+  def initialize split:, ignore: nil
+    @split = Array split
+    
+    
+  end # #initialize
+  
+  
+  # Instance Methods
+  # ======================================================================
+  
+  def matcher_for search_string
+    @split.each
+  end
+  
+  
+  def find_only! search_string
+    matcher = matcher_for search_string
+    
+    # Search entries that have the same seg count first
+    found = @seg_count_index[matcher.seg_count].find_all_map { |entry|
+      matcher.match entry
+    }
+    
+    case found.length
+    when 0
+      # move on..
+    when 1
+      return found[0]
+    else
+      raise TooManyError.new found
+    end
+    
+    # Ok, try slice matches for entries with *more* segments only
+    slice_matches = @seg_count_index.keys.
+      select { |count| count > matcher.seg_count }.
+      map { |key| @seg_count_index[key] }.
+      reduce( :+ ).
+      select { |entry|
+        matcher.match_slice entry
+      }
+    
+    
+  end
+  
+end # class NRSER::Labs::Globlin