mustermann 1.0.2.rc1 → 1.0.2.rc2

data/mustermann-contrib/lib/mustermann/visualizer/highlighter/composite.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-module Mustermann
-  module Visualizer
-    # @!visibility private
-    module Highlighter
-      # @!visibility private
-      module Composite
-        extend self
-
-        # @!visibility private
-        def highlight?(pattern)
-          pattern.is_a? Mustermann::Composite
-        end
-
-        # @!visibility private
-        def highlight(pattern, renderer)
-          operator = " #{pattern.operator} "
-          patterns = pattern.patterns.map { |p| highlight_nested(p, renderer) }.join(quote(renderer, operator))
-          renderer.pre(:composite) + patterns + renderer.post(:composite)
-        end
-
-        # @!visibility private
-        def highlight_nested(pattern, renderer)
-          highlighter = Highlighter.highlighter_for(pattern)
-          if highlighter.respond_to? :nested_highlight
-            highlighter.nested_highlight(pattern, renderer)
-          else
-            type  = quote(renderer, pattern.class.name[/[^:]+$/].downcase + ":", :type)
-            quote = quote(renderer, ?")
-            type + quote + highlighter.highlight(pattern, renderer) + quote
-          end
-        end
-
-        # @!visibility private
-        def nested_highlight(pattern, renderer)
-          quote(renderer, ?() + highlight(pattern, renderer) + quote(renderer, ?))
-        end
-
-        # @!visibility private
-        def quote(renderer, string, type = :quote)
-          renderer.pre(type) + renderer.escape(string, string) + renderer.post(type)
-        end
-      end
-    end
-  end
-end

data/mustermann-contrib/lib/mustermann/visualizer/highlighter/dummy.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-module Mustermann
-  module Visualizer
-    # @!visibility private
-    module Highlighter
-      # Provides highlighting for patterns that don't have a highlighter.
-      # @!visibility private
-      module Dummy
-        # @!visibility private
-        def self.highlight(pattern, renderer)
-          output = String.new
-          output << renderer.pre(:root) << renderer.pre(:unknown)
-          output << renderer.escape(pattern.to_s)
-          output << renderer.post(:unknown) << renderer.post(:root)
-        end
-      end
-    end
-  end
-end

data/mustermann-contrib/lib/mustermann/visualizer/highlighter/regular.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-require 'strscan'
-
-module Mustermann
-  module Visualizer
-    # @!visibility private
-    module Highlighter
-      # Provides highlighting for {Mustermann::Regular}
-      # @!visibility private
-      class Regular
-        # @!visibility private
-        SPECIAL_ESCAPE = ['w', 'W', 'd', 'D', 'h', 'H', 's', 'S', 'G', 'b', 'B']
-        private_constant(:SPECIAL_ESCAPE)
-
-        # @!visibility private
-        def self.highlight?(pattern)
-          pattern.class.name == "Mustermann::Regular"
-        end
-
-        # @!visibility private
-        def self.highlight(pattern, renderer)
-          new(renderer).highlight(pattern)
-        end
-
-        # @!visibility private
-        attr_reader :renderer, :output, :scanner
-
-        # @!visibility private
-        def initialize(renderer)
-          @renderer = renderer
-          @output   = String.new
-        end
-
-        # @!visibility private
-        def highlight(pattern)
-          output << renderer.pre(:root)
-          @scanner = ::StringScanner.new(pattern.to_s)
-          scan
-          output << renderer.post(:root)
-        end
-
-        # @!visibility private
-        def scan(stop = nil)
-          until scanner.eos?
-            case char = scanner.getch
-            when stop                then return char
-            when ?/                  then element(:separator, char)
-            when Regexp.escape(char) then element(:char, char)
-            when ?\\                 then escaped(scanner.getch)
-            when ?(                  then potential_capture
-            when ?[                  then char_class
-            when ?^, ?$              then element(:illegal, char)
-            when ?{                  then element(:special, "\{#{scanner.scan(/[^\}]*\}/)}")
-            else element(:special, char)
-            end
-          end
-        end
-
-        # @!visibility private
-        def char_class
-          if result = scanner.scan(/\[:\w+:\]\]/)
-            element(:special, "[#{result}")
-          else
-            element(:special, ?[)
-            element(:special, ?^) if scanner.scan(/\^/)
-          end
-        end
-
-        # @!visibility private
-        def potential_capture
-          if scanner.scan(/\?<(\w+)>/)
-            element(:capture, "(?<") do
-              element(:name, scanner[1])
-              output << ">" << scan(?))
-            end
-          elsif scanner.scan(/\?(?:(?:-\w+)?:|>|<=|<!|!|=)/)
-            element(:special, "(#{scanner[0]}")
-          else
-            element(:capture, "(") { output << scan(?)) }
-          end
-        end
-
-        # @!visibility private
-        def escaped(char)
-          case char
-          when  *SPECIAL_ESCAPE    then element(:special, "\\#{char}")
-          when 'A', 'Z', 'z'       then element(:illegal, "\\#{char}")
-          when 'g'                 then element(:special, "\\#{char}#{scanner.scan(/<\w*>/)}")
-          when 'p', 'u'            then element(:special, "\\#{char}#{scanner.scan(/\{[^\}]*\}/)}")
-          when ?/                  then element(:separator, char)
-          else element(:escaped, ?\\) { element(:escaped_char, char) }
-          end
-        end
-
-        # @!visibility private
-        def element(type, content = nil)
-          output << renderer.pre(type)
-          output << renderer.escape(content) if content
-          yield if block_given?
-          output << renderer.post(type)
-        end
-      end
-    end
-  end
-end

data/mustermann-contrib/lib/mustermann/visualizer/pattern_extension.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-module Mustermann
-  module Visualizer
-    # Mixin that will be added to {Mustermann::Pattern}.
-    module PatternExtension
-      prepend_features Composite
-      prepend_features Pattern
-
-      # @example
-      #   puts Mustermann.new("/:page").to_ansi
-      #
-      # @return [String] ANSI colorized version of the pattern.
-      def to_ansi(inspect: nil, **theme)
-        Visualizer.highlight(self, **theme).to_ansi(inspect: inspect)
-      end
-
-      # @example
-      #   puts Mustermann.new("/:page").to_html
-      #
-      # @return [String] HTML version of the pattern.
-      def to_html(inspect: nil, tag: :span, class_prefix: "mustermann_", css: :inline, **theme)
-        Visualizer.highlight(self, **theme).to_html(inspect: inspect, tag: tag, class_prefix: class_prefix, css: css)
-      end
-
-      # @example
-      #   puts Mustermann.new("/:page").to_tree
-      #
-      # @return [String] tree version of the pattern.
-      def to_tree
-        Visualizer.tree(self).to_s
-      end
-
-      # If invoked directly by puts: ANSI colorized version of the pattern.
-      # If invoked by anything else: String version of the pattern.
-      #
-      # @example
-      #   require 'mustermann/visualizer'
-      #   pattern = Mustermann.new('/:page')
-      #   puts pattern        # will have color
-      #   puts pattern.to_s   # will not have color
-      #
-      # @return [String] non-colorized or colorized version of the pattern
-      def to_s
-        caller_locations.first.label == 'puts' ? to_ansi : super
-      end
-
-      # If invoked directly by IRB, same as {#color_inspect}, otherwise same as  {Mustermann::Pattern#inspect}.
-      def inspect
-        caller_locations.first.base_label == '<module:IRB>' ? color_inspect : super
-      end
-
-      # @return [String] ANSI colorized version of {Mustermann::Pattern#inspect}
-      def color_inspect(base_color = nil, **theme)
-        base_color ||= Highlight::DEFAULT_THEME[:base01]
-        template = is_a?(Composite) ? "*#<%p:(*%s*)>*" : "*#<%p:*%s*>*"
-        Hansi.render(template, self.class, to_ansi(inspect: true, **theme), "*" => base_color)
-      end
-
-      # If invoked directly by IRB, same as {#color_inspect}, otherwise same as Object#pretty_print.
-      def pretty_print(q)
-        if q.class.name.to_s[/[^:]+$/] == "ColorPrinter"
-          q.text(color_inspect, inspect.length)
-        else
-          super
-        end
-      end
-    end
-  end
-end

data/mustermann-contrib/lib/mustermann/visualizer/renderer/ansi.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-module Mustermann
-  module Visualizer
-    # @!visibility private
-    module Renderer
-      # Generates ANSI colored strings.
-      # @!visibility private
-      class ANSI
-        # @!visibility private
-        def initialize(target, mode: Hansi.mode, **options)
-          @target  = target
-          @mode    = mode
-          @options = options
-        end
-
-        # @!visibility private
-        def render
-          template = @target.to_hansi_template(**@options)
-          Hansi.render(template, tags: true, theme: @target.theme, mode: @mode)
-        end
-      end
-    end
-  end
-end

data/mustermann-contrib/lib/mustermann/visualizer/renderer/generic.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-module Mustermann
-  module Visualizer
-    # @!visibility private
-    module Renderer
-      # Logic shared by most renderers.
-      class Generic
-        # @!visibility private
-        def initialize(target, inspect: nil, add_qoutes: true)
-          @target     = target
-          @inspect    = inspect
-          @add_qoutes = !target.pattern.is_a?(Mustermann::Composite)
-        end
-
-        # @!visibility private
-        def render
-          quote =  "#{pre(:quote)}#{escape_string(?")}#{post(:quote)}" if @inspect and @add_qoutes
-          pre(:pattern).to_s + preamble.to_s + quote.to_s + @target.render(self) + quote.to_s + post(:pattern).to_s
-        end
-
-        # @!visibility private
-        def preamble
-        end
-
-        # @!visibility private
-        def escape(value, inspect_value = value.to_s.inspect[1..-2])
-          escape_string(@inspect ? inspect_value : value.to_s)
-        end
-
-        # @!visibility private
-        def escape_string(string)
-          string
-        end
-
-        # @!visibility private
-        def pre(type)
-          ""
-        end
-
-        # @!visibility private
-        def post(type)
-          ""
-        end
-      end
-    end
-  end
-end

