ruco 0.2.18 → 0.2.19

data/spec/ruco/option_accessor_spec.rb

@@ -1,26 +0,0 @@
-require "spec_helper"
-
-describe Ruco::OptionAccessor do
-  let(:options){ Ruco::OptionAccessor.new }
-
-  it "can be accessed like a hash" do
-    options[:xx].should == nil
-    options[:xx] = 1
-    options[:xx].should == 1
-  end
-
-  it "can be written" do
-    options.foo = true
-    options[:foo].should == true
-  end
-
-  it "can access nested keys" do
-    options.foo_bar = 1
-    options.history_size = 1
-    options.nested(:history).should == {:size => 1}
-  end
-
-  it "has empty hash for nested key" do
-    options.nested(:history).should == {}
-  end
-end

data/spec/ruco/screen_spec.rb

@@ -1,52 +0,0 @@
-require "spec_helper"
-
-describe Ruco::Screen do
-  describe :curses_style do
-    it "is 'normal' for nothing" do
-      Ruco::Screen.curses_style(:normal, true).should == 256
-    end
-
-    it "is red for red" do
-      pending
-      Ruco::Screen.curses_style(:red, true).should == Curses::color_pair( Curses::COLOR_RED )
-    end
-
-    it "is reverse for reverse" do
-      Ruco::Screen.curses_style(:reverse, true).should == 512
-    end
-
-    it "raises on unknown style" do
-      lambda{
-        Ruco::Screen.curses_style(:foo, true)
-      }.should raise_error
-    end
-
-    describe 'without colors' do
-      it "is 'normal' for normal" do
-        Ruco::Screen.curses_style(:normal, false).should == Curses::A_NORMAL
-      end
-
-      it "is reverse for reverse" do
-        Ruco::Screen.curses_style(:reverse, false).should == Curses::A_REVERSE
-      end
-
-      it "is normal for unknown style" do
-        Ruco::Screen.curses_style(:foo, false).should == Curses::A_NORMAL
-      end
-    end
-  end
-
-  describe :html_to_terminal_color do
-    # http://www.mudpedia.org/wiki/Xterm_256_colors
-    [
-      ['#ff0000', 196],
-      ['#00ff00', 46],
-      ['#0000ff', 21],
-      ['#ffffff', 231]
-    ].each do |html,term|
-      it "converts #{html} to #{term}" do
-        Ruco::Screen.html_to_terminal_color(html).should == term
-      end
-    end
-  end
-end

data/spec/ruco/status_bar_spec.rb

@@ -1,49 +0,0 @@
-require "spec_helper"
-
-describe Ruco::StatusBar do
-  let(:file){ 'spec/temp.txt' }
-  let(:editor){ Ruco::Editor.new(file, :lines => 5, :columns => 35) }
-  let(:bar){ Ruco::StatusBar.new(editor, :columns => 35) }
-
-  it "shows name and version" do
-    bar.view.should include("Ruco #{Ruco::VERSION}")
-  end
-
-  it "shows the file" do
-    bar.view.should include(file)
-  end
-
-  it "can show to long files" do
-    editor = Ruco::Editor.new('123456789abcdefghijklmnop', :lines => 5, :columns => 20)
-    bar = Ruco::StatusBar.new(editor, :columns => 30)
-    bar.view.should == "Ruco #{Ruco::VERSION} -- 1234...nop   1:1"
-    bar.view.size.should == 30
-  end
-
-  it "indicates modified" do
-    bar.view.should_not include('*')
-    editor.insert('x')
-    bar.view.should include('*')
-  end
-
-  it "indicates writable" do
-    bar.view.should_not include('!')
-  end
-
-  it "indicates writable if file is missing" do
-    editor.stub!(:file).and_return '/gradasadadsds'
-    bar.view.should_not include('!')
-  end
-
-  it "indicates not writable" do
-    # this test will always fail on Windows with cygwin because of how cygwin sets up permissions
-    unless RUBY_PLATFORM =~ /mingw/
-      editor.stub!(:file).and_return '/etc/sudoers'
-      bar.view.should include('!')
-    end
-  end
-
-  it "shows line and column and right side" do
-    bar.view.should =~ /1:1$/
-  end
-end

data/spec/ruco/style_map_spec.rb

