spacy 0.1.4

data/.gitignore

@@ -0,0 +1,4 @@
+*~
+.DS_Store
+Spacy.app
+Gemfile.lock

data/.gitmodules

@@ -0,0 +1,12 @@
+[submodule "xot"]
+	path = xot
+	url = ../xot.git
+[submodule "rucy"]
+	path = rucy
+	url = ../rucy.git
+[submodule "rays"]
+	path = rays
+	url = ../rays.git
+[submodule "reflex"]
+	path = reflex
+	url = ../reflex.git

data/ChangeLog

@@ -0,0 +1,3 @@
+2011-06-07  @tokujiros <tokujiros@gmail.com>
+
+	* add text classes.

data/Gemfile

@@ -0,0 +1,35 @@
+# -*- mode: ruby; coding: utf-8 -*-
+
+
+source 'https://rubygems.org'
+
+
+SUBMODULES = %w[xot rucy rays reflexion]
+
+
+def local_path (name)
+  File.expand_path "../#{name.gsub /xion/, 'x'}", __FILE__
+end
+
+def have_local (name)
+  File.directory? local_path name
+end
+
+def submodule (*names)
+  names.each do |name|
+    if have_local name
+      gem name, path: local_path(name)
+    else
+      gem name
+    end
+  end
+end
+
+
+group :development do
+  gem 'rake'
+end
+
+submodule *SUBMODULES
+
+gem 'spacy', path: '.' if SUBMODULES.all? {|name| have_local name}

data/Rakefile

@@ -0,0 +1,39 @@
+# -*- ruby -*-
+
+
+require 'bundler/setup'
+require 'spacy/module'
+
+
+MODULE     = Spacy
+SUBMODULES = %w[xot rucy rays reflex]
+TASKS      = %w[git gem test submodule mac]
+
+
+begin
+
+  require 'xot/rake'
+  require 'xot/module'
+  require 'rucy/module'
+  require 'rays/module'
+  require 'reflex/module'
+
+rescue LoadError
+
+  load 'task/submodule.rake'
+
+  task :default => 'submodule:init'
+
+else
+
+  include Xot::Rake
+
+  task :default => :status
+
+  task :build => :app
+
+  task :run => :build
+
+  [Xot, Rucy, Rays, Reflex, Spacy].each {|m| m.load_tasks *TASKS}
+
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.4

data/bin/spacy

