ver 2009.12.14 → 2010.02

data/spec/ver/methods/move.rb

@@ -0,0 +1,150 @@
+require_relative '../../helper'
+
+VER.spec do
+  describe VER::Methods::Move do
+    text = VER.buffers.values.first.text
+    text.delete('1.0', 'end')
+    text.insert('end', "First line\nSecond line\nThird line")
+
+    it 'moves to start of buffer' do
+      text.index(:insert).should == text.index('3.10')
+      VER::Methods::Move.start_of_text(text)
+      text.index(:insert).should == text.index('1.0')
+    end
+
+    it 'moves to next line' do
+      VER::Methods::Move.next_line(text)
+      text.index(:insert).should == text.index('1.0 + 1 displaylines')
+    end
+
+    it 'moves to previous line' do
+      VER::Methods::Move.prev_line(text)
+      text.index(:insert).should == text.index('1.0')
+    end
+
+    it 'moves to next char' do
+      VER::Methods::Move.next_char(text)
+      text.index(:insert).should == text.index('1.1')
+    end
+
+    it 'moves to prev char' do
+      VER::Methods::Move.prev_char(text)
+      text.index(:insert).should == text.index('1.0')
+    end
+
+    it 'moves to next word' do
+      text.value = 'one two'
+      text.mark_set(:insert, '1.0')
+      text.get('insert', 'insert lineend').should == 'one two'
+
+      VER::Methods::Move.next_word(text)
+      text.get('insert', 'insert lineend').should == 'two'
+
+      VER::Methods::Move.next_word(text)
+      text.get('insert', 'insert lineend').should == ''
+    end
+
+    it 'moves to previous word' do
+      text.value = 'one two'
+      text.mark_set(:insert, 'end')
+      text.get('insert', 'insert lineend').should == ''
+
+      VER::Methods::Move.prev_word(text)
+      text.get('insert', 'insert lineend').should == 'two'
+
+      VER::Methods::Move.prev_word(text)
+      text.get('insert', 'insert lineend').should == 'one two'
+
+      VER::Methods::Move.prev_word(text)
+      text.get('insert', 'insert lineend').should == 'one two'
+    end
+
+    it 'jumps to matching brace in (foo)' do
+      text.value = "(foo)"
+      text.mark_set(:insert, '1.0') # -> (foo
+
+      VER::Methods::Move.matching_brace(text, 1)
+      text.get('insert', 'insert lineend').should == ')'
+      text.index(:insert).should == text.index('1.4') # foo) <-
+
+      VER::Methods::Move.matching_brace(text, 1)
+      text.get('insert', 'insert lineend').should == '(foo)'
+      text.index(:insert).should == text.index('1.0') # -> (foo
+    end
+
+    it 'jumps to matching braces in (foo (bar))' do
+      text.value = "(foo (bar))"
+      text.mark_set(:insert, '1.0') # -> (foo
+
+      VER::Methods::Move.matching_brace(text, 1)
+      text.get('insert', 'insert lineend').should == ')'
+      text.index(:insert).should == text.index('1.10') # bar)) <-
+
+      VER::Methods::Move.matching_brace(text, 1)
+      text.get('insert', 'insert lineend').should == '(foo (bar))'
+      text.index(:insert).should == text.index('1.0') # -> (foo
+
+      text.mark_set(:insert, '1.5') # (bar
+      text.get('insert', 'insert lineend').should == '(bar))'
+
+      VER::Methods::Move.matching_brace(text, 1)
+      text.get('insert', 'insert lineend').should == '))'
+      text.index(:insert).should == text.index('1.9') # bar) <-
+
+      VER::Methods::Move.matching_brace(text, 1)
+      text.get('insert', 'insert lineend').should == '(bar))'
+      text.index(:insert).should == text.index('1.5') # -> (bar
+    end
+
+    it 'jumps to matching braces in (a (b (c (d))))' do
+      text.value = "(a (b (c (d))))"
+      text.mark_set(:insert, '1.0')
+      text.get('insert', 'insert lineend').should == '(a (b (c (d))))'
+
+
+      VER::Methods::Move.matching_brace(text, 1)
+      text.get('insert', 'insert lineend').should == ')'
+      text.index(:insert).should == text.index('1.14')
+
+      VER::Methods::Move.matching_brace(text, 1)
+      text.get('insert', 'insert lineend').should == '(a (b (c (d))))'
+      text.index(:insert).should == text.index('1.0')
+
+
+      text.mark_set(:insert, '1.3')
+      text.get('insert', 'insert lineend').should == '(b (c (d))))'
+
+      VER::Methods::Move.matching_brace(text, 1)
+      text.get('insert', 'insert lineend').should == '))'
+      text.index(:insert).should == text.index('1.13')
+
+      VER::Methods::Move.matching_brace(text, 1)
+      text.get('insert', 'insert lineend').should == '(b (c (d))))'
+      text.index(:insert).should == text.index('1.3')
+
+
+      text.mark_set(:insert, '1.6')
+      text.get('insert', 'insert lineend').should == '(c (d))))'
+
+      VER::Methods::Move.matching_brace(text, 1)
+      text.get('insert', 'insert lineend').should == ')))'
+      text.index(:insert).should == text.index('1.12')
+
+      VER::Methods::Move.matching_brace(text, 1)
+      text.get('insert', 'insert lineend').should == '(c (d))))'
+      text.index(:insert).should == text.index('1.6')
+
+
+      text.mark_set(:insert, '1.9')
+      text.get('insert', 'insert lineend').should == '(d))))'
+
+      VER::Methods::Move.matching_brace(text, 1)
+      text.get('insert', 'insert lineend').should == '))))'
+      text.index(:insert).should == text.index('1.11')
+
+      VER::Methods::Move.matching_brace(text, 1)
+      text.get('insert', 'insert lineend').should == '(d))))'
+      text.index(:insert).should == text.index('1.9')
+    end
+  end
+end

