nrser 0.1.4 → 0.2.0.pre.0

data/lib/nrser/functions/string/style.rb

@@ -0,0 +1,71 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+##
+# Functional methods to stylize a string through substitution
+##
+
+module NRSER
+  
+  # @!group String Functions
+  # ============================================================================
+  
+  # Proxies to {NRSER::Char::AlphaNumericSub#sub} on
+  # {NRSER::Char::AlphaNumericSub.unicode_math_italic} to convert regular
+  # UTF-8/ASCII `a-zA-Z` characters to the "Unicode Math Italic" set.
+  # 
+  # @param [String] string
+  #   Input.
+  # 
+  # @return [String]
+  #   Output. Probably won't be `#ascii_only?`.
+  # 
+  def self.u_italic string
+    NRSER::Char::AlphaNumericSub.unicode_math_italic.sub string
+  end
+  
+  
+  # Proxies to {NRSER::Char::AlphaNumericSub#sub} on
+  # {NRSER::Char::AlphaNumericSub.unicode_math_italic} to convert regular
+  # UTF-8/ASCII `a-zA-Z` characters to the "Unicode Math Italic" set.
+  # 
+  # @param [String] string
+  #   Input.
+  # 
+  # @return [String]
+  #   Output. Probably won't be `#ascii_only?`.
+  # 
+  def self.u_bold string
+    NRSER::Char::AlphaNumericSub.unicode_math_bold.sub string
+  end
+  
+  
+  # Proxies to {NRSER::Char::AlphaNumericSub#sub} on
+  # {NRSER::Char::AlphaNumericSub.unicode_math_bold_italic} to convert regular
+  # UTF-8/ASCII `a-zA-Z` characters to the "Unicode Math Bold Italic" set.
+  # 
+  # @param [String] string
+  #   Input.
+  # 
+  # @return [String]
+  #   Output. Probably won't be `#ascii_only?`.
+  # 
+  def self.u_bold_italic string
+    NRSER::Char::AlphaNumericSub.unicode_math_bold_italic.sub string
+  end
+  
+  
+  # Proxies to {NRSER::Char::AlphaNumericSub#sub} on
+  # {NRSER::Char::AlphaNumericSub.unicode_math_monospace} to convert regular
+  # UTF-8/ASCII `a-zA-Z` characters to the "Unicode Math Monospace" set.
+  # 
+  # @param [String] string
+  #   Input.
+  # 
+  # @return [String]
+  #   Output. Probably won't be `#ascii_only?`.
+  # 
+  def self.u_mono string
+    NRSER::Char::AlphaNumericSub.unicode_math_monospace.sub string
+  end
+  
+end # module NRSER

data/lib/nrser/mean_streak.rb

@@ -12,6 +12,8 @@ require 'commonmarker'
 
 # Project / Package
 # -----------------------------------------------------------------------
+require_relative './mean_streak/document'
+
 
 # Refinements
 # =======================================================================
@@ -61,14 +63,32 @@ class NRSER::MeanStreak
   # @return [CommonMarker::Node]
   #   The `document` node.
   # 
-  def self.parse text, options = :DEFAULT, extensions = []
-    
+  def self.parse source, options = :DEFAULT, extensions = []
+    default.parse source, cm_options: options, cm_extensions: extensions
+  end
+  
+  
+  # TODO document `type_renderers` attribute.
+  # 
+  # @return [Hash<Symbol, Proc>]
+  #     
+  attr_reader :type_renderers
+  
+  
+  
+  def initialize &block
+    @type_renderers = {}
+    block.call( self ) if block
   end
   
   
   # Instance Methods
   # ============================================================================
   
+  def render_type type, &renderer
+    @type_renderers[type] = renderer
+  end
+  
   
   # @todo Document parse method.
   # 
@@ -86,10 +106,15 @@ class NRSER::MeanStreak
   end # #parse
   
   
+  def render doc_or_source
+    doc = if doc_or_source.is_a? NRSER::MeanStreak::Document
+      doc_or_source
+    else
+      parse doc_or_source
+    end
+    
+    doc.render
+  end
+  
+  
 end # class NRSER::ShellDown
-
-
-# Post-Processing
-# =======================================================================
-
-require_relative './mean_streak/document'

data/lib/nrser/mean_streak/document.rb

@@ -1,30 +1,30 @@
+# encoding: UTF-8
 # frozen_string_literal: true
 
 # Requirements
 # =======================================================================
 
