hansi 0.1.0 → 0.2.1

data/lib/hansi/string_renderer.rb

@@ -0,0 +1,103 @@
+require 'strscan'
+
+module Hansi
+  class StringRenderer
+    ParseError ||= Class.new(SyntaxError)
+
+    def self.render(*args, **options)
+      input, markup = [], {}
+
+      args.each do |arg|
+        if arg.respond_to? :to_hash
+          markup.merge! arg.to_hash
+        else
+          input << arg
+        end
+      end
+
+      new(markup, **options).render(*input)
+    end
+
+    def initialize(markup = {}, theme: :default, escape: ?\\, tags: false, mode: Hansi.mode)
+      @theme    = Theme[theme]
+      @escape   = escape
+      @tags     = tags
+      @markup   = markup
+      @mode     = mode
+      @simple   = Regexp.union(@markup.keys)
+      reserved  = @markup.keys
+      reserved += [?<, ?>] if @tags
+      reserved << @escape if @escape
+      @reserved = Regexp.union(reserved)
+    end
+
+    def render(input, *values)
+      scanner = StringScanner.new(input)
+      insert  = true
+      stack   = []
+      output  = String.new
+
+      until scanner.eos?
+        if scanner.scan(@simple)
+          stack.last == scanner[0] ? stack.pop : stack.push(scanner[0])
+          insert = true
+        elsif @escape and scanner.scan(/#{Regexp.escape(@escape)}(.)/)
+          output << color_codes(stack) if insert
+          output << scanner[1]
+          insert = false
+        elsif @tags and scanner.scan(/<(\/)?([^>\s]+)>/)
+          insert = true
+          if scanner[1]
+            unexpected(scanner[2], stack.last)
+            stack.pop
+          else
+            stack << scanner[2]
+          end
+        else
+          output << color_codes(stack) if insert
+          output << scanner.getch
+          insert = false
+        end
+      end
+
+      unexpected(nil, stack.last)
+      output << Hansi.reset
+      values.any? ? output % values : output
+    end
+
+    def color_codes(stack)
+      codes = [Hansi.reset, :default, *stack].map { |element| ansi_for(element) }
+      codes.compact.join
+    end
+
+    def describe(element)
+      case element
+      when @simple then element.inspect
+      when nil     then "end of string"
+      else "</#{element}>".inspect
+      end
+    end
+
+    def unexpected(element, expected)
+      return if element == expected
+      return if element == "#" and expected.start_with?("#")
+      return if expected.start_with?("#{element}(") and expected.end_with?(")")
+      raise ParseError, "unexpected #{describe(element)}, expecting #{describe(expected)}"
+    end
+
+    def ansi_for(input)
+      case input
+      when /^\e/         then input
+      when *@markup.keys then ansi_for(@markup[input])
+      when nil, false    then nil
+      when AnsiCode      then input.to_ansi(mode: @mode)
+      else ansi_for(@theme[input])
+      end
+    end
+
+    def escape(string)
+      return string unless @escape
+      string.gsub(@reserved) { |s| "#{@escape}#{s}" }
+    end
+  end
+end

data/lib/hansi/theme.rb

@@ -0,0 +1,66 @@
+module Hansi
+  class Theme
+    def self.[](key)
+      case key
+      when self   then key
+      when Symbol then Themes.fetch(key)
+      when Hash   then new(**key)
+      when Array  then key.map { |k| self[k] }.inject(:merge)
+      else raise ArgumentError, "cannot convert %p into a %p" % [key, self]
+      end
+    end
+
+    def self.[]=(key, value)
+      Themes[key.to_sym] = self[value]
+    end
+
+    attr_reader :rules
+    def initialize(*inherit, **rules)
+      inherited = inherit.map { |t| Theme[t].rules }.inject({}, :merge)
+      @rules    = inherited.merge(rules).freeze
+    end
+
+    def ==(other)
+      other.class == self.class and other.rules == self.rules
+    end
+
+    def eql?(other)
+      other.class.eql?(self.class) and other.rules.eql?(self.rules)
+    end
+
+    def hash
+      rules.hash
+    end
+
+    def [](key)
+      return self[rules[key]]        if rules.include? key
+      return self[rules[key.to_sym]] if key.respond_to? :to_sym and rules.include? key.to_sym
+      ColorParser.parse(key)
+    rescue ColorParser::IllegalValue
+    end
+
+    def merge(other)
+      other_rules = self.class[other].rules
+      self.class.new(**rules.merge(other_rules))
+    end
+
+    def to_h
+      mapped = rules.keys.map { |key| [key, self[key]] if self[key] }
+      Hash[mapped.compact]
+    end
+
+    def to_css(&block)
+      mapping = rules.keys.group_by { |key| self[key] }
+      mapping = mapping.map { |c,k| c.to_css(*k, &block) }
+      mapping.compact.join(?\n)
+    end
+
+    def theme_name
+      Themes.keys.detect { |key| Themes[key] == self }
+    end
+
+    def inspect
+      "%p[%p]" % [self.class, theme_name || rules]
+    end
+  end
+end

data/lib/hansi/themes.rb

@@ -0,0 +1,24 @@
+module Hansi
+  Themes ||= {
+    default:   Theme.new,
+    solarized: Theme.new({
+      base03:    "#002b36",
+      base02:    "#073642",
+      base01:    "#586e75",
+      base00:    "#657b83",
+      base0:     "#839496",
+      base1:     "#93a1a1",
+      base2:     "#eee8d5",
+      base3:     "#fdf6e3",
+      yellow:    "#b58900",
+      orange:    "#cb4b16",
+      red:       "#dc322f",
+      magenta:   "#d33682",
+      violet:    "#6c71c4",
+      blue:      "#268bd2",
+      cyan:      "#2aa198",
+      green:     "#859900",
+      default:   :base00
+    })
+  }
+end

data/lib/hansi/version.rb

@@ -0,0 +1,3 @@
+module Hansi
+  VERSION = '0.2.1'
+end

data/lib/hansi.rb

@@ -0,0 +1,53 @@
+module Hansi
+  TRUE_COLOR = 256**3
+
+  def self.[](*args)
+    ColorParser.parse(*args)
+  end
+
+  def self.mode
+    @mode ||= mode_for(ENV)
+  end
+
+  def self.mode=(value)
+    @mode = value
+  end
+
+  def self.mode_for(env, **options)
+    ModeDetector.new(env, **options).mode
+  end
+
+  def self.render(*input, **options)
+    renderer_for(input.first).render(*input, **options)
+  end
+
+  def self.renderer_for(input)
+    case input
+    when String        then StringRenderer
+    when Symbol, Array then SexpRenderer
+    when AnsiCode      then ColorRenderer
+    else raise ArgumentError, "don't know how to render %p" % input
+    end
+  end
+
+  def self.reset
+    Hansi[:reset].to_ansi
+  end
+
+  def self.color_names
+    PALETTES['web'].keys
+  end
+
+  require 'hansi/ansi_code'
+  require 'hansi/color'
+  require 'hansi/special'
+
+  require 'hansi/color_parser'
+  require 'hansi/color_renderer'
+  require 'hansi/mode_detector'
+  require 'hansi/palettes'
+  require 'hansi/sexp_renderer'
+  require 'hansi/string_renderer'
+  require 'hansi/theme'
+  require 'hansi/themes'
+end

data/spec/hansi/color_parser_spec.rb

@@ -0,0 +1,17 @@
+describe Hansi::ColorParser do
+  subject(:parser) { Hansi::ColorParser }
+  it { should parse("#f00")             .as(red: 255)                        }
+  it { should parse("00ff00")           .as(green: 255)                      }
+  it { should parse("#f")               .as(red: 255, green: 255, blue: 255) }
+  it { should parse("#f0")              .as(red: 240, green: 240, blue: 240) }
+  it { should parse(red: 1.0)           .as(red: 255)                        }
+  it { should parse(red: 300)           .as(red: 255)                        }
+  it { should parse(red: -10)           .as(red: 0)                          }
+  it { should parse(:rebeccapurple)     .as(red: 102, green: 51,  blue: 153) }
+  it { should parse("\e[31m")           .as(red: 194, green: 54,  blue:  33) }
+  it { should parse("\e[38;5;208m")     .as(red: 255, green: 135, blue:   0) }
+  it { should parse("\e[38;2;255;0;0m") .as(red: 255)                        }
+
+  it { should_not parse("#ffff")    }
+  it { should_not parse(Object.new) }
+end

data/spec/hansi/color_renderer_spec.rb

@@ -0,0 +1,6 @@
+describe Hansi::ColorRenderer do
+  before { Hansi.mode = 16 }
+  subject(:renderer) { Hansi::ColorRenderer }
+  it { should render(Hansi[:red]).as("\e[91m") }
+  it { should render(Hansi[:red], "foo").as("\e[91mfoo\e[0m") }
+end

data/spec/hansi/color_spec.rb

@@ -0,0 +1,46 @@
+describe Hansi::Color do
+  subject(:color) { Hansi::Color.new(255, 0, 0) }
+
+  describe :hash do
+    specify { color.hash.should be == Hansi["f00"].hash }
+  end
+
+  describe :eql? do
+    specify { color.should be_eql Hansi["f00"] }
+  end
+
+  describe :to_s do
+    specify { color.to_s.should be == "#ff0000" }
+  end
+
+  describe :to_css_rule do
+    specify { color.to_css_rule.should be == "color: #ff0000;" }
+  end
+
+  describe :to_css do
+    specify { color.to_css("name")         .should be == ".name {\n  color: #ff0000;\n}\n" }
+    specify { color.to_css("name", &:to_s) .should be == "name {\n  color: #ff0000;\n}\n"  }
+  end
+
+  describe :to_web_name do
+    specify { color.to_web_name.should be == :red }
+  end
+
+  describe :closest do
+    specify { color.closest([color, Hansi[:orange]])        .should be == color }
+    specify { color.closest([Hansi[:blue], Hansi[:orange]]) .should be == Hansi[:orange] }
+  end
+
+  describe :to_ansi do
+    specify { color.to_ansi(mode: 0)                  .should be == ""                 }
+    specify { color.to_ansi(mode: 8)                  .should be == "\e[31m"           }
+    specify { color.to_ansi(mode: 16)                 .should be == "\e[91m"           }
+    specify { color.to_ansi(mode: 88)                 .should be == "\e[38;5;9m"       }
+    specify { color.to_ansi(mode: 256)                .should be == "\e[38;5;9m"       }
+    specify { color.to_ansi(mode: Hansi::TRUE_COLOR)  .should be == "\e[38;2;255;0;0m" }
+
+    specify "unknown mode" do
+      expect { color.to_ansi(mode: 99) }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/hansi/mode_detector_spec.rb

@@ -0,0 +1,35 @@
+describe Hansi::ModeDetector do
+  example do
+    detector = Hansi::ModeDetector.new(ENV)
+    expect(detector)      .to be_shell_out
+    expect(detector.io)   .to be == $stdout
+    expect(detector.mode) .to be_an(Integer)
+  end
+
+  example do
+    detector = Hansi::ModeDetector.new({})
+    expect(detector)      .not_to be_shell_out
+    expect(detector.io)   .to     be_nil
+    expect(detector.mode) .to     be == 0
+  end
+
+  example do
+    detector = Hansi::ModeDetector.new({'TERM' => 'xterm'})
+    expect(detector.mode).to be == 16
+  end
+
+  example do
+    detector = Hansi::ModeDetector.new({'TERM' => 'footerm-256color'})
+    expect(detector.mode).to be == 256
+  end
+
+  example do
+    detector = Hansi::ModeDetector.new({'TERM' => 'footerm+24bit'})
+    expect(detector.mode).to be == Hansi::TRUE_COLOR
+  end
+
+  example do
+    detector = Hansi::ModeDetector.new({'TERM' => 'footerm+3byte'})
+    expect(detector.mode).to be == Hansi::TRUE_COLOR
+  end
+end

data/spec/hansi/sexp_renderer_spec.rb

@@ -0,0 +1,7 @@
+describe Hansi::SexpRenderer do
+  before { Hansi.mode = 16 }
+  subject(:renderer) { Hansi::SexpRenderer }
+  it { should render([:red, "foo"])                         .as("\e[0m\e[91mfoo\e[0m")                       }
+  it { should render([:red, [:blue, "b"], "c"], join: " ")  .as("\e[0m\e[91m\e[34mb\e[0m \e[0m\e[91mc\e[0m") }
+  it { should render([:default, "foo"], theme: :solarized)  .as("\e[0m\e[90mfoo\e[0m")                       }
+end

data/spec/hansi/special_spec.rb

@@ -0,0 +1,6 @@
+describe Hansi::Special do
+  describe :to_css_rule do
+    example { Hansi[:bold]    .to_css_rule.should be == 'font-weight: bold;' }
+    example { Hansi[:fraktur] .to_css_rule.should be == '/* cannot convert <Hansi::Special:"\e[20m"> to css */' }
+  end
+end

data/spec/hansi/string_renderer_spec.rb

@@ -0,0 +1,32 @@
+describe Hansi::StringRenderer do
+  before { Hansi.mode = 16 }
+  subject(:renderer) { Hansi::StringRenderer }
+
+  it { should render("foo *bar*")                         .as("\e[0m\e[10mfoo *bar*\e[0m")               }
+  it { should render("<foo>")                             .as("\e[0m\e[10m<foo>\e[0m")                   }
+  it { should render("foo *bar*", "*" => :bold)           .as("\e[0m\e[10mfoo \e[0m\e[10m\e[1mbar\e[0m") }
+  it { should render("foo \\*bar\\*", "*" => :bold)       .as("\e[0m\e[10mfoo *bar*\e[0m")               }
+  it { should render("<bold>foo</bold>", tags: true)      .as("\e[0m\e[10m\e[1mfoo\e[0m")                }
+  it { should render("foo", mode: 256, theme: :solarized) .as("\e[0m\e[38;5;66mfoo\e[0m")                }
+  it { should render("*%s*", "*", "*" => :bold)           .as("\e[0m\e[10m\e[1m*\e[0m")                  }
+
+  it { should_not render("<red>", tags: true)   }
+  it { should_not render("*",     "*" => :bold) }
+
+  describe :escape do
+    context "special character" do
+      subject(:renderer) { Hansi::StringRenderer.new({"*" => :bold}) }
+      it { should escape("foo *bar*").as("foo \\*bar\\*") }
+    end
+
+    context "nothing special" do
+      subject(:renderer) { Hansi::StringRenderer.new }
+      it { should escape("<foo> *bar*").as("<foo> *bar*") }
+    end
+
+    context "tags" do
+      subject(:renderer) { Hansi::StringRenderer.new(tags: true) }
+      it { should escape("<foo> bar").as("\\<foo\\> bar") }
+    end
+  end
+end

data/spec/hansi/theme_spec.rb

@@ -0,0 +1,43 @@
+describe Hansi::Theme do
+  subject(:theme) { Hansi::Theme.new(foo: :bar, bar: :red) }
+
+  describe :[] do
+    specify { Hansi::Theme[:solarized][:yellow]            .should be == Hansi[181, 137, 0]                         }
+    specify { Hansi::Theme[:default][:yellow]              .should be == Hansi[255, 255, 0]                         }
+    specify { Hansi::Theme[Hansi::Theme[:solarized]]       .should be == Hansi::Theme[:solarized]                   }
+    specify { Hansi::Theme[red: :blue]                     .should be == Hansi::Theme.new(red: :blue)               }
+    specify { Hansi::Theme[[{red: :blue}, {green: :blue}]] .should be == Hansi::Theme.new(red: :blue, green: :blue) }
+    specify { expect { Hansi::Theme[Object.new] }.to raise_error(ArgumentError) }
+  end
+
+  describe :[]= do
+    specify do
+      Hansi::Theme[:foo] = :solarized
+      Hansi::Theme[:foo][:yellow].should be == Hansi[181, 137, 0]
+    end
+  end
+
+  describe :merge do
+    specify do
+      new_theme = theme.merge(foo: :baz)
+      expect(new_theme.rules).to include(foo: :baz)
+    end
+  end
+
+  describe :hash do
+    specify { Hansi::Theme[:default].hash.should be == Hansi::Theme[{}].hash }
+  end
+
+  describe :eql? do
+    specify { Hansi::Theme[:default].should be_eql Hansi::Theme[{}] }
+  end
+
+  describe :to_h do
+    specify { theme.to_h.should be == { foo: Hansi[:red], bar: Hansi[:red] }}
+  end
+
+  describe :to_css do
+    specify { theme.to_css                       .should be == ".foo, .bar {\n  color: #ff0000;\n}\n" }
+    specify { theme.to_css { |name| "##{name}" } .should be == "#foo, #bar {\n  color: #ff0000;\n}\n" }
+  end
+end

data/spec/hansi_spec.rb

@@ -0,0 +1,41 @@
+describe Hansi do
+  describe :mode_for do
+    specify { Hansi.mode_for({})                             .should be == 0   }
+    specify { Hansi.mode_for({'TERM' => 'footerm-256color'}) .should be == 256 }
+  end
+
+  describe :color_names do
+    specify { Hansi.color_names.should include(:red)           }
+    specify { Hansi.color_names.should include(:rebeccapurple) }
+  end
+
+  describe :render do
+    subject(:renderer) { Hansi }
+
+    context "string renderer" do
+      it { should render("foo *bar*")                         .as("\e[0m\e[10mfoo *bar*\e[0m")               }
+      it { should render("<foo>")                             .as("\e[0m\e[10m<foo>\e[0m")                   }
+      it { should render("foo *bar*", "*" => :bold)           .as("\e[0m\e[10mfoo \e[0m\e[10m\e[1mbar\e[0m") }
+      it { should render("foo \\*bar\\*", "*" => :bold)       .as("\e[0m\e[10mfoo *bar*\e[0m")               }
+      it { should render("<bold>foo</bold>", tags: true)      .as("\e[0m\e[10m\e[1mfoo\e[0m")                }
+      it { should render("foo", mode: 256, theme: :solarized) .as("\e[0m\e[38;5;66mfoo\e[0m")                }
+      it { should render("*%s*", "*", "*" => :bold)           .as("\e[0m\e[10m\e[1m*\e[0m")                  }
+
+      it { should_not render("<red>", tags: true)   }
+      it { should_not render("*",     "*" => :bold) }
+    end
+
+    context 'sexp renderer' do
+      it { should render([:red, "foo"])                         .as("\e[0m\e[91mfoo\e[0m")                       }
+      it { should render([:red, [:blue, "b"], "c"], join: " ")  .as("\e[0m\e[91m\e[34mb\e[0m \e[0m\e[91mc\e[0m") }
+      it { should render([:default, "foo"], theme: :solarized)  .as("\e[0m\e[90mfoo\e[0m")                       }
+    end
+
+    context 'color renderer' do
+      it { should render(Hansi[:red])        .as("\e[91m")         }
+      it { should render(Hansi[:red], "foo") .as("\e[91mfoo\e[0m") }
+    end
+
+    it { should_not render(Object.new) }
+  end
+end

data/spec/support/coverage.rb

@@ -0,0 +1,14 @@
+require 'simplecov'
+require 'coveralls'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+])
+
+SimpleCov.start do
+  project_name 'hansi'
+  coverage_dir '.coverage'
+  add_filter "/spec/"
+  add_filter "/lib/hansi/mode_detector.rb"
+end

