nrser 0.0.26 → 0.0.27

data/lib/nrser/rspex/shared_examples.rb

@@ -0,0 +1,116 @@
+# Declarations
+# =======================================================================
+
+module NRSER; end
+module NRSER::RSpex; end
+
+
+# Definitions
+# =======================================================================
+
+# Just a namespace module where I stuck shared examples, with lil' utils to
+# alias them to multiple string and symbol names if you like.
+# 
+module NRSER::RSpex::SharedExamples
+  
+  # Module (Class/self) Methods (Helpers)
+  # =====================================================================
+  
+  # Shitty but simple conversion of natural string names to more symbol-y
+  # ones.
+  # 
+  # @example
+  #   name_to_sym 'expect subject'
+  #   # => :expect_subject
+  # 
+  # @example
+  #   name_to_sym 'function'
+  #   # => :function
+  # 
+  # Doesn't do anything fancy-pants under the hood.
+  # 
+  # @param [String | Symbol] name
+  # 
+  # @return [Symbol]
+  # 
+  def self.name_to_sym name
+    name.
+      to_s.
+      gsub( /\s+/, '_' ).
+      gsub( /[^a-zA-Z0-9_]/, '' ).
+      downcase.
+      to_sym
+  end
+  
+  
+  # Bind a proc as an RSpec shared example to string and symbol names
+  def self.bind_names proc, name, prefix: nil
+    names = [name.to_s, name_to_sym( name )]
+    
+    unless prefix.nil?
+      names << "#{ prefix } #{ name}"
+      names << name_to_sym( "#{ prefix }_#{ name}" )
+    end
+    
+    names.each do |name|
+      shared_examples name, &proc
+    end
+  end
+  
+  
+  # Shared Example Blocks and Binding
+  # =====================================================================
+  
+  EXPECT_SUBJECT = ->( *expectations ) do
+    merge_expectations( *expectations ).each { |state, specs|
+      specs.each { |verb, noun|
+        it {
+          # like: is_expected.to(include(noun))
+          is_expected.send state, self.send(verb, noun)
+        }
+      }
+    }
+  end # is expected
+  
+  bind_names EXPECT_SUBJECT, "expect subject"
+  
+  
+  # Shared example for a functional method that compares input and output pairs.
+  # 
+  FUNCTION = ->( mapping: {}, raising: {} ) do
+    mapping.each { |args, expected|
+      # args = NRSER.as_array args
+      
+      # context "called with #{ args.map( &NRSER::RSpex.method( :short_s ) ).join ', ' }" do
+      #   subject { super().call *args }
+      describe_called_with *args do
+        
+        it {
+          expected = unwrap expected, context: self
+          
+          matcher = if expected.respond_to?( :matches? )
+            expected
+          elsif expected.is_a? NRSER::Message
+            expected.send_to self
+          else
+            eq expected
+          end
+          
+          is_expected.to matcher
+        }
+      end
+    }
+    
+    raising.each { |args, error|
+      args = NRSER.as_array args
+      
+      context "called with #{ args.map( &NRSER::RSpex.method( :short_s ) ).join ', ' }" do
+      # it "rejects #{ args.map( &:inspect ).join ', ' }" do
+        it { expect { subject.call *args }.to raise_error( *error ) }
+      end
+    }
+  end
+  
+  bind_names FUNCTION, 'function', prefix: 'a'
+  
+end # module NRSER::RSpex::SharedExamples

data/lib/nrser/string.rb

@@ -1,7 +1,20 @@
 require_relative './string/looks_like'
 
 module NRSER
+  # @!group String Functions
+  
+  WHITESPACE_RE = /\A[[:space:]]*\z/
+  
+  UNICODE_ELLIPSIS = '…'
+  
+  
+  def self.whitespace? string
+    string =~ WHITESPACE_RE
+  end
+  
+  
   class << self
+    
     # Functions the operate on strings.
     
     # turn a multi-line string into a single line, collapsing whitespace
@@ -17,34 +30,24 @@ module NRSER
     
     def common_prefix strings
       raise ArgumentError.new("argument can't be empty") if strings.empty?
-      sorted = strings.sort.reject {|line| line == "\n"}
+      
+      sorted = strings.sort
+      
       i = 0
