color-japanese 1.0.0

data/helper/rake_sh_filter.rb

@@ -0,0 +1,23 @@
+module FileUtils
+  SHELL_COMMAND_FILTER = []
+
+  alias sh_original sh
+  def sh(*cmd, &block)
+    cmd = SHELL_COMMAND_FILTER.inject(cmd){|c,filter| filter.call(c) or c }
+    sh_original(*cmd, &block)
+  end
+
+  def add_sh_filter(&block)
+    SHELL_COMMAND_FILTER << block
+  end
+
+  def add_sh_filter_for(pattern, &block)
+    add_sh_filter {|cmd|
+      if cmd[0] =~ pattern
+        block.call(cmd)
+      else
+        cmd
+      end
+    }
+  end
+end

data/helper/util.rb

@@ -0,0 +1,19 @@
+def windows?
+  RUBY_PLATFORM =~ /win/
+end
+
+def with_temporary_rename(from, to)
+  mv from, to
+  yield
+ensure
+  mv to, from
+end
+
+def has_dot?
+  if windows?
+    v = `dot -V 2>&1` rescue nil
+    v and v =~ /Graphviz/
+  else
+    `which dot` =~ /\/dot/
+  end
+end

data/lib/color/rgb/jp.rb

@@ -0,0 +1,12 @@
+require "color/rgb/jp/jisz8102"
+require "color/rgb/jp/traditional"
+require "color/rgb/jp/version"
+
+module Color::RGB::JP
+  def self.pallets
+    [
+      Color::RGB::JP::Traditional,
+      Color::RGB::JP::JISZ8102
+    ]
+  end
+end

data/lib/color/rgb/jp/base.rb

@@ -0,0 +1,10 @@
+require "color"
+
+module Color::RGB::JP
+  module Base; end
+end
+
+require "color/rgb/jp/base/encode"
+require "color/rgb/jp/base/color_name"
+require "color/rgb/jp/base/named_rgb"
+require "color/rgb/jp/base/pallet"

data/lib/color/rgb/jp/base/color_name.rb

