ruco 0.2.18 → 0.2.19

data/spec/ruco/file_store_spec.rb

@@ -1,102 +0,0 @@
-require "spec_helper"
-
-describe Ruco::FileStore do
-  def mark_all_as_old
-    store.send(:entries).each{|e| File.utime(1,1,e) }
-  end
-
-  before do
-    @folder = 'spec/sessions'
-    `rm -rf #{@folder}`
-  end
-
-  after do
-    `rm -rf #{@folder}`
-  end
-
-  let(:store){ Ruco::FileStore.new(@folder, :keep => 3) }
-
-  it "can get unstored stuff" do
-    store.get('xxx').should == nil
-  end
-
-  it "can store stuff" do
-    store.set('xxx', 1)
-    store.get('xxx').should == 1
-  end
-
-  it "can store :keep keys" do
-    store.set('xxx', 1)
-    store.set('yyy', 1)
-    store.set('zzz', 1)
-    mark_all_as_old
-    store.set('aaa', 2)
-    store.get('aaa').should == 2
-    ['xxx','yyy','zzz'].map{|f| store.get(f) }.should =~ [1,1,nil]
-  end
-
-  it "does not drop if used multiple times" do
-    store.set('xxx', 1)
-    store.set('yyy', 1)
-    store.set('zzz', 1)
-    store.set('zzz', 1)
-    mark_all_as_old
-    store.set('zzz', 1)
-    store.set('zzz', 1)
-    store.get('xxx').should == 1
-  end
-
-  it "can cache" do
-    store.cache('x'){ 1 }.should == 1
-    store.cache('x'){ 2 }.should == 1
-  end
-
-  it "can cache false" do
-    store.cache('x'){ false }.should == false
-    store.cache('x'){ 2 }.should == false
-  end
-
-  it "does not cache nil" do
-    store.cache('x'){ nil }.should == nil
-    store.cache('x'){ 2 }.should == 2
-  end
-
-  it "can delete" do
-    store.set('x', 1)
-    store.set('y', 2)
-    store.delete('x')
-    store.get('x').should == nil
-    store.get('y').should == 2
-  end
-
-  it "can delete uncached" do
-    store.set('x', 1)
-    store.delete('z')
-    store.get('x').should == 1
-    store.get('z').should == nil
-  end
-
-  it "can clear" do
-    store.set('x', 1)
-    store.clear
-    store.get('x').should == nil
-  end
-
-  it "can clear unstored" do
-    store.clear
-    store.get('x').should == nil
-  end
-
-  it "can store pure strings" do
-    store = Ruco::FileStore.new(@folder, :keep => 3, :string => true)
-    store.set('xxx','yyy')
-    File.read(store.file('xxx')).should == 'yyy'
-    store.get('xxx').should == 'yyy'
-  end
-
-  it "works without colors" do
-    store = Ruco::FileStore.new(@folder)
-    store.set('xxx',1)
-    store.get('xxx').should == 1
-  end
-end

data/spec/ruco/form_spec.rb

@@ -1,83 +0,0 @@
-require "spec_helper"
-
-describe Ruco::Form do
-  let(:form){ Ruco::Form.new('Test', :columns => 30){|value| @result = value } }
-
-  it "positions cursor in text field" do
-    form.cursor.should == [0, 5]
-  end
-
-  describe :insert do
-    it "adds label size and input size" do
-      form.insert('abc')
-      form.cursor.should == [0, 8]
-    end
-
-    it "does not return result on normal insert" do
-      form.insert('abc')
-      @result.should == nil
-    end
-
-    it "returns result on enter" do
-      form.insert('abc')
-      form.insert("d\n")
-      @result.should == "abcd"
-    end
-
-    it "returns result on normal insert when auto_enter is given" do
-      form.instance_eval{ @options[:auto_enter] = true }
-      form.insert('a')
-      @result.should == 'a'
-    end
-  end
-
-  describe :move do
-    it "moves in text-field" do
-      form.insert('abc')
-      form.move(:relative, 0, -1)
-      form.cursor.should == [0,7]
-    end
-
-    it "cannot move out of left side" do
-      form.move(:relative, 0, -3)
-      form.cursor.should == [0,5]
-    end
-
-    it "cannot move out of right side" do
-      form.move(:relative, 0, 4)
-      form.cursor.should == [0,5]
-      form.insert('abc')
-      form.move(:relative, 0, 4)
-      form.cursor.should == [0,8]
-    end
-  end
-
-  describe :delete do
-    it "removes characters forward" do
-      form.insert('abc')
-      form.move(:relative, 0, -2)
-      form.delete(1)
-      form.view.should == 'Test ac' 
-    end
-
-    it "removes characters backward" do
-      form.insert('abc')
-      form.move(:relative, 0, -1)
-      form.delete(-1)
-      form.view.should == 'Test ac'
-    end
-
-    it "moves the cursor backward" do
-      form.insert('abc')
-      form.move(:relative, 0, -1)
-      form.delete(-1)
-      form.cursor.should == [0,6]
-    end
-  end
-
-  describe :view do
-    it "can be viewed" do
-      form.view.should == "Test "
-    end
-  end
-end

