hansi 0.1.0 → 0.1.1

data/lib/hansi/sexp_renderer.rb

@@ -0,0 +1,27 @@
+require 'strscan'
+
+module Hansi
+  class SexpRenderer
+    def self.render(*args, **options)
+      new(**options).render(args)
+    end
+
+    def initialize(theme: :default, mode: Hansi.mode, join: "")
+      @theme = Theme[theme]
+      @mode  = mode
+      @join  = join
+    end
+
+    def render(input, codes: nil)
+      return "#{codes}#{input}#{Hansi.reset}" unless input.respond_to? :to_ary and sexp = input.to_ary
+      return render(sexp.first) if sexp.size < 2
+
+      style, *content = sexp
+      codes ||= Hansi.reset
+      style &&= @theme[style]
+      codes  += style.to_ansi(mode: @mode).to_s if style
+
+      content.map { |e| render(e, codes: codes) }.join(@join)
+    end
+  end
+end

data/lib/hansi/special.rb

@@ -0,0 +1,25 @@
+module Hansi
+  class Special < AnsiCode
+    def initialize(ansi, css = nil)
+      ansi  = "\e[#{ansi}m" unless ansi.is_a? String and ansi.start_with? "\e"
+      css   = css.map { |a| a.map { |v| Symbol === v ? v.to_s.tr('_','-') : v.to_s }.join(': ') } if css.is_a? Hash
+      css   = css.join("; ") if css.is_a? Array
+      css   = css + ";" if css and not css.end_with? ";"
+      @ansi = ansi
+      @css  = css
+    end
+
+    def to_css_rule
+      @css || super
+    end
+
+    def to_ansi(mode: Hansi.mode, **options)
+      mode &&= mode[/\d+/].to_i unless mode.is_a? Integer
+      @ansi if mode > 1
+    end
+
+    def inspect
+      "<%p:%p>" % [self.class, @ansi]
+    end
+  end
+end

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  = ""
+
+      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(**other_rules, **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.1.1'
+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
+    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,36 @@
+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 :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