landescape 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 22dbf4f4d4ebb551c726f65d7894706fd8e8cb7c
+  data.tar.gz: 5fad1bddcbfb7860b9eff86c48808e99fa934d7b
+SHA512:
+  metadata.gz: cc43b68028b01c3d3229b75008430cc0d8ef2ed2e6733212bdbe31266214fe029d331142b6ab2f96b435cb2e1e9c22402bcdb18d3fe9921d80e71cd4bb51f54a
+  data.tar.gz: 2c498dc00f67c24cd5c92a8f722e6c6bacb0dd11d9b7f0da8c6b2a9387fc0b99e13be151b4635522e7fad85515be195a72af122205c7c01847ca112667db25c5

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 hibariya
+
+MIT License
+
+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,86 @@
+# Landescape
+
+Landscape is a library for handling escape sequence.
+
+## Is It Good?
+
+Yes. But Landescape has some problems for now.
+**API will changed in future versions.**
+
+Landescape doesn't support followings now:
+
+* Coloring
+* Any terminals except vt100
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'landescape'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install landescape
+
+## Usage
+
+### Tokenize, And convert to human readable statements
+
+```ruby
+source = StringIO.new("\e[1mHello\e[m.") # IO like object
+
+# tokenize
+tokenizer = Landescape::Tokenizer.start(source)
+tokens    = tokenizer.result # => #<Queue:0x007ff0bc08f098 @que=["\e[1m", "H", "e", "l", "l", "o", "\e[m", "."], (snip...)>
+
+# convert
+converter = Landescape::Converter::VT100.start(tokens, non_block: true)
+converter.result # => #<Queue:0x007ff0bc1cdc70 @que=[[:set_attributes, 1], [:print, "H"], [:print, "e"], [:print, "l"], [:print, "l"], [:print, "o"], [:exit_attribute_mode], [:print, "."]], (snip...)>
+```
+
+### Invoke shell on Curses window
+
+```ruby
+require 'curses'
+require 'pty'
+require 'landescape'
+
+Curses.noecho
+
+window = Curses.stdscr
+window.addstr 'Landescape example for curses'
+window.refresh
+
+terminal = window.subwin(27, 102, 10, 10)
+terminal.scrollok true
+
+PTY.getpty 'TERM=vt100 bash --noprofile' do |stdout, stdin, pid|
+  stdin.puts <<-SHELL
+    tput cols 100
+    tput lines 25
+    clear
+  SHELL
+
+  Thread.fork do
+    while char = terminal.getch
+      stdin.putc char
+    end
+  end
+
+  Landescape.run stdout, terminal
+
+  Curses.close_screen if Process.detach(pid).join
+end
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new :spec
+
+task default: :spec

data/examples/shell_on_curses.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+require 'pty'
+require 'curses'
+require 'landescape'
+
+Curses.noecho
+
+window = Curses.stdscr
+window.addstr 'Landescape example for curses'
+window.refresh
+
+terminal = window.subwin(27, 102, 10, 10)
+terminal.scrollok true
+
+PTY.getpty 'TERM=vt100 bash --noprofile' do |stdout, stdin, pid|
+  stdin.puts <<-SHELL
+    tput cols 100
+    tput lines 25
+    clear
+  SHELL
+
+  Thread.fork do
+    while char = terminal.getch
+      stdin.putc char
+    end
+  end
+
+  Landescape.run stdout, terminal
+
+  Curses.close_screen if Process.detach(pid).join
+end

data/landescape.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'landescape/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'landescape'
+  spec.version       = Landescape::VERSION
+  spec.authors       = %w(hibariya)
+  spec.email         = %w(celluloid.key@gmail.com)
+  spec.description   = %(A library for handling escape sequence)
+  spec.summary       = %(Handle escape sequence)
+  spec.homepage      = 'https://github.com/hibariya/landescape'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = %w(lib examples)
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+end

data/lib/landescape.rb

@@ -0,0 +1,38 @@
+require 'thread'
+require 'landescape/version'
+
+module Landescape
+  autoload :Tokenizer, 'landescape/tokenizer'
+  autoload :Converter, 'landescape/converter'
+  autoload :Evaluator, 'landescape/evaluator'
+
+  autoload :Curses,    'landescape/evaluator/curses'
+
+  class Nullogger
+    def method_missing(*); end
+  end
+
+  class << self
+    attr_writer :logger
+
+    def logger
+      @logger ||= Nullogger.new
+    end
+
+    def run(source, window, options = {})
+      options = {non_block: false, converter: Converter::VT100, evaluator: Curses}.merge(options)
+      converter_klass, evaluator_klass = [:converter, :evaluator].map {|n|
+        options.delete(n)
+      }
+
+      tokenizer = Tokenizer.start(source)
+      converter = converter_klass.start(tokenizer.result, options)
+
+      evaluator_klass.start(converter.result, window, options).tap {|evaluator|
+        at_exit do
+          [tokenizer, converter, evaluator].each &:stop
+        end
+      }
+    end
+  end
+end

data/lib/landescape/converter.rb

@@ -0,0 +1,124 @@
+module Landescape
+  # Convert: ['\e[1;2f', 'H', 'i']] to [[:cursor_address, 1, 2], [:print, 'H'], [:print, 'i']]
+  module Converter
+    class Base
+      CODES = {}
+
+      class << self
+        def start(tokens, options = {})
+          new(tokens, options).tap(&:start)
+        end
+      end
+
+      attr_reader :tokens, :result
+
+      def initialize(tokens, options = {})
+        @options = {non_block: false}.merge(options)
+        @result  = Queue.new
+        @tokens  = tokens
+      end
+
+      def start
+        @convert_thread = Thread.fork {
+          loop do
+            token =
+              begin
+                tokens.shift(@options[:non_block])
+              rescue ThreadError
+                Thread.exit
+              end
+
+            _, detected = self.class::CODES.detect {|pattern, _| pattern === token }
+            match       = Regexp.last_match
+            statement   =
+              if detected
+                name, args_proc = detected.values_at(:name, :args)
+                args            = args_proc ? args_proc.call(match.captures) : nil
+
+                Landescape.logger.debug %([statement] #{name}(#{Array(args).join(', ')}))
+                [name, *args]
+              else
+                Landescape.logger.debug %([statement] print(#{token.inspect}))
+                [:print, *token]
+              end
+
+            result.push statement
+          end
+        }
+      end
+
+      def stop
+        @convert_thread.exit if @convert_thread.alive?
+      end
+    end
+
+    class VT100 < Base
+      CODES = {
+        /^\e\[(\d+)?(?:;(\d+))?[Hf]$/ => {
+          name: :cursor_address,
+          args: ->(captures) { captures.map(&:to_i) }
+        },
+
+        /^\e\[(\d+)?A$/ => {
+          name: :cursor_up,
+          args: ->(captures) { captures.first.to_i }
+        },
+
+        /^\e\[(\d+)?B$/ => {
+          name: :cursor_down,
+          args: ->(captures) { captures.first.to_i }
+        },
+
+        /^\e\[(\d+)?C$/ => {
+          name: :cursor_right,
+          args: ->(captures) { captures.first.to_i }
+        },
+
+        /^\e\[(\d+)?D$/ => {
+          name: :cursor_left,
+          args: ->(captures) { captures.first.to_i }
+        },
+
+        /^\e\[0?m$/ => {name: :exit_attribute_mode},
+
+        /^\e\[([\d;]+)m$/ => {
+          name: :set_attributes,
+          args: ->(captures) { captures.join.split(/;/).map(&:to_i) }
+        },
+
+        /^\e\[(\d+);(\d+)r$/ => {
+          name: :change_scroll_region,
+          args: ->(captures) { captures.map(&:to_i) }
+        },
+
+        /^\e\[s$/   => {name: :save_cursor},
+        /^\e\[u$/   => {name: :restore_cursor},
+        /^\e\[2?J$/ => {name: :clear_screen},
+        /^\e\[K$/   => {name: :clear_eol},
+
+        /^\eD$/ => {name: :scroll_forward},
+        /^\eM$/ => {name: :scroll_reverse},
+
+        /^\e\[\?1h$/ => {name: :keypad_xmit},
+        /^\e\[\?1l$/ => {name: :keypad_local},
+
+        # cursor_normal is probably not available on vt100
+        /^\e\[\?25h$/ => {name: :cursor_visible},
+        /^\e\[\?25l$/ => {name: :cursor_invisible},
+
+        # backslashes
+        /^\n$/   => {name: :newline},
+        /^\r$/   => {name: :carriage_return},
+        /^(\a)$/ => {name: :bell},
+
+        # really...? maybe doubt!
+        /^\e\\$/ => {name: :carriage_return},
+
+        /^(\u000F|\e.+)$/ => {
+          name: :unknown,
+          args: ->(captures) { captures.first }
+        }
+      }
+    end
+  end
+end

data/lib/landescape/evaluator.rb

@@ -0,0 +1,50 @@
+module Landescape
+  module Evaluator
+    class Base
+      class << self
+        def start(statements, window, options = {})
+          new(statements, window, options).tap(&:start)
+        end
+      end
+
+      attr_reader :statements
+
+      def initialize(statements, window, options = {})
+        @options    = {non_block: false}.merge(options)
+        @window     = window
+        @statements = statements
+      end
+
+      def start
+        @eval_thread = Thread.fork {
+          loop do
+            name, *args =
+              begin
+                statements.shift(@options[:non_block])
+              rescue ThreadError
+                Thread.kill
+              end
+
+            if self.class.method_defined?(name)
+              __send__ name, *args
+            else
+              not_supported name, *args
+            end
+          end
+        }
+      end
+
+      def stop
+        @eval_thread.exit if @eval_thread.alive?
+      end
+
+      def unknown(token)
+        Landescape.logger.warn %([unknown] #{token.inspect})
+      end
+
+      def not_supported(name, *args)
+        Landescape.logger.warn %([not supported] #{name}(#{args.join(', ')}))
+      end
+    end
+  end
+end

data/lib/landescape/evaluator/curses.rb

@@ -0,0 +1,131 @@
+require 'curses'
+require 'landescape/evaluator'
+
+module Landescape
+  module Evaluator
+    class Curses < Base
+      GRAPHICS_MODES = {
+        1 => ::Curses::A_BOLD,
+        4 => ::Curses::A_UNDERLINE,
+        5 => ::Curses::A_BLINK,
+        7 => ::Curses::A_REVERSE
+      }
+
+      attr_reader :window
+
+      def initialize(statements, window, options = {})
+        super
+
+        @saved_cursor  = nil
+        @scroll_region = [0, window.maxy]
+      end
+
+      def print(str)
+        window.addstr str
+
+        window.refresh
+      end
+
+      def set_attributes(*modes)
+        return exit_attribute_mode if modes.empty?
+
+        modes.each do |mode|
+          if attr = GRAPHICS_MODES[mode]
+            window.attron attr
+          else
+            exit_attribute_mode
+          end
+        end
+      end
+
+      def exit_attribute_mode
+        window.attroff GRAPHICS_MODES.values.inject(:|)
+      end
+
+      def change_scroll_region(top, bottom)
+        @scroll_region = [top, bottom]
+
+        window.setscrreg *@scroll_region
+      end
+
+      def scroll_reverse
+        window.scrl -1
+      end
+
+      def scroll_forward
+        window.scrl 1
+      end
+
+      def cursor_address(line, column)
+        scroll_forward if line > window.cury && window.maxy.pred <= window.cury
+
+        window.setpos line, column
+      end
+
+      def newline
+        scroll_forward if window.cury == @scroll_region.last
+
+        cursor_address (window.cury.succ), 0
+      end
+
+      def carriage_return
+        cursor_address window.cury, 0
+      end
+
+      def cursor_up(step)
+        cursor_address (window.cury - step), window.curx
+      end
+
+      def cursor_down(step)
+        cursor_address (window.cury + step), window.curx
+      end
+
+      def cursor_right(step)
+        cursor_address window.cury, (window.curx + step)
+      end
+
+      def cursor_left(step)
+        cursor_address window.cury, (window.curx - step)
+      end
+
+      def save_cursor
+        @saved_cursor = [window.cury, window.curx]
+      end
+
+      def restore_cursor
+        cursor_address *@saved_cursor
+      end
+
+      def cursor_visible
+        window.curs_set 2
+      end
+
+      def cursor_invisible
+        window.curs_set 0
+      end
+
+      def keypad_xmit
+        window.keypad true
+      end
+
+      def keypad_local
+        window.keypad false
+      end
+
+      def clear_screen
+        cursor_address 0, 0
+
+        window.clear
+        window.refresh
+      end
+
+      def clear_eol
+        window.clrtoeol
+
+        window.refresh
+      end
+    end
+  end
+
+  Curses = Evaluator::Curses
+end

data/lib/landescape/tokenizer.rb

@@ -0,0 +1,122 @@
+module Landescape
+  # Tokenize: "\e[1;2fHi" to ['\e[1;2f', 'H', 'i']]
+  class Tokenizer
+    class << self
+      def start(source)
+        new(source).tap(&:start)
+      end
+    end
+
+    attr_reader :source, :result
+
+    def initialize(source)
+      @result = Queue.new
+      @source =
+        if source.respond_to?(:getc)
+          source
+        else
+          StringIO.new(source.to_s)
+        end
+
+      at_exit do
+        @source.close unless @source.closed?
+      end
+    end
+
+    def start
+      @tokenize_thread = Thread.fork {
+        while char = read_char
+          tokens =
+            case char
+            when nil  then Thread.exit # StringIO#getc # => nil (EOF)
+            when /\e/ then escape char
+            else char
+            end
+
+          Array(tokens).each do |token|
+            result.push token
+          end
+        end
+      }
+    end
+
+    def stop
+      @tokenize_thread.exit if @tokenize_thread.alive?
+    end
+
+    private
+
+    def escape(token)
+      token << read_char
+
+      case token.chars.last
+      when /\[/
+        escape_code token
+      when /[()]/
+        escape_code_parens token
+      when /#/
+        escape_code_sharp token
+      when /\//
+        escape_code_slash token
+      when /[\da-zA-Z<=>_\\]/
+        token
+      else
+        fallback token
+      end
+    end
+
+    def escape_code(token)
+      token << read_char
+
+      case token.chars.last
+      when /[\d?;<=>]/
+        escape_code token
+      when /[a-zA-Z]/
+        token
+      else
+        fallback token
+      end
+    end
+
+    def escape_code_parens(token)
+      token << read_char
+
+      case token.chars.last
+      when /[\da-zA-Z]/
+        token
+      else
+        fallback token
+      end
+    end
+
+    def escape_code_sharp(token)
+      token << read_char
+
+      case token.chars.last
+      when /\d/
+        token
+      else
+        fallback token
+      end
+    end
+
+    def escape_code_slash(token)
+      token << read_char
+
+      case token.chars.last
+      when /[a-zA-Z]/
+        token
+      else
+        fallback token
+      end
+    end
+
+    def fallback(token)
+      token.chars
+    end
+
+    def read_char
+      source.getc
+    end
+  end
+end

data/lib/landescape/version.rb

@@ -0,0 +1,3 @@
+module Landescape
+  VERSION = "0.0.1"
+end

data/spec/converter_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Landescape::Converter::VT100 do
+  def convert(tokens)
+    converter      = Landescape::Converter::VT100.start(array_to_result(tokens), non_block: true)
+    convert_thread = converter.instance_variable_get(:@convert_thread)
+    convert_thread.join if convert_thread.alive?
+
+    result_to_array(converter.result)
+  end
+
+  it { convert(%W(\e[4m H i \e[m .)).should == [[:set_attributes, 4], [:print, 'H'], [:print, 'i'], [:exit_attribute_mode], [:print, '.']] }
+  it { convert(%W(\e[50;2H)).should == [[:cursor_address, 50, 2]] }
+  it { convert(%W(\e[5A)).should    == [[:cursor_up, 5]] }
+  it { convert(%W(\e[5B)).should    == [[:cursor_down, 5]] }
+  it { convert(%W(\e[5C)).should    == [[:cursor_right, 5]] }
+  it { convert(%W(\e[5D)).should    == [[:cursor_left, 5]] }
+  it { convert(%W(\e[1m)).should    == [[:set_attributes, 1]] }
+  it { convert(%W(\e[1;20r)).should == [[:change_scroll_region, 1, 20]] }
+  it { convert(%W(\e[s)).should     == [[:save_cursor]] }
+  it { convert(%W(\e[u)).should     == [[:restore_cursor]] }
+  it { convert(%W(\e[2J)).should    == [[:clear_screen]] }
+  it { convert(%W(\e[J)).should     == [[:clear_screen]] }
+  it { convert(%W(\e[K)).should     == [[:clear_eol]] }
+  it { convert(%W(\e[?1h)).should   == [[:keypad_xmit]] }
+  it { convert(%W(\e[?1l)).should   == [[:keypad_local]] }
+  it { convert(%W(\e[?25h)).should  == [[:cursor_visible]] }
+  it { convert(%W(\e[?25l)).should  == [[:cursor_invisible]] }
+  it { convert(%W(\n)).should       == [[:newline]] }
+  it { convert(%W(\r)).should       == [[:carriage_return]] }
+  it { convert(%W(\a)).should       == [[:bell]] }
+  it { convert(%W(\e\\)).should     == [[:carriage_return]] }
+  it { convert(%W(\u000F)).should   == [[:unknown, "\u000F"]] }
+end

data/spec/evaluator_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Landescape::Evaluator do
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'landescape'
+require 'support/example_helper'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.order = 'random'
+
+  config.include ExampleHelper
+end

data/spec/support/example_helper.rb

@@ -0,0 +1,14 @@
+module ExampleHelper
+  def array_to_result(a)
+    a.each.with_object(Queue.new) {|token, q|
+      q.push token
+    }
+  end
+
+  def result_to_array(q)
+    result_array = []
+    result_array << q.shift until q.empty?
+
+    result_array
+  end
+end

data/spec/tokenizer_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Landescape::Tokenizer do
+  def tokenize(str)
+    tokenizer       = Landescape::Tokenizer.start(str)
+    tokenize_thread = tokenizer.instance_variable_get(:@tokenize_thread)
+    tokenize_thread.join if tokenize_thread.alive?
+
+    result_to_array(tokenizer.result)
+  end
+
+  it { tokenize("\e]***").should            == %W(\e ] * * *) }
+  it { tokenize("Hi\e[32mHello\e[m").should == %W(H i \e[32m H e l l o \e[m) }
+  it { tokenize("\e[1;10H").should          == %W(\e[1;10H) }
+  it { tokenize("\e[;H").should             == %W(\e[;H) }
+  it { tokenize("\e[A").should              == %W(\e[A) }
+  it { tokenize("\e[u").should              == %W(\e[u) }
+  it { tokenize("\e[2J").should             == %W(\e[2J) }
+  it { tokenize("\e[?1h").should            == %W(\e[?1h) }
+
+  it { tokenize("\e(A\e)0").should          == %W(\e\(A \e\)0) }
+  it { tokenize("\e#4").should              == %W(\e#4) }
+  it { tokenize("\eB").should               == %W(\eB) }
+  it { tokenize("\e<").should               == %W(\e<) }
+  it { tokenize("\e>").should               == %W(\e>) }
+  it { tokenize("\e=").should               == %W(\e=) }
+  it { tokenize("\eD\eM").should            == %W(\eD \eM) }
+  it { tokenize("\e\\").should              == %W(\e\\) }
+
+  it { tokenize("\n\r").should              == %W(\n \r) }
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: landescape
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- hibariya
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-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.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: A library for handling escape sequence
+email:
+- celluloid.key@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/shell_on_curses.rb
+- landescape.gemspec
+- lib/landescape.rb
+- lib/landescape/converter.rb
+- lib/landescape/evaluator.rb
+- lib/landescape/evaluator/curses.rb
+- lib/landescape/tokenizer.rb
+- lib/landescape/version.rb
+- spec/converter_spec.rb
+- spec/evaluator_spec.rb
+- spec/spec_helper.rb
+- spec/support/example_helper.rb
+- spec/tokenizer_spec.rb
+homepage: https://github.com/hibariya/landescape
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- examples
+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.1.10
+signing_key: 
+specification_version: 4
+summary: Handle escape sequence
+test_files:
+- spec/converter_spec.rb
+- spec/evaluator_spec.rb
+- spec/spec_helper.rb
+- spec/support/example_helper.rb
+- spec/tokenizer_spec.rb