+      
       while sorted.first[i] == sorted.last[i] &&
             i < [sorted.first.length, sorted.last.length].min
         i = i + 1
       end
-      strings.first[0...i]
+      
+      sorted.first[0...i]
     end # common_prefix
     
     
-    def dedent str
-      return str if str.empty?
-      lines = str.lines
-      indent = common_prefix(lines).match(/^\s*/)[0]
-      return str if indent.empty?
-      lines.map {|line|
-        line = line[indent.length..line.length] if line.start_with? indent
-      }.join
-    end # dedent
-    
-    # I like dedent better, but other libs seems to call it deindent
-    alias_method :deindent, :dedent
-    
-    
-    def filter_repeated_blank_lines str
+    def filter_repeated_blank_lines str, remove_leading: false
       out = []
       lines = str.lines
-      skipping = false
+      skipping = remove_leading
       str.lines.each do |line|
         if line =~ /^\s*$/
           unless skipping
@@ -60,16 +63,26 @@ module NRSER
     end # filter_repeated_blank_lines
     
     
-    # adapted from acrive_support 4.2.0
-    # 
-    # <https://github.com/rails/rails/blob/7847a19f476fb9bee287681586d872ea43785e53/activesupport/lib/active_support/core_ext/string/indent.rb>
-    #
-    def indent str, amount = 2, indent_string=nil, indent_empty_lines=false
-      indent_string = indent_string || str[/^[ \t]/] || ' '
-      re = indent_empty_lines ? /^/ : /^(?!$)/
-      str.gsub(re, indent_string * amount)
-    end
+    def lazy_filter_repeated_blank_lines source, remove_leading: false
+      skipping = remove_leading
+      
+      source = source.each_line if source.is_a? String
+      
+      Enumerator::Lazy.new source do |yielder, line|
+        if line =~ /^\s*$/
+          unless skipping
+            yielder << line
+          end
+          skipping = true
+        else
+          skipping = false
+          yielder << line
+        end
+      end
+      
+    end # filter_repeated_blank_lines
     
+
     # Truncates a given +text+ after a given <tt>length</tt> if +text+ is longer than <tt>length</tt>:
     #
     #   'Once upon a time in a world far far away'.truncate(27)
@@ -108,6 +121,125 @@ module NRSER
       "#{str[0, stop]}#{omission}"
     end
     
+    
+    # Cut the middle out of a string and stick an ellipsis in there instead.
+    # 
+    # @param [String] string
+    #   Source string.
+    # 
+    # @param [Fixnum] max
+    #   Max length to allow for the output string.
+    # 
+    # @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.
+    # 
+    # @return [String]
+    #   String of at most `max` length with the middle chopped out if needed
+    #   to do so.
+    def ellipsis string, max, omission: UNICODE_ELLIPSIS
+      return string unless string.length > max
+      
+      trim_to = max - omission.length
+      
+      start = string[0, (trim_to / 2) + (trim_to % 2)]
+      finish = string[-( (trim_to / 2) - (trim_to % 2) )..-1]
+      
+      start + omission + finish
+    end 
+    
+    
+    # **EXPERIMENTAL!**
+    # 
+    # Try to do "smart" job adding ellipsis to the middle of strings by 
+    # splitting them by a separator `split` - that defaults to `, ` - then
+    # building the result up by bouncing back and forth between tokens at the
+    # beginning and end of the string until we reach the `max` length limit.
+    # 
+    # Intended to be used with possibly long single-line strings like 
+    # `#inspect` returns for complex objects, where tokens are commonly 
+    # separated by `, `, and producing a reasonably nice result that will fit
+    # in a reasonable amount of space, like `rspec` output (which was the 
+    # motivation).
+    # 
+    # If `string` is already less than `max` then it is just returned.
+    # 
+    # If `string` doesn't contain `split` or just the first and last tokens
+    # alone would push the result over `max` then falls back to 
+    # {NRSER.ellipsis}.
+    # 
+    # If `max` is too small it's going to fall back nearly always... around 
+    # `64` has seemed like a decent place to start from screwing around on 
+    # the REPL a bit.
+    # 
+    # @param [String] string
+    #   Source string.
+    # 
+    # @param [Fixnum] max
+    #   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:
+    #   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:
+    #   The string to tokenize the `string` parameter by. If you pass a 
+    #   {Regexp} here it might work, it might loop out, maybe.
+    # 
+    # @return [String]
+    #   String of at most `max` length with the middle chopped out if needed
+    #   to do so.
+    # 
+    def smart_ellipsis string, max, omission: UNICODE_ELLIPSIS, split: ', '
+      return string unless string.length > max
+      
+      unless string.include? split
+        return ellipsis string, max, omission: omission
+      end
+      
+      tokens = string.split split
+      
+      char_budget = max - omission.length
+      start = tokens[0] + split
+      finish = tokens[tokens.length - 1]
+      
+      if start.length + finish.length > char_budget
+        return ellipsis string, max, omission: omission
+      end
+      
+      next_start_index = 1
+      next_finish_index = tokens.length - 2
+      next_index_is = :start
+      next_index = next_start_index
+      
+      while (
+        start.length + 
+        finish.length +
+        tokens[next_index].length +
+        split.length
+      ) <= char_budget do
+        if next_index_is == :start
+          start += tokens[next_index] + split
+          next_start_index += 1
+          next_index = next_finish_index
+          next_index_is = :finish
+        else # == :finish
+          finish = tokens[next_index] + split + finish
+          next_finish_index -= 1
+          next_index = next_start_index
+          next_index_is = :start
+        end
+      end
+      
+      start + omission + finish
+      
+    end # #method_name
+    
+    
+    
     # Get the constant identified by a string.
     # 
     # @example

