color_echo 2.0.4 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5c40fafb369a9dab0acabca7b1803e6ea98fc1a3
-  data.tar.gz: cf298e3ed99b6a11be36d25b04480fde833cee85
+  metadata.gz: d6506be07d0069c30e631fe82b4b2efb44deb11c
+  data.tar.gz: 6c5ef32192472f4be0d8c507fb50ad5bdb59e221
 SHA512:
-  metadata.gz: 7d0ae0460fac4bc29f849f91f9bb27846d9939d1e98391acbb9547f069c782d3730382e9413e710db4e9967fbd3db082720e1d7b66bf6067bf3bc204cc1ef038
-  data.tar.gz: 6286cbe9988d02ad0bc075d8041555a68c5355a0f49d91bcd2b44f2e0151d00ecb92ffe54355667bf0c14ed4785437697ab42ad4328715877eb9be502094769e
+  metadata.gz: 15e8243c5504922d0fd2bc9bd90acac164f8d028af05d5d3b2e6b92c5af9c56e1ac81f51a1117d9b8dbb2ceac30e09681effd2529ed5c496eeb4268ae5235fc8
+  data.tar.gz: a0cc6e4418eff5461d137ebeb36b9898dacbc3d63aca9a3a190499b2056acd9f45d74cc143f1e0483c616c3fbca12e782c5182eb588be381530733e5c01fc35c

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2014 Kazuya Hotta
+Copyright (c) 2014,2015 Kazuya Hotta
 
 MIT License
 

data/README.md

@@ -1,406 +1,9 @@
-# color_echo
-Decorate the command line output with ANSI escape sequence.     
-Text that output by "print, puts, p" method is decorated.    
-It is also can to decorate only your specified words!   
+# Color Echo
+Decorates command line output with ANSI escape sequence.   
 