data/spec/ruco/history_spec.rb

@@ -1,143 +0,0 @@
-require "spec_helper"
-
-describe Ruco::History do
-  let(:history){ Ruco::History.new(:state => {:x => 1}, :track => [:x], :entries => 3) }
-
-  it "knows its state" do
-    history.state.should == {:x => 1}
-  end
-
-  it "can add a state" do
-    history.add :x => 2
-    history.state.should == {:x => 2}
-  end
-
-  it "can undo a state" do
-    history.add :x => 2
-    history.undo
-    history.state.should == {:x => 1}
-  end
-
-  it "can undo-redo-undo a state" do
-    history.add :x => 2
-    history.undo
-    history.redo
-    history.state.should == {:x => 2}
-  end
-
-  it "cannot redo a modified stack" do
-    history.add :x => 2
-    history.undo
-    history.add :x => 3
-    history.redo
-    history.state.should == {:x => 3}
-    history.redo
-    history.state.should == {:x => 3}
-  end
-
-  it "cannot undo into nirvana" do
-    history.add :x => 2
-    history.undo
-    history.undo
-    history.state.should == {:x => 1}
-  end
-
-  it "cannot redo into nirvana" do
-    history.add :x => 2
-    history.redo
-    history.state.should == {:x => 2}
-  end
-
-  it "cannot undo unimportant changes" do
-    history.add(:x => 1, :y => 1)
-    history.undo
-    history.state.should == {:x => 1}
-  end
-
-  it "tracks unimportant fields when an important one changes" do
-    history.add(:x => 2, :y => 1)
-    history.add(:x => 3)
-    history.undo
-    history.state.should == {:x => 2, :y => 1}
-    history.undo
-    history.state.should == {:x => 1}
-  end
-
-  it "does not track more than x states" do
-    history.add(:x => 2)
-    history.add(:x => 3)
-    history.add(:x => 4)
-    history.add(:x => 5)
-    history.undo
-    history.undo
-    history.undo
-    history.undo
-    history.state.should == {:x => 3}
-  end
-  
-  describe 'with strings' do
-    let(:history){ Ruco::History.new(:state => {:x => 'a'}, :track => [:x], :timeout => 0.1) }
-    
-    it "triggers a new state on insertion and deletion" do
-      %w{ab abc ab a a}.each{|state| history.add(:x => state)}
-      
-      history.undo
-      history.state.should == {:x => "abc"}
-      
-      history.undo
-      history.state.should == {:x => "a"}
-    end
-  end
-
-  describe 'with timeout' do
-    let(:history){ Ruco::History.new(:state => {:x => 1}, :track => [:x], :entries => 3, :timeout => 0.1) }
-
-    it "adds fast changes" do
-      history.add(:x => 2)
-      history.add(:x => 3)
-      history.add(:x => 4)
-      history.undo
-      history.state.should == {:x => 1}
-    end
-
-    it "does not modify undone states" do
-      history.undo
-      history.state.should == {:x => 1}
-      history.add(:x => 4)
-      history.undo
-      history.state.should == {:x => 1}
-    end
-
-    it "does not modify redone states" do
-      history.add(:x => 2)
-      history.undo
-      sleep 0.2
-      history.redo
-      history.state.should == {:x => 2}
-      history.add(:x => 3)
-      history.undo
-      history.state.should == {:x => 2}
-    end
-
-    it "does not add slow changes" do
-      history.add(:x => 2)
-      history.add(:x => 3)
-      sleep 0.2
-      history.add(:x => 4)
-      history.undo
-      history.state.should == {:x => 3}
-    end
-  end
-  
-  describe 'with no entry limit' do
-    let(:history){ Ruco::History.new(:state => {:x => 1}, :track => [:x], :entries => 0, :timeout => 0) }
-    
-    it "should track unlimited states" do
-      200.times do |i|
-        history.add(:x => i+5)
-      end
-      history.stack.length.should == 201
-    end
-  end
-
-end