@@ -1,124 +0,0 @@
-require "spec_helper"
-
-describe Ruco::StyleMap do
-  let(:map){ Ruco::StyleMap.new(3) }
-
-  describe :flat do
-    it "is empty by default" do
-      map.flatten.should == [nil, nil, nil]
-    end
-
-    it "reproduces simple styles" do
-      map.add(:red, 1, 3..5)
-      # red from 3 to 5
-      map.flatten.should == [
-        nil,
-        [nil, nil, nil, :red, nil, nil, :normal],
-        nil
-      ]
-    end
-
-    it "reproduces merged styles" do
-      map.add(:reverse, 1, 2..4)
-      map.add(:red, 1, 3..5)
-      # reverse at 2 -- reverse and red at 3,4 -- red at 5
-      map.flatten.should == [
-        nil,
-        [nil, nil, :reverse, :red, nil, :red, :normal],
-        nil
-      ]
-    end
-
-    it "reproduces styles with same style repeated" do
-      map.add(:red, 1, 2..4)
-      map.add(:red, 1, 6..7)
-      # red 2,3,4 normal on 5 red on 6,7
-      map.flatten.should == [
-        nil,
-        [nil, nil, :red, nil, nil, :normal, :red, nil, :normal],
-        nil
-      ]
-    end
-
-    it "overwrites styles" do
-      map.add(:reverse, 0, 0..1)
-      map.add(:normal, 0, 0..1)
-      map.flatten.should == [
-        [:normal, nil, :normal],
-        nil,
-        nil
-      ]
-    end
-  end
-
-  describe 'array style operations' do
-    it "adds two maps" do
-      s1 = Ruco::StyleMap.new(1)
-      s1.add(:reverse, 0, 0..1)
-      s2 = Ruco::StyleMap.new(2)
-      s2.add(:reverse, 0, 2..3)
-      (s1 + s2).flatten.should == [
-        [:reverse, nil, :normal],
-        [nil, nil, :reverse, nil, :normal],
-        nil
-      ]
-    end
-
-    it "can shift" do
-      s = Ruco::StyleMap.new(2)
-      s.add(:reverse, 0, 0..1)
-      s.add(:reverse, 1, 1..2)
-      s.shift.flatten.should == [[:reverse, nil, :normal]]
-      s.flatten.should == [[nil, :reverse, nil, :normal]]
-    end
-
-    it "can pop" do
-      s = Ruco::StyleMap.new(2)
-      s.add(:reverse, 0, 0..1)
-      s.add(:reverse, 1, 1..2)
-      s.pop.flatten.should == [[nil, :reverse, nil, :normal]]
-      s.flatten.should == [[:reverse, nil, :normal]]
-    end
-  end
-
-  describe :left_pad! do
-    it "adds whitespace to left side" do
-      s = Ruco::StyleMap.new(2)
-      s.add(:reverse, 0, 0..1)
-      s.add(:reverse, 1, 1..2)
-      s.left_pad!(3)
-      s.flatten.should == [
-        [nil, nil, nil, :reverse, nil, :normal],
-        [nil, nil, nil, nil, :reverse, nil, :normal]
-      ]
-    end
-  end
-
-  describe :invert! do
-    it "inverts styles" do
-      s = Ruco::StyleMap.new(2)
-      s.add(:reverse, 0, 0..1)
-      s.add(:normal, 1, 1..2)
-      s.add(:red, 1, 4..5)
-      s.invert!
-      s.flatten.should == [
-        [:normal, nil, :normal],
-        [nil, :reverse, nil, :normal, :red, nil, :normal]
-      ]
-    end
-  end
-
-  describe :styled do
-    it "can style an unstyled line" do
-      Ruco::StyleMap.styled("a", nil).should == [[:normal, "a"]]
-    end
-
-    it "can style a styled line" do
-      Ruco::StyleMap.styled("a", [:reverse ,nil]).should == [[:normal, ""], [:reverse, "a"]]
-    end
-
-    it "keeps unstyled parts" do
-      Ruco::StyleMap.styled("abc", [:reverse, :normal]).should == [[:normal, ""], [:reverse, "a"],[:normal,'bc']]
-    end
-  end
-end

data/spec/ruco/syntax_parser_spec.rb