-Version: 2.0.2   
-Compliant Rubys Version: 2.0.0, 2.1.0 (for Linux)  
-License: MIT  
-Gems repository: http://rubygems.org/gems/color_echo     
-Japanese Document: https://github.com/khotta/color_echo/blob/master/README.ja.md
+Documents and all informations are as below =(^x^=    
+http://colorecho.net    
 
-## Installation
-
-Add this line to your application's Gemfile:
-
-    gem 'color_echo'
-
-Or install it yourself as:
-
-    $ gem install color_echo
-
-
-## Can to select 256 colors!    
-Please install color_echo and do `color_echo -l`.   
-ex.) CE.ch :index197, :index230    
-![screen shot](/images/color_index.png)
-![screen shot](/images/color_index2.png)
-
-## You can to decorate your specified words!   
-
-```ruby
-CE.fg(:h_cyan).pickup("color_echo", :h_white, :red, :underscore).pickup("COLOR_ECHO", :h_yellow)
-
-puts <<EOS
-xxxxxxxxxxxxxxxxxcolor_echoxxxxxxxxxxxxxxxxxxxxxxxx
-xxxxcolor_echoxxxxxxxCOLOR_ECHOxxxxxxxxxxxxxxxxxxxx
-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
-xxxxxxxxxxxxxxxxxcolor_echoxxxxxxxxxxcolor_echoxxxx
-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
-EOS
-```
-![screen shot](/images/pickup1.png)
-
-
-
-## Do you want to return words with the escape sequence?
-
-Please write `require "color_echo/get"` rather than `require "color_echo"`.
-```ruby
-require "color_echo/get"
-
-greet  = CE.fg(:yellow).get("Hello")
-name   = CE.ch(:h_blue, :gray).get("Foo")
-myname = CE.tx(:underscore).rainbow.get("Bar")
-
-puts greet + ", " + name + "!"
-puts "My name is " + myname
-
-output = CE.fg(:blue).pickup(/color$/, :index199).pickup(/^color/, :h_green).get("color color color")
-puts "output is -> " + output
-```
-![screen shot](/images/get1.png)
-
-
-## Command Line Interface
-You can use color_echo on command line!   
-![screen shot](/images/cli1.png)
-![screen shot](/images/cli2.png)
-
-
-## module functions
-
-#### CE.pickup(target, foreground=:red, backgruond=nil, *text_attribute)    
-To decorate the words that specfied in the String or Regexp or Array of them.    
-If state of enable rainbow mode, This feature is disabled.    
- - Parameter target -> string|regexp or array of them
- - Parameter foreground -> symbol|nil
- - Parameter background -> symbol|nil
- - Parameter text_attribute -> symbol or array of them
- - Return -> self
-
-
-#### CE.hitline(foreground=nil, background=nil, *text_attribute)    
-To decorate match lines by CE.pickup method with specified here.         
- - Parameter foreground -> symbol|nil    
- - Parameter background -> symbol|nil    
- - Parameter text_attribute -> symbol or array of them    
- - Return -> self   
-
-
-#### CE.ch_fg(foreground)
-Change the foreground color to the your specified color.    
- - Alias -> fg    
- - Parameter foreground -> symbol    
- - Return -> self    
-
-* symbol list of foreground:    
-    * black  
-    * red   
-    * green   
-    * yellow  
-    * blue   
-    * magenta  
-    * cyan  
-    * white   
-    * gray   
-    * h_red   
-    * h_green   
-    * h_yellow   
-    * h_blue   
-    * h_magenta   
-    * h_cyan   
-    * h_white   
-    * index[1-256]   
-
-ex.) CE.ch_fg :red #=> foreground color will be changed red  
-
-
-
-
-#### CE.ch_bg(background)   
-Change the background color to the your specified color.     
- - Alias -> bg   
- - Parameter background -> symbol    
- - Return -> self    
-
-* symbol list of background:    
-    * black  
-    * red   
-    * green   
-    * yellow  
-    * blue   
-    * magenta  
-    * cyan  
-    * white  
-    * gray   
-    * h_red   
-    * h_green   
-    * h_yellow   
-    * h_blue   
-    * h_magenta   
-    * h_cyan   
-    * h_white   
-    * index[1-256]   
-
-ex.) CE.ch_bg :white #=> background color will be changed white  
-
-
-
-#### CE.ch_tx(*text_attribute)        
-Change the text attribute to the your specified decoration.     
- - Alias -> tx   
- - Parameter text_attribute -> symbol or array of them   
- - Return -> self    
-
-* symbol list of text attribute:    
-    * bold  
-    * underscore  
-    * blink    
-    * reverse_video 
-    * concealed   
-
-ex.) CE.ch_tx :blink #=> text blink on   
-
-
-#### CE.ch(foreground, background=nil, *text_attribute)
-Change collectively.     
- - Parameter foreground -> symbol|nil    
- - Parameter background -> symbol|nil     
- - Parameter text_attribute -> symbol or array of them
- - Return -> self    
-
-ex.) CE.ch :white, :green   
-ex.) CE.ch :h_red, nil, :blink   
-
-
-#### CE.reset(scope=:all)
-Reset to set the escape sequence.   
- - Alias -> off, disable    
- - Parameter scope -> symbol or array of them
- - Return -> self    
-
-ex.) CE.reset            #=> reset all of the set escape sequence.    
-ex.) CE.reset :fg        #=> foreground color will be reset.     
-ex.) CE.reset :bg        #=> background color will be reset.     
-ex.) CE.reset :tx        #=> text attribute will be reset.    
-ex.) CE.reset :pickup    #=> the pickups text will be reset.    
-ex.) CE.reset :hitline   #=> sequence code list will be reset that is used at match line by CE.pickup.    
-ex.) CE.reset :rainbow   #=> rainbow mode will be reset and swich off.    
-ex.) CE.reset [:fg. :tx] #=> foreground color and ext attribute will be reset.     
-
-
-#### CE.once     
-Reset automatically after once output.     
- - Return -> self    
-
-
-#### CE.times(cnt)
-Reset automatically after cnt times output.     
- - Parameter cnt -> integer    
- - Return -> self    
-
-```ruby   
-CE.once.ch :h_yellow, :h_red, :underscore
-puts "decorated"
-puts "switch off"
-
-puts "\n"
-
-CE.times(3).rainbow
-puts "one"
-puts "two"
-puts "three"
-puts "switch off"
-```
-![screen shot](/images/result_off.png)
-
-
-#### CE.enable_refresh(scope=:all)
-Try to remove the sequence code from the given.     
- - Parameter scope -> symbol
-    - :all: Try to remove the sequence code from the given always.
-    - :prematch: If given matches, Try to remove sequence code from it. 
- - Return -> self   
-
-
-#### CE.disable_refresh
-Not try to remove the sequence code from the given.    
-Default is this.   
- - Return -> self   
-
-
-#### CE.unuse
-Force ignore the function of this library.    
-
-
-#### CE.rainbow
-Text color will change to rainbow color.   
- - Return -> self
-
-
-#### CE.get(text)    
-Decorate and return argument with ANSI escape sequence.   
-If you want to use this module function; You have to require "color_echo/get" only!     
- - Parameter text -> string 
- - Return -> string
-
-
-### Example
-```ruby
-#
-# Example Code
-#
-#require "color_echo"
-
-# force ignore the function of this library
-#CE.unuse
-
-CE.ch :yellow
-puts "fooooooooo"
-puts "baaaaaaaar"
-puts "AAAAA", "BBBBB", "CCCCC"
-
-CE.ch :white, :red
-print "fooooooooo"
-print "baaaaaaaar"
-print "AAAAA", "BBBBB", "CCCCC"
-
-CE.ch :black, :magenta, :underscore
-p "fooooooooo"
-p "baaaaaaaar"
-p "AAAAA", "BBBBB", "CCCCC"
-
-ary = ["Duis", "aute", "irure", "dolor", "in", "reprehenderit", "in", "voluptate"]
-
-CE.off
-puts "switch off all colors and attribute."
-
-CE.fg :red
-puts ary
-
-CE.bg :cyan
-print ary
-
-CE.tx :underscore
-p ary
-
-CE.fg(:black).bg(:white).tx(:blink)
-puts <<EOM
-Lorem ipsum dolor sit amet,
-consectetur adipisicing elit,
-sed do eiusmod tempor incididunt
-ut labore et dolore magna aliqua.
-EOM
-
-CE.off
-CE.rainbow
-puts "fooooooooo"
-puts "baaaaaaaar"
-puts "AAAAA", "BBBBB", "CCCCC"
-puts ary
-
-print "fooooooooo"
-print "baaaaaaaar"
-print "AAAAA", "BBBBB", "CCCCC"
-print ary
-
-p "fooooooooo"
-p "baaaaaaaar"
-p "AAAAA", "BBBBB", "CCCCC"
-p ary
-
-puts <<EOM
-Lorem ipsum dolor sit amet,
-consectetur adipisicing elit,
-sed do eiusmod tempor incididunt
-ut labore et dolore magna aliqua.
-EOM
-
-CE.tx(:underscore).bg(:black)
-CE.rainbow
-hash = {:foo => [111, 222, 333], :bar => {:str => String}}
-p hash
-p "fooooooo", ["AAA", "BBB", "CCC"]
-
-CE.off
-puts "Disable rainbow mode."
-```
-
-#### Result
-
-![screen shot](/images/screenshot.png)
-
-## Release Note
-* v2.0.3, 2016-01-06
-    * rebuild by old gem, because latest gem can't use symbolic link in bin/.
-
-* v2.0.2, 2016-01-06
-    * Fixed problem as below; https://github.com/khotta/color_echo/issues/1
-    * This version has problem of fail to execute colorecho command, Please use v2.0.3 and over.
-
-* v2.0.1, 2015-08-21
-    * Fixed bug that highlight of line is incorrect in commandline interface.
-
-* v2.0.0, 2015-05-20
-    * Add new method -> CE::hitline, CE.enable_refresh, CE.disable_refresh, Please check the reference.   
-    * Can to select new parameter ':hitline' in CE.reset.    
-    * Flushes any buffered data when output data to STDOUT.   
-    * Fixed bug, When the input was included invalid encoding.    
-    * Fixed not to be output the interruptted message, When you pressed ctl + C.   
-    * Fixed default foreground color to yellow in command line interface.      
-
-* v1.3.0, 2015-02-06
-    * Change some options help messages.
-    * You can call 'colorecho' as 'color_echo' in command line interface.
-
-* v1.2.0, 2015-01-28
-    * Add -e option.
-
-* v1.1.0, 2015-01-27
-    * Modified to output the argument when the standard input is hit.
-    * Add --stripe option in the command line interface.
-    * Change the delimiter of long option with a hyphen -> -symbol-list,--index-list; Can to specify also underscore as before.
-
-* v1.0.0, 2015-01-23
-    * Add command line interface.
-
-* v0.9.0, 2015-01-19
-    * Add a mode to receive as the words with ANSI escape sequence; without output to display.
-
-* v0.8.0, 2015-01-14
-    * Change for the specified arguments of reset method.
-    * Fix small bugs.
-
-* v0.7.0, 2015-01-08
-    * Add new method -> pickup
-    * Add new symbol that can to specify in reset method of first parameter -> CE.reset(:pickup)
-
-* v0.6.0, 2015-01-05
-    * Add command line tool.
-
-* v0.5.0, 2014-12-16
-    * Add a new method -> \#once, \#times
-
-* v0.4.0, 2014-12-11
-    * Add 256 colors.
-
-* v0.3.0, 2014-12-08
-    * Add high colors.
-    * Can to select multi value in ch_tx method.
-    * Add parameter to the #reset method.   
-
-* v0.2.4, 2014-12-04
-    * Can to specify a non-string when rainbow mode.
-    * Cab take over the setting of other types of sequence when rainbow mode.
-
-* v0.2.3, 2014-12-02
-    * Fix small bugs.
-
-* v0.2.0
-    * Added new method -> rainbow
-    * Added some method alias.
-
-* v0.1.0
-    * Added new method -> ch, unuse
-    * Added some method alias.
+### You can choose 256 colors!!
+![screen shot](/image/colorindex01.png)
+![screen shot](/image/colorindex02.png)