data/mustermann-contrib/lib/mustermann/visualizer/renderer/hansi_template.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-require 'mustermann/visualizer/renderer/generic'
-
-module Mustermann
-  module Visualizer
-    # @!visibility private
-    module Renderer
-      # Generates Hansi template string.
-      # @see Mustermann::Visualizer::Renderer::ANSI
-      # @!visibility private
-      class HansiTemplate < Generic
-        # @!visibility private
-        def initialize(*)
-          @hansi = Hansi::StringRenderer.new(tags: true)
-          super
-        end
-
-        # @!visibility private
-        def escape_string(string)
-          @hansi.escape(string)
-        end
-
-        # @!visibility private
-        def pre(type)
-          "<#{type}>"
-        end
-
-        # @!visibility private
-        def post(type)
-          "</#{type}>"
-        end
-      end
-    end
-  end
-end

data/mustermann-contrib/lib/mustermann/visualizer/renderer/html.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-require 'mustermann/visualizer/renderer/generic'
-require 'cgi'
-
-module Mustermann
-  module Visualizer
-    # @!visibility private
-    module Renderer
-      # Generates HTML output.
-      # @!visibility private
-      class HTML < Generic
-        # @!visibility private
-        def initialize(target, tag: :span, class_prefix: "mustermann_", css: :inline, **options)
-          raise ArgumentError, 'css option %p not supported, should be true, false or inline' if css != true and css != false and css != :inline
-          super(target, **options)
-          @css, @tag, @class_prefix = css, tag, class_prefix
-        end
-
-        # @!visibility private
-        def preamble
-          "<style type=\"text/css\">\n%s</style>" %  stylesheet if  @css == true
-        end
-
-        # @!visibility private
-        def stylesheet
-          @target.theme.to_css { |name| ".#{@class_prefix}pattern .#{@class_prefix}#{name}" }
-        end
-
-        # @!visibility private
-        def escape_string(string)
-          CGI.escape_html(string)
-        end
-
-        # @!visibility private
-        def pre(type)
-          if @css == :inline
-            return "" unless rule = @target.theme[type]
-            "<#{@tag} style=\"#{rule.to_css_rule}\">"
-          else
-            "<#{@tag} class=\"#{@class_prefix}#{type}\">"
-          end
-        end
-
-        # @!visibility private
-        def post(type)
-          "</#{@tag}>"
-        end
-      end
-    end
-  end
-end