@@ -1,78 +0,0 @@
-require "spec_helper"
-
-describe Ruco::SyntaxParser do
-  def parse(text, languages=['ruby'])
-    Ruco::SyntaxParser.syntax_for_lines(text, languages)
-  end
-
-  describe :parse_lines do
-    it "shows positions for simple lines" do
-      parse(["class Foo","end"]).should == [[
-        ["keyword.control.class.ruby", 0...5],
-        ["entity.name.type.class.ruby", 6...9],
-        ["meta.class.ruby", 0...9]],
-        [["keyword.control.ruby", 0...3]
-      ]]
-    end
-
-    it "shows positions for complicated lines" do
-      parse(["class foo end blob else Foo"]).should == [[
-        ["keyword.control.class.ruby", 0...5],
-        ["entity.name.type.class.ruby", 6...9],
-        ["meta.class.ruby", 0...9],
-        ["keyword.control.ruby", 10...13],
-        ["keyword.control.ruby", 19...23],
-        ["variable.other.constant.ruby", 24...27]
-      ]]
-    end
-
-    it "does not show keywords in strings" do
-      parse(["Bar 'Bar' foo"]).should == [[
-        ["variable.other.constant.ruby", 0...3],
-        ["punctuation.definition.string.begin.ruby", 4...5],
-        ["punctuation.definition.string.end.ruby", 8...9],
-        ["string.quoted.single.ruby", 4...9]
-      ]]
-    end
-
-    it "does not show strings in comments" do
-      parse(["'Bar' # 'Bar'"]).should == [[
-        ["punctuation.definition.string.begin.ruby", 0...1],
-        ["punctuation.definition.string.end.ruby", 4...5],
-        ["string.quoted.single.ruby", 0...5],
-        ["punctuation.definition.comment.ruby", 6...7],
-        ["comment.line.number-sign.ruby", 6...13]
-      ]]
-    end
-
-    it "shows multiline comments" do
-      parse(["=begin","1 : 2","=end"]).should == [
-        [["punctuation.definition.comment.ruby", 0...6], ["comment.block.documentation.ruby", 0...7]],
-        [["comment.block.documentation.ruby", 0...6]],
-        [["punctuation.definition.comment.ruby", 0...4], ["comment.block.documentation.ruby", 0...4]]
-      ]
-    end
-
-    it "continues multiline on last line before closing it" do
-      parse(["%Q{\n\na  }"]).should == [
-        [["punctuation.definition.string.begin.ruby", 0...3], ["string.quoted.double.ruby.mod", 0...4]],
-        [["string.quoted.double.ruby.mod", 0...1]],
-        [["punctuation.definition.string.end.ruby", 3...4], ["string.quoted.double.ruby.mod", 0...4]]
-      ]
-    end
-
-    it "can handle unfound syntaxes" do
-      parse('aaaa', ['fooo']).should == []
-    end
-
-    it "can handle RegexpErrors" do
-      parse(["(?# 2:  NIL     )(NIL)(?=[\\x80-\\xff(){ \\x00-\\x1f\\x7f%*\#{'\"'}\\\\\\[\\]+])|\\"])
-    end
-  end
-
-  describe :syntax_nodes do
-    it "detects languages not present in ultraviolet" do
-      Ruco::SyntaxParser.syntax_node(['html+erb']).should_not == nil
-    end
-  end
-end

data/spec/ruco/text_area_spec.rb