-# Stdlib
-# -----------------------------------------------------------------------
-
 # Deps
 # -----------------------------------------------------------------------
-
-# Project / Package
-# -----------------------------------------------------------------------
+require 'pastel'
 
 
 # Refinements
 # =======================================================================
 
+using NRSER
+using NRSER::Types
+
 
 # Declarations
 # =======================================================================
 
+class NRSER::MeanStreak; end
+
 
 # Definitions
 # =======================================================================
 
-
 # @todo document NRSER::MeanStreak::Document class.
 class NRSER::MeanStreak::Document
   
@@ -49,7 +49,7 @@ class NRSER::MeanStreak::Document
                   cm_extensions: []
     new mean_streak: mean_streak,
         source: source,
-        doc: CommonMarker.render_doc( source, options, extensions )
+        doc: CommonMarker.render_doc( source, cm_options, cm_extensions )
   end # .parse
   
   singleton_class.send :alias_method, :from_string, :parse
@@ -99,53 +99,238 @@ class NRSER::MeanStreak::Document
   
   # Instance Methods
   # ======================================================================
-
+  
+  def pastel
+    @pastel ||= Pastel.new
+  end
+  
+  
   # The lines in {#source} as a {Hamster::Vector} of frozen strings.
   # 
   # @return [Hamster::Vector<String>]
   # 
   def source_lines
-    @source_lines = Hamster::Vector.new source.lines.map( &:freeze )
+    @source_lines ||= Hamster::List[*source.lines.map( &:freeze )]
   end
-
-
+  
+  
+  def source_byte_indexes node
+    pos = node.sourcepos
+    
+    indexes = {
+      first_byte: {
+        line: pos[:start_line] - 1,
+        column: pos[:start_column] - 1,
+      },
+      last_byte: {
+        line: pos[:end_line] - 1,
+        column: pos[:end_column] - 1,
+      },
+    }
+    
+    indexes.each do |key, byte_index_pos|
+      byte_index_pos[:index] = source_byte_index **byte_index_pos
+    end
+    
+    indexes
+  end
+  
+  
+  def source_byte_index line:, column:
+    # source_lines[0...line].map( &:bytesize ).reduce( column, :+ )
+    byte_index = column
+    if line > 0
+      source_lines[0..(line - 1)].each { |_| byte_index += _.bytesize }
+    end
+    byte_index
+  end
+  
+  
+  def source_byteslice **kwds
+    t.and(
+      # All the values must be `nil` or non-negative integer
+      t.hash_(keys: t.sym, values: t.non_neg_int?),
+      # Exactly one of `start_on` and `start_after` must be `nil`
+      t.xor(t.shape(start_on: nil), t.shape(start_after: nil)),
+      # Exactly one of `end_on` and `end_before` must be `nil`
+      t.xor(t.shape(end_on: nil), t.shape(end_before: nil))
+    ).check kwds
+    
+    # The first byte we're gonna slice is either the `start_on` keyword
+    # provided or the `start_after` bumped forward by 1 (which we can do
+    # because it must point to the last *byte* before the slice, *not the
+    # character*, so +1 gets us to the first slice byte)
+    start_on = kwds[:start_on] || (kwds[:start_after] + 1)
+    
+    # In the same way, we can figure out the last byte after the slice
+    end_before = kwds[:end_before] || (kwds[:end_on] + 1)
+    
+    # Sanity check
+    if start_on > end_before
+      # We done fucked up, which is not that unusual for me with this shit
+      raise "Shit... start_on: #{ start_on }, end_before: #{ end_before }"
+    end
+    
+    # Take the slice... the `...` range seems kinda easier 'cause the resulting
+    # byte size is the difference `next_byte - end_before`
+    source.byteslice start_on...end_before
+  end
+  
+  
   # Get the substring of the source that a node came from (via its
   # `#sourcepos`).
   # 
   # @return [String]
   # 
   def source_for_node node
-    pos = node.sourcepos
+    indexes = source_byte_indexes node
     
