dev-ui 0.0.1

data/lib/dev/ui/formatter.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require 'dev/ui'
+require 'strscan'
+
+module Dev
+  module UI
+    class Formatter
+      SGR_MAP = {
+        # presentational
+        'red'     => '31',
+        'green'   => '32',
+        'yellow'  => '33',
+        'blue'    => '34',
+        'magenta' => '35',
+        'cyan'    => '36',
+        'bold'    => '1',
+        'reset'   => '0',
+
+        # semantic
+        'error'   => '31', # red
+        'success' => '32', # success
+        'warning' => '33', # yellow
+        'info'    => '34', # blue
+        'command' => '36', # cyan
+      }.freeze
+
+      BEGIN_EXPR = '{{'
+      END_EXPR   = '}}'
+
+      SCAN_FUNCNAME = /\w+:/
+      SCAN_GLYPH    = /.}}/
+      SCAN_BODY     = /
+        .*?
+        (
+          #{BEGIN_EXPR} |
+          #{END_EXPR}   |
+          \z
+        )
+      /mx
+
+      DISCARD_BRACES = 0..-3
+
+      LITERAL_BRACES = :__literal_braces__
+
+      class FormatError < StandardError
+        attr_accessor :input, :index
+
+        def initialize(message = nil, input = nil, index = nil)
+          super(message)
+          @input = input
+          @index = index
+        end
+      end
+
+      def initialize(text)
+        @text = text
+      end
+
+      def format(sgr_map = SGR_MAP, enable_color: true)
+        @nodes = []
+        stack = parse_body(StringScanner.new(@text))
+        prev_fmt = nil
+        content = @nodes.each_with_object(String.new) do |(text, fmt), str|
+          if prev_fmt != fmt && enable_color
+            text = apply_format(text, fmt, sgr_map)
+          end
+          str << text
+          prev_fmt = fmt
+        end
+
+        stack.reject! { |e| e == LITERAL_BRACES }
+
+        return content unless enable_color
+        return content if stack == prev_fmt
+
+        unless stack.empty? && (@nodes.size.zero? || @nodes.last[1].empty?)
+          content << apply_format('', stack, sgr_map)
+        end
+        content
+      end
+
+      private
+
+      def apply_format(text, fmt, sgr_map)
+        sgr = fmt.each_with_object(String.new('0')) do |name, str|
+          next if name == LITERAL_BRACES
+          begin
+            str << ';' << sgr_map.fetch(name)
+          rescue KeyError
+            raise FormatError.new(
+              "invalid format specifier: #{name}",
+              @text,
+              -1
+            )
+          end
+        end
+        Dev::UI::ANSI.sgr(sgr) + text
+      end
+
+      def parse_expr(sc, stack)
+        if match = sc.scan(SCAN_GLYPH)
+          glyph_handle = match[0]
+          begin
+            glyph = Glyph.lookup(glyph_handle)
+            emit(glyph.char, [glyph.color.name.to_s])
+          rescue Glyph::InvalidGlyphHandle
+            index = sc.pos - 2 # rewind past '}}'
+            raise FormatError.new(
+              "invalid glyph handle at index #{index}: '#{glyph_handle}'",
+              @text,
+              index
+            )
+          end
+        elsif match = sc.scan(SCAN_FUNCNAME)
+          funcname = match.chop
+          stack.push(funcname)
+        else
+          # We read a {{ but it's not apparently Formatter syntax.
+          # We could error, but it's nicer to just pass through as text.
+          # We do kind of assume that the text will probably have balanced
+          # pairs of {{ }} at least.
+          emit('{{', stack)
+          stack.push(LITERAL_BRACES)
+        end
+        parse_body(sc, stack)
+        stack
+      end
+
+      def parse_body(sc, stack = [])
+        match = sc.scan(SCAN_BODY)
+        if match && match.end_with?(BEGIN_EXPR)
+          emit(match[DISCARD_BRACES], stack)
+          parse_expr(sc, stack)
+        elsif match && match.end_with?(END_EXPR)
+          emit(match[DISCARD_BRACES], stack)
+          if stack.pop == LITERAL_BRACES
+            emit('}}', stack)
+          end
+          parse_body(sc, stack)
+        elsif match
+          emit(match, stack)
+        else
+          emit(sc.rest, stack)
+        end
+        stack
+      end
+
+      def emit(text, stack)
+        return if text.nil? || text.empty?
+        @nodes << [text, stack.reject { |n| n == LITERAL_BRACES }]
+      end
+    end
+  end
+end

data/lib/dev/ui/frame.rb