@@ -0,0 +1,39 @@
+require "color/rgb/jp/base/encode"
+
+module Color::RGB::JP::Base
+
+  class ColorName
+    include Encode
+
+    def self.encoded_attr_reader(internal_encoding, *attributes)
+      attributes.each do |attr|
+        class_eval %Q{
+          def #{attr}(encoding = "#{internal_encoding}")
+            encode_to(encoding, "#{internal_encoding}", @#{attr})
+          end
+        }
+      end
+    end
+
+    encoded_attr_reader Encode::INTERNAL_ENCODING, :kanji, :hiragana, :katakana, :romaji
+    attr_reader :const_name
+
+    def initialize(const_name, kanji, hiragana, katakana = nil, romaji = nil)
+      @const_name = const_name
+      @kanji = kanji
+      @hiragana = hiragana
+      @katakana = katakana
+      @romaji = romaji
+    end
+
+    def to_s
+      romaji
+    end
+
+    def names(encoding = Encode::INTERNAL_ENCODING)
+      %W(kanji hiragana katakana romaji).map{|e| self.__send__(e, encoding) }
+    end
+    alias to_a names
+  end
+
+end

data/lib/color/rgb/jp/base/encode.rb

@@ -0,0 +1,23 @@
+require "iconv"
+
+module Color::RGB::JP::Base
+
+  module Encode
+    INTERNAL_ENCODING = "UTF-8"
+
+    module_function
+
+    def encode_to(to, from, value)
+      return nil if value.nil?
+      return value if to.nil?
+      return value if from.nil?
+      return value if from == to
+      return Iconv.iconv(to, from, value)[0]
+    end
+
+    def with_internal_encoding(value, from)
+      yield encode_to(INTERNAL_ENCODING, from, value)
+    end
+  end
+
+end

data/lib/color/rgb/jp/base/named_rgb.rb

@@ -0,0 +1,15 @@
+module Color::RGB::JP::Base
+
+  class NamedRGB
+    attr_reader :name, :rgb
+    def initialize(name, rgb)
+      @name = name
+      @rgb = rgb
+    end
+
+    def to_s
+      "%s (%s)" % [name.romaji, rgb.html]
+    end
+  end
+
+end

data/lib/color/rgb/jp/base/pallet.rb

@@ -0,0 +1,49 @@
+require "color"
+
+require "color/rgb/jp/base/encode"
+require "color/rgb/jp/base/named_rgb"
+require "color/rgb/jp/base/color_name"
+
+module Color::RGB::JP::Base
+
+  module Pallet
+    include Encode
+    include Enumerable
+
+    def colors
+      @colors
+    end
+
+    def each(&block)
+      colors.each(&block)
+    end
+
+    def [](name, encoding = nil)
+      with_internal_encoding(name, encoding) {|n|
+        @index[normalize(n)]
+      }
+    end
+
+    def define_color(const, hex, *names)
+      @colors ||= []
+      @index ||= {}
+
+      name = ColorName.new(const, *names)
+      rgb = ::Color::RGB.from_html(hex)
+      color = NamedRGB.new(name, rgb)
+      @colors << color
+
+      [const, *names].compact.each {|e|
+        @index[normalize(e)] ||= color
+      }
+      color
+    end
+    alias c define_color
+
+    def normalize(v)
+      v.gsub(/-/, "").downcase
+    end
+    private :normalize
+  end
+
+end

data/lib/color/rgb/jp/compiler/command.rb

@@ -0,0 +1,102 @@
+require "optparse"
+
+require "color/rgb/jp"
+require "color/rgb/jp/compiler/compiler"
+
+class Color::RGB::JP::Compiler::Command
+
+  def self.dispatch
+    output = $stdout
+    encoding = Color::RGB::JP::Base::Encode::INTERNAL_ENCODING
+    pallet = "jis"
+    prefix = "##"
+    do_compile = true
+    generator = "#{$0} #{ARGV * " "}"
+
+    ARGV.options do |opt|
+      opt.program_name = "color-japanese"
+      opt.version = Color::RGB::JP::VERSION::STRING
+      opt.banner = "Usage: jcolorc [options] <source file>"
+      opt.separator ""
+      opt.separator "  Options:"
+      opt.on("-o <output file>", "--output",
+             "output file (default: stdout)") {|v| output = v}
+      opt.on("-p <color pallet>", "--pallet",
+             "color pallet (jis or traditional).",
+             "(default: #{pallet})") {|v| pallet = v }
+      opt.on("-K<kcode>",
+             "specifies KANJI code-set (default: #{encoding})") {|v| encoding = parse_kcode(v) }
+      opt.on("-E",
+             "output preprocessed ERB script") { do_compile = false }
+      opt.on("--prefix=<directive prefix>",
+             "prefix the pre-processor directive.",
+             "(default: #{prefix})") {|v| prefix = v}
+      opt.separator ""
+      opt.on_tail("-v", "--version", "print the version"){
+        puts opt.ver
+        exit 0
+      }
+      opt.on_tail("-h", "--help", "print this message"){
+        puts opt
+        exit 0
+      }
+      opt.parse!
+    end
+
+    pallet = parse_pallet(pallet)
+    input = parse_input(ARGV)
+
+    check_not_blank(prefix, "Error: no prefix.")
+    check_not_blank(output, "Error: no output file.")
+
+    $KCODE = encoding
+
+    jcolorc = Color::RGB::JP::Compiler::Compiler.new(pallet, encoding, prefix, generator)
+    jcolorc.execute(input, output, do_compile)
+  end
+
+  def self.check_not_blank(v, msg)
+    error_exit(msg, 1) if v.nil? or v == ""
+  end
+
+  def self.parse_input(args)
+    case args.length
+    when 0
+      $stdin
+    when 1
+      ARGV.shift
+    else
+      error_exit("Error: too many source file.", 1)
+    end
+  end
+
+  def self.parse_kcode(kcode)
+    case kcode.downcase
+    when "e", "euc", /\Aeuc[_-]?jp/
+      "EUC-JP"
+    when "s", "sjis", /\Ashift[_-]?jis\z/
+      "Shift_JIS"
+    when "u", /\Autf[_-]?8\z/
+      "UTF-8"
+    else
+      error_exit("invalid KCODE #{kcode.dump}", 1)
+    end
+  end
+
+  def self.parse_pallet(pallet_name)
+    case pallet_name
+    when /\Ajis/i
+      Color::RGB::JP::JISZ8102
+    when /\Atrad/i
+      Color::RGB::JP::Traditional
+    else
+      error_exit("invalid pallet name `#{pallet_name}': jis or traditional", 1)
+    end
+  end
+
+  def self.error_exit(msg, status)
+    $stderr.puts msg if msg
+    $stderr.puts ARGV.options
+    exit status
+  end
+end

data/lib/color/rgb/jp/compiler/compiler.rb

@@ -0,0 +1,203 @@
+require "erb"
+
+require "rubygems"
+require "color/rgb/jp"
+
+
+module Color::RGB::JP
+  module Compiler; end
+end
+
+class Color::RGB::JP::Compiler::Compiler
+
+  COLOR_NAME_CHAR = /[^[:space:][:punct:][:cntrl:]]/
+  COLOR_NAME_RE = /#{COLOR_NAME_CHAR}+(?:-#{COLOR_NAME_CHAR}+)*/
+
+  DEFAULT_PREPROCESSOR = [:preprocess_alias, :preprocess_color]
+  DEFAULT_TRIM_MODE = ">%"
+
+  attr_accessor :pallet, :encoding, :prefix, :generator, :preprocessor, :trim_mode
+
+  def initialize(pallet, encoding, prefix, generator)
+    @pallet = pallet
+    @encoding = encoding
+    @prefix = prefix
+    @generator = generator
+    @preprocessor = DEFAULT_PREPROCESSOR
+    @trim_mode = DEFAULT_TRIM_MODE
+  end
+
+  def execute(input, output, do_compile)
+    with_input_stream(input) do |is|
+      erbscript = preprocess(is.read, input)
+      with_output_stream(output) do |os|
+        if do_compile
+          os.write compile(erbscript, input)
+        else
+          os.write erbscript
+        end
+      end
+    end
+  end
+
+  def preprocess(src, input)
+    preprocess_snippet(prefix) + do_preprocess(src, @prefix)
+  end
+
+  def compile(src, input)
+    e = ERB.new(src, 0, @trim_mode)
+    e.filename = input if String === input
+    e.result
+  end
+
+  private
+
+  def do_preprocess(src, prefix)
+    @preprocessor.inject(src){|r,fn|
+      if Proc === fn
+        fn.call(self, r, prefix) || r
+      else
+        self.__send__(fn, r, prefix) || r
+      end
+    }
+  end
+
+  def preprocess_alias(src, prefix)
+    scan_erb(src, /#{prefix}\s*alias[ \t]*((?:#{COLOR_NAME_RE}| )*)/, "<%"){|m|
+      n, v = m.strip.split(/\s+/, 2)
+      "Color::RGB::JP::ERBUtil.alias(%q{#{n}}, %Q{#{v}})"
+    }
+  end
+
+  def preprocess_color(src, prefix)
+    scan_erb(src, /#{prefix}(#{COLOR_NAME_RE})/, "<%="){|m|
+      "Color::RGB::JP::ERBUtil.to_rgb(%q{#{m}})"
+    }
+  end
+
+  def scan_erb(src, re, embed_mode, &block)
+    context = :text
+    src.gsub(/(<%)|(%>)|(^%)|(\n|$)|#{re}/) {
+      tokens = [:stag, :etag, :percent, :lf, :value].zip(Regexp.last_match.captures)
+      context, r = process_token(context, embed_mode, *tokens.find{|e| e[1]}, &block)
+      r
+    }
+  end
+
+  def process_token(context, embed_mode, token, value)
+    case context
+    when :erb1
+      case token
+      when :value;    [context, embed_erb(yield(value))]
+      when :lf;       [:text, value]
+      else            [context, value]
+      end
+    when :erbtag
+      case token
+      when :value;    [context, embed_erb(yield(value))]
+      when :etag;     [:text, value]
+      else            [context, value]
+      end
+    when :text
+      case token
+      when :value;    [context, embed_erb(yield(value), embed_mode)]
+      when :stag;     [:erbtag, value]
+      when :percent;  [:erb1, value]
+      else            [context, value]
+      end
+    else
+      raise "[bug] unknown context `#{context}': token=#{token}, value=#{value}"
+    end
+  end
+
+  def embed_erb(str, tag = nil)
+    if tag.nil?
+      str
+    else
+      "#{tag} #{str} %>"
+    end
+  end
+
+  def preprocess_snippet(prefix)
+    return <<-SNIPPET.gsub(/^    /, "")
+    <%
+    #
+    # Auto generated by "#{@generator}".
+    # Date: #{Time.now.iso8601}.
+    #
+
+    require "color/rgb/jp"
+
+    $KCODE = "#{@encoding}"
+
+    class Color::RGB
+      undef to_s
+      alias to_s html
+    end
+
+    module Color::RGB::JP::ERBUtil
+      _pallet = ::#{@pallet.name}
+      _alias = {}
+
+      define_method(:pallet) do
+        _pallet
+      end
+      module_function :pallet
+
+      define_method(:alias) do |name, value|
+        _alias[name] = value
+      end
+      module_function :alias
+
+      define_method(:alias?) do |name|
+        _alias.key?(name)
+      end
+      module_function :alias?
+
+      define_method(:to_rgb) do |name|
+        c = lookup(name)
+        unless c
+          msg = "undefined color name: `\#{name}'"
+          msg << " (alias of '\#{resolve_alias(name)}')" if alias?(name)
+          warn msg
+          return "#{prefix}\#{name}"
+        end
+        c.rgb
+      end
+      module_function :to_rgb
+
+      define_method(:resolve_alias) do |name|
+        if _alias.key?(name)
+          resolve_alias(_alias[name])
+        else
+          name
+        end
+      end
+      module_function :resolve_alias
+
+      define_method(:lookup) do |name|
+        _pallet[resolve_alias(name), "#{@encoding}"]
+      end
+      module_function :lookup
+    end
+    %>
+    SNIPPET
+  end
+
+  def with_input_stream(stream)
+    if stream.respond_to?(:read)
+      yield stream
+    else
+      open(stream) {|s| yield s }
+    end
+  end
+
+  def with_output_stream(stream)
+    if stream.respond_to?(:write)
+      yield stream
+    else
+      open(stream, "w") {|s| yield s }
+    end
+  end
+
+end