@@ -1,183 +0,0 @@
-# encoding: utf-8
-require "spec_helper"
-
-describe Ruco::TextArea do
-  describe :move do
-    describe 'pages' do
-      it "can move down a page" do
-        text = Ruco::TextArea.new("1\n2\n3\n4\n5\n6\n7\n8\n9\n", :lines => 3, :columns => 3)
-        text.move(:page_down)
-        text.view.should == "3\n4\n5"
-        text.cursor.should == [1,0]
-      end
-
-      it "keeps cursor position when moving down" do
-        text = Ruco::TextArea.new("1\n2abc\n3\n4\n5ab\n6\n7\n8\n9\n", :lines => 3, :columns => 5)
-        text.move(:to, 1,4)
-        text.move(:page_down)
-        text.view.should == "4\n5ab\n6"
-        text.cursor.should == [1,3]
-      end
-
-      it "can move up a page" do
-        text = Ruco::TextArea.new("0\n1\n2\n3\n4\n5\n6\n7\n8\n", :lines => 3, :columns => 3)
-        text.move(:to, 4, 0)
-        text.view.should == "3\n4\n5"
-        text.cursor.should == [1,0]
-        text.move(:page_up)
-        text.view.should == "0\n1\n2"
-        text.cursor.should == [1,0]
-      end
-
-      it "keeps column position when moving up" do
-        text = Ruco::TextArea.new("0\n1\n2ab\n3\n4\n5abc\n6\n7\n8\n9\n10\n11\n", :lines => 3, :columns => 5)
-        text.move(:to, 5, 3)
-        text.view.should == "4\n5abc\n6"
-        text.cursor.should == [1,3]
-        text.move(:page_up)
-        text.view.should == "1\n2ab\n3"
-        text.cursor.should == [1,3]
-      end
-
-      it "moves pages symetric" do
-        text = Ruco::TextArea.new("0\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0\n", :lines => 3, :columns => 3)
-        text.move(:to, 4, 1)
-        text.view.should == "3\n4\n5"
-        text.cursor.should == [1,1]
-
-        text.move(:page_down)
-        text.move(:page_down)
-        text.move(:page_up)
-        text.move(:page_up)
-
-        text.cursor.should == [1,1]
-        text.view.should == "3\n4\n5"
-      end
-    end
-  end
-
-  describe :insert do
-    let(:text){Ruco::TextArea.new("", :lines => 3, :columns => 10)}
-
-    describe "inserting surrounding characters" do
-      xit "does nothing special when pasting" do
-        text.insert("'bar'")
-        text.view.should == "'bar'\n\n"
-        text.cursor.should == [0,5]
-      end
-
-      xit "inserts a pair when just typing" do
-        text.insert("'")
-        text.view.should == "''\n\n"
-        text.cursor.should == [0,1]
-      end
-
-      xit "closes the surround if only char in surround" do
-        text.insert("'")
-        text.insert("'")
-        text.view.should == "''\n\n"
-        text.cursor.should == [0,2]
-      end
-
-      xit "overwrites next if its the same" do
-        text.insert("'bar'")
-        text.move(:relative, 0,-1)
-        text.insert("'")
-        text.view.should == "'bar'\n\n"
-        text.cursor.should == [0,5]
-      end
-
-      it "surrounds text when selecting" do
-        text.insert('bar')
-        text.move(:to, 0,0)
-        text.selecting{ move(:to, 0,2) }
-        text.insert("{")
-        text.view.should == "{ba}r\n\n"
-        text.cursor.should == [0,4]
-      end
-
-      it "does not surround text with closing char when selecting" do
-        text.insert('bar')
-        text.move(:to, 0,0)
-        text.selecting{ move(:to, 0,2) }
-        text.insert("}")
-        text.view.should == "}r\n\n"
-        text.cursor.should == [0,1]
-      end
-
-      it "replaces surrounding quotes" do
-        text.insert('"bar"')
-        text.move(:to, 0,0)
-        text.selecting{ move(:to, 0,5) }
-        text.insert("'")
-        text.view.should == "'bar'\n\n"
-        text.cursor.should == [0,5]
-      end
-
-      it "replace surrounding braces" do
-        text.insert('(bar)')
-        text.move(:to, 0,0)
-        text.selecting{ move(:to, 0,5) }
-        text.insert("'")
-        text.view.should == "'bar'\n\n"
-        text.cursor.should == [0,5]
-      end
-
-      it "does not replace when only one side has surrounding char" do
-        text.insert("\"bar\"")
-        text.move(:to, 0,0)
-        text.selecting{ move(:to, 0,3) }
-        text.insert("'")
-        text.view.should == "'\"ba'r\"\n\n"
-        text.cursor.should == [0,5]
-      end
-
-      it "expands selection when surrounding" do
-        text.insert('bar')
-        text.move(:to, 0,0)
-        text.selecting{ move(:to, 0,2) }
-        text.insert("{")
-        text.view.should == "{ba}r\n\n"
-        text.selection.should == ([0,0]..[0,4])
-      end
-
-      it "keeps selection when replacing surround" do
-        text.insert('"bar"')
-        text.move(:to, 0,0)
-        text.selecting{ move(:to, 0,5) }
-        text.insert("'")
-        text.view.should == "'bar'\n\n"
-        text.selection.should == ([0,0]..[0,5])
-      end
-
-      it "surrounds across lines" do
-        text.insert("ab\ncd\nef")
-        text.move(:to, 0,0)
-        text.selecting{ move(:to, 1,0) }
-        text.insert("'")
-        text.view.should == "'ab\n'cd\nef"
-        text.selection.should == ([0,0]..[1,1])
-      end
-    end
-  end
-
-  if ''.respond_to?(:encoding)
-    describe "encoding" do
-      def build(encoding)
-        Ruco::TextArea.new("asd".force_encoding(encoding), :lines => 3, :columns => 10)
-      end
-
-      it "upgrades ascii-8 to utf8" do
-        build('ASCII-8BIT').lines.first.encoding.to_s.should == 'UTF-8'
-      end
-
-      it "upgrades ascii-7 to utf8" do
-        build('US-ASCII').lines.first.encoding.to_s.should == 'UTF-8'
-      end
-
-      it "does not convert weird encodings to utf-8" do
-        build('eucJP').lines.first.encoding.to_s.should == 'EUC-JP'
-      end
-    end
-  end
-end