tcl-ruby 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 05002f0d80add9496fd333278753cb393c1cb467
-  data.tar.gz: cc478beb9d6bb5c8562d089931570efe36fb4c70
+  metadata.gz: 07b644f73103f389ffc7575edd8a550b330f6774
+  data.tar.gz: 55726309ea62a15b0d77e67c5f6462b44b561303
 SHA512:
-  metadata.gz: ec9711ba1d51886f8ae015af255b5f40bb792278d23f8c1d8714b8ed6cc5ce6a90e9632f40390777e3c3c62e346ea33eb59d3bc68e51d0ccb088ef53f0f0be30
-  data.tar.gz: a932d6e3cbceba76a77fc4250130ab62f6d834a7167bdf63e6981e545d703488a92c0d9e6462c2d43b8952de780cfcbea17af56500e2789648e1b2fedcc81be8
+  metadata.gz: 89b1f5f58c6058715c363f13b10825c4e03592e67ea176abdcc5b4f51f7f6d46a5aa5984fe0b55684d80683eea2e9ded573b479a906b8b4d971fccabe839f3a0
+  data.tar.gz: ebc2b1bf14efde9a4f53b76ca863847b08bd1fefecd2d1ef22c804f65a85be6a1150b20caba4371357c3371b1e4e14daa47d582edca01623d80d8bdf8bdb29d0

data/.rubocop.yml

@@ -1,3 +1,11 @@
 Lint/Debugger:
   Exclude:
     - bin/console
+
+# Missing top level class documentation comment.
+Style/Documentation:
+  Enabled: false
+
+# Avoid the use of double negation (!!)
+Style/DoubleNegation:
+  Enabled: false

data/.travis.yml

@@ -1,4 +1,5 @@
 language: ruby
 rvm:
   - 2.2.0
+  - 2.1.0
 before_install: gem install bundler -v 1.11.2

data/README.md

