tcl-ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 05002f0d80add9496fd333278753cb393c1cb467
+  data.tar.gz: cc478beb9d6bb5c8562d089931570efe36fb4c70
+SHA512:
+  metadata.gz: ec9711ba1d51886f8ae015af255b5f40bb792278d23f8c1d8714b8ed6cc5ce6a90e9632f40390777e3c3c62e346ea33eb59d3bc68e51d0ccb088ef53f0f0be30
+  data.tar.gz: a932d6e3cbceba76a77fc4250130ab62f6d834a7167bdf63e6981e545d703488a92c0d9e6462c2d43b8952de780cfcbea17af56500e2789648e1b2fedcc81be8

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/log

data/.rspec

@@ -0,0 +1 @@
+--color

data/.rubocop.yml

@@ -0,0 +1,3 @@
+Lint/Debugger:
+  Exclude:
+    - bin/console

data/.travis.yml

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

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in tcl-ruby.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,44 @@
+PATH
+  remote: .
+  specs:
+    tcl-ruby (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.1)
+    diff-lcs (1.2.5)
+    method_source (0.8.2)
+    pry (0.10.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.5.0)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.4)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+    slop (3.6.0)
+
+PLATFORMS
+  ruby
+  x86-mingw32
+
+DEPENDENCIES
+  bundler (~> 1.11)
+  pry
+  rake (~> 10.0)
+  rspec (~> 3.0)
+  tcl-ruby!
+
+BUNDLED WITH
+   1.11.2

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 kiyonori-matsumoto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,54 @@
+[![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)
+
+# Tcl::Ruby
+
+Tcl interpreter for ruby
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'tcl-ruby'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tcl-ruby
+
+## Usage
+
+Instanciate Interpreter
+```ruby
+f = Interpreter.new
+```
+Parse commands you want to
+```ruby
+f.parse('llength {A B C D}')
+=> 4
+```
+You can get variables with Interpreter#variables
+```ruby
+f.parse('set A 123')
+f.variables('A')
+=> '123'
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/kiyonori-matsumoto/tcl-ruby.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'tcl/ruby'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require 'pry'
+f = Tcl::Ruby::Interpreter.new
+# Pry.start
+binding.pry
+
+# require "irb"
+# IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/tcl/ruby/command.rb

@@ -0,0 +1,68 @@
+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}")
+        end
+      end
+
+      def replace(list)
+        return list if list[0] == '{'
+        # 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/, '')
+          end
+          raise(TclVariableNotFoundError, v.to_s, '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
+          else
+            raise(TclVariableNotFoundError, v.to_s, 'variable is array') if @variables[v].is_a?(Hash)
+            @variables[v]
+          end
+        end
+        # replace commands
+        l = l.gsub(/\[(.+)\]/) { parse(Regexp.last_match(1)) }
+      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
+          @global[v] = @variables[v]
+        end if @variables.key?(:___global)
+        @v_stack.push(@variables)
+        @variables = {}
+        arg.zip(proc_arg).each do |v|
+          @variables[v[1]] = v[0]
+        end
+        ret = catch(:return) do
+          parse(proc_info[1])
+        end
+        @variables[:___global].each do |v| # FIXME: Buggy
+          @global[v] = @variables[v]
+        end if @variables.key?(:___global)
+        @variables = @v_stack.pop
+        ret
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+module Tcl
+  module Ruby
+    class Interpreter
+      private
+
+      def ___array(arg)
+        send("___array_#{arg[0]}", arg[1..-1])
+      end
+
+      def ___array_set(arg)
+        name = arg[0]
+        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?
+        @variables[name] ||= {}
+        @variables[name].merge!(Hash[*l])
+      end
+
+      def ___array_unset(arg)
+        raise(TclArgumentError, 'array unset arrayName ?pattern?') unless
+          (1..2).cover?(arg.size)
+        name = arg[0]
+        return '' unless @variables[name].is_a?(Hash)
+        if arg.size == 2
+          pattern = arg[1]
+          @variables[name].delete(pattern)
+        else
+          @variables.delete(name)
+        end
+        ''
+      end
+
+      def ___array_get(arg)
+        raise(TclArgumentError, 'array get arrayName ?pattern?') unless
+          (1..2).cover?(arg.size)
+        name = arg[0]
+        return '' unless @variables[name].is_a?(Hash)
+        if arg.size == 2
+          pattern = arg[1]
+          return '' unless @variables[name].key?(pattern)
+          "#{pattern} #{@variables[name][pattern]}"
+        else
+          @variables[name].flatten.join(' ')
+        end
+      end
+
+      def ___array_exists(arg)
+        raise(TclArgumentError, 'array exists arrayName') unless arg.size == 1
+        name = arg[0]
+        @variables[name].is_a?(Hash) ? '1' : '0'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+module Tcl
+  module Ruby
+    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]]
+      end
+
+      def ___expr(arg)
+        eval arg.join('')
+      end
+
+      def ___if(arg)
+        arg.delete('then')
+        arg.delete('else')
+        arg.delete('elseif')
+        while arg[1]
+          r = eval(replace(arg[0]))
+          return parse(arg[1]) if r && r != 0
+          arg.shift(2)
+        end
+        return parse(arg[0]) if arg[0]
+        nil
+      end
+
+      def ___for(arg)
+        raise(CommandError, 'for start test next body') unless arg.size == 4
+        parse(arg[0])
+        catch(:break) do
+          while eval(replace(arg[1]))
+            catch(:continue) do
+              parse(arg[3])
+            end
+            parse(arg[2])
+          end
+        end
+      end
+
+      def ___foreach(arg)
+        varlist = []
+        list = []
+        while arg[2]
+          varlist << parse(arg[0], true)
+          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
+            end
+            catch(:continue) do
+              parse(body)
+            end
+          end
+        end
+      end
+
+      def ___while(arg)
+        body = arg[1]
+        catch(:break) do
+          while eval(replace(arg[0]))
+            catch(:continue) do
+              parse(body)
+            end
+          end
+        end
+      end
+
+      def ___break(_arg)
+        throw :break
+      end
+
+      def ___continue(_arg)
+        throw :continue
+      end
+
+      def ___return(arg)
+        throw(:return, arg[0])
+      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
+      end
+
+      def ___puts(arg)
+        puts arg[0]
+      end
+
+      def ___proc(arg)
+        raise(TclArgumentError, 'proc name args body') unless arg.size == 3
+        @proc[arg[0]] = arg[1..2]
+      end
+
+      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/list.rb

@@ -0,0 +1,72 @@
+module Tcl
+  module Ruby
+    class Interpreter
+      private
+
+      def ___llength(arg)
+        raise(CommandError, 'llength list') if arg.size != 1
+        parse(arg[0], true).size
+      end
+
+      def ___list(arg)
+        arg.join(' ').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
+          end
+          l
+        end
+      end
+
+      def ___join(arg)
+        raise(CommandError, 'join list joinString?') unless (1..2).cover? arg.size
+        separator = arg[1] || ' '
+        parse(arg[0], 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(' ')}}"
+        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
+        else
+          ''
+        end
+      end
+
+      def ___lappend(arg)
+        l = parse(variables(arg[0]), true)
+        l.push(*arg[1..-1])
+        @variables[arg[0]] = l.to_list
+      end
+    end
+  end
+end

data/lib/tcl/ruby/error.rb

@@ -0,0 +1,17 @@
+module Tcl
+  module Ruby
+    class TclError < StandardError; end
+    class ParseError < TclError; end
+    class CommandError < TclError; end
+    class TclArgumentError < TclError
+      def initialize(msg)
+        super("wrong \# args: should be\"#{msg}\"")
+      end
+    end
+    class TclVariableNotFoundError < TclError
+      def initialize(var, type = '')
+        super("can't read \"#{var}\": #{type}")
+      end
+    end
+  end
+end

data/lib/tcl/ruby/list_array.rb

@@ -0,0 +1,75 @@
+module Tcl
+  module Ruby
+    class ListArray
+      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
+        @ary = []
+      end
+
+      def <<(buffer)
+        @ary << buffer.dup unless buffer.empty?
+        buffer.clear
+        self
+      end
+
+      def to_string
+        @ary.map! { |e| _to_string(e) }
+        self
+      end
+
+      def to_list
+        @ary.map { |e| _to_list(e) }.join(' ')
+      end
+
+      def map!(&block)
+        @ary.map!(&block)
+        self
+      end
+
+      def map(&block)
+        r = dup
+        r.map!(&block)
+        r
+      end
+
+      def [](arg)
+        if arg.is_a?(Range)
+          r = dup
+          r.ary = r.ary[arg]
+          r
+        else
+          @ary.[](arg)
+        end
+      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/parser.rb

@@ -0,0 +1,72 @@
+require 'strscan'
+
+module Tcl
+  module Ruby
+    class Interpreter
+      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
+          end
+        end
+        r << buffer
+        raise(ParseError, 'unmatched parenthesises') if
+        ddepth != 0 || pdepth != 0 || bdepth != 0
+        if to_list
+          r.to_string
+        else
+          ret = command(r) unless r.empty?
+          ret
+        end
+      end
+    end
+  end
+end

data/lib/tcl/ruby/util.rb

@@ -0,0 +1,27 @@
+module Tcl
+  module Ruby
+    class Interpreter
+      def initialize
+        @variables = {}
+        @global = @variables
+        @v_stack = []
+        @hooks = {}
+        @proc = {}
+      end
+
+      def variables(arg)
+        raise(TclVariableNotFoundError, "can't read $#{arg}, no such variables") unless @variables.key?(arg)
+        @variables[arg]
+      end
+
+      def add_hook(name, &block)
+        raise(ArgumentError, 'block is not given') unless block_given?
+        @hooks[name.to_s] = block
+      end
+
+      def delete_hook(name)
+        @hooks.delete(name.to_s)
+      end
+    end
+  end
+end

data/lib/tcl/ruby/version.rb

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

data/lib/tcl/ruby.rb

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

data/tcl-ruby.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tcl/ruby/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'tcl-ruby'
+  spec.version       = Tcl::Ruby::VERSION
+  spec.authors       = ['Kiyonori Matsumoto']
+
+  spec.summary       = 'Tcl Interpreter for ruby'
+  spec.homepage      = "https://github.com/kiyonori-matsumoto/tcl-ruby"
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.11'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'pry'
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: tcl-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kiyonori Matsumoto
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-06-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/tcl/ruby.rb
+- lib/tcl/ruby/command.rb
+- lib/tcl/ruby/commands/array.rb
+- lib/tcl/ruby/commands/basic.rb
+- lib/tcl/ruby/commands/list.rb
+- lib/tcl/ruby/error.rb
+- lib/tcl/ruby/list_array.rb
+- lib/tcl/ruby/parser.rb
+- lib/tcl/ruby/util.rb
+- lib/tcl/ruby/version.rb
+- tcl-ruby.gemspec
+homepage: https://github.com/kiyonori-matsumoto/tcl-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Tcl Interpreter for ruby
+test_files: []