data/lib/nrser/temp/unicode_math.rb

@@ -0,0 +1,48 @@
+module NRSER
+  module UnicodeMath
+    SET_STARTS = {
+      bold: {
+        upper: '1D400',
+        lower: '1D41A',
+      },
+      
+      bold_script: {
+        upper: '1D4D0',
+        lower: '1D4EA',
+      },
+    }
+    
+    class CharacterTranslator
+      def initialize name, upper_start, lower_start
+        @name = name
+        @upper_start = upper_start
+        @lower_start = lower_start
+      end
+      
+      def translate_char char
+        upper_offset = char.ord - 'A'.ord
+        lower_offset = char.ord - 'a'.ord
+        
+        if upper_offset >= 0 && upper_offset < 26
+          [ @upper_start.hex + upper_offset ].pack "U"
+        elsif lower_offset >= 0 && lower_offset < 26
+          [ @lower_start.hex + lower_offset ].pack "U"
+        else
+          char
+        end
+      end
+      
+      def translate string
+        string.each_char.map( &method( :translate_char ) ).join
+      end
+      
+      alias_method :[], :translate
+    end
+    
+    def self.[] name
+      name = name.to_sym
+      starts = SET_STARTS.fetch name
+      CharacterTranslator.new name, starts[:upper], starts[:lower]
+    end
+  end
+end

data/lib/nrser/text.rb

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

data/lib/nrser/text/indentation.rb