data/spec/ruco/keyboard_spec.rb

@@ -1,136 +0,0 @@
-# encoding: UTF-8
-require "spec_helper"
-
-describe Keyboard do
-  def output
-    keys = []
-    Timeout.timeout(0.3) do
-      Keyboard.output do |key|
-        keys << key
-      end
-    end
-    keys
-  rescue Timeout::Error
-    keys
-  end
-
-  def type(chars)
-    Keyboard.input do
-      char = chars.shift
-      if char == :sleep_long
-        sleep 0.1
-        nil
-      else
-        char
-      end
-    end
-  end
-
-  it "can listen to simple keys" do
-    type [32]
-    output.should == [' ']
-  end
-
-  it "can listen to multiple keys" do
-    type [32, :sleep_long, 97]
-    output.should == [' ','a']
-  end
-
-  it "can listen ctrl+x" do
-    type [26]
-    output.should == [:'Ctrl+z']
-  end
-
-  it "can listen to enter" do
-    type [13]
-    output.should == [:enter]
-  end
-
-  it "does not listen to nil / NOTHING" do
-    type [nil, Keyboard::NOTHING, 13]
-    output.should == [:enter]
-  end
-
-  it "can fetch uft8-chars" do
-    type [195, 164]
-    output.should == ['ä']
-  end
-
-  it "cannot fetch long sequences" do
-    type [195, :sleep_long, 164]
-    output.map{|s|s.bytes.to_a}.should == [[195], [164]]
-  end
-
-  it "fetches pastes between normal key strokes" do
-    type [32, :sleep_long, 32, 13, 32, :sleep_long, 32]
-    output.should == [' '," \n ",' ']
-  end
-
-  it "returns pastes that do not need indentation fix as normal chars" do
-    type [32, :sleep_long, 32, 32, 32, :sleep_long, 32]
-    output.should == [' ',' ',' ',' ',' ']
-  end
-
-  it "returns control chars separately" do
-    type [260, 127, 127, 261, 260, 195, 164, 261, 260, 195, 164]
-    output.should == [:left, :backspace, :backspace, :right, :left, "ä", :right, :left, "ä"]
-  end
-
-  it "ignores wtf number that is entered when using via ssh" do
-    type [2**64-1, 2**32-1]
-    output.should == []
-  end
-
-  it "returns key-code for unprintable keys" do
-    type [11121, 324234]
-    output.should == [11121, 324234]
-  end
-
-  it "recognises escape sequence for Shift+down" do
-    type [27, 91, 49, 59, 50, 66]
-    output.should == [:"Shift+down"]
-  end
-
-  it "ignores to long escape sequences" do
-    type [27, 91, 49, 59, 50, 66, 59, 50, 66, 59, 50, 66]
-    output.should == [:escape, "[", "1", ";", "2", "B", ";", "2", "B", ";", "2", "B"]
-  end
-
-  it "recognises escape sequence for Shift+up" do
-    type [27, 91, 49, 59, 50, 65]
-    output.should == [:"Shift+up"]
-  end
-
-  it "recognises escape sequence for mac iterm Ctrl+Shift+right" do
-    type [27, 91, 67]
-    output.should == [:"Ctrl+Shift+right"]
-  end
-
-  it "recognises escape sequence for mac iterm Ctrl+Shift+left" do
-    type [27, 27, 91, 68]
-    output.should == [:"Ctrl+Shift+left"]
-  end
-
-  if RUBY_VERSION > '1.9.0'
-    it "can handle strings from 1.9" do
-      type ['a']
-      output.should == ["a"]
-    end
-  end
-
-  it "can handle Alt+x codes" do
-    type [27,103]
-    output.should == [:"Alt+g"]
-  end
-
-  it "can return normal escape" do
-    type [27]
-    output.should == [:escape]
-  end
-
-  it "can paste quickly" do
-    t = Time.now.to_f
-    type Array.new(999).map{ 27 }
-    (Time.now.to_f - t).should <= 0.01
-  end
-end