data/bin/colorecho

@@ -1,29 +1,30 @@
 #!/usr/bin/env ruby
+# coding: utf-8
 
+# Load file
 require_relative "./lib/display"
 
-#
+# const
+DEFAULT_FG_PICKUP = :cyan
+DEFAULT_FG_STRIPE = :cyan
+CONF_DEFAULT_NAME = "default"
+
 # Load color_echo
 # @return void
-#
 def require_color_echo
     require "color_echo"
     #require_relative "../lib/color_echo"
 end
 
-#
 # Load color_echo/get
 # @return void
-#
 def require_color_echo_get
     require "color_echo/get"
     #require_relative "../lib/color_echo/get"
 end
 
-#
 # output in interactive
 # @return void
-#
 def output_interactive
     output_stripe_interactive if @is_stripe
 
@@ -39,10 +40,8 @@ def output_interactive
     end
 end
 
-#
 # output like stripe in interactive
 # @return void
-#
 def output_stripe_interactive
     cnt = 0
     begin
@@ -58,23 +57,26 @@ def output_stripe_interactive
     end
 end
 
-#
 # output
 # @return void
-#
 def output(target)
     output_stripe(target) if @is_stripe
 
-    # performance down when it read line by line..?
-    targets = target.split($/)
+    #targets = target.split($/) #=> This way dosen't work as expected the issue of String#split
+    targets = target.split($/, target.size)
     total   = targets.count
     cnt     = 0
     targets.each do |record|
         cnt += 1