@@ -0,0 +1,14 @@
+#!/Users/snori/.rvm/rubies/ruby-1.9.2-p180/bin/ruby
+# -*- mode: ruby; coding: utf-8 -*-
+
+
+(%w[xot rays reflex].product(%w[ext lib]) + [["lib"]]).each do |paths|
+  root = (__FILE__ =~ /\/Spacy.app\// ? "../../.." : "..").split('/')
+  $: << File.expand_path(File.join File.dirname(__FILE__), *root, *paths)
+end
+
+require 'rubygems'
+require 'spacy'
+
+
+Spacy::Application.new.run

data/lib/spacy.rb

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+
+
+require 'spacy/module'
+require 'spacy/application'
+require 'spacy/window'
+require 'spacy/text'
+require 'spacy/textbuffer'
+require 'spacy/textline'
+require 'spacy/extensions'

data/lib/spacy/application.rb

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+
+
+require 'reflex/autoinit'
+require 'reflex/reflex'
+require 'spacy/window'
+
+
+module Spacy
+
+
+  class Application < Reflex::Application
+
+    def initialize ()
+      super :name => 'Spacy'
+      @window = Window.new
+    end
+
+    def run ()
+      @window.show
+      super
+    end
+
+  end # Application
+
+
+end # Spacy

data/lib/spacy/extensions.rb

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+
+
+class String
+
+  def to_textline ()
+    Spacy::TextLine.new self
+  end
+
+end# String

data/lib/spacy/key.rb

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+
+
+module Spacy
+
+
+  class Key
+
+    include Comparable
+
+    attr_reader :key, :shift, :ctrl, :alt
+
+    def initialize (key, shift = false, ctrl = false, alt = false)
+      @key, @shift, @ctrl, @alt = key.to_sym, shift, ctrl, alt
+    end
+
+    def to_s ()
+      s = ''
+      s << '/' if @alt
+      s << '^' if @ctrl
+      s << @key
+      s
+    end
+
+    def << (key)
+      raise ArgumentError unless key.kind_of? Key
+      KeyStroke.new << self << key
+    end
+
+    def hash ()
+      to_s.hash
+    end
+
+    def eql? (obj)
+      to_s == obj.to_s
+    end
+
+    def <=> (obj)
+      to_s <=> obj.to_s
+    end
+
+    def inspect ()
+      mods = ''
+      mods << ', shift' if @shift
+      mods << ', ctrl'  if @ctrl
+      mods << ', alt'   if @alt
+      "#<Spacy::Key '#{@key.to_s}#{mods}'>"
+    end
+
+  end# Key
+
+
+end # Spacy

data/lib/spacy/keymap.rb

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+
+
+module Spacy
+
+
+  class KeyMap
+
+    def initialize ()
+      @map = {}
+    end
+
+    def add (key, &proc)
+      @map[key] = proc
+    end
+
+    def remove (key)
+      @map.delete key
+    end
+
+    def key_down (key, repeat)
+      proc = @map[key]
+      proc.call key if proc
+    end
+
+    def key_up (key)
+    end
+
+    def key_press (chars)
+    end
+
+    def [] (key)
+      @map[key]
+    end
+
+    def []= (key, proc)
+      @map[key] = proc
+    end
+
+  end# KeyMap
+
+
+end # Spacy

data/lib/spacy/keystroke.rb

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+
+
+module Spacy
+
+
+  class KeyStroke
+
+    include Comparable
+
+    def initialize ()
+      @keys = []
+    end
+
+    def to_s ()
+      @keys.join
+    end
+
+    def push (key)
+      @keys << key
+    end
+
+    alias << push
+
+    def hash ()
+      to_s.hash
+    end
+
+    def eql? (obj)
+      to_s == obj.to_s
+    end
+
+    def <=> (obj)
+      to_s <=> obj.to_s
+    end
+
+  end# KeyStroke
+
+
+end # Spacy

data/lib/spacy/module.rb

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+
+
+module Spacy
+
+
+  extend module ClassMethods
+
+    def root_dir ()
+      File.expand_path(File.join File.dirname(__FILE__), '..', '..')
+    end
+
+    def include_dirs ()
+      [File.join(root_dir, 'include')]
+    end
+
+    def library_dirs ()
+      %w[lib].map {|dir| File.join root_dir, dir}
+    end
+
+    def task_dir ()
+      File.join root_dir, 'task'
+    end
+
+    def load_tasks (*names)
+      if names.empty?
+        Dir["#{task_dir}/**/*.rake"].each {|path| load path}
+      else
+        names.each do |name|
+          path = "#{task_dir}/#{name}.rake"
+          load path if File.exist? path
+        end
+      end
+    end
+
+    def version ()
+      open(File.join root_dir, 'VERSION') {|f| f.readline.chomp}
+    end
+
+    self
+
+  end# ClassMethods
+
+
+end# Spacy

data/lib/spacy/text.rb

@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+
+
+require 'forwardable'
+require 'spacy/textbuffer'
+
+
+module Spacy
+
+
+  class Text
+
+    extend Forwardable
+
+    attr_reader :buffer
+
+    def_delegators :@buffer,
+      :each, :last, :nrow, :ncolumn, :to_a, :to_s,
+      :[], :[]=
+
+    def initialize (arg = nil)
+      @buffer = (TextBuffer === arg) ? arg : TextBuffer.new(arg)
+      @first = @last = 0
+    end
+
+    def pos ()
+      @first
+    end
+
+    def pos= (n)
+      last = @buffer.last
+      n = 0    if n < 0
+      n = last if n > last
+      select n
+    end
+
+    def cursor ()
+      @buffer.pos2cursor pos
+    end
+
+    def cursor= (*args)
+      args.flatten!
+      args << 0 while args.size < 2
+      self.pos = @buffer.cursor2pos *args
+    end
+
+    def row ()
+      @buffer.pos2cursor(pos)[0]
+    end
+
+    def column ()
+      @buffer.pos2cursor(pos)[1]
+    end
+
+    def row= (n)
+      self.cursor = n, column
+    end
+
+    def column= (n)
+      self.cursor = row, n
+    end
+
+    def replace (str, first, last = nil)
+      last = first unless last
+      @buffer.erase first, last
+      @buffer.insert first, str
+    end
+
+    def select (*args)
+      first, last = case args[0]
+      when Range
+        args[0].to_a
+      when Integer
+        args
+      end
+      last = first unless last
+      first, last = last, first unless first < last
+      @first, @last = first, last
+      selection
+    end
+
+    def selection ()
+      @first..@last
+    end
+
+    def selection= (str)
+      select replace(str, @first, @last)
+    end
+
+    def << (str)
+      replace str, last
+    end
+
+    def inspect ()
+      "#<Text row: #{row}, column: #{column}, buffer: #{buffer.inspect}>"
+    end
+
+  end# Text
+
+
+end# Spacy

data/lib/spacy/textbuffer.rb

@@ -0,0 +1,160 @@
+# -*- coding: utf-8 -*-
+
+
+module Spacy
+
+
+  class TextBuffer
+
+    include Enumerable
+
+    def initialize (str = nil)
+      @lines = [TextLine.new]
+      insert 0, str.to_s if str
+    end
+
+    def insert (pos, str)
+      last_ = last
+      raise RangeError unless 0 <= pos && pos <= last_
+      str.to_s.split(/(\r\n|\r|\n)/).each do |s|
+        row, col = p2c pos, last_
+        added = 0
+        if s =~ /\r|\n/
+          split_line row, col
+          added = 1
+        else
+          self[row].insert s, col
+          added = s.size
+        end
+        pos   += added
+        last_ += added
+      end
+      pos
+    end
+
+    def erase (first, last = nil)
+      last = first + 1 unless last
+      first, last = last, first unless first < last
+      last_ = self.last
+      row1, col1 = p2c first, last_
+      row2, col2 = p2c last, last_
+      return self if row1 == row2 && col1 == col2
+
+      if row1 == row2
+        @lines[row1].erase col1, col2
+      else
+        @lines[row2][0...col2] = @lines[row1][0...col1]
+        @lines[row1...row2] = []
+      end
+      self
+    end
+
+    def nrow ()
+      @lines.size
+    end
+
+    def ncolumn (row)
+      raise RangeError unless 0 <= row && row < nrow
+      self[row].ncolumn
+    end
+
+    def last ()
+      raise 'Invalid text buffer.' if @lines.empty?
+      inject(0) {|n, line| n + line.ncolumn} - 1
+    end
+
+    def empty? ()
+      nrow == 1 && ncolumn(0) == 1
+    end
+
+    def to_a ()
+      @lines
+    end
+
+    def to_s ()
+      to_a.join("\n")
+    end
+
+    def [] (*args)
+      @lines[*args]
+    end
+
+    def []= (row, line)
+      @lines[row] = line.to_textline
+    end
+
+    def each (*args, &block)
+      @lines.each *args, &block
+    end
+
+    def pos2cursor (pos)
+      last_ = last
+      if pos < 0
+        pos = 0
+      elsif pos > last_
+        pos = last_
+      end
+      p2c pos, last_
+    end
+
+    def cursor2pos (row, col)
+      nrow_ = nrow
+      if row < 0
+        row = 0
+      elsif row >= nrow_
+        row = nrow_ - 1
+      end
+      ncol_ = ncolumn(row)
+      if col < 0
+        col = 0
+      elsif col >= ncol_
+        col = ncol_ - 1
+      end
+      c2p row, col, nrow_, ncol_
+    end
+
+    def inspect ()
+      text = @lines.map{|x| x.to_s}.join('\n')[0, 64]
+      "#<TextBuffer #{nrow} lines, '#{text}'>"
+    end
+
+    private
+
+      def split_line (row, col)
+        line = self[row]
+        lineend = line.ncolumn - 1
+        newline = TextLine.new line[col...lineend]
+        line[col...lineend] = ''
+        @lines.insert row + 1, newline
+      end
+
+      def p2c (pos, last_)
+        raise RangeError unless 0 <= pos && pos <= last_
+        row = col = n = 0
+        each do |line|
+          nn = n + line.ncolumn
+          if n <= pos && pos < nn
+            col = pos - n
+            break
+          end
+          n = nn
+          row += 1
+        end
+        [row, col]
+      end
+
+      def c2p (row, col, nrow_, ncol_)
+        raise RangeError unless
+          0 <= row && row < nrow_ && 0 <= col && col < ncol_
+        n = 0
+        each.with_index do |line, index|
+          break if index == row
+          n += line.ncolumn
+        end
+        n + col
+      end
+
+  end# TextBuffer
+
+
+end# Spacy

data/lib/spacy/textline.rb

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+
+
+module Spacy
+
+
+  class TextLine
+
+    include Comparable
+
+    def initialize (str = nil)
+      @str = ''
+      insert str, 0 if str
+    end
+
+    def insert (str, pos)
+      raise RangeError unless 0 <= pos && pos <= last
+      str = str.to_s
+      raise ArgumentError, "'str' has new-line char(s)." if str =~ /\r|\n/
+      @str.insert pos, str
+      self
+    end
+
+    def erase (first, last = nil)
+      last = first + 1 unless last
+      first, last = last, first unless first < last
+      raise RangeError unless 0 <= first && last <= self.last
+      @str[first...last] = '' if first != last
+      self
+    end
+
+    def concat (str)
+      insert str, last
+    end
+
+    alias << concat
+
+    def last ()
+      @str.size
+    end
+
+    def ncolumn ()
+      last + 1
+    end
+
+    def to_s ()
+      @str
+    end
+
+    def to_textline ()
+      self
+    end
+
+    def [] (*args)
+      @str.[](*args)
+    end
+
+    def []= (*args)
+      @str.[]=(*args)
+    end
+
+    def <=> (obj)
+      to_s <=> obj.to_s
+    end
+
+    def inspect ()
+      "#<TextLine '#{@str}'>"
+    end
+
+  end# TextLine
+
+
+end# Spacy

data/lib/spacy/window.rb

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*-
+
+
+require 'rays/image'
+require 'reflex/application'
+require 'reflex/window'
+require 'spacy/text'
+
+
+module Spacy
+
+
+  class Window < Reflex::Window
+
+    def initialize ()
+      super
+      set :title,  Reflex::Application.instance.name
+      set :bounds, 100, 100, 600, 500
+      @text = Text.new
+      p = painter
+      p.background 1
+      p.fill 0
+      p.stroke nil
+      p.font Rays::Font.new "Menlo", 12
+    end
+
+    def update (dt)
+      @t ||= Time.now
+      @c ||= 0
+      redraw
+      @c += 1
+      @fps = @c / (Time.now - @t)
+      puts "#{@fps} FPS" if (@c % 100) == 0
+    end
+
+    def draw ()
+      super
+      paint do |p|
+        h = p.font.height
+        draw_text p, h
+        draw_cursor p, h
+        draw_fps p
+      end
+    end
+
+    def close ()
+      #Profiler__.print_profile STDOUT
+      super
+    end
+
+    def key_down (key)
+      @text.selection = key.chars
+    end
+
+    def key_up (key)
+    end
+
+    def points_down (points)
+    end
+
+    def points_up (points)
+    end
+
+    def points_moved (points)
+    end
+
+    private
+
+      def draw_text (p, lineheight)
+        y = 0
+        @text.each do |line|
+          p.text line, 0, y
+          y += lineheight
+        end
+      end
+
+      def draw_cursor (p, lineheight)
+        row, col = @text.cursor
+        x = p.font.width @text[row][0..col]
+        p.rect x, row * lineheight, 4, lineheight
+      end
+
+      def draw_fps (p)
+        pos = bounds(0)[1].move_by(-64, -20).to_a(2)
+        p.text "#{@fps.to_i} FPS", *pos if @fps
+      end
+
+  end# Window
+
+
+end # Spacy

data/spacy.gemspec

@@ -0,0 +1,44 @@
+# -*- mode: ruby; coding: utf-8 -*-
+
+
+$: << File.expand_path('../lib', __FILE__)
+
+require 'spacy/module'
+
+
+Gem::Specification.new do |s|
+  def glob (*patterns)
+    patterns.map {|pat| Dir.glob(pat).to_a}.flatten
+  end
+
+  mod   = Spacy
+  name  = mod.name.downcase
+  rdocs = glob *%w[README]
+
+  s.name        = name
+  s.summary     = 'A text editor written by Ruby.'
+  s.description = 'A text editor runs on Ruby and uses SPACE as a trigger key for every action.'
+  s.version     = mod.version
+
+  s.authors  = %w[snori]
+  s.email    = 'snori@xord.org'
+  s.homepage = "http://github.com/xord/#{name}"
+
+  s.platform              = Gem::Platform::RUBY
+  s.required_ruby_version = '>=1.9.0'
+
+  s.add_runtime_dependency 'bundler'
+  s.add_runtime_dependency 'xot'
+  s.add_runtime_dependency 'rays'
+  s.add_runtime_dependency 'reflexion'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'gemcutter'
+
+  s.files            = `git ls-files`.split $/
+  s.executables      = s.files.grep(%r{^bin/}) {|f| File.basename f}
+  s.test_files       = s.files.grep %r{^(test|spec|features)/}
+  s.extra_rdoc_files = rdocs.to_a
+  s.has_rdoc         = true
+
+  s.extensions << 'Rakefile'
+end

data/task/mac.rake

@@ -0,0 +1,45 @@
+# -*- mode: ruby; coding: utf-8 -*-
+
+
+task :app => 'app:build'
+
+%w[clean run].each do |t|
+  task t.intern => "app:#{t}"
+end
+
+
+namespace :app do
+
+
+  mod     = MODULE
+  name    = env :NAME,   MODULE.name.downcase
+  bindir  = env :BINDIR, 'bin'
+  ruby    = env :RUBY,   'ruby'
+
+  bin       = "#{bindir}/#{name}"
+  appname   = name.capitalize
+  appdir    = "#{appname}.app"
+  appbindir = "#{appdir}/Contents/MacOS"
+  out       = "#{appbindir}/#{name}"
+
+  tmps = [appdir]
+
+
+  task :build => out
+
+  task :clean do
+    sh %( rm -rf #{tmps.join ' '} )
+  end
+
+  task :run => :app do
+    sh %( #{ruby} #{bin} )
+  end
+
+  file out => [bin, appbindir] do
+    sh %( cp #{bin} #{appbindir} )
+  end
+
+  directory appbindir
+
+
+end# :app

data/task/submodule.rake

@@ -0,0 +1,39 @@
+# -*- mode: ruby; coding: utf-8 -*-
+
+
+def env (name, defval = nil)
+  Object.const_get(name) rescue ENV[name.to_s] || defval
+end unless respond_to? :env
+
+def header (mod)
+  puts "-- #{mod.to_s.capitalize} " + "-" * 50
+end unless respond_to? :header
+
+
+namespace :submodule do
+
+
+  mods  = env :SUBMODULES, []
+  git   = env :GIT,        'git'
+
+
+  task :init => mods.map {|m| "submodule:#{m}:init"}
+
+  mods.each do |mod|
+    namespace mod.intern do
+
+      rakefile = File.join mod, 'Rakefile'
+
+      task :init => rakefile
+
+      file rakefile do
+        header mod
+        sh %( git submodule update --init #{mod} )
+        sh %( cd #{mod} && git checkout master )
+      end
+
+    end# mod.intern
+  end
+
+
+end# submodule

data/test/helpers.rb

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+
+
+%w[lib xot/lib rays/ext rays/lib reflex/ext reflex/lib].each do |dir|
+  paths = ["..", dir]
+  $: << File.expand_path(File.join File.dirname(__FILE__), *paths)
+end
+
+require 'test/unit'
+require 'spacy'

data/test/test_text.rb

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+
+
+$: << File.dirname(__FILE__)
+
+require 'helpers'
+
+
+class TestText < Test::Unit::TestCase
+
+  LINES = %w[123 456]
+
+  def buffer (str = nil)
+    str = LINES.join("\n") unless str
+    str = str.dup if String === str
+    Spacy::TextBuffer.new str
+  end
+
+  def text ()
+    Spacy::Text.new buffer
+  end
+
+  def test_pos ()
+    lineend = LINES[0].size
+    assert_equal [0, 0],       text.cursor
+    assert_equal [0, 1],       text.tap{|t| t.pos += 1}.cursor
+    assert_equal [0, lineend], text.tap{|t| t.pos = lineend}.cursor
+    assert_equal [1, 0],       text.tap{|t| t.pos = lineend + 1}.cursor
+  end
+
+  def test_cursor ()
+    lineend = LINES[0].size
+    size    = LINES.inject(0) {|n, s| n + s.size + 1} - 1
+    assert_equal lineend, text.tap{|t| t.cursor = 0, lineend}.pos
+    assert_equal size,    text.tap{|t| t.cursor = 1, 4}.pos
+  end
+
+  def test_row ()
+    assert_equal [1, 0], text.tap{|t| t.row += 1}.cursor
+    assert_equal [0, 1], text.tap{|t| t.column += 1}.cursor
+  end
+
+end# TestText

data/test/test_textbuffer.rb

@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+
+
+$: << File.dirname(__FILE__)
+
+require 'helpers'
+
+
+class TestTextBuffer < Test::Unit::TestCase
+
+  LINES = %w[123 456]
+
+  def buffer (str = nil)
+    str = LINES.join("\n") unless str
+    str = str.dup if String === str
+    Spacy::TextBuffer.new str
+  end
+
+  def test_new ()
+    assert_equal LINES.join("\n"), buffer.to_s
+    assert_equal '123', buffer(123).to_s
+  end
+
+  def test_insert ()
+    assert_equal "x123\n456",    buffer.tap{|b| b.insert 0, 'x'}.to_s
+    assert_equal "1x23\n456",    buffer.tap{|b| b.insert 1, 'x'}.to_s
+    assert_equal "123x\n456",    buffer.tap{|b| b.insert 3, 'x'}.to_s
+    assert_equal "123\nx456",    buffer.tap{|b| b.insert 4, 'x'}.to_s
+    assert_equal "1a\nb23\n456", buffer.tap{|b| b.insert 1, "a\nb"}.to_s
+    assert_equal "123\n456x",    buffer.tap{|b| b.insert b.last, 'x'}.to_s
+    assert_raise(RangeError) {buffer.tap{|b| b.insert -1, 'x'}}
+    assert_raise(RangeError) {buffer.tap{|b| b.insert b.last + 1, 'x'}}
+  end
+
+  def test_erase ()
+    assert_equal "23\n456",   buffer.erase(0).to_s
+    assert_equal "123\n456",  buffer.erase(0, 0).to_s
+    assert_equal "23\n456",   buffer.erase(0, 1).to_s
+    assert_equal "3\n456",    buffer.erase(0, 2).to_s
+    assert_equal "\n456",     buffer.erase(0, 3).to_s
+    assert_equal "456",       buffer.erase(0, 4).to_s
+    assert_equal "56",        buffer.erase(0, 5).to_s
+    assert_equal "13\n456",   buffer.erase(1, 2).to_s
+    assert_equal "\n456",     buffer.erase(3, 0).to_s
+    assert_equal "123\n45",   buffer.tap{|b| b.erase b.last - 1}.to_s
+    assert_equal "123\n456",  buffer.tap{|b| b.erase b.last, b.last}.to_s
+    assert_raise(RangeError) {buffer.tap{|b| b.erase -1}}
+    assert_raise(RangeError) {buffer.tap{|b| b.erase b.last}}
+    assert_raise(RangeError) {buffer.tap{|b| b.erase -1, 0}}
+    assert_raise(RangeError) {buffer.tap{|b| b.erase  0, b.last + 1}}
+    assert_raise(RangeError) {buffer.tap{|b| b.erase -1, b.last + 1}}
+  end
+
+  def test_nrow ()
+    assert_equal LINES.size, buffer.nrow
+  end
+
+  def test_ncolumn ()
+    assert_equal LINES[0].size + 1, buffer.ncolumn(0)
+    assert_equal LINES[1].size + 1, buffer.ncolumn(1)
+    assert_raise(RangeError) {buffer.ncolumn(-1)}
+    assert_raise(RangeError) {buffer.ncolumn(2)}
+  end
+
+  def test_last ()
+    assert_equal LINES.join("\n").size, buffer.last
+  end
+
+  def test_to_a ()
+    assert_equal LINES.map{|s| Spacy::TextLine.new s}, buffer.to_a
+  end
+
+  def test_to_s ()
+    assert_equal LINES.join("\n"), buffer.to_s
+    assert_equal '', buffer('').to_s
+  end
+
+  def test_each ()
+    buffer.each.with_index do |line, index|
+      assert_equal LINES[index], line.to_s
+    end
+  end
+
+end# TestTextBuffer

data/test/test_textline.rb

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+
+
+$: << File.dirname(__FILE__)
+
+require 'helpers'
+
+
+class TestTextLine < Test::Unit::TestCase
+
+  LINE = '123'
+
+  def line (str = nil)
+    str = LINE unless str
+    str = str.dup if String === str
+    Spacy::TextLine.new str
+  end
+
+  def test_new ()
+    assert_equal '123', line.to_s
+    assert_equal '123', line(123).to_s
+    assert_raise(ArgumentError) {line "123\n"}
+  end
+
+  def test_insert ()
+    assert_equal 'x123', line.insert('x', 0).to_s
+    assert_equal '1x23', line.insert('x', 1).to_s
+    assert_equal '123x', line.tap{|l| l.insert 'x', l.last}.to_s
+    assert_raise(RangeError)    {line.insert 'x', -1}
+    assert_raise(RangeError)    {line.tap{|l| l.insert 'x', l.last + 1}}
+    assert_raise(ArgumentError) {line.insert "x\n", 0}
+  end
+
+  def test_erase ()
+    assert_equal '23',  line.erase(0).to_s
+    assert_equal '123', line.erase(0, 0).to_s
+    assert_equal '23',  line.erase(0, 1).to_s
+    assert_equal '13',  line.erase(1, 2).to_s
+    assert_equal '',    line.tap{|l| l.erase 0, l.last}.to_s
+    assert_equal '1',   line.tap{|l| l.erase 1, l.last}.to_s
+    assert_equal '',    line.tap{|l| l.erase l.last, 0}.to_s
+    assert_raise(RangeError) {line.erase -1, 0}
+    assert_raise(RangeError) {line.tap{|l| l.erase  0, l.last + 1}}
+    assert_raise(RangeError) {line.tap{|l| l.erase -1, l.last + 1}}
+  end
+
+  def test_ncolumn ()
+    assert_equal LINE.size + 1, line.ncolumn
+  end
+
+  def test_to_s ()
+    assert_equal '123', line.to_s
+    assert_equal '', line('').to_s
+  end
+
+end# TestTextLine

metadata

@@ -0,0 +1,175 @@
+--- !ruby/object:Gem::Specification
+name: spacy
+version: !ruby/object:Gem::Version
+  version: 0.1.4
+  prerelease: 
+platform: ruby
+authors:
+- snori
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: xot
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rays
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: reflexion
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: gemcutter
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A text editor runs on Ruby and uses SPACE as a trigger key for every
+  action.
+email: snori@xord.org
+executables:
+- spacy
+extensions:
+- Rakefile
+extra_rdoc_files: []
+files:
+- .gitignore
+- .gitmodules
+- ChangeLog
+- Gemfile
+- Rakefile
+- VERSION
+- bin/spacy
+- lib/spacy.rb
+- lib/spacy/application.rb
+- lib/spacy/extensions.rb
+- lib/spacy/key.rb
+- lib/spacy/keymap.rb
+- lib/spacy/keystroke.rb
+- lib/spacy/module.rb
+- lib/spacy/text.rb
+- lib/spacy/textbuffer.rb
+- lib/spacy/textline.rb
+- lib/spacy/window.rb
+- spacy.gemspec
+- task/mac.rake
+- task/submodule.rake
+- test/helpers.rb
+- test/test_text.rb
+- test/test_textbuffer.rb
+- test/test_textline.rb
+homepage: http://github.com/xord/spacy
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2855528895130620030
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: A text editor written by Ruby.
+test_files:
+- test/helpers.rb
+- test/test_text.rb
+- test/test_textbuffer.rb
+- test/test_textline.rb