@@ -0,0 +1,176 @@
+require 'dev/ui'
+
+module Dev
+  module UI
+    module Frame
+      class << self
+        DEFAULT_FRAME_COLOR = Dev::UI.resolve_color(:cyan)
+
+        # Can be invoked in two ways: block and blockless
+        # In block form, the frame is closed automatically when the block returns
+        # In blockless form, caller MUST call Frame.close when the frame is
+        #   logically done.
+        # blockless form is strongly discouraged in cases where block form can be
+        #   made to work.
+        def open(
+          text,
+          color: DEFAULT_FRAME_COLOR,
+          failure_text: nil,
+          success_text: nil,
+          timing:       nil
+        )
+          color = Dev::UI.resolve_color(color)
+
+          unless block_given?
+            if failure_text
+              raise ArgumentError, "failure_text is not compatible with blockless invocation"
+            elsif success_text
+              raise ArgumentError, "success_text is not compatible with blockless invocation"
+            elsif !timing.nil?
+              raise ArgumentError, "timing is not compatible with blockless invocation"
+            end
+          end
+
+          timing = true if timing.nil?
+
+          t_start = Time.now.to_f
+          Dev::UI.raw do
+            puts edge(text, color: color, first: Dev::UI::Box::Heavy::TL)
+          end
+          FrameStack.push(color)
+
+          return unless block_given?
+
+          closed = false
+          begin
+            success = false
+            success = yield
+          rescue Exception
+            closed = true
+            t_diff = timing ? (Time.now.to_f - t_start) : nil
+            close(failure_text, color: :red, elapsed: t_diff)
+            raise
+          else
+            success
+          ensure
+            unless closed
+              t_diff = timing ? (Time.now.to_f - t_start) : nil
+              if success != false
+                close(success_text, color: color, elapsed: t_diff)
+              else
+                close(failure_text, color: :red, elapsed: t_diff)
+              end
+            end
+          end
+        end
+
+        def close(text, color: DEFAULT_FRAME_COLOR, elapsed: nil)
+          color = Dev::UI.resolve_color(color)
+
+          FrameStack.pop
+          kwargs = {}
+          if elapsed
+            kwargs[:right_text] = "(#{elapsed.round(2)}s)"
+          end
+          Dev::UI.raw do
+            puts edge(text, color: color, first: Dev::UI::Box::Heavy::BL, **kwargs)
+          end
+        end
+
+        def divider(text, color: nil)
+          color = Dev::UI.resolve_color(color)
+          item  = Dev::UI.resolve_color(FrameStack.pop)
+
+          Dev::UI.raw do
+            puts edge(text, color: (color || item), first: Dev::UI::Box::Heavy::DIV)
+          end
+          FrameStack.push(item)
+        end
+
+        def prefix(color: nil)
+          pfx = String.new
+          items = FrameStack.items
+          items[0..-2].each do |item|
+            pfx << Dev::UI.resolve_color(item).code << Dev::UI::Box::Heavy::VERT
+          end
+          if item = items.last
+            c = Thread.current[:devui_frame_color_override] || color || item
+            pfx << Dev::UI.resolve_color(c).code \
+              << Dev::UI::Box::Heavy::VERT << ' ' << Dev::UI::Color::RESET.code
+          end
+          pfx
+        end
+
+        def with_frame_color_override(color)
+          prev = Thread.current[:devui_frame_color_override]
+          Thread.current[:devui_frame_color_override] = color
+          yield
+        ensure
+          Thread.current[:devui_frame_color_override] = prev
+        end
+
+        def prefix_width
+          w = FrameStack.items.size
+          w.zero? ? 0 : w + 1
+        end
+
+        private
+
+        def edge(text, color: raise, first: raise, right_text: nil)
+          color = Dev::UI.resolve_color(color)
+          text  = Dev::UI.resolve_text("{{#{color.name}:#{text}}}")
+
+          prefix = String.new
+          FrameStack.items.each do |item|
+            prefix << Dev::UI.resolve_color(item).code << Dev::UI::Box::Heavy::VERT
+          end
+          prefix << color.code << first << (Dev::UI::Box::Heavy::HORZ * 2)
+          text ||= ''
+          unless text.empty?
+            prefix << ' ' << text << ' '
+          end
+
+          suffix = String.new
+          if right_text
+            suffix << ' ' << right_text << ' ' << color.code << (Dev::UI::Box::Heavy::HORZ * 2)
+          end
+
+          textwidth = Dev::UI::ANSI.printing_width(prefix + suffix)
+          termwidth = Dev::UI::Terminal.width
+          termwidth = 30 if termwidth < 30
+
+          if textwidth > termwidth
+            suffix = ''
+            prefix = prefix[0...termwidth]
+            textwidth = termwidth
+          end
+          padwidth = termwidth - textwidth
+          pad = Dev::UI::Box::Heavy::HORZ * padwidth
+
+          prefix + color.code + pad + suffix + Dev::UI::Color::RESET.code + "\n"
+        end
+
+        module FrameStack
+          ENVVAR = 'DEV_FRAME_STACK'
+
+          def self.items
+            ENV.fetch(ENVVAR, '').split(':').map(&:to_sym)
+          end
+
+          def self.push(item)
+            curr = items
+            curr << item.name
+            ENV[ENVVAR] = curr.join(':')
+          end
+
+          def self.pop
+            curr = items
+            ret = curr.pop
+            ENV[ENVVAR] = curr.join(':')
+            ret.nil? ? nil : ret.to_sym
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev/ui/glyph.rb