-        eval(@code_decorate)
+        begin
+            eval(@code_decorate)
+        rescue SyntaxError
+            msg = %(Invalid value: #{@code_decorate})
+            error_display(msg, "Syntax")
+        end
 
         begin
-            if !@last_lb && cnt == total
+            if cnt == total && !@last_lb
                 print CE.get(record)
             else
                 puts CE.get(record)
@@ -86,13 +88,13 @@ def output(target)
     exit 0
 end
 
-#
 # output like stripe
 # @return void
-#
 def output_stripe(target)
-    cnt = 0
-    target.split($/).each do |record|
+    #targets = target.split($/) #=> This way dosen't work as expected the issue of String#split
+    targets = target.split($/, target.size)
+    cnt     = 0
+    targets.each do |record|
         eval(@code_decorate) if cnt % 2 == 0
         puts CE.get(record)
         cnt += 1
@@ -100,105 +102,328 @@ def output_stripe(target)
     exit 0
 end
 
-#
+# Return Symbol object if val was not nil
+# @param string|nil input
+# @return symbol|nil
+def get_symbol(input)
+    return nil if input == nil
+    return input.intern
+end
+
+# Return String like Symbol following ":string"
+# @param string|nil input
+# @return string
+def get_symbol_string(input)
+    return "nil" if input == nil
+    return ":#{input}"
+end
+
+# Return Symbol object list if val was not nil
+# @param string|nil input
+# @return array|nil
+def get_symbol_list(input)
+    return nil if input == nil
+
+    list = []
+    input.split(",").each do |val|
+        list << val.intern
+    end
+    return list
+end
+
+# Return String like Symbol that likes ":string"
+# @param array|string|nil input
+# @return string
+def get_symbol_string_list(input)
+    return "nil" if input == nil
+
+    input = input.split(",") if !input.is_a?(Array) 
+
+    list = []
+    input.each do |val|
+        list << ":#{val}"
+    end
+    list = list.join(",")
+
+    return "[#{list}]"
+end
+
+# @param string|nil fg
+# @param string|nil bg
+# @param string|nil tx
+# @return [symbol|nil ,symbol|nil ,symbol|nil]
+def convert_symbol(fg, bg, tx)
+    return get_symbol(fg), get_symbol(bg), get_symbol_list(tx)
+end
+
+# @param string|nil fg
+# @param string|nil bg
+# @param array|string tx
+# @return [string, string, string]
+def convert_symbol_string(fg, bg, tx)
+    return get_symbol_string(fg), get_symbol_string(bg), get_symbol_string_list(tx)
+end
+
+# Parse and update decoration code with pickup & highlight
+# @return void
+def parse_pickups
+    code_addition = ""
+    @pickups.each_index do |index|
+        p_list  = @pickups[index].split(/(?<!\\),/)
+
+        # No input pattern
+        if p_list.size == 0
+            error_display(%(You have to specify pattern when using -p option!), "Argument")
+        end
+
+        pattern = p_list[0]
+        fg = nil
+        bg = nil
+        tx = nil
+        fg = p_list[1]               if defined?(p_list[1])
+        bg = p_list[2]               if defined?(p_list[2])
+        tx = p_list[3...p_list.size] if defined?(p_list[3])
+        fg = DEFAULT_FG_PICKUP if fg == nil && bg == nil && tx == nil
+        fg, bg, tx = convert_symbol_string(fg, bg, tx)
+
+        if pattern[0] == "/" && (pattern[-1] == "/" || pattern[-2] == "/")
+            pattern_str = pattern
+        else
+            pattern_str = %("#{pattern}")
+        end
+
+        code_addition += %(.pickup(#{pattern_str}, #{fg}, #{bg}, #{tx}))
+    end
+
+    # highlights
+    if @highlights.size > 0
+        @highlights.each do |highlight|
+            params = []
+            highlight.split(",").each do |el|
+                el.strip!
+                if el != "nil"
+                    params << ":#{el}"
+                else
+                    params << "nil"
+                end
+            end
+            code_addition += %(.highlight(#{params.join(",")}))
+        end
+    end
+
+    @code_decorate = %(CE.ch(@fg, @bg, @tx)) + code_addition
+end
+
+# Read options files
+# @param data string
+def read_conf(conf_path, list)
+    if list.size > 2
+        error_display(%(-c option is allowed to use only one time!), "Argument")
+    end
+
+    additions     = []
+    no_val_allows = ["-w", "--watch", "-n", "-e", "--stripe", "-r", "--refresh-match", "-R", "--refresh"]
+    no_val_allows.concat(["w", "watch", "n", "e", "stripe", "r", "refresh-match", "R", "refresh"])
+    list += list.pop.split(",")
+    list.each do |file_name|
+        full_path = conf_path + File::SEPARATOR + file_name
+
+        if FileTest.exist?(full_path) && !FileTest.directory?(full_path)
+            begin
+                f = File.open(full_path, File::RDONLY)
+                data = f.readlines
+                f.close
+            rescue => e
+                error_display("#{e.class}: #{e.message}", "File Open")
+            end
+
+            data.each do |option|
+                # This is comment
+                option.strip!
+                next if /^#/ =~ option
+                next if option == ""
+
+                op = option.split("=")
+                if op.size != 2 && no_val_allows.index(op[0]) == nil
+                    error_display(%(Wrong syntax '#{op.join("=")}' Check your options file: #{full_path}), "Configuration")
+                end
+
+                opname = ((/^-/ =~ op[0]) == nil) ? (op[0].size > 1 ? "--" : "-") + op[0] : op[0]
+                additions << opname
+                additions << op[1] if defined? op[1]
+            end
+        else
+            # Missing specified file
+            if (file_name != CONF_DEFAULT_NAME)
+                if FileTest.directory?(full_path)
+                    msg = %(This is directory: #{full_path})
+                else
+                    msg = %(Missing your specified options file: #{full_path})
+                end
+                error_display(msg, "Configuration")
+            end
+        end
+    end
+
+    # Parse options from options files
+    # Always prevail the options be specfied at command line
+    fg                = nil
+    bg                = nil
+    tx                = nil
+    pickups           = []
+    highlights        = []
+    is_watch          = false
+    last_lb           = true
+    enable_lf         = false
+    is_stripe         = false
+    refresh_pre_match = false
+    refresh           = false
+
+    begin
+        OptionParser.new do |opt|
+            opt.on("-f val", "--fg val",      ) { |val| fg = val }
+            opt.on("-b val", "--bg val",      ) { |val| bg = val }
+            opt.on("-t val", "--tx val",      ) { |val| tx = val }
+            opt.on("-p val", "--pickup format") { |val| pickups    << val }
+            opt.on("-H", "--highlight format" ) { |val| highlights << val }
+            opt.on("-w", "--watch",           ) { is_watch          = true  }
+            opt.on("-n",                      ) { last_lb           = false }
+            opt.on("-e",                      ) { enable_lf         = true  }
+            opt.on("--stripe",                ) { is_stripe         = true  }
+            opt.on("-r", "--refresh-match"    ) { refresh_pre_match = true  }
+            opt.on("-R", "--refresh"          ) { refresh           = true  }
+            opt.parse!(additions)
+        end
+        @fg ||= fg
+        @bg ||= bg
+        @tx ||= tx
+        @pickups    += pickups
+        @highlights += highlights
+        @is_watch          = true  if !@is_watch && is_watch
+        @last_lb           = false if @last_lb && !last_lb
+        @enable_lf         = true  if !@enable_lf && enable_lf
+        @is_stripe         = true  if !@is_stripe && is_stripe
+        @refresh_pre_match = true  if !@refresh_pre_match && refresh_pre_match
+        @refresh           = true  if !@refresh && refresh
+
+    rescue => err
+        msg1 = err.message
+        msg2 = %(You can't specify this option here, Please check your options files.)
+        error_display([msg1, msg2], "Configuration")
+    end
+end
+
+# Parse options
+# @return void
+def parse_conf
+    # find options
+    if ENV["COLORECHO"] != nil
+        conf_path = ENV["COLORECHO"]
+    elsif ENV["HOME"] == nil
+        conf_path = ""
+    else
+        conf_path  = ENV["HOME"]
+        conf_path += File::SEPARATOR if (/#{File::SEPARATOR}$/ =~ @conf_path) == nil
+        conf_path += ".colorecho"
+    end
+
+    if FileTest.directory?(conf_path)
+        # found options directory
+        @conf_list.unshift(CONF_DEFAULT_NAME)
+        options_conf = read_conf(conf_path, @conf_list)
+
+    elsif FileTest.exist?(conf_path)
+        # color_echo options path is not directory
+        if @conf_list.size > 0
+            msg1 = %('#{conf_path}' is not directory!)
+            msg2 = %(Couldn't find your options.)
+            error_display([msg1, msg2], "Configuration")
+        end
+    else
+        # no color_echo options directory
+        if @conf_list.size > 0
+            msg1 = %(Could't find a options directory of color_echo: #{conf_path})
+            msg2 = %(You can create options files in $HOME/.colorecho/ or specified directory by env variable $COLORECHO.)
+            error_display([msg1, msg2], "Configuration")
+        end
+    end
+end
+
 # parse the options
 # @return void
-#
 def parse_options
-    @fg                = "yellow"
+    @fg                = nil
     @bg                = nil
     @tx                = nil
-    @highlight         = nil
     @pickups           = []
+    @highlights        = []
     @is_watch          = false
     @last_lb           = true
     @enable_lf         = false
     @is_stripe         = false
     @refresh_pre_match = false
     @refresh           = false
+    @conf_list         = []
 
     begin
         @opt.parse!(ARGV)
 
     rescue => err
-        warn %(Parse Error! Please check usage!) + $/ + $/
-        puts @opt.help
-        warn $/ + %(Do you want to read example to use?)
-        warn %(  -> Please execute: 'colorecho -h')
+        msg  = %(Please take a look at usage.) + $/ * 2
+        msg += @opt.help
+        error_display(msg, "Parse")
     end
 
-    @fg = @fg.intern if @fg != nil
-    @bg = @bg.intern if @bg != nil
+    # parse options
+    parse_conf
 
-    if @tx != nil
-        res = []
-        @tx.split(",").each do |val|
-            res << val.intern
-        end
-        @tx = res
-    end
+    # cast String to Symbol
+    @fg, @bg, @tx = convert_symbol(@fg, @bg, @tx)
+
+    # set default stripe color if foreground was nil
+    @fg = DEFAULT_FG_STRIPE if @is_stripe && @fg == nil && @bg == nil && @tx == nil
 
     # ignore --pickup option when specified --stripe option
     if @pickups.size > 0 && @is_stripe
-        warn "pickup option is ignored because your specified --stripe option."
+        warn_display(%(--pickup option was ignored because you are specified --stripe option.), "Argument")
         @pickups = []
     end
 
+    # code for decoration
+    @code_decorate = %(CE.ch(@fg, @bg, @tx))
+
     # parse pickups
     if @pickups.size > 0
-        code_pickup = ""
-        @pickups.each_index do |index|
-            if @pickups[index][0] == "/" && (@pickups[index][-1] == "/" || @pickups[index][-2] == "/")
-                @pickups[index] = eval(@pickups[index])
-            end
-
-            code_pickup += %(.pickup(@pickups[#{index}], @fg, @bg, @tx))
-        end
-        @code_decorate = "CE" + code_pickup
-
-        # highlight
-        if @highlight != nil
-            params = []
-            @highlight.split(",").each do |el|
-                el.strip!
-                if el != "nil"
-                    params << ":#{el}"
-                else
-                    params << "nil"
-                end
-            end
-            code_highlight = %(CE.hitline(#{params.join(",")}))
-        end
-        @code_decorate = code_highlight + ";" + @code_decorate if code_highlight != nil
-    else
-        @code_decorate = %(CE.ch(@fg, @bg, @tx))
+        parse_pickups
     end
 end
 
 # -----------
 # top level
 # -----------
-require "optparse"
+begin
+    require "optparse"
+rescue LoadError
+    error_display(%('optparse' is required for color_echo.), "Load")
+end
 @opt = OptionParser.new
 
-@opt.on("-s",     "--symbol-list",   @explain_s)      { display_symbol_list }
-@opt.on("-l",     "--index-list",    @explain_l)      { display_color_index }
+@opt.on("-s", "--symbol-list",       @explain_s)      { display_symbol_list }
+@opt.on("-l", "--index-list",        @explain_l)      { display_color_index }
 @opt.on("-f val", "--fg val",        @explain_f)      { |val| @fg = val }
 @opt.on("-b val", "--bg val",        @explain_b)      { |val| @bg = val }
 @opt.on("-t val", "--tx val",        @explain_t)      { |val| @tx = val }
-@opt.on("-p val", "--pickup val",    @explain_p)      { |val| @pickups << val }
-@opt.on("-H",     "--highlight val", @explain_H)      { |val| @highlight = val}
-@opt.on("-w",     "--watch",         @explain_w)      { @is_watch          = true  }
+@opt.on("-p val", "--pickup format", @explain_p)      { |val| @pickups    << val }
+@opt.on("-H", "--highlight format",  @explain_H)      { |val| @highlights << val }
+@opt.on("-w", "--watch",             @explain_w)      { @is_watch          = true  }
 @opt.on("-n",                        @explain_n)      { @last_lb           = false }
 @opt.on("-e",                        @explain_e)      { @enable_lf         = true  }
 @opt.on("--stripe",                  @explain_stripe) { @is_stripe         = true  }
-@opt.on("-r", "--refresh-pre-match", @explain_r)      { @refresh_pre_match = true  }
+@opt.on("-r", "--refresh-match",     @explain_r)      { @refresh_pre_match = true  }
 @opt.on("-R", "--refresh",           @explain_R)      { @refresh           = true  }
+@opt.on("-c conf_name",              @explain_c)      { |val| @conf_list << val }
 @opt.on("-v",                        @explain_v)      { version }
-@opt.on("-h",     "--help",          @explain_h)      { usage }
-
-@opt.on("--symbol_list", @explain_s + " - [compatibility]" ) { display_symbol_list }
-@opt.on("--index_list", @explain_l  + " - [compatibility]") { display_color_index }
+@opt.on("-h", "--help",              @explain_h)      { usage }
 
 @opt.banner = <<EOS
 Usage:
@@ -209,15 +434,16 @@ EOS
 # has stdin?
 has_stdin = select([STDIN], [], [], 0) != nil || FileTest.pipe?(STDIN)
 
-# argv error
+# no argument
 if !has_stdin && ARGV.size == 0
     puts @opt.help
+    exit 0
 end
 
+# load color_echo liblary
 require_color_echo_get
 Version = CE::VERSION
 
-# parse options and set the decorate code that execute by eval
 parse_options
 
 # need refresh?
@@ -236,7 +462,7 @@ else
         begin
             target = STDIN.read
         rescue Interrupt
-            puts $/ + %(No STDIN, Try to use -w option if you need Interactive mode.)
+            error_display(%(No STDIN, Try to use -w option if you need Interactive mode.))
         end
 
         if ARGV.size > 0
@@ -247,7 +473,6 @@ else
         end
     else
         target  = ARGV.join(" ")
-        target += $/ if @last_lb
     end
 
     if @enable_lf