data/spec/support/env.rb

@@ -0,0 +1,10 @@
+require 'tool/warning_filter'
+$-w = true
+
+require 'rspec'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = [:should, :expect]
+  end
+end

data/spec/support/escape_matcher.rb

@@ -0,0 +1,28 @@
+RSpec::Matchers.define :escape do |*args|
+  match do |renderer|
+    begin
+      @rendered = renderer.escape(*args)
+    rescue Exception => e
+      @exception = e
+      false
+    else
+      if @expected ||= nil
+        @rendered == @expected
+      else
+        !!@rendered
+      end
+    end
+  end
+
+  chain :as do |result|
+    @expected = result
+  end
+
+  failure_message do |renderer|
+    if @exception ||= nil
+      "expected %p to escape %p, but got exception: %p" % [renderer, args, @exception]
+    else
+      "expected %p to escape %p as %p, but got %p" % [render, args, @expected, @rendered]
+    end
+  end
+end

data/spec/support/parse_matcher.rb

@@ -0,0 +1,28 @@
+RSpec::Matchers.define :parse do |*args|
+  match do |parser|
+    begin
+      @parsed = parser.parse(*args)
+    rescue Exception => e
+      @exception = e
+      false
+    else
+      if @expected ||= nil
+        @parsed == @expected
+      else
+        !!@parsed
+      end
+    end
+  end
+
+  chain :as do |*result|
+    @expected = parser.parse(*result)
+  end
+
+  failure_message do |parser|
+    if @exception ||= nil
+      "expected %p to parse %p, but got exception: %p" % [parser, args, @exception]
+    else
+      "expected %p to parse %p as %p, but got %p" % [parser, args, @expected, @parsed]
+    end
+  end
+end

data/spec/support/render_matcher.rb

@@ -0,0 +1,28 @@
+RSpec::Matchers.define :render do |*args, **options|
+  match do |renderer|
+    begin
+      @rendered = renderer.render(*args, **options)
+    rescue Exception => e
+      @exception = e
+      false
+    else
+      if @expected ||= nil
+        @rendered == @expected
+      else
+        !!@rendered
+      end
+    end
+  end
+
+  chain :as do |result|
+    @expected = result
+  end
+
+  failure_message do |renderer|
+    if @exception ||= nil
+      "expected %p to render %p, but got exception: %p" % [renderer, args, @exception]
+    else
+      "expected %p to render %p as %p, but got %p" % [render, args, @expected, @rendered]
+    end
+  end
+end

data/spec/support.rb

@@ -0,0 +1,6 @@
+require 'support/env'
+require 'support/coverage'
+require 'support/escape_matcher'
+require 'support/parse_matcher'
+require 'support/render_matcher'
+require 'hansi'