refined-refinements 0.0.1 → 0.0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 5294d42af35dee68ae9f9d9477d83a39ec3d5de2
-  data.tar.gz: '056769fd009f3c71f019322a53ff7577b543a585'
+SHA256:
+  metadata.gz: 9e237cd63850813d78118fb36f6d6a2af9997aad27efd52a29558364392a4320
+  data.tar.gz: acb9d42dd6b27cd7ff457c1dc496e4bf315e86a01ecac2f8fc6e6d2f41e5d0c9
 SHA512:
-  metadata.gz: d915c1737d66d960769ba4c72ddbd2022d7b326a5cf2639d46d93c87592335dd19dea33a181d012e914b28e46a4d57e9f12ea289cfb5a8b9f5842872942bc631
-  data.tar.gz: 86d9e617849bcbc70fdfe70db3630ec6eadc04c1da25ac67965e618eb7c52bac3f318dff45a39381bf58565f996256938241e0b3c44b6d6b326f953ed58d1a6c
+  metadata.gz: afc0245977ea79e641818fb28b1415e6876a7da70ca673c46b982c35a3d8946ff3472ac508594966845bf51f87503f643c81616ac8216b891717b8b679e9ad33
+  data.tar.gz: bd488952fb4efe31047de84b29c6f222e23b2a36f39c4735802ce77b8b424216f726741eec2fbd04e07c7bc6a0940b693fb57c82b5badeca11cf8167c69b2beb

data/lib/refined-refinements/cached_http.rb

@@ -0,0 +1,58 @@
+require 'open-uri'
+require 'base64'
+require 'socket' # undefined SocketError otherwise, it's weird.
+
+# RR::CachedHttp.cache_dir = 'tmp'
+# # RR::CachedHttp.offline = true
+# RR::CachedHttp.get('http://google.com/test')
+module RR
+  module CachedHttp
+    def self.cache_dir
+      @cache_dir || '/tmp'
+    end
+
+    def self.cache_dir=(cache_dir)
+      @cache_dir = cache_dir
+    end
+
+    def self.offline?
+      @offline
+    end
+
+    def self.offline=(boolean)
+      @offline = boolean
+    end
+
+    def self.cache_path(url)
+      File.join(self.cache_dir, Base64.encode64(url).chomp.split("\n").last)
+    end
+
+    def self.get(url)
+      if self.offline?
+        self.retrieve_from_cache(url)
+      else
+        self.fetch(url)
+      end
+    rescue SocketError
+      self.retrieve_from_cache(url, true)
+    rescue Exception => e
+      p [:e, e]; raise e
+    end
+
+    def self.retrieve_from_cache(url, tried_to_fetch = false)
+      if File.exist?(self.cache_path(url))
+        File.read(self.cache_path(url))
+      else
+        raise "URL #{url} is not cached#{" and can't be fetched" if tried_to_fetch}."
+      end
+    end
+
+    def self.fetch(url)
+      open(url).read.tap do |fetched_data|
+        File.open(self.cache_path(url), 'w') do |file|
+          file.write(fetched_data)
+        end
+      end
+    end
+  end
+end

data/lib/refined-refinements/cli/commander.rb

@@ -0,0 +1,57 @@
+require 'refined-refinements/string'
+require 'refined-refinements/colours'
+
+module RR
+  class Commander
+    using RR::ColourExts
+
+    def self.commands
+      @commands ||= Hash.new
+    end
+
+    def self.command(command_name, command_class)
+      self.commands[command_name] = command_class
+    end
+
+    def help_template(program_name)
+      <<-EOF
+<red.bold>:: #{program_name} ::</red.bold>
+
+<cyan.bold>Commands</cyan.bold>
+      EOF
+    end
+
+    def help
+      self.commands.reduce(self.help_template) do |buffer, (command_name, command_class)|
+        command_help = command_class.help && command_class.help.split("\n").map { |line| line.sub(/^ {4}/, '') }.join("\n")
+        command_class.help ? [buffer, command_help].join("\n") : buffer
+      end.colourise
+    end
+
+    def commands
+      self.class.commands
+    end
+
+    def run(command_name, args)
+      command_class = self.class.commands[command_name]
+      command = command_class.new(args)
+      command.run
+    end
+  end
+
+  class Command
+    using RR::ColourExts
+    using RR::StringExts # #titlecase
+
+    class << self
+      attr_accessor :help
+      def main_command
+        File.basename($0)
+      end
+    end
+
+    def initialize(args)
+      @args = args
+    end
+  end
+end