data/mustermann-contrib/lib/mustermann/visualizer/renderer/sexp.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-require 'mustermann/visualizer/renderer/generic'
-
-module Mustermann
-  module Visualizer
-    # @!visibility private
-    module Renderer
-      # Generates a s-expression like string.
-      # @!visibility private
-      class Sexp < Generic
-        # @!visibility private
-        def render
-          @inspect = false
-          super.gsub(/ ?\)( \))*/) { |s| s.gsub(' ', '') }.strip
-        end
-
-
-        # @!visibility private
-        def pre(type)
-          "(#{type} " if type != :pattern
-        end
-
-        # @!visibility private
-        def escape_string(input)
-          inspect = input.inspect
-          input   = inspect if inspect != "\"#{input}\""
-          input   = inspect if input =~ /[\s\"\'\(\)]/
-          input + " "
-        end
-
-        # @!visibility private
-        def post(type)
-          ") " if type != :pattern
-        end
-      end
-    end
-  end
-end

data/mustermann-contrib/lib/mustermann/visualizer/tree.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-require 'hansi'
-
-module Mustermann
-  module Visualizer
-    # Represents a (sub)tree and at the same time a node in the tree.
-    class Tree
-      # @!visibility private
-      attr_reader :line, :children, :prefix_color, :before, :after
-
-      # @!visibility private
-      def initialize(line, *children, prefix_color: :default, before: "", after: "")
-        @line         = line
-        @children     = children
-        @prefix_color = prefix_color
-        @before       = before
-        @after        = after
-      end
-
-      # used for positioning {#after}
-      # @!visibility private
-      def line_widths(offset = 0)
-        child_widths = children.flat_map { |c| c.line_widths(offset + 2)  }
-        width        = length(line + before) + offset
-        [width, *child_widths]
-      end
-
-      # Renders the tree.
-      # @return [String] rendered version of the tree
-      def to_s
-        render("", "", line_widths.max)
-      end
-
-      # Renders tree, including nesting.
-      # @!visibility private
-      def render(first_prefix, prefix, width)
-        output = before + Hansi.render(prefix_color, first_prefix) + line
-        output = ljust(output, width) + "  " + after + "\n"
-        children[0..-2].each { |child| output += child.render(prefix + "├ ", prefix + "│ ", width) }
-        output += children.last.render(prefix + "└ ", prefix + "  ", width) if children.last
-        output
-      end
-
-      # @!visibility private
-      def length(string)
-        deansi(string).length
-      end
-
-      # @!visibility private
-      def deansi(string)
-        string.gsub(/\e\[[^m]+m/, '')
-      end
-
-      # @!visibility private
-      def ljust(string, width)
-        missing = width - length(string)
-        append  = missing > 0 ? " " * missing : ""
-        string + append
-      end
-
-      private :ljust, :deansi, :length
-    end
-  end
-end