@@ -0,0 +1,210 @@
+# Requirements
+# =======================================================================
+
+# Stdlib
+# -----------------------------------------------------------------------
+
+# Deps
+# -----------------------------------------------------------------------
+
+# Project / Package
+# -----------------------------------------------------------------------
+require_relative './lines'
+
+
+module NRSER
+  # @!group Text
+  
+  
+  # Constants
+  # =====================================================================
+  
+  INDENT_RE = /\A[\ \t]*/
+  
+  INDENT_TAG_MARKER     = "\x1E"
+  INDENT_TAG_SEPARATOR  = "\x1F"
+  
+  
+  # Functions
+  # =====================================================================
+  
+  def self.find_indent text
+    common_prefix lines( text ).map { |line| line[INDENT_RE] }
+  end
+  
+  
+  def self.indented? text
+    !( find_indent( text ).empty? )
+  end
+  
+  
+  # adapted from active_support 4.2.0
+  # 
+  # <https://github.com/rails/rails/blob/7847a19f476fb9bee287681586d872ea43785e53/activesupport/lib/active_support/core_ext/string/indent.rb>
+  #
+  def self.indent text,
+                  amount = 2,
+                  indent_string: nil,
+                  indent_empty_lines: false,
+                  skip_first_line: false
+    if skip_first_line
+      lines = self.lines text
+      
+      lines.first + indent(
+        rest( lines ).join,
+        amount,
+        indent_string: indent_string,
+        skip_first_line: false
+      )
+      
+    else
+      indent_string = indent_string || text[/^[ \t]/] || ' '
+      re = indent_empty_lines ? /^/ : /^(?!$)/
+      text.gsub re, indent_string * amount
+      
+    end
+  end
+  
+  
+  def self.dedent text, ignore_whitespace_lines: true
+    return text if text.empty?
+    
+    all_lines = text.lines
+    
+    indent_significant_lines = if ignore_whitespace_lines
+      all_lines.reject { |line| whitespace? line }
+    else
+      all_lines
+    end
+    
+    indent = find_indent indent_significant_lines
+    
+    return text if indent.empty?
+    
+    all_lines.map { |line|
+      if line.start_with? indent
+        line[indent.length..-1]
+      elsif line.end_with? "\n"
+        "\n"
+      else
+        ""
+      end
+    }.join
+  end # .dedent
+  
+  # I like dedent better, but other libs seems to call it deindent
+  singleton_class.send :alias_method, :deindent, :dedent
+  
+  
+  # Tag each line of `text` with special marker characters around it's leading
+  # indent so that the resulting text string can be fed through an
+  # interpolation process like ERB that may inject multiline strings and the
+  # result can then be fed through {NRSER.indent_untag} to apply the correct
+  # indentation to the interpolated lines.
+  # 
+  # Each line of `text` is re-formatted like:
+  # 
+  #     "<marker><leading_indent><separator><line_without_leading_indent>"
+  # 
+  # `marker` and `separator` can be configured via keyword arguments, but they
+  #  default to:
+  # 
+  # -   `marker` - {NRSER::INDENT_TAG_MARKER}, the no-printable ASCII 
+  #     *record separator* (ASCII character 30, "\x1E" / "\u001E").
+  #     
+  # -   `separator` - {NRSER::INDENT_TAG_SEPARATOR}, the non-printable ASCII
+  #     *unit separator* (ASCII character 31, "\x1F" / "\u001F")
+  # 
+  # @example With default marker and separator
+  #   NRSER.indent_tag "    hey there!"
+  #   # => "\x1E    \x1Fhey there!"
+  # 
+  # @param [String] text
+  #   String text to indent tag.
+  # 
+  # @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:
+  #   Special string to separate the leading indent from the rest of the line.
+  # 
+  # @return [String]
+  #   Tagged text.
+  #     
+  def self.indent_tag text,
+                      marker: INDENT_TAG_MARKER,
+                      separator: INDENT_TAG_SEPARATOR
+    text.lines.map { |line|
+      indent = if match = INDENT_RE.match( line )
+        match[0]
+      else
+        ''
+      end
+      
+      "#{ marker }#{ indent }#{ separator }#{ line[indent.length..-1] }"
+    }.join
+  end # .indent_tag
+  
+  
+  # Reverse indent tagging that was done via {NRSER.indent_tag}, indenting
+  # any untagged lines to the same level as the one above them.
+  # 
+  # @param [String] text
+  #   Tagged text string.
+  # 
+  # @param [String] marker:
+  #   Must be the marker used to tag the text.
+  # 
+  # @param [String] separator:
+  #   Must be the separator used to tag the text.
+  # 
+  # @return [String]
+  #   Final text with interpolation and indent correction.
+  # 
+  def self.indent_untag text,
+                        marker: INDENT_TAG_MARKER,
+                        separator: INDENT_TAG_SEPARATOR
+    
+    current_indent = ''
+    
+    text.lines.map { |line|
+      if line.start_with? marker
+        current_indent, line = line[marker.length..-1].split( separator, 2 )
+      end
+      
+      current_indent + line
+      
+    }.join
+    
+  end # .indent_untag
+  
+  
+  
+  # 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:
+  #   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:
+  #   Must be the separator used to tag the text.
+  # 
+  # @return [String]
+  #   Final text with interpolation and indent correction.
+  # 
+  def self.with_indent_tagged text,
+                              marker: INDENT_TAG_MARKER,
+                              separator: INDENT_TAG_SEPARATOR,
+                              &interpolate_block
+    indent_untag(
+      interpolate_block.call(
+        indent_tag text, marker: marker, separator: separator
+      ),
+      marker: marker,
+      separator: separator,
+    )
+  end # .with_indent_tagged
+  
+end # module NRSER