data/lib/refined-refinements/cli/prompt.rb

@@ -0,0 +1,140 @@
+# def prompt_type
+#   @prompt.prompt(:type, 'Type', options: Expense::TYPES) do
+#     clean_value do |raw_value|
+#       self.retrieve_by_index_or_self_if_on_the_list(Expense::TYPES, raw_value)
+#     end
+#
+#     validate_clean_value do |clean_value|
+#       Expense::TYPES.include?(clean_value)
+#     end
+#   end
+# end
+
+require 'refined-refinements/colours'
+
+module RR
+  class InvalidResponse < StandardError; end
+
+  class Answer
+    def initialize
+      @callbacks = Hash.new { Proc.new { true } }
+    end
+
+    def validate_raw_value(*regexps, allow_empty: nil)
+      @callbacks[:validate_raw_value] = Proc.new do |raw_value|
+        unless (allow_empty && raw_value.empty?) || regexps.any? { |regexp| raw_value.match(regexp) }
+          raise InvalidResponse.new("Doesn't match any of the regexps.")
+        end
+      end
+    end
+
+    def validate_clean_value(&block)
+      @callbacks[:validate_clean_value] = block
+    end
+
+    def clean_value(&block)
+      @callbacks[:get_clean_value] = block
+    end
+
+    def run(raw_value)
+      @callbacks[:validate_raw_value].call(raw_value)
+      clean_value = @callbacks[:get_clean_value].call(raw_value)
+
+      unless @callbacks[:validate_clean_value].call(clean_value)
+        raise InvalidResponse.new("validate_clean_value failed")
+      end
+
+      clean_value
+    end
+
+    def self_or_retrieve_by_index(list, raw_value, default_value = nil)
+      if raw_value.match(/^\d+$/)
+        list[raw_value.to_i - 1]
+      elsif raw_value.empty?
+        default_value
+      else
+        raw_value
+      end
+    end
+
+    def retrieve_by_index_or_self_if_on_the_list(list, raw_value, default_value = nil)
+      if raw_value.match(/^\d+$/)
+        list[raw_value.to_i - 1]
+      elsif list.include?(raw_value)
+        raw_value
+      elsif raw_value.empty? && default_value
+        default_value
+      else
+        raise InvalidResponse.new(raw_value)
+      end
+    end
+
+    def convert_money_to_cents(raw_value)
+      if raw_value.match(/\./)
+        raw_value.delete('.').to_i
+      else
+        "#{raw_value}00".to_i
+      end
+    end
+  end
+
+  class Prompt
+    using RR::ColourExts
+
+    attr_reader :data
+    def initialize(&block)
+      @data, @block = Hash.new, block || Proc.new do |prompt|
+        require 'readline'
+        Readline.readline(prompt, true)
+      end
+    end
+
+    # options: ['one', 'two']
+    # help: 'One of one, two or any integer value.'
+    def prompt(key, prompt_text, **options, &block)
+      answer = Answer.new
+      answer.instance_eval(&block)
+
+      help = help(**options)
+      prompt = "<bold>#{prompt_text}</bold>#{" (#{help})" if help}: ".colourise
+      @data[key] = answer.run(@block.call(prompt))
+      raise InvalidResponse.new if @data[key].nil? && options[:required]
+      @data[key]
+    rescue InvalidResponse => error
+      puts "<red>Invalid response</red> (#{error.message}), try again.".colourise
+      retry
+    end
+
+    # currency_help = " (#{self.show_label_for_self_or_retrieve_by_index(currencies)})" unless currencies.empty?
+    # print "Currency#{currency_help}: "
+    # expense_data[:currency] = self.self_or_retrieve_by_index(currencies, STDIN.readline.chomp, 'EUR')
+    # TODO: Say that it defaults to EUR.
+    # TODO: raw_value = 'EUR' vs. default: 'EUR' ???
+    # TODO: If it evals as nil, shall we still add it to the data?
+    def help(help: nil, options: Array.new, default: nil, **rest)
+      if help then help
+      elsif help.nil? && ! options.empty?
+        options = options.map.with_index { |key, index|
+          if default == key
+            "<green.bold>#{key}</green.bold> <bright_black>default</bright_black>"
+          else
+            "<green>#{key}</green> <magenta>#{index + 1}</magenta>"
+          end
+        }.join(' ').colourise
+        # default ? "#{options}; defaults to #{default}" : options
+      else end
+    end
+
+    def set_completion_proc(proc, character = ' ', &block)
+      return block.call unless defined?(::Readline)
+      original_append_character = Readline.completion_append_character
+      Readline.completion_append_character = ' '
+      Readline.completion_proc = proc
+      block.call
+    ensure
+      return unless defined?(::Readline)
+      Readline.completion_proc = nil
+      Readline.completion_append_character = original_append_character
+    end
+  end
+end

data/lib/refined-refinements/collection.rb

@@ -0,0 +1,150 @@
+require 'yaml'
+require 'forwardable'
+require 'pathname'
+
+# flashcards = Collection.new(Flashcard, 'es.yml')
+# flashcards << flashcard
+# flashcards.save
+module RR
+  class Collection
+    def self.data_file_dir
+      Pathname.new("~/Dropbox/Data/Data/Flashcards").expand_path
+    end
+
+    # def initialize(item_class, basename)
+    #   @path = self.class.data_file_dir.join("#{basename}.yml")
+    #   @item_class, @activity_filters = item_class, Hash.new
+    # end
+    def initialize(basename)
+      @path = self.class.data_file_dir.join(basename)
+      @activity_filters = Hash.new
+    end
+
+    def items(&block)
+      @items ||= self.load_raw_collection.map do |data|
+        begin
+          block.call(data)
+        rescue => error
+          abort "Loading item #{data.inspect} failed: #{error.message}.\n\n#{error.backtrace}"
+        end
+      end
+    end
+
+    def active_items
+      return self.items if @activity_filters.empty?
+
+      @activity_filters.keys.reduce(self.items) do |items, filter_name|
+        self.run_filter(filter_name, items)
+      end
+    end
+
+    def run_filter(filter_name, items)
+      items.select { |item| @activity_filters[filter_name].call(item) }
+    end
+
+    def filter(filter_name, &block)
+      @activity_filters[filter_name] = block if block
+      self
+    end
+
+    def filter_out(filter_name, &block)
+      @activity_filters[filter_name] = Proc.new { |item| ! block.call(item) } if block
+      self
+    end
+
+    def filters
+      @activity_filters.keys
+    end
+
+    def has_filter?(filter_name)
+      @activity_filters.has_key?(filter_name)
+    end
+
+    def filtered_out_items(filter_name)
+      self.items - self.run_filter(filter_name, self.items)
+    end
+
+    # flashcards[:expressions, 'hacer']
+    # flashcards[:translations, :silent_translations, 'to be']
+    def [](key, value)
+      self.items.select do |item|
+        [item.send(key)].flatten.include?(value)
+      end
+    end
+
+    extend Forwardable
+
+    # Generally we want to avoid proxying methods, unless
+    # it is clear whether they would be performed on items or active_items.
+    def_delegator :items, :<<
+
+    def replace(original_item, new_item)
+      index = self.items.index(original_item)
+      self.items.delete(original_item)
+      self.items.insert(index, new_item)
+    end
+
+    def save
+      return if self.items.empty?
+
+      if File.mtime(@path.to_s) > @loaded_at
+        raise "Cannot be saved #{File.mtime(@path.to_s).inspect} vs. #{@loaded_at.inspect}"
+      end
+
+      self.save_to(@path) && self.save_to(self.back_up_path)
+
+      @loaded_at = Time.now # Otherwise the next save call with fail.
+      true
+    end
+
+    def save_to(path)
+      updated_data = self.serialise
+      if (! File.exist?(path)) || File.read(path) != updated_data
+        path.open('w') do |file|
+          file.write(updated_data)
+        end
+        return true
+      else
+        return false
+      end
+    end
+
+    def back_up_path
+      chunks    = @path.basename.to_s.split('.')
+      timestamp = Time.now.strftime('%Y-%m-%d-%H-%M')
+      basename  = chunks.insert(-2, timestamp).join('.')
+
+      self.class.data_file_dir.join('Backups', basename)
+    end
+
+    # TODO: Should we deprecate this?
+    # It's best to use explicit .items/.active_items calls.
+    include Enumerable
+
+    def each(&block)
+      if block
+        self.active_items.each(&block)
+      else
+        self.active_items.to_enum
+      end
+    end
+
+    protected
+    def load_raw_collection
+      @loaded_at = Time.now
+
+      self.deserialise(@path.to_s)
+    rescue Errno::ENOENT
+      Array.new
+    end
+
+    def deserialise(path)
+      # YAML treats an empty string as false.
+      YAML.load_file(path) || Array.new
+    end
+
+    def serialise
+      self.items.map(&:data).to_yaml
+    end
+  end
+end

data/lib/refined-refinements/colours.rb

@@ -1,8 +1,15 @@
 require 'term/ansicolor'
+require 'refined-refinements/string'
 require 'refined-refinements/matching'
 
 module RR
   module ColourExts
+    REGEXP = /
+      <(?<dot_separated_methods>[^>]+)>
+        (?<text_between_tags>.*?)
+      <\/\k<dot_separated_methods>>
+    /xm
+
     def self.colours
       @colours ||= Object.new.extend(Term::ANSIColor)
     end
@@ -10,33 +17,128 @@ module RR
     refine String do
       using RR::MatchingExts
 
-      def colourise(options = Hash.new)
-        regexp = /
-          <(?<dot_separated_methods>[^>]+)>
-            (?<text_between_tags>.*?)
-          <\/\k<dot_separated_methods>>
-        /xm
-
+      def parse_colours(options = Hash.new, &block)
         colours = RR::ColourExts.colours
+        # was_called = false
+
+        if options[:recursed]
+          string = self
+        else
+          # This solves the problem of having blank spots that never get evaluated
+          # i. e. in "Hello <bold>world</bold>!" it'd be "Hello " and "!".
+          # This is a problem with bold: true or in curses, where the text never
+          # get rendered.
+          string = options[:bold] ? "<bold>#{self}</bold>" : self
+
+          # "hey\n" -> wrapping with escape sequences after \n breaks chomp, strip and the likes.
+          string.gsub!(/(\s*)<\/bold>/, '</bold>\1')
+        end
+
+        result = string.gsub(RR::ColourExts::REGEXP) do |match|
+          # was_called = true
 
-        result = self.gsub(regexp) do |match|
           # p [:m, match] ####
           methods = match[:dot_separated_methods].split('.').map(&:to_sym)
           methods.push(:bold) if options[:bold]
           # p [:i, match[:text_between_tags], methods, options] ####
 
-          methods.reduce(inner_text = match[:text_between_tags]) do |result, method|
+          inner_text = match[:text_between_tags]
+          block.call(inner_text, methods, options)
+        end
+
+        # block.call(result, Array.new, options) #unless was_called
+
+        result.match(RR::ColourExts::REGEXP) ? result.colourise(options.merge(recursed: true)) : result #block.call(result, [options[:bold] ? :bold : nil].compact, options)
+      end
+
+      # FIXME: bold true doesn't do anything for the text that is not wrapped
+      # in anything, only for text that is between tags. I. e. "Hey <green>you</green>!"
+      def colourise(options = Hash.new)
+        colours = RR::ColourExts.colours
+
+        self.parse_colours(options) do |inner_text, methods, options|
+          methods.reduce(inner_text) do |result, method|
             # (print '  '; p [:r, result, method]) if result.match(/(<\/[^>]+>)/) ####
             result.gsub!(/(<\/[^>]+>)/, "#{colours.send(method)}\\1")
             # puts "#{result.inspect}.#{method}" ####
             "#{colours.send(method)}#{result}#{colours.reset unless options[:recursed]}"
           end
         end
+      end
+
+      # "Hey <green>y<bold>o</bold>u</green>!"
+      # 1. "Hey ", []
+      # 2. "y", [:green]
+      # 3. "o", [:green, :bold]
+      # 4. "u", [:green]
+      # 5. "!", []
+      def _chunks_with_colours(options = Hash.new)
+        # p [:call, self, options]
+        options[:chunks] ||= Array.new
+        was_called = false
+
+        self.colourise.sub(/\e\[(\d+)m/) do |match, before_match, after_match|
+          was_called = true
+
+          store = Term::ANSIColor::Attribute.instance_variable_get(:@__store__)
+          colour_name = store.find { |name, attribute| attribute.code == match[1] }[0]
+
+          options[:chunks] << before_match unless before_match.empty?
+          options[:chunks] << colour_name
+
+          after_match._chunks_with_colours(options)
+        end
+
+        options[:chunks] << self unless was_called
+
+        options[:chunks]
+      end
+
+      def chunks_with_colours(options = Hash.new)
+        buffer, result = Array.new, Array.new
+
+        # p [:s, self.colourise]
+        self._chunks_with_colours(options).each do |item|
+          # p [:x, result, buffer, item]
+          if item.is_a?(Symbol)
+            buffer << item
+          else
+            result << [item, buffer.uniq.dup]
+            buffer.clear
+          end
+        end
 
-        result.match(regexp) ? result.colourise(options.merge(recursed: true)) : result
+        result
       end
     end
   end
+
+  class TemplateString
+    using RR::StringExts
+    using RR::ColourExts
+
+    def initialize(template_string = '')
+      @template_string = template_string
+    end
+
+    def length
+      self.remove_tags.length
+    end
+
+    def titlecase
+      @template_string.sub(/>(#{self.remove_tags[0]})/) do |match|
+        ">#{$1.upcase}"
+      end
+    end
+
+    def remove_tags
+      @template_string.gsub(/<[^>]+>/, '')
+    end
+
+    def to_s
+      @template_string.colourise
+    end
+  end
 end
 
 # using RR::ColourExts

data/lib/refined-refinements/curses/app.rb

@@ -0,0 +1,196 @@
+require 'curses'
+require 'refined-refinements/curses/colours'
+require 'refined-refinements/curses/commander'
+
+using RR::ColourExts
+
+class QuitAppError < StandardError
+end
+
+class KeyboardInterrupt < StandardError
+  attr_reader :key_code
+  def initialize(key_code)
+    @key_code = key_code
+  end
+
+  def escape?
+    @key_code == 27
+  end
+
+  def ctrl_d?
+    @key_code == 4
+  end
+
+  def inspect
+    "#<#{self.class.name}: @key_code=#{@key_code.inspect}>"
+  end
+end
+
+class App
+  def initialize
+    @history = Array.new
+  end
+
+  def run(&block)
+    self.set_up
+
+    loop do
+      @current_window = window = Curses::Window.new(Curses.lines, Curses.cols, 0, 0)
+      window.keypad = true
+      block.call(self, window)
+    end
+  rescue Interrupt, QuitAppError # Ctrl+C # TODO: Add Ctrl+D into this.
+  ensure # TODO: Without this, there's no difference.
+    Curses.close_screen
+  end
+
+  def destroy
+    raise QuitAppError.new
+  end
+
+  def set_up
+    Curses.init_screen
+    Curses.start_color
+    Curses.nonl # enter is 13
+  end
+
+  # TODO: Ctrl+a, Ctrl+e, Ctrl+k, delete.
+  #
+  # TODO: unicode handling. Currently #getch is not unicode aware.
+  #   Each unicode char would trigger #getch twice, with numeric values such as
+  #   é: 195, 169 or ś: 197, 155.
+  def readline(prompt, window = @current_window, &unknown_key_handler)
+    Curses.noecho
+    window.write(prompt)
+
+    buffer, cursor, original_x = String.new, 0, window.curx
+    char_buffer = []
+
+    until (char = window.getch) == 13 || @quit
+      begin
+        if (190..200).include?(char) # Reading unicode.
+          char_buffer = [char]
+        else
+          char_buffer << char
+          buffer, cursor = process_chars(char_buffer, buffer, cursor, window, original_x)
+          char_buffer.clear
+        end
+      rescue KeyboardInterrupt => interrupt
+        begin
+          unknown_key_handler.call(interrupt) if unknown_key_handler
+        rescue QuitError
+          @quit = true
+        end
+      end
+
+      # begin
+      #   sp = ' ' * (window.maxx - window.curx - buffer.length - prompt.gsub(/<[^>]+>/, '').length)
+      # rescue
+      #   sp = ' ERR ' # FIXME.
+      # end
+
+      window.setpos(window.cury, 0)
+      window.deleteln
+      window.write("#{prompt}#{buffer}")
+      # window.setpos(window.cury, original_x)
+      # window.write(buffer + sp)
+
+      # DBG
+      a, b = window.cury, cursor + original_x
+      # window.setpos(window.cury + 1, 0)
+      # window.write("<blue.bold>~</blue.bold> DBG: X position <green>#{original_x}</green>, cursor <green>#{cursor}</green>, buffer <green>#{buffer.inspect}</green>, history: <green>#{@history.inspect}</green> ... writing to <green>#{a}</green> x <green>#{b}</green>")
+      # window.setpos(window.cury - 1, cursor + original_x)
+
+      window.setpos(window.cury, cursor + original_x)
+      window.refresh
+    end
+
+    @history << buffer
+    Curses.echo
+    window.setpos(window.cury + 1, 0)
+    # window.write([:input, buffer].inspect + "\n")
+    # window.refresh
+    # sleep 2.5
+    return buffer
+  end
+
+  def commander
+    Commander.new
+  end
+
+  def process_chars(chars, buffer, cursor, window, original_x)
+    @log ||= File.open('log', 'a')
+    @log.puts("#{Time.now.to_i}: #{chars.inspect}")
+    @log.flush
+    # Tes-Ctrl+a-Ctrl+k produces [1] for Ctrl+a and [1, 11] for Ctrl+k.
+    # Multiple presses of Ctrl+whatever alternates, for instance for Ctrl+e
+    # it is [5], [5, 5], [5], [5, 5] etc. Therefore only the last number is relevant.
+    chars = [chars[-1]] if chars.all? { |char| char.is_a?(Integer) && char < 100 }
+    if chars.length > 1
+      # TODO:
+      process_char('É', buffer, cursor, window, original_x)
+    else
+      process_char(chars[0], buffer, cursor, window, original_x)
+    end
+  end
+
+  def process_char(char, buffer, cursor, window, original_x)
+    case char
+    when 1 # Ctrl+a.
+      cursor = 0
+    when 5 # Ctrl+e.
+      cursor = buffer.length
+    when 11 # Ctrl+k.
+      # yank_register = buffer[cursor..-1] # Ctrl+y suspends it currently.
+      if cursor == 0
+        buffer = ''
+      else
+        buffer = buffer[0..(cursor - 1)]
+      end
+    when 127 # Backspace.
+      unless buffer.empty?
+        buffer = buffer[0..-2]; cursor -= 1
+      end
+    when 258 # Down arrow
+      # TODO
+      window.write("X")
+      window.refresh
+    when 259 # Up arrow.
+      # TODO:
+      @history_index ||= @history.length - 1
+
+      window.setpos(window.cury + 1, 0)
+      window.write("DBG: #{@history_index}, #{(0..@history.length).include?(@history_index)}")
+      window.setpos(window.cury - 1, cursor + original_x)
+      window.refresh
+
+      if (0..@history.length).include?(@history_index)
+        @buffer_before_calling_history = buffer
+        buffer = @history[@history_index - 1]
+      else
+        window.setpos(window.cury, 0)
+        if @history.empty?
+          window.write("~ The history is empty.")
+        else
+          window.write("~ Already at the first item.")
+        end
+        window.setpos(window.cury - 1, original_x)
+        window.refresh
+      end
+      cursor = buffer.length
+    when 260 # Left arrow.
+      cursor -= 1 unless original_x == window.curx
+      # window.setpos(window.cury, window.curx - 1)
+    when 261 # Right arrow.
+      cursor += 1 unless original_x + buffer.length == window.curx
+      # window.setpos(window.cury, window.curx + 1)
+    when String
+      # window.addch(char)
+      buffer.insert(cursor, char); cursor += 1
+    else
+      raise KeyboardInterrupt.new(char) # TODO: Just return it, it's not really an error.
+    end
+
+    return buffer, cursor
+  end
+end

data/lib/refined-refinements/curses/colours.rb

@@ -0,0 +1,56 @@
+require 'refined-refinements/colours'
+
+module RR
+  module ColourExts
+    refine Curses::Window do
+      def defined_colours
+        Curses.constants.grep(/^COLOR_/).map do |colour|
+          colour.to_s.sub(/^COLOR_/, '').downcase.to_sym
+        end
+      end
+
+      def defined_attributes
+        Curses.constants.grep(/^A_/).map do |colour|
+          colour.to_s.sub(/^A_/, '').downcase.to_sym
+        end
+      end
+
+      # window.write("<red>Dog's <bold>bollocks</bold>!</red>")
+      def write(template)
+        template.chunks_with_colours.each do |chunk, colours|
+          attributes = colours.select { |method| self.defined_attributes.include?(method) }.map do |attribute_name|
+            Curses.const_get(:"A_#{attribute_name.to_s.upcase}") || raise("Unknown attribute #{attribute_name}.")
+          end
+
+          colours.select { |method| self.defined_colours.include?(method) }.each do |colour_name|
+            fg_colour = get_colour(colour_name)
+            Curses.init_pair(fg_colour, fg_colour, Curses::COLOR_BLACK)
+            attributes << (Curses.color_pair(fg_colour) | Curses::COLOR_WHITE)
+          end
+
+          if ! attributes.empty? && ! colours.include?(:clear)
+            self.multi_attron(*attributes) do
+              self.addstr(chunk)
+            end
+          else
+            self.addstr(chunk)
+          end
+        end
+      end
+
+      def get_colour(colour_name)
+        Curses.const_get(:"COLOR_#{colour_name.to_s.upcase}") || raise("Unknown colour: #{colour_name}")
+      end
+
+      def multi_attron(*attributes, &block)
+        self.attron(attributes.shift) do
+          if attributes.empty?
+            block.call
+          else
+            self.multi_attron(*attributes, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/refined-refinements/curses/commander.rb

@@ -0,0 +1,100 @@
+require 'refined-refinements/string'
+
+class QuitError < StandardError
+end
+
+class Command
+  attr_reader :keys, :help
+  def initialize(keys, help = nil, &handler)
+    @keys, @help, @handler = keys, help, handler
+  end
+
+  def handles?(command_key)
+    @keys.include?(command_key)
+  end
+
+  def execute(commander_window, command_key)
+    @handler.call(commander_window, command_key)
+  end
+end
+
+class Commander
+  using RR::ColourExts
+  using RR::StringExts
+
+  def initialize
+    @commands = Array.new
+    # @commands << Command.new(['?'], "Display help.") do |commander_window|
+    #   commander_window.write(self.help)
+    #   commander_window.getch # Enter or any key.
+    # end
+  end
+
+  def run(&block)
+    Curses.noecho
+    Curses.curs_set(0)
+
+    commander_window = Curses::Window.new(Curses.lines, Curses.cols, 0, 0)
+    commander_window.keypad = true
+
+    if block
+      block.call(self, commander_window)
+      commander_window.refresh
+    end
+
+    commander_window.setpos(commander_window.cury + 4, 0)
+
+    command_key = commander_window.getch
+    if command = self.find_command(command_key)
+      command.execute(commander_window, command_key) # Return message.
+    else
+      # TODO: command not found, display message?
+      self.run(&block) # Restart.
+    end
+  ensure
+    Curses.echo
+  end
+
+  def loop(&block)
+    Kernel.loop { self.run(&block) }
+  rescue QuitError
+    # void
+  end
+
+  def command(keys_or_key, help = nil, &handler)
+    @commands << Command.new([keys_or_key].flatten, help, &handler) # TODO: (One) key vs. keys?
+  end
+
+  def default_command(&handler)
+    @default_command = Command.new(Array.new, nil, &handler)
+  end
+
+  def find_command(command_key)
+    @commands.find { |command| command.handles?(command_key) } || @default_command
+  end
+
+  def help
+    commands_help = @commands.reduce(Array.new) do |buffer, command|
+      if command.help
+        keys_text = command.keys.join_with_and('or') do |word|
+          "<yellow.bold>#{word}</yellow.bold>"
+        end
+
+        buffer << "#{keys_text} to #{command.help}"
+      else
+        buffer
+      end
+    end
+
+    "<red.bold>Help:</red.bold> Press #{commands_help.join_with_and('or')}."
+  end
+
+  def available_commands_help
+    commands_help = @commands.reduce(Array.new) { |buffer, command|
+      keys_text = command.keys.join_with_and('or') { |word| "<yellow.bold>#{word}</yellow.bold>" }
+      buffer << "#{keys_text}"
+    }.join_with_and
+
+    "<green>Available commands</green> are #{commands_help}. Press <yellow>?</yellow> for <red>help</red>."
+  end
+end

data/lib/refined-refinements/string.rb

@@ -5,5 +5,13 @@ module RR
         "#{self[0].upcase}#{self[1..-1]}"
       end
     end
+
+    refine Array do
+      def join_with_and(xxx = 'and', delimiter = ', ', &block)
+        block = Proc.new { |item| item } if block.nil?
+        return block.call(self[0]) if self.length == 1
+        "#{self[0..-2].map(&block).join(delimiter)} #{xxx} #{block.call(self[-1])}"
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: refined-refinements
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.1.1
 platform: ruby
 authors:
 - James C Russell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-27 00:00:00.000000000 Z
+date: 2017-12-20 00:00:00.000000000 Z
 dependencies: []
 description: "."
 email: james@101ideas.cz
@@ -17,7 +17,14 @@ extensions: []
 extra_rdoc_files: []
 files:
 - README.md
+- lib/refined-refinements/cached_http.rb
+- lib/refined-refinements/cli/commander.rb
+- lib/refined-refinements/cli/prompt.rb
+- lib/refined-refinements/collection.rb
 - lib/refined-refinements/colours.rb
+- lib/refined-refinements/curses/app.rb
+- lib/refined-refinements/curses/colours.rb
+- lib/refined-refinements/curses/commander.rb
 - lib/refined-refinements/date.rb
 - lib/refined-refinements/matching.rb
 - lib/refined-refinements/string.rb
@@ -41,7 +48,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: ''