-    if pos[:start_line] == pos[:end_line]
-      source_lines[pos[:start_line] - 1][
-        (pos[:start_column] - 1)...pos[:end_column]
-      ]
-    else
-      lines = source_lines[(pos[:start_line] - 1)...pos[:end_line]]
-      
-      # Trim the start off the first line, unless the start column is 1
-      unless pos[:start_column] == 1
-        lines[0] = lines[0][(pos[:start_column] - 1)..-1]
+    # This one is *really* easy now!
+    source_byteslice(
+      # Start on the first byte
+      start_on: indexes[:first_byte][:index],
+      # End on the last
+      end_on: indexes[:last_byte][:index]
+    )
+  end
+  
+  
+  def source_between start_node, end_node
+    # Ok, all we do is take a byte slice based on their byte indexes
+    source_byteslice(
+      # The index of the start node's last type is the byte just *before*
+      # the slice starts
+      start_after: source_byte_indexes( start_node )[:last_byte][:index],
+      # The index of the end node's first byte is the byte just *after* the
+      # slice ends
+      end_before: source_byte_indexes( end_node )[:first_byte][:index]
+    )
+  end
+  
+  
+  def source_before_first_child node
+    slice = source_byteslice(
+      start_on: source_byte_indexes( node )[:first_byte][:index],
+      end_before: source_byte_indexes( node.first )[:first_byte][:index],
+    )
+    
+    # See comments in {#render_children}
+    if  mean_streak.type_renderers[:code] &&
+        node.first.type == :code &&
+        slice.start_with?( '`' )
+      slice = slice.sub /\A`+/, ''
+    end
+    
+    slice
+  end
+  
+  
+  def source_after_last_child node
+    last_child = node.each.to_a.last
+    
+    slice = source_byteslice(
+      start_after: source_byte_indexes( last_child )[:last_byte][:index],
+      end_on: source_byte_indexes( node )[:last_byte][:index]
+    )
+    
+    # See comments in {#render_children}
+    if  mean_streak.type_renderers[:code] &&
+        last_child.type == :code &&
+        slice.end_with?( '`' )
+      slice = slice.sub /`+\z/, ''
+    end
+    
+    slice
+  end
+  
+  
+  def render_children node
+    prev = nil
+    parts = []
+    node.each do |child|
+      unless prev.nil?
+        between = source_between( prev, child )
+        
+        # We may need to modify the source strings *surrounding* specific
+        # nodes...
+        # 
+        # `:code` is an example thus far: it stores the code string in
+        # `#string_content` so - unlike `:emph` and `:strong` where the
+        # delimiters end up in the "before first child" and "after last child"
+        # *inside* the node's source slice - in `:code` they end up *outside*,
+        # in the source between it and the previous and next sibling nodes.
+        # 
+        # 
+        # 
+        if mean_streak.type_renderers[:code]
+          # There is a renderer for the `:code` type, so assume that it will
+          # take are of any surrounding characters for `:code` strings and
+          # chomp off the starting and ending backticks
+          if prev.type == :code
+            # Previous node is `:code`, chomp off any leading backtick
+            # between = between[1..-1] if between.start_with?( '`' )
+            between = between.sub /\A`+/, ''
+          elsif child.type == :code
+            # Current node is `:code`, chomp off any leading backtick
+            between = between.sub /`+\z/, ''
+          end
+        end
+        
+        parts << between
       end
       
-      # Trim the end off the first line, unless the end column is the last
-      # line's length
-      unless pos[:end_column] == lines[-1].length
-        lines[-1] = lines[-1][0...pos[:end_column]]
-      end
+      parts << render_node( child )
       
-      lines.join
+      prev = child
     end
+    
+    parts.join
   end
-
-
-  def render_node node, output = ''
+  
+  
+  def render_node_2 prev_node, source_before, node, source_after, next_node
     
   end
   
-end # class NRSER::MeanStreak::Document
-
 
-# Post-Processing
-# =======================================================================
+  def render_node node
+    if mean_streak.type_renderers[node.type]
+      mean_streak.type_renderers[node.type].call self, node
+    else
+      if node.first
+        # Has children
+        source_before_first_child( node ) +
+        render_children( node ) +
+        source_after_last_child( node )
+      else
+        # No children! Easy!
+        source_for_node node
+      end
+    end
+  end
+  
+  
+  def render
+    render_node doc
+  end
+  
+  
+  def find_by **attrs
+    doc.walk.find_all { |node|
+      attrs.all? { |name, value|
+        begin
+          value === node.send( name )
+        rescue
+          false
+        end
+      }
+    }
+  end
+  
+  
+  def find_type type
+    doc.walk.find_all { |node| node.type == type }
+  end
+  
+  
+end # class NRSER::MeanStreak::Document