data/spec/ver/minor_mode.rb

@@ -0,0 +1,90 @@
+require_relative '../helper'
+
+MinorMode = VER::MinorMode
+Keymap = VER::Keymap
+
+VER.spec do
+  describe VER::MinorMode do
+    before do
+      MinorMode.clear
+    end
+
+    it 'has a name' do
+      mode = MinorMode[:spec]
+      mode.name.should == :spec
+    end
+
+    it 'has no parents at first' do
+      mode = MinorMode[:spec]
+      mode.parents.should.be.empty
+    end
+
+    it 'can depend on another minor mode' do
+      control = MinorMode[:control]
+      movement = MinorMode[:movement]
+      control.inherits(:movement)
+
+      control.parents.should == [movement]
+    end
+
+    it 'looks up key-sequences in the inheritance chain' do
+      control = MinorMode[:control]
+      movement = MinorMode[:movement]
+      movement.map(:next_line, ['j'])
+      control.map(:quit, ['q'])
+      control.inherits(:movement)
+
+      action_mode, action = control.resolve(['q'])
+      action_mode.should == control
+      action.method.should == :quit
+
+      action_mode, action = control.resolve(['j'])
+      action_mode.should == movement
+      action.method.should == :next_line
+    end
+
+    it 'indicates whether a sequence can be found' do
+      control = MinorMode[:control]
+      control.map(:quit, ['Z', 'Z'])
+
+      action_mode, action = control.resolve(['Z', 'Z'])
+      action_mode.should == control
+      action.method.should == :quit
+
+      control.resolve(['Z']).should.be.kind_of Keymap::Results::Incomplete
+      control.resolve(['X']).should.be.kind_of Keymap::Results::Impossible
+    end
+
+    it 'may have a fallback that is returned on Impossible results' do
+      mode = MinorMode[:spec]
+      mode.map(:kill_word, ['d', 'w'])
+      mode.missing(:insert)
+
+      action_mode, action = mode.resolve(['d', 'w'])
+      action.method.should == :kill_word
+
+      action_mode, action = mode.resolve(['y'])
+      action.method.should == :insert
+    end
+
+    it "can do lookup spanning multiple minor modes" do
+      move = MinorMode[:move]
+      move.map(:next_line, ['j'])
+      move.map(:prev_line, ['k'])
+      kill = MinorMode[:kill]
+      kill.map(:kill_line, ['d', 'd'])
+      kill.map(:kill_motion, ['d', :move])
+      control = MinorMode[:control]
+      control.inherits :move, :kill
+
+      action_mode, action = control.resolve(['d', 'd'])
+      action_mode.should == kill
+      action.method.should == :kill_line
+
+      action_mode, action = control.resolve(['d', 'j'])
+      action_mode.should == kill
+      action.method.should == :kill_motion
+      action.args.first.method.should == :next_line
+    end
+  end
+end

data/spec/ver/plugin/smart_autoindent.rb