@@ -0,0 +1,49 @@
+require 'dev/ui'
+
+module Dev
+  module UI
+    class Glyph
+      MAP = {}
+
+      attr_reader :handle, :codepoint, :color, :char, :to_s, :fmt
+      def initialize(handle, codepoint, color)
+        @handle    = handle
+        @codepoint = codepoint
+        @color     = color
+        @char      = [codepoint].pack('U')
+        @to_s      = color.code + char + Color::RESET.code
+        @fmt       = "{{#{color.name}:#{char}}}"
+
+        MAP[handle] = self
+      end
+
+      STAR     = new('*', 0x2b51,  Color::YELLOW) # BLACK SMALL STAR
+      INFO     = new('i', 0x1d4be, Color::BLUE)   # MATHEMATICAL SCRIPT SMALL I
+      QUESTION = new('?', 0x003f,  Color::BLUE)   # QUESTION MARK
+      CHECK    = new('v', 0x2713,  Color::GREEN)  # CHECK MARK
+      X        = new('x', 0x2717,  Color::RED)    # BALLOT X
+
+      class InvalidGlyphHandle < ArgumentError
+        def initialize(handle)
+          @handle = handle
+        end
+
+        def message
+          keys = Glyph.available.join(',')
+          "invalid glyph handle: #{@handle} " \
+            "-- must be one of Dev::UI::Glyph.available (#{keys})"
+        end
+      end
+
+      def self.lookup(name)
+        MAP.fetch(name.to_s)
+      rescue KeyError
+        raise InvalidGlyphHandle, name
+      end
+
+      def self.available
+        MAP.keys
+      end
+    end
+  end
+end

data/lib/dev/ui/interactive_prompt.rb

@@ -0,0 +1,114 @@
+require 'io/console'
+
+module Dev
+  module UI
+    class InteractivePrompt
+      def self.call(options)
+        list = new(options)
+        options[list.call - 1]
+      end
+
+      def initialize(options)
+        @options = options
+        @active = 1
+        @marker = '>'
+        @answer = nil
+      end
+
+      def call
+        Dev::UI.raw { print(ANSI.hide_cursor) }
+        while @answer.nil?
+          render_options
+          wait_for_user_input
+
+          # This will put us back at the beginning of the options
+          # When we redraw the options, they will be overwritten
+          Dev::UI.raw do
+            @options.size.times { print(ANSI.previous_line) }
+            print(ANSI.previous_line + ANSI.end_of_line + "\n")
+          end
+        end
+        render_options
+        @answer
+      ensure
+        Dev::UI.raw do
+          print(ANSI.show_cursor)
+          puts(ANSI.previous_line + ANSI.end_of_line)
+        end
+      end
+
+      private
+
+      def wait_for_user_input
+        char = read_char
+        char = char.chomp unless char.chomp.empty?
+        case char
+        when "\e[A", 'k'    # up
+          @active = @active - 1 >= 1 ? @active - 1 : @options.length
+        when "\e[B", 'j'    # down
+          @active = @active + 1 <= @options.length ? @active + 1 : 1
+        when " ", "\r"      # enter/select
+          @answer = @active
+        when ('1'..@options.size.to_s)
+          @active = char.to_i
+          @answer = char.to_i
+        when 'y', 'n'
+          return unless (@options - %w(yes no)).empty?
+          opt = @options.detect { |o| o.start_with?(char) }
+          @active = @options.index(opt) + 1
+          @answer = @options.index(opt) + 1
+        when "\u0003", "\e" # Control-C or escape
+          raise Interrupt
+        end
+      end
+
+      # Will handle 2-3 character sequences like arrow keys and control-c
+      def read_char
+        raw_tty! do
+          input = $stdin.getc.chr
+          return input unless input == "\e"
+
+          input << begin
+              $stdin.read_nonblock(3)
+            rescue
+              ''
+            end
+          input << begin
+              $stdin.read_nonblock(2)
+            rescue
+              ''
+            end
+          input
+        end
+      rescue IOError
+        "\e"
+      end
+
+      def raw_tty!
+        begin
+          $stdin.raw! unless ENV['TEST']
+        rescue Errno::ENOTTY
+          ''
+        end
+        yield
+      ensure
+        begin
+          $stdin.cooked!
+        rescue Errno::ENOTTY
+          ''
+        end
+      end
+
+      def render_options
+        @options.each_with_index do |choice, index|
+          num = index + 1
+          message = "  #{num}. {{bold:#{choice}}}"
+          message = "{{blue:> #{message.strip}}}" if num == @active
+          Dev::UI.with_frame_color(:blue) do
+            puts Dev::UI.fmt(message)
+          end
+        end
+      end
+    end
+  end
+end