@@ -1,4 +1,4 @@
-[![Code Climate](https://codeclimate.com/github/kiyonori-matsumoto/tcl-ruby/badges/gpa.svg)](https://codeclimate.com/github/kiyonori-matsumoto/tcl-ruby) [![Build Status](https://travis-ci.org/kiyonori-matsumoto/tcl-ruby.svg?branch=master)](https://travis-ci.org/kiyonori-matsumoto/tcl-ruby)
+[![Code Climate](https://codeclimate.com/github/kiyonori-matsumoto/tcl-ruby/badges/gpa.svg)](https://codeclimate.com/github/kiyonori-matsumoto/tcl-ruby) [![Build Status](https://travis-ci.org/kiyonori-matsumoto/tcl-ruby.svg?branch=master)](https://travis-ci.org/kiyonori-matsumoto/tcl-ruby) [![Gem Version](https://badge.fury.io/rb/tcl-ruby.svg)](https://badge.fury.io/rb/tcl-ruby)
 
 # Tcl::Ruby
 
@@ -23,19 +23,22 @@ Or install it yourself as:
 ## Usage
 
 Instanciate Interpreter
+
 ```ruby
-f = Interpreter.new
+f = Tcl::Ruby::Interpreter.new
 ```
 Parse commands you want to
+
 ```ruby
 f.parse('llength {A B C D}')
-=> 4
+# => 4
 ```
 You can get variables with Interpreter#variables
+
 ```ruby
 f.parse('set A 123')
 f.variables('A')
-=> '123'
+# => '123'
 ```
 
 ## Development

data/lib/tcl/ruby.rb

@@ -1,8 +1,12 @@
 require 'tcl/ruby/command.rb'
 require 'tcl/ruby/error.rb'
 require 'tcl/ruby/list_array.rb'
+require 'tcl/ruby/option_parser.rb'
 require 'tcl/ruby/parser.rb'
+require 'tcl/ruby/string.rb'
 require 'tcl/ruby/util.rb'
+require 'tcl/ruby/commands/array.rb'
 require 'tcl/ruby/commands/basic.rb'
+require 'tcl/ruby/commands/inout.rb'
 require 'tcl/ruby/commands/list.rb'
-require 'tcl/ruby/commands/array.rb'
+require 'tcl/ruby/commands/string.rb'

data/lib/tcl/ruby/command.rb

@@ -1,52 +1,96 @@
+require 'strscan'
+
 module Tcl
   module Ruby
     class Interpreter
-      def command(arg)
-        return @prev if arg[0][0] == '#'
-        # return previous command result when comment statement executed
-        arg.map! { |e| replace(e) }
-        arg.to_string
-        name = arg[0]
-        if @proc.key?(name)
-          exec_proc(arg[1..-1], @proc[name])
-        elsif @hooks.key?(name)
-          @hooks[name].call(arg[1..-1])
-        elsif respond_to?("___#{name}", true)
-          @prev = send("___#{name}", arg[1..-1])
-        else
-          raise(CommandError, "command not found, #{name}")
+      private
+
+      def command(cmds)
+        ret = nil
+        cmds.each do |arg|
+          next if arg.empty?
+          arg.replace(&method(:replace))
+          name = "___#{arg[0]}"
+          if @proc.key?(arg[0]) then ret = exec_proc(arg[1..-1], @proc[arg[0]])
+          elsif @hooks.key?(arg[0]) then ret = @hooks[arg[0]].call(arg[1..-1])
+          elsif respond_to?(name, true)
+          begin
+            ret = send(name, *arg[1..-1])
+          rescue ArgumentError => e
+            raise(TclArgumentError, "#{arg[0]}: #{e.message}")
+          end
+          else
+            raise(CommandError, "command not found, #{arg[0]}")
+          end
         end
+        ret
       end
 
       def replace(list)
-        return list if list[0] == '{'
+        # replace commands
+        list = replace_commands(list)
+
         # replace variable
-        l = list.gsub(/\$\{(.+?)\}|\$([\w()]+)/) do
-          v = Regexp.last_match(Regexp.last_match(1) ? 1 : 2)
-          h = vv = nil
-          if (m = v.match(/\((\w+)\)\z/))
-            h = m[1]
-            vv = v
-            v = vv.sub(/\((\w+)\)\z/, '')
+        replace_variable(list)
+      end
+
+      def replace_commands(list)
+        l = list.dup
+        s = StringScanner.new(l)
+        buffer = nil
+        depth = 0
+        until s.empty?
+          if s.scan(/\\./m)
+            buffer << s[0] if buffer
+          elsif s.scan(/\[/)
+            if depth == 0
+              pos = s.pos - 1
+              buffer = ''
+            end
+            depth += 1
+            buffer << s[0]
+          elsif s.scan(/\]/)
+            depth -= 1
+            buffer << s[0]
+            if depth == 0
+              l[pos, buffer.length] = parse(buffer[1..-2]).to_s
+              s.string = l
+              buffer = nil
+            end
+          elsif s.scan(/[^\[\]\\]+/m)
+            buffer << s[0] if buffer
           end
-          raise(TclVariableNotFoundError, v.to_s, 'no such variable') unless
+        end
+        raise(ParseError, 'unmatched brackets') if depth != 0
+        l
+      end
+
+      def replace_variable(elem)
+        elem.gsub!(/\$\{(.+?)\}|\$(\w+\([^\s)]+\))|\$(\w+)/) do |_|
+          v = Regexp.last_match(1) || Regexp.last_match(2) ||
+              Regexp.last_match(3)
+          h = nil
+          vv = v.dup
+          v.sub!(/\(([^\s)]+)\)\z/) { |_m| h = Regexp.last_match(1); '' }
+          raise TclVariableNotFoundError.new(v, 'no such variable') unless
             @variables.key?(v)
-          if h
-            raise(TclVariableNotFoundError, vv.to_s, "variable isn't array") unless @variables[v].is_a?(Hash)
-            @variables[v][h].to_s
+          if h # variable specified is hash
+            raise TclVariableNotFoundError.new(vv, "variable isn't array") unless @variables[v].is_a?(Hash)
+            h = replace_variable(h) # analyze var_string on parenthesis
+            @variables[v][h]
           else
-            raise(TclVariableNotFoundError, v.to_s, 'variable is array') if @variables[v].is_a?(Hash)
+            raise TclVariableNotFoundError.new(v, 'variable is array') if
+              @variables[v].is_a?(Hash)
             @variables[v]
           end
         end
-        # replace commands
-        l = l.gsub(/\[(.+)\]/) { parse(Regexp.last_match(1)) }
+        elem
       end
 
       def exec_proc(arg, proc_info)
         proc_arg = parse(proc_info[0], true)
         raise(TclArgumentError, proc_arg.to_s) if proc_arg.size != arg.size
-        @variables[:___global].each do |v| # FIXME: Buggy
+        @variables[:___global].each do |v| # backup globals
           @global[v] = @variables[v]
         end if @variables.key?(:___global)
         @v_stack.push(@variables)
@@ -57,10 +101,13 @@ module Tcl
         ret = catch(:return) do
           parse(proc_info[1])
         end
-        @variables[:___global].each do |v| # FIXME: Buggy
+        @variables[:___global].each do |v| # write back
           @global[v] = @variables[v]
         end if @variables.key?(:___global)
         @variables = @v_stack.pop
+        @variables[:___global].each do |v| # re-copy global
+          @variables[v] = @global[v]
+        end if @variables.key?(:___global)
         ret
       end
     end

data/lib/tcl/ruby/commands/array.rb

@@ -3,28 +3,23 @@ module Tcl
     class Interpreter
       private
 
-      def ___array(arg)
-        send("___array_#{arg[0]}", arg[1..-1])
+      def ___array(*arg)
+        send("___array_#{arg[0]}", *arg[1..-1])
+      rescue ArgumentError => e
+        raise(TclArgumentError, "array #{arg[0]}: #{e.message}")
       end
 
-      def ___array_set(arg)
-        name = arg[0]
+      def ___array_set(name, list)
         raise(CommandError, "#{name} is not array") unless
           @variables[name].is_a?(Hash) || !@variables.key?(name)
-        l = parse(arg[1], true)
-        raise(TclArgumentError, 'list must have an even number of elements') unless
-          l.size.even?
+        l = parse(list, true).to_h
         @variables[name] ||= {}
-        @variables[name].merge!(Hash[*l])
+        @variables[name].merge!(l)
       end
 
-      def ___array_unset(arg)
-        raise(TclArgumentError, 'array unset arrayName ?pattern?') unless
-          (1..2).cover?(arg.size)
-        name = arg[0]
+      def ___array_unset(name, pattern = nil)
         return '' unless @variables[name].is_a?(Hash)
-        if arg.size == 2
-          pattern = arg[1]
+        if pattern
           @variables[name].delete(pattern)
         else
           @variables.delete(name)
@@ -32,13 +27,9 @@ module Tcl
         ''
       end
 
-      def ___array_get(arg)
-        raise(TclArgumentError, 'array get arrayName ?pattern?') unless
-          (1..2).cover?(arg.size)
-        name = arg[0]
+      def ___array_get(name, pattern = nil)
         return '' unless @variables[name].is_a?(Hash)
-        if arg.size == 2
-          pattern = arg[1]
+        if pattern
           return '' unless @variables[name].key?(pattern)
           "#{pattern} #{@variables[name][pattern]}"
         else
@@ -46,9 +37,7 @@ module Tcl
         end
       end
 
-      def ___array_exists(arg)
-        raise(TclArgumentError, 'array exists arrayName') unless arg.size == 1
-        name = arg[0]
+      def ___array_exists(name)
         @variables[name].is_a?(Hash) ? '1' : '0'
       end
     end

data/lib/tcl/ruby/commands/basic.rb

@@ -3,18 +3,27 @@ module Tcl
     class Interpreter
       private
 
-      def ___set(arg)
-        raise(TclArgumentError, 'set variable ?newValue?') unless
-          (1..2).cover? arg.size
-        @variables[arg[0]] = arg[1] if arg.size == 2
-        @variables[arg[0]]
+      def ___set(var_name, value = nil)
+        if (m = var_name.match(/(\w+)\((\S+?)\)/))
+          ___array_set(m[1], "{#{m[2]}} {#{value}}") if value
+          ___array_get(m[1], "{#{m[2]}}")
+        else
+          @variables[var_name] = value if value
+          @variables[var_name]
+        end
       end
 
-      def ___expr(arg)
+      def ___expr(*arg)
         eval arg.join('')
       end
 
-      def ___if(arg)
+      def ___eval(*arg)
+        raise(TclArgumentError, 'wrong number of arguments(0 for 1..)') if
+        arg.empty?
+        parse(___concat(*arg))
+      end
+
+      def ___if(*arg)
         arg.delete('then')
         arg.delete('else')
         arg.delete('elseif')
@@ -27,20 +36,19 @@ module Tcl
         nil
       end
 
-      def ___for(arg)
-        raise(CommandError, 'for start test next body') unless arg.size == 4
-        parse(arg[0])
+      def ___for(start, tst, nxt, body)
+        parse(start)
         catch(:break) do
-          while eval(replace(arg[1]))
+          while eval(replace(tst))
             catch(:continue) do
-              parse(arg[3])
+              parse(body)
             end
-            parse(arg[2])
+            parse(nxt)
           end
         end
       end
 
-      def ___foreach(arg)
+      def ___foreach(*arg)
         varlist = []
         list = []
         while arg[2]
@@ -48,26 +56,22 @@ module Tcl
           list << parse(arg[1], true)
           arg.shift(2)
         end
-        body = arg[0]
         catch(:break) do
           while list.any?(&:any?)
             # assign variables
             varlist.each_with_index do |v, idx|
-              v.each do |vv|
-                @variables[vv] = list[idx].shift || ''
-              end
+              v.each { |vv| @variables[vv] = list[idx].shift || '' }
             end
             catch(:continue) do
-              parse(body)
+              parse(arg[0])
             end
           end
         end
       end
 
-      def ___while(arg)
-        body = arg[1]
+      def ___while(tst, body)
         catch(:break) do
-          while eval(replace(arg[0]))
+          while eval(replace(tst))
             catch(:continue) do
               parse(body)
             end
@@ -75,41 +79,38 @@ module Tcl
         end
       end
 
-      def ___break(_arg)
+      def ___break
         throw :break
       end
 
-      def ___continue(_arg)
+      def ___continue
         throw :continue
       end
 
-      def ___return(arg)
-        throw(:return, arg[0])
+      def ___return(val = nil)
+        throw(:return, val)
       end
 
-      def ___incr(arg)
-        raise(TclArgumentError, 'incr varName ?increment?') unless (1..2).cover?(arg.size)
-        incr = (arg[1]) ? arg[1].to_i : 1
-        @variables[arg[0]] = ((@variables[arg[0]] || 0).to_i + incr).to_s
+      def ___incr(var_name, increment = 1)
+        @variables[var_name] = ((@variables[var_name] || 0).to_i +
+          increment.to_i).to_s
       end
 
-      def ___puts(arg)
-        puts arg[0]
+      def ___format(str, *args)
+        str % args
       end
 
-      def ___proc(arg)
-        raise(TclArgumentError, 'proc name args body') unless arg.size == 3
-        @proc[arg[0]] = arg[1..2]
+      def ___proc(name, args, body)
+        @proc[name] = [args, body]
       end
 
-      def ___global(arg)
+      def ___global(*arg)
         @variables[:___global] ||= []
         arg.each do |v|
           @variables[:___global] << v
           @variables[v] = @global[v] if @global
         end
       end
-      # define_method('___#') { |_p| nil }
     end
   end
 end

data/lib/tcl/ruby/commands/inout.rb

@@ -0,0 +1,54 @@
+module Tcl
+  module Ruby
+    class Interpreter
+      private
+
+      def ___open(filename, access = 'r', permission = 0744)
+        begin
+          fp = open(filename, access, permission)
+        rescue
+          raise(CommandError, "File #{filename} cannot open")
+        end
+        k = "file#{fp.object_id.to_s(36)}"
+        @files[k] = fp
+        k
+      end
+
+      def ___close(id)
+        fp = get_fp(id, delete: true)
+        fp.close
+      end
+
+      def ___gets(id, var_name = nil)
+        fp = get_fp(id)
+        str = fp.gets
+        if var_name
+          @variables[var_name] = str
+          str.length
+        else
+          str
+        end
+      end
+
+      def ___puts(*arg)
+        opts = {}
+        opts = OptionParser.parse(['nonewline'], arg) if arg.size != 1
+        __puts_body(*arg, opts)
+      end
+
+      def __puts_body(id = nil, val, nonewline: false)
+        fp = id ? get_fp(id) : $stdout
+        if nonewline
+          fp.print val
+        else
+          fp.puts val
+        end
+      end
+
+      def ___eof(id)
+        fp = get_fp(id)
+        fp.eof? ? '1' : '0'
+      end
+    end
+  end
+end

data/lib/tcl/ruby/commands/list.rb

@@ -3,69 +3,113 @@ module Tcl
     class Interpreter
       private
 
-      def ___llength(arg)
-        raise(CommandError, 'llength list') if arg.size != 1
-        parse(arg[0], true).size
+      def ___concat(*arg)
+        arg.map(&:strip).join(' ')
       end
 
-      def ___list(arg)
-        arg.join(' ').to_s
+      def ___llength(list)
+        parse(list, true).size.to_s
       end
 
-      def ___lindex(arg)
-        if arg[1].nil?
-          arg[0]
-        elsif arg[1] == ''
-          arg[0]
-        else
-          l = arg[0]
-          arg[1..-1].each do |as|
-            parse(as, true).each do |a|
-              l = parse(l, true)
-              a.gsub!(/end/, (l.size - 1).to_s)
-              pos = eval(a)
-              if (0...l.size).cover?(pos)
-                l = l[pos]
-              else
-                return ''
-              end
-            end
+      def ___list(*arg)
+        ListArray.new(arg).to_list
+      end
+
+      def ___lindex(list, *indexes)
+        return list if indexes.nil? || indexes.empty?
+        l = list
+        indexes.each do |as|
+          parse(as, true).each do |a|
+            l = parse(l, true)
+            pos = parse_index_format(a)
+            l = l[pos]
           end
-          l
         end
+        l || ''
       end
 
-      def ___join(arg)
-        raise(CommandError, 'join list joinString?') unless (1..2).cover? arg.size
-        separator = arg[1] || ' '
-        parse(arg[0], true).join(separator)
+      def ___join(list, separator = ' ')
+        parse(list, true).join(separator)
       end
 
-      def ___linsert(arg)
-        raise(CommandError, 'linsert list insertposition elements') unless arg.size >= 3
-        l = parse(arg[0], true)
-        l.insert(arg[1].to_i, *arg[2..-1])
-        # "{#{l.join(' ')}}"
+      def ___linsert(list, index, element, *elements)
+        l = parse(list, true)
+        l.insert(parse_index_format(index), element, *elements)
         l.to_list
       end
 
-      def ___lrange(arg)
-        raise(CommandError, 'lrange list first last') unless arg.size == 3
-        first = arg[1].to_i
-        first = 0 if first < 0
-        last = arg[2].to_i
-        l = parse(arg[0], true)
-        if first <= last
-          l[first..last].to_list
+      def ___lrange(list, first, last)
+        first = parse_index_format first
+        last = parse_index_format last
+        l = parse(list, true)
+        l[first..last].to_list
+      end
+
+      def ___lappend(var_name, *values)
+        l = parse(variables(var_name), true)
+        l.push(*values)
+        @variables[var_name] = l.to_list
+      end
+
+      def ___lsort(*args)
+        opts = {}
+        if args.size > 1
+          opts = OptionParser.parse(
+            ['ascii', 'dictionary', 'integer', 'real', 'command?', 'increasing',
+             'decreasing', 'index?', 'unique'], args)
+        end
+        __lsort_body(*args, opts)
+      end
+
+      def __lsort_body(list, opts)
+        l = parse(list, true)
+        func = if opts['directionary'] then :upcase
+               elsif opts['integer'] then :to_i
+               elsif opts['real'] then :to_f
+               else :to_s
+               end
+        if opts['index']
+          index = parse_index_format(opts['index'])
+          sort_func = -> (x) { parse(x, true)[index].send(func) }
         else
-          ''
+          sort_func = func
         end
+        l.uniq!(&sort_func) if opts['unique']
+        l.sort_by!(&sort_func)
+        l.reverse! if opts['decreasing']
+        ListArray.new(l).to_list
       end
 
-      def ___lappend(arg)
-        l = parse(variables(arg[0]), true)
-        l.push(*arg[1..-1])
-        @variables[arg[0]] = l.to_list
+      def ___lsearch(*args)
+        opts = {}
+        if args.size > 2
+          opts = OptionParser.parse(
+            ['all', 'ascii', 'decreasing', 'dictionary', 'exact', 'glob',
+             'increasing', 'inline', 'integer', 'not', 'real', 'regexp',
+             'sorted', 'start?'], args)
+        end
+        __lsearch_body(*args, opts)
+      end
+
+      def __lsearch_body(list, pattern, opts)
+        l = parse(list, true)
+        func = case [opts['all'], opts['inline']]
+               when [true, true] then :select
+               when [true, nil] then :find_index_all
+               when [nil, true] then :find
+               else :index
+               end
+        block = if opts['regexp'] then -> (b, x) { !!(x =~ /#{pattern}/) == b }
+                elsif opts['exact'] then -> (b, x) { (x == pattern) == b }
+                else
+                  pattern.gsub!(/\*/, '.*')
+                  pattern.tr!('?', '.')
+                  pattern.gsub!(/\\(.)/) { Regexp.last_match(1) }
+                  -> (b, x) { !!(x =~ /\A#{pattern}\z/) == b }
+                end.curry
+
+        v = l.send(func, &block.call(!opts['not']))
+        ListArray.new(v).to_list
       end
     end
   end

data/lib/tcl/ruby/commands/string.rb

@@ -0,0 +1,118 @@
+require 'strscan'
+
+module Tcl
+  module Ruby
+    class Interpreter
+      private
+
+      def ___string(*arg)
+        send("___string_#{arg[0]}", *arg[1..-1])
+      rescue ArgumentError => e
+        raise(TclArgumentError, "string #{arg[0]}: #{e.message}")
+      end
+
+      def ___string_length(str)
+        str.length
+      end
+
+      def ___string_equal(*arg)
+        opts = {}
+        if arg.size != 2
+          opts = OptionParser.parse(['nocase', 'length?'], arg)
+          raise(TclArgumentError, 'string equal ?-nocase? ?-length int? string1 string2') unless arg.size == 2
+        end
+        __string_equal_body(*arg, opts)
+      end
+
+      def __string_equal_body(str1, str2, opts = {})
+        if opts.key?('nocase')
+          str1 = str1.upcase
+          str2 = str2.upcase
+        end
+        if opts.key?('length')
+          range = (0...opts['length'].to_i)
+          (str1[range] == str2[range]) ? '1' : '0'
+        else
+          (str1 == str2) ? '1' : '0'
+        end
+      end
+
+      def ___string_index(str, index)
+        str[parse_index_format(index)]
+      end
+
+      def ___string_map(*arg)
+        opts = {}
+        if arg.size != 2
+          opts = OptionParser.parse(['nocase'], arg)
+          raise(TclArgumentError, 'string map ?-nocase? charMap string') unless arg.size == 2
+        end
+        __string_map_body(*arg, opts)
+      end
+
+      def __string_map_body(char_map, str, opts = {})
+        h = parse(char_map, true).to_h
+        scan = StringScanner.new str
+        rstr = ''
+        until scan.empty?
+          r = h.each do |k, v|
+            next unless (opts['nocase'] && scan.scan(/#{k}/i)) ||
+                        scan.scan(/#{k}/)
+            rstr << v
+            break false
+          end
+          rstr << scan.scan(/./) if r
+        end
+        rstr
+      end
+
+      def ___string_range(str, first, last)
+        first = parse_index_format first
+        last = parse_index_format last
+        str[first..last]
+      end
+
+      def ___string_repeat(str, count)
+        str * count.to_i
+      end
+
+      def ___string_tolower(str, first = 0, last = nil)
+        last ||= str.size
+        __string_tosomething(str, first, last, :downcase)
+      end
+
+      def __string_tosomething(str, first, last, modifier)
+        first = parse_index_format first
+        last  = parse_index_format last
+        str[first..last] = str[first..last].send(modifier)
+        str
+      end
+
+      def ___string_totitle(str, first = 0, last = -1)
+        __string_tosomething(str, first, last, :capitalize)
+      end
+
+      def ___string_toupper(str, first = 0, last = -1)
+        __string_tosomething(str, first, last, :upcase)
+      end
+
+      def ___string_trim(str, chars = '\s')
+        __string_trimmer(str, chars, 3)
+      end
+
+      def ___string_trimleft(str, chars = '\s')
+        __string_trimmer(str, chars, 1)
+      end
+
+      def ___string_trimright(str, chars = '\s')
+        __string_trimmer(str, chars, 2)
+      end
+
+      def __string_trimmer(str, chars, mode)
+        str.sub!(/\A[#{chars}]+/, '') if mode & 1 != 0
+        str.sub!(/[#{chars}]+\z/, '') if mode & 2 != 0
+        str
+      end
+    end
+  end
+end

data/lib/tcl/ruby/error.rb

@@ -4,9 +4,9 @@ module Tcl
     class ParseError < TclError; end
     class CommandError < TclError; end
     class TclArgumentError < TclError
-      def initialize(msg)
-        super("wrong \# args: should be\"#{msg}\"")
-      end
+      # def initialize(msg)
+      #   super("wrong \# args: should be\"#{msg}\"")
+      # end
     end
     class TclVariableNotFoundError < TclError
       def initialize(var, type = '')

data/lib/tcl/ruby/list_array.rb

@@ -1,33 +1,77 @@
+require 'forwardable'
+
 module Tcl
   module Ruby
     class ListArray
+      extend Forwardable
+
+      def_delegators :@ary, :find, :any?
+
       Array.public_instance_methods(false).each do |name|
-        next if name == '<<'
         define_method(name) do |*args, &block|
           @ary.send(name, *args, &block)
         end
       end
 
-      def initialize
+      def uniq!(&block)
+        @ary = @ary.reverse.uniq(&block).reverse
+        self
+      end
+
+      def uniq(&block)
+        dup.uniq!(&block)
+      end
+
+      def find_index_all
+        raise ArgumentError unless block_given?
+        r = []
+        @ary.each_with_index do |e, idx|
+          r << idx.to_s if yield(e)
+        end
+        r
+      end
+
+      def initialize(ary = [])
+        @ary = Array(ary).map(&:to_s)
+        @brackets = []
+      end
+
+      def clear
         @ary = []
+        @brackets = []
+      end
+
+      def bracket_add(val)
+        @brackets[@ary.size] ||= []
+        @brackets[@ary.size] << val
       end
 
       def <<(buffer)
         @ary << buffer.dup unless buffer.empty?
         buffer.clear
+        buffer.init
         self
       end
 
       def to_string
-        @ary.map! { |e| _to_string(e) }
+        @ary.map!(&:to_tcl_string)
         self
       end
 
       def to_list
-        @ary.map { |e| _to_list(e) }.join(' ')
+        @ary.map(&:to_tcl_list).join(' ')
+      end
+
+      def replace
+        @ary.size.times do |n|
+          @ary[n] = yield(@ary[n]) unless @ary[n].brace?
+        end
+        # @ary.map! { |m| m.brace? ? m : yield(m) }
+        self
       end
 
       def map!(&block)
+        @ary.each(&:init)
         @ary.map!(&block)
         self
       end
@@ -48,28 +92,15 @@ module Tcl
         end
       end
 
+      def to_h
+        raise(TclArgumentError, 'list must have an even number of elements') if
+          @ary.size.odd?
+        Hash[@ary.each_slice(2).to_a]
+      end
+
       protected
 
       attr_accessor :ary
-
-      private
-
-      def _to_string(str)
-        if str[0] == '{' && str[-1] == '}'
-          str = str[1..-2]
-        elsif str[0] == '"' && str[-1] == '"'
-          str = str[1..-2]
-        end
-        str
-      end
-
-      def _to_list(str)
-        if str == '' || str.match(/\s/)
-          "{#{str}}"
-        else
-          str
-        end
-      end
     end
   end
 end

data/lib/tcl/ruby/option_parser.rb

@@ -0,0 +1,28 @@
+module Tcl
+  module Ruby
+    class OptionParser
+      # options_format
+      # array of string
+      # xxxx or xxxx?
+      # ? indicates that value has one argument
+      def self.parse(options, args)
+        ops = options.map do |e|
+          v = e.sub(/\?/, '')
+          ["-#{v}", v, e[-1] == '?']
+        end
+        ret = {}
+        loop do
+          r = ops.each do |o|
+            next unless args[0] == o[0]
+            args.shift
+            ret[o[1]] = true
+            ret[o[1]] = args.shift if o[2]
+            break false
+          end
+          break if r
+        end
+        ret
+      end
+    end
+  end
+end

data/lib/tcl/ruby/parser.rb

@@ -3,68 +3,100 @@ require 'strscan'
 module Tcl
   module Ruby
     class Interpreter
+      EX_CHAR_CHECK = lambda do |s, t|
+        (t && !s.check(/\s|\z/)) || (!t && !s.check(/\s|\z|;/))
+      end.curry
+
       def parse(str, to_list = false)
-        s = StringScanner.new(str)
-        r = ListArray.new
-        pdepth = ddepth = bdepth = 0
-        buffer = ''
-        ret = nil
-        until s.empty?
-          if s.scan(/\\./m)
-            buffer << s[0] unless s[0][1] =~ /\s/
-          elsif !to_list && s.scan(/\r\n|\r|\n|;/)
-            if pdepth == 0 && ddepth == 0 && bdepth == 0
-              r << buffer
-              ret = command(r) unless r.empty?
-              r = ListArray.new
-            else
-              buffer << s[0]
-            end
-          elsif s.scan(/\s+/)
-            if pdepth == 0 && ddepth == 0 && bdepth == 0
-              r << buffer
-            else
-              buffer << s[0]
-            end
-          else
-            buffer <<
-              if s.scan(/{/)
-                # pdepth += 1 if ddepth == 0
-                pdepth += 1 if buffer == '' || pdepth != 0
-                s[0]
-              elsif s.scan(/}/)
-                ret = s[0] # pdepth -= 1 if ddepth == 0
-                pdepth -= 1 if pdepth != 0
-                raise(ParseError, 'extra characters after close-brace') if
-                  buffer[0] == '{' && pdepth == 0 && !s.check(/\s|\z/)
-                ret
-              elsif !to_list && s.scan(/\[/)
-                bdepth += 1 if pdepth == 0
-                s[0]
-              elsif !to_list && s.scan(/\]/)
-                bdepth -= 1 if pdepth == 0
-                s[0]
-              elsif s.scan(/"/)
-                ret = s[0]
-                ddepth = 1 - ddepth if buffer == '' || buffer[0] == '"'
-                raise(ParseError, 'extra characters after close-quote') if
-                  buffer[0] == '"' && ddepth == 0 && !s.check(/\s|\z/)
-                ret
-              elsif s.scan(/\S/)
-                s[0]
-              else
-                raise(ParseError, "parse error #{s.rest}")
-              end
+        str2 = (str + "\n").gsub(/\\\n\s*/, ' ') # replace \ & \n & extra ws
+        @s = StringScanner.new(str2)
+        @list_array = ListArray.new
+        @pstack = [] # stack for brace, bracket, quote
+        @buffer = '' # ListElement.new('')'' # buffer for list element
+        @commands = []
+        until @s.empty?
+          if @s.scan(/\\./) then @buffer << @s[0]
+          elsif @s.scan(/\#/) then parse_comments
+          elsif !to_list && @s.scan(/\r\n|\r|\n|;/) then parse_command_ends
+          elsif @s.scan(/\s/) then parse_blanks
+          elsif @s.scan(/\S/)
+            @buffer << @s[0]
+            analyze_parentheses(to_list, EX_CHAR_CHECK[@s]) if
+              @buffer.parenthesis?
           end
         end
-        r << buffer
-        raise(ParseError, 'unmatched parenthesises') if
-        ddepth != 0 || pdepth != 0 || bdepth != 0
-        if to_list
-          r.to_string
+        check_pstack
+        to_list ? @list_array.to_string : command(@commands)
+      end
+
+      private
+
+      def check_pstack
+        raise(ParseError, "unmatched #{@pstack.last}s") if @pstack.any?
+      end
+
+      def parse_command_ends
+        bl = @s[0]
+        if @pstack.empty?
+          @list_array << @buffer
+          @list_array.to_string
+          @commands << @list_array.dup
+          @list_array.clear
         else
-          ret = command(r) unless r.empty?
-          ret
+          @buffer << bl
+        end
+      end
+
+      def parse_blanks
+        @pstack.empty? ? @list_array << @buffer : @buffer << @s[0]
+      end
+
+      def parse_comments
+        if @buffer.empty? && @list_array.empty?
+          @s.scan(/.+$/)
+        else
+          @buffer << @s[0]
+        end
+      end
+
+      def matched_parentheses(id, has_ex_char)
+        if @pstack.last == id
+          r = @pstack.pop
+          if @pstack.empty? && has_ex_char
+            raise(ParseError, "extra characters after close-#{id}")
+          end
+          r
+        end
+      end
+
+      def analyze_braces(to_list, extra_characters_check)
+        if @buffer[-1] == '{'
+          @pstack.push(:brace) if @pstack.last != :quote
+        else
+          matched_parentheses(:brace, extra_characters_check[to_list])
+        end
+      end
+
+      def analyze_quotes(to_list, extra_characters_check)
+        unless matched_parentheses(:quote, extra_characters_check[to_list])
+          @pstack.push :quote if @pstack.last != :brace
+        end
+      end
+
+      def analyze_brackets
+        if @buffer[-1] == '[' && @pstack.last != :brace
+          @pstack.push :bracket
+        elsif @pstack.last == :bracket
+          @pstack.pop
+        end
+      end
+
+      def analyze_parentheses(to_list, extra_characters_check)
+        bl = @buffer[-1]
+        case bl
+        when '{', '}' then analyze_braces(to_list, extra_characters_check)
+        when '[', ']' then analyze_brackets unless to_list
+        when '"' then analyze_quotes(to_list, extra_characters_check)
         end
       end
     end

data/lib/tcl/ruby/string.rb

@@ -0,0 +1,39 @@
+class String
+  def brace?
+    @brace ||= self[0] == '{'
+  end
+
+  def bracket?
+    @bracket ||= self[0] == '['
+  end
+
+  def quote?
+    @quote ||= self[0] == '"'
+  end
+
+  def parenthesis?
+    brace? || bracket? || quote?
+  end
+
+  def to_tcl_string
+    if parenthesis?
+      if (brace? && self[-1] == '}') || (quote? && self[-1] == '"')
+        b = self[1..-2]
+        clear << b
+      end
+    end
+    self
+  end
+
+  def to_tcl_list
+    if self == '' || match(/\s/)
+      "{#{self}}"
+    else
+      self
+    end
+  end
+
+  def init
+    @brace = @bracket = @quote = nil
+  end
+end

data/lib/tcl/ruby/util.rb

@@ -7,10 +7,12 @@ module Tcl
         @v_stack = []
         @hooks = {}
         @proc = {}
+        @files = {}
       end
 
       def variables(arg)
-        raise(TclVariableNotFoundError, "can't read $#{arg}, no such variables") unless @variables.key?(arg)
+        raise TclVariableNotFoundError.new(arg, 'no such variables') unless
+          @variables.key?(arg)
         @variables[arg]
       end
 
@@ -22,6 +24,35 @@ module Tcl
       def delete_hook(name)
         @hooks.delete(name.to_s)
       end
+
+      def commands
+        r = []
+        r.concat private_methods.select { |e| e.match(/^___/) }
+                                .map { |e| e[3..-1] }
+        r.concat @proc.keys
+        r.concat @hooks.keys
+        r
+      end
+
+      private
+
+      def parse_index_format(a)
+        case a
+        when /end-(\d+)/ then -1 - Regexp.last_match(1).to_i
+        when /end/ then -1
+        else
+          r = a.to_i
+          r < 0 ? 0 : r
+        end
+      end
+
+      def get_fp(id, delete: false)
+        if @files.key?(id)
+          delete ? @files.delete(id) : @files[id]
+        else
+          raise(CommandError, "cannnot find channel named #{id}")
+        end
+      end
     end
   end
 end

data/lib/tcl/ruby/version.rb

@@ -1,5 +1,5 @@
 module Tcl
   module Ruby
-    VERSION = '0.1.0'.freeze
+    VERSION = '0.1.1'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tcl-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Kiyonori Matsumoto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-06-02 00:00:00.000000000 Z
+date: 2016-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -87,10 +87,14 @@ files:
 - lib/tcl/ruby/command.rb
 - lib/tcl/ruby/commands/array.rb
 - lib/tcl/ruby/commands/basic.rb
+- lib/tcl/ruby/commands/inout.rb
 - lib/tcl/ruby/commands/list.rb
+- lib/tcl/ruby/commands/string.rb
 - lib/tcl/ruby/error.rb
 - lib/tcl/ruby/list_array.rb
+- lib/tcl/ruby/option_parser.rb
 - lib/tcl/ruby/parser.rb
+- lib/tcl/ruby/string.rb
 - lib/tcl/ruby/util.rb
 - lib/tcl/ruby/version.rb
 - tcl-ruby.gemspec