@@ -0,0 +1,276 @@
+require_relative '../../helper'
+require 'ffi-tk'
+
+class SpecText < Tk::Text
+  attr_accessor :syntax
+
+  def options
+    VER.options
+  end
+
+  def load_preferences
+    true
+  end
+
+  def preferences
+    eval(File.read("config/preferences/#{syntax}.rb"))
+  end
+end
+
+# NOTE: do _not_ remove trailing whitespace in this file, it's essential.
+
+VER.spec do
+  require 'config/plugin/smart_autoindent'
+
+  describe VER::Methods::SmartAutoindent do
+    describe 'insert indented newline' do
+      Indent = VER::Methods::SmartAutoindent
+
+      def fake_input(text, string)
+        string.each_line.with_index do |line, index|
+          puts " #{line.lstrip.inspect} ".center(80, '-') if $DEBUG
+          Indent.newline(text) unless index == 0
+          text.insert :insert, line.chomp.lstrip
+          puts text.value.gsub(/^( +)(.*)$/, "\e[41m\\1\e[0m\\2") if $DEBUG
+        end
+      end
+
+      def check(syntax, code)
+        text = SpecText.new
+        text.syntax = syntax
+        fake_input(text, code)
+        if $DEBUG
+          puts " <result> ".center(80, '*')
+          puts text.value.gsub(/^( +)(.*)$/, "\e[41m\\1\e[0m\\2")
+          puts " </result> ".center(80, '*')
+          puts " <original> ".center(80, '*')
+          puts code.gsub(/^( +)(.*)$/, "\e[41m\\1\e[0m\\2")
+          puts " </original> ".center(80, '*')
+        end
+        text.value.chomp.should == code.chomp
+      ensure
+        text.destroy
+      end
+
+      def with_text(syntax)
+        text = SpecText.new
+        text.syntax = syntax
+        yield text
+        text.value.chomp
+      ensure
+        text.destroy
+      end
+
+      it 'indents by simple rules' do
+        # the end will be ok once next newline is entered
+        check(:Ruby, <<-RUBY)
+class Foo
+  def bar
+  end
+  end
+        RUBY
+      end
+
+      it 'indents deeper' do
+        check(:Ruby, <<-RUBY)
+class Foo
+  def bar
+    if foo
+      bar
+    else
+      foobar
+    end
+  end
+end
+        RUBY
+      end
+
+      it 'indents with empty lines' do
+        check(:Ruby, <<-RUBY)
+class Foo
+  def bar
+    return 1 if foo
+
+    x = foobar * 2
+    y = foobar / 2
+
+    # maybe some comment here
+    # that should not affect anything
+
+    return x * y
+  end
+end
+        RUBY
+      end
+
+      it 'indents partial already' do
+        check(:Ruby, <<-RUBY)
+class Foo
+  def bar
+        RUBY
+      end
+
+      it 'indents next line at start of buffer' do
+        check(:Ruby, <<-RUBY)
+class Foo
+  
+        RUBY
+      end
+
+      it 'indents an empty case statement' do
+        check(:Ruby, <<-RUBY)
+case foo
+when bar
+when foobar
+else
+end
+        RUBY
+      end
+
+      it 'indents a filled case statement' do
+        check(:Ruby, <<-RUBY)
+case foo
+when bar
+  stuff
+when foobar
+  more stuff
+else
+  other stuff
+  end
+        RUBY
+      end
+
+      it 'indents an if/elsif/else statement' do
+        # the end will be ok once next newline is entered
+        check(:Ruby, <<-RUBY)
+if 1 == 2
+  a
+elsif 2 == 3
+  b
+elsif 4 == 5
+  c
+else
+  d
+  end
+        RUBY
+      end
+
+      it 'indents some block structures' do
+        # the end will be ok once next newline is entered
+        check(:Ruby, <<-RUBY)
+[1,2,3].each do |element|
+  p element
+end
+
+[1,2,3].each{|element|
+  p element
+}
+
+loop do
+  puts "Hello, World!"
+end
+
+while ok
+  puts "I'm fine"
+  end
+        RUBY
+      end
+
+      it 'indents begin/rescue/else/end' do
+        # the end will be ok once next newline is entered
+        check(:Ruby, <<-RUBY)
+begin
+  foo
+rescue
+  bar
+else
+  foobar
+  end
+        RUBY
+      end
+
+      it 'indents rescue in a method' do
+        # the end will be ok once next newline is entered
+        check(:Ruby, <<-RUBY)
+class Foo
+  def bar
+    some stuff
+  rescue => ex
+    p ex
+  else
+    p :ok
+  end
+end
+        RUBY
+      end
+
+      it 'indents after a nested block' do
+        # the end will be ok once next newline is entered
+        check(:Ruby, <<-RUBY)
+module VER
+  major_mode :Fundamental do
+    stuff do
+    end
+    
+        RUBY
+      end
+
+      it 'indents nested module/class/method' do
+        # the end will be ok once next newline is entered
+        check(:Ruby, <<-'RUBY')
+# the best editor since ed
+module VER
+  # a module for modules with methods
+  module Methods
+    # the module handles indentation
+    module Indent
+      class << self
+        # just a newline for fun and profit, and it needs so many specs?
+        def insert_newline(text)
+          stuff.each do |thing|
+            for thang in thing do
+              p thang
+            end
+          end
+        end
+
+        # another method to make this look nicer
+        def another_method
+          stuff
+        rescue => exception
+          case exception.message
+          when 'hi'
+            puts "hi there too"
+          else
+            size = exception.backtrace.inject 0 do |sum, line|
+              sum + line.size
+            end
+            puts("Whoa, an exception with #{size} chars" \
+            ", wouldn't you die to know what it was?")
+          end
+        end
+      end
+    end
+  end
+end
+        RUBY
+      end
+
+      it 'indents after a nested block' do
+        # the end will be ok once next newline is entered
+        check(:newLisp, <<-LISP)
+(if (= 1 2)
+  (+ 1 3))
+LISP
+      end
+
+      it 'inserts newlines in the middle of a line' do
+        with_text(:Ruby){|text|
+          text.insert :insert, "one two"
+          text.mark_set :insert, '4.0'
+          Indent.newline(text)
+        }.should == "one\ntwo"
+      end
+    end
+  end
+end