atig 0.4.5 → 0.5.0

data/spec/db/listenable_spec.rb

@@ -1,6 +1,5 @@
 # -*- mode:ruby; coding:utf-8 -*-
 
-require File.expand_path( '../../spec_helper', __FILE__ )
 require 'atig/db/listenable'
 
 class SampleListener
@@ -24,9 +23,9 @@ describe Atig::Db::Listenable, "when it is called" do
   it "should call all listener" do
     @listeners.hi 1,2,3
 
-    @args.length.should == 3
+    expect(@args.length).to eq(3)
     1.upto(2) {|i|
-      @args[i].should == [1,2,3]
+      expect(@args[i]).to eq([1,2,3])
     }
   end
 end

data/spec/db/lists_spec.rb

@@ -1,11 +1,10 @@
 # -*- mode:ruby; coding:utf-8 -*-
 
-require File.expand_path( '../../spec_helper', __FILE__ )
 require 'atig/db/lists'
 
 describe Atig::Db::Lists do
   def user(id, name, protect, only)
-    OpenStruct.new(:id => id, :screen_name=>name, :protected=>protect, :only=>only)
+    OpenStruct.new(id: id, screen_name:name, protected:protect, only:only)
   end
 
   before do
@@ -29,15 +28,15 @@ describe Atig::Db::Lists do
     @lists.update("a" => [ @alice, @bob ],
                   "b" => [ @alice, @bob , @charriey ])
 
-    @lists.find_by_screen_name('alice').sort.should == ["a", "b"]
-    @lists.find_by_screen_name('charriey').should == ["b"]
+    expect(@lists.find_by_screen_name('alice').sort).to eq(["a", "b"])
+    expect(@lists.find_by_screen_name('charriey')).to eq(["b"])
   end
 
   it "should have lists" do
     @lists.update("a" => [ @alice, @bob ],
                   "b" => [ @alice, @bob , @charriey ])
 
-    @lists.find_by_list_name('a').should == [ @alice, @bob ]
+    expect(@lists.find_by_list_name('a')).to eq([ @alice, @bob ])
   end
 
   it "should have each" do
@@ -51,52 +50,52 @@ describe Atig::Db::Lists do
     @lists.each do|name,users|
       hash[name] = users
     end
-    hash.should == data
+    expect(hash).to eq(data)
   end
 
   it "should call listener when new list" do
     @lists.update("a" => [ @alice, @bob ])
 
-    @args.keys.should include(:new, :join)
-    @args[:new].should == [ "a" ]
-    @args[:join].should == [ "a", [ @alice, @bob ] ]
+    expect(@args.keys).to include(:new, :join)
+    expect(@args[:new]).to eq([ "a" ])
+    expect(@args[:join]).to eq([ "a", [ @alice, @bob ] ])
   end
 
   it "should call listener when partcial update" do
     @lists.update("a" => [ @alice ])
     @lists["a"].update([ @alice, @bob, @charriey ])
-    @args[:join].should == ["a", [ @bob, @charriey ]]
+    expect(@args[:join]).to eq(["a", [ @bob, @charriey ]])
   end
 
   it "should call on_invalidated" do
     called = false
     @lists.on_invalidated do|name|
-      name.should == "a"
+      expect(name).to eq("a")
       called = true
     end
     @lists.invalidate("a")
 
-    called.should be_true
+    expect(called).to be_truthy
   end
 
   it "should call listener when delete list" do
     @lists.update("a" => [ @alice, @bob ])
     @lists.update({})
-    @args.keys.should include(:new, :join, :del)
-    @args[:del].should == ["a"]
+    expect(@args.keys).to include(:new, :join, :del)
+    expect(@args[:del]).to eq(["a"])
   end
 
   it "should call listener when join user" do
     @lists.update("a" => [ @alice ])
     @lists.update("a" => [ @alice, @bob, @charriey ])
 
-    @args[:join].should == ["a", [ @bob, @charriey ]]
+    expect(@args[:join]).to eq(["a", [ @bob, @charriey ]])
   end
 
   it "should call listener when exit user" do
     @lists.update("a" => [ @alice, @bob, @charriey ])
     @lists.update("a" => [ @alice ])
-    @args[:part].should == ["a", [ @bob, @charriey ]]
+    expect(@args[:part]).to eq(["a", [ @bob, @charriey ]])
   end
 
   it "should call listener when change user mode" do
@@ -104,6 +103,6 @@ describe Atig::Db::Lists do
     bob = user @bob.id, 'bob', false, false
     @lists.update("a" => [ @alice, bob ])
 
-    @args[:mode].should == [ "a", [ bob ]]
+    expect(@args[:mode]).to eq([ "a", [ bob ]])
   end
 end

data/spec/db/roman_spec.rb

@@ -1,6 +1,5 @@
 # -*- mode:ruby; coding:utf-8 -*-
 
-require File.expand_path( '../../spec_helper', __FILE__ )
 require 'atig/db/roman'
 
 describe Atig::Db::Roman do
@@ -9,9 +8,8 @@ describe Atig::Db::Roman do
   end
 
   it "should make readble tid" do
-    @roman.make(0).should == 'a'
-    @roman.make(1).should == 'i'
-    @roman.make(2).should == 'u'
+    expect(@roman.make(0)).to eq('a')
+    expect(@roman.make(1)).to eq('i')
+    expect(@roman.make(2)).to eq('u')
   end
 end
-

data/spec/db/sized_uniq_array_spec.rb

@@ -1,13 +1,12 @@
 # -*- mode:ruby; coding:utf-8 -*-
 
-require File.expand_path( '../../spec_helper', __FILE__ )
 require 'atig/db/sized_uniq_array'
 require 'ostruct'
 
 describe Atig::Db::SizedUniqArray do
   def item(id)
     item = double "Item-#{id}"
-    item.stub(:id).and_return id
+    allow(item).to receive(:id).and_return id
     item
   end
 
@@ -24,40 +23,40 @@ describe Atig::Db::SizedUniqArray do
   end
 
   it "should include items" do
-    @array.to_a.should == [ @item1, @item2, @item3 ]
+    expect(@array.to_a).to eq([ @item1, @item2, @item3 ])
   end
 
   it "should rorate array" do
     @array << @item4
-    @array.to_a.should == [ @item2, @item3, @item4 ]
+    expect(@array.to_a).to eq([ @item2, @item3, @item4 ])
   end
 
   it "should have reverse_each" do
     xs = []
     @array.reverse_each {|x| xs << x }
-    xs.should == [ @item3, @item2, @item1 ]
+    expect(xs).to eq([ @item3, @item2, @item1 ])
   end
 
   it "should not have duplicate element" do
     @array << item(1)
-    @array.to_a.should == [ @item1, @item2, @item3 ]
+    expect(@array.to_a).to eq([ @item1, @item2, @item3 ])
   end
 
   it "should be accesible by index" do
-    @array[0].should == @item1
-    @array[1].should == @item2
-    @array[2].should == @item3
+    expect(@array[0]).to eq(@item1)
+    expect(@array[1]).to eq(@item2)
+    expect(@array[2]).to eq(@item3)
   end
 
   it "should not change index" do
     @array << @item4
-    @array[0].should == @item4
-    @array[1].should == @item2
-    @array[2].should == @item3
+    expect(@array[0]).to eq(@item4)
+    expect(@array[1]).to eq(@item2)
+    expect(@array[2]).to eq(@item3)
   end
 
   it "should return index when add element" do
-    (@array << @item4).should == 0
-    (@array << @item3).should == nil
+    expect(@array << @item4).to eq(0)
+    expect(@array << @item3).to eq(nil)
   end
 end

data/spec/db/statuses_spec.rb

@@ -1,16 +1,15 @@
 # -*- mode:ruby; coding:utf-8 -*-
 
-require File.expand_path( '../../spec_helper', __FILE__ )
 require 'fileutils'
 require 'atig/db/statuses'
 
 describe Atig::Db::Statuses do
   def status(id, text, time)
-    OpenStruct.new(:id => id, :text => text, :created_at => time.strftime("%a %b %d %H:%M:%S +0000 %Y"))
+    OpenStruct.new(id: id, text: text, created_at: time.strftime("%a %b %d %H:%M:%S +0000 %Y"))
   end
 
   def user(name)
-    OpenStruct.new(:screen_name => name, :id => name)
+    OpenStruct.new(screen_name: name, id: name)
   end
 
   before do
@@ -26,9 +25,9 @@ describe Atig::Db::Statuses do
     @alice = user 'alice'
     @bob = user 'bob'
 
-    @db.add :status => @a , :user => @alice, :source => :srcA
-    @db.add :status => @b , :user => @bob  , :source => :srcB
-    @db.add :status => @c , :user => @alice, :source => :srcC
+    @db.add status: @a , user: @alice, source: :srcA
+    @db.add status: @b , user: @bob  , source: :srcB
+    @db.add status: @c , user: @alice, source: :srcC
   end
 
   after(:all) do
@@ -43,142 +42,142 @@ describe Atig::Db::Statuses do
     entry = nil
     @db.listen{|x| entry = x }
 
-    @db.add :status => @d, :user => @alice, :source => :timeline, :fuga => :hoge
+    @db.add status: @d, user: @alice, source: :timeline, fuga: :hoge
 
-    entry.source.should == :timeline
-    entry.status.should == @d
-    entry.tid.should match(/\w+/)
-    entry.sid.should match(/\w+/)
-    entry.user.should   == @alice
-    entry.source.should == :timeline
-    entry.fuga.should == :hoge
+    expect(entry.source).to eq(:timeline)
+    expect(entry.status).to eq(@d)
+    expect(entry.tid).to match(/\w+/)
+    expect(entry.sid).to match(/\w+/)
+    expect(entry.user).to   eq(@alice)
+    expect(entry.source).to eq(:timeline)
+    expect(entry.fuga).to eq(:hoge)
   end
 
   it "should not contain duplicate" do
     called = false
     @db.listen{|*_| called = true }
 
-    @db.add :status => @c, :user => @bob, :source => :timeline
-    called.should be_false
+    @db.add status: @c, user: @bob, source: :timeline
+    expect(called).to be_falsey
   end
 
   it "should be found by id" do
     entry = @db.find_by_id 1
-    entry.id.should == 1
-    entry.status.should == @a
-    entry.user  .should == @alice
-    entry.tid   .should match(/\w+/)
-    entry.sid.should match(/\w+/)
+    expect(entry.id).to eq(1)
+    expect(entry.status).to eq(@a)
+    expect(entry.user)  .to eq(@alice)
+    expect(entry.tid)   .to match(/\w+/)
+    expect(entry.sid).to match(/\w+/)
   end
 
   it "should have unique tid" do
     db = Atig::Db::Statuses.new 'test.db'
-    db.add :status => @d , :user => @alice, :source => :srcA
+    db.add status: @d , user: @alice, source: :srcA
 
     a = @db.find_by_id(1)
     d = @db.find_by_id(4)
-    a.tid.should_not == d.tid
-    a.sid.should_not == d.cid
+    expect(a.tid).not_to eq(d.tid)
+    expect(a.sid).not_to eq(d.cid)
   end
 
   it "should be found all" do
     db = @db.find_all
-    db.size.should == 3
+    expect(db.size).to eq(3)
     a,b,c = db
 
-    a.status.should == @c
-    a.user  .should == @alice
-    a.tid   .should match(/\w+/)
-    a.sid   .should match(/\w+/)
+    expect(a.status).to eq(@c)
+    expect(a.user)  .to eq(@alice)
+    expect(a.tid)   .to match(/\w+/)
+    expect(a.sid)   .to match(/\w+/)
 
-    b.status.should == @b
-    b.user  .should == @bob
-    b.tid   .should match(/\w+/)
-    b.sid   .should match(/\w+/)
+    expect(b.status).to eq(@b)
+    expect(b.user)  .to eq(@bob)
+    expect(b.tid)   .to match(/\w+/)
+    expect(b.sid)   .to match(/\w+/)
 
-    c.status.should == @a
-    c.user.should   == @alice
-    c.tid.should    match(/\w+/)
-    c.sid.should    match(/\w+/)
+    expect(c.status).to eq(@a)
+    expect(c.user).to   eq(@alice)
+    expect(c.tid).to    match(/\w+/)
+    expect(c.sid).to    match(/\w+/)
   end
 
   it "should be found by tid" do
     entry = @db.find_by_id(1)
-    @db.find_by_tid(entry.tid).should == entry
+    expect(@db.find_by_tid(entry.tid)).to eq(entry)
   end
 
   it "should be found by sid" do
     entry = @db.find_by_id(1)
-    @db.find_by_sid(entry.sid).should == entry
+    expect(@db.find_by_sid(entry.sid)).to eq(entry)
   end
 
   it "should be found by tid" do
-    @db.find_by_tid('__').should be_nil
+    expect(@db.find_by_tid('__')).to be_nil
   end
 
   it "should be found by user" do
     a,b = *@db.find_by_user(@alice)
 
-    a.status.should == @c
-    a.user  .should == @alice
-    a.tid   .should match(/\w+/)
-    a.sid   .should match(/\w+/)
+    expect(a.status).to eq(@c)
+    expect(a.user)  .to eq(@alice)
+    expect(a.tid)   .to match(/\w+/)
+    expect(a.sid)   .to match(/\w+/)
 
-    b.status.should == @a
-    b.user.should   == @alice
-    b.tid.should    match(/\w+/)
-    b.sid.should    match(/\w+/)
+    expect(b.status).to eq(@a)
+    expect(b.user).to   eq(@alice)
+    expect(b.tid).to    match(/\w+/)
+    expect(b.sid).to    match(/\w+/)
   end
 
   it "should be found by screen_name" do
     db = @db.find_by_screen_name('alice')
-    db.size.should == 2
+    expect(db.size).to eq(2)
     a,b = db
 
-    a.status.should == @c
-    a.user  .should == @alice
-    a.tid   .should match(/\w+/)
-    a.sid   .should match(/\w+/)
+    expect(a.status).to eq(@c)
+    expect(a.user)  .to eq(@alice)
+    expect(a.tid)   .to match(/\w+/)
+    expect(a.sid)   .to match(/\w+/)
 
-    b.status.should == @a
-    b.user.should   == @alice
-    b.tid.should    match(/\w+/)
-    b.sid.should    match(/\w+/)
+    expect(b.status).to eq(@a)
+    expect(b.user).to   eq(@alice)
+    expect(b.tid).to    match(/\w+/)
+    expect(b.sid).to    match(/\w+/)
   end
 
   it "should be found by screen_name with limit" do
-    xs = @db.find_by_screen_name('alice', :limit => 1)
-    xs.size.should == 1
+    xs = @db.find_by_screen_name('alice', limit: 1)
+    expect(xs.size).to eq(1)
 
     a,_ = xs
-    a.status.should == @c
-    a.user  .should == @alice
-    a.tid   .should match(/\w+/)
-    a.sid   .should match(/\w+/)
+    expect(a.status).to eq(@c)
+    expect(a.user)  .to eq(@alice)
+    expect(a.tid)   .to match(/\w+/)
+    expect(a.sid)   .to match(/\w+/)
   end
 
   it "should remove by id" do
     @db.remove_by_id 1
-    @db.find_by_id(1).should be_nil
+    expect(@db.find_by_id(1)).to be_nil
   end
 
   it "should have uniq tid/sid when removed" do
     old = @db.find_by_id 3
     @db.remove_by_id 3
-    @db.add :status => @c , :user => @alice, :source => :src
+    @db.add status: @c , user: @alice, source: :src
     new = @db.find_by_id 3
 
-    old.tid.should_not == new.tid
-    old.sid.should_not == new.sid
+    expect(old.tid).not_to eq(new.tid)
+    expect(old.sid).not_to eq(new.sid)
   end
 
   it "should cleanup" do
-    Atig::Db::Statuses::Size = 10 unless defined? Atig::Db::Statuses::Size # hack 
+    Atig::Db::Statuses::Size = 10 unless defined? Atig::Db::Statuses::Size # hack
     Atig::Db::Statuses::Size.times do|i|
       s = status i+100, 'a', Time.utc(2010,1,5)+i+1
-      @db.add :status => s , :user => @alice  , :source => :srcB
+      @db.add status: s , user: @alice  , source: :srcB
     end
     @db.cleanup
-    @db.find_by_status_id(@a.id).should == nil
+    expect(@db.find_by_status_id(@a.id)).to eq(nil)
   end
 end

data/spec/ifilter/expand_url_spec.rb

@@ -1,6 +1,5 @@
 # -*- mode:ruby; coding:utf-8 -*-
 
-require File.expand_path( '../../spec_helper', __FILE__ )
 require 'atig/ifilter/expand_url'
 require 'atig/twitter_struct'
 
@@ -10,57 +9,57 @@ end
 
 describe Atig::IFilter::ExpandUrl, "when disable whole url" do
   def filtered(text)
-    ifilter = Atig::IFilter::ExpandUrl.new OpenStruct.new(:log=>double('log'),:opts=>OpenStruct.new)
+    ifilter = Atig::IFilter::ExpandUrl.new OpenStruct.new(log:double('log'),:opts=>OpenStruct.new)
     ifilter.call status(text)
   end
 
   it "should expand bit.ly" do
-    filtered("This is http://bit.ly/hoge").should be_text("This is [http://bit.ly/hoge]")
-    filtered("This is http://bitly.com/hoge").should be_text("This is [http://bitly.com/hoge]")
+    expect(filtered("This is http://bit.ly/hoge")).to be_text("This is [http://bit.ly/hoge]")
+    expect(filtered("This is http://bitly.com/hoge")).to be_text("This is [http://bitly.com/hoge]")
   end
 
   it "should expand htn.to" do
-    filtered("This is http://htn.to/TZdkXg").should be_text("This is [http://htn.to/TZdkXg]")
-    filtered("This is http://htnnto/TZdkXg").should be_text("This is http://htnnto/TZdkXg")
+    expect(filtered("This is http://htn.to/TZdkXg")).to be_text("This is [http://htn.to/TZdkXg]")
+    expect(filtered("This is http://htnnto/TZdkXg")).to be_text("This is http://htnnto/TZdkXg")
   end
 
   it "should expand tmblr.co" do
-    filtered("This is http://tmblr.co/Z0rNbyxhxUK5").should be_text("This is [http://tmblr.co/Z0rNbyxhxUK5]")
+    expect(filtered("This is http://tmblr.co/Z0rNbyxhxUK5")).to be_text("This is [http://tmblr.co/Z0rNbyxhxUK5]")
   end
 
   it "should expand nico.ms" do
-    filtered("This is http://nico.ms/sm11870888").should be_text("This is [http://nico.ms/sm11870888]")
+    expect(filtered("This is http://nico.ms/sm11870888")).to be_text("This is [http://nico.ms/sm11870888]")
   end
 
   it "should through other url" do
-    filtered("http://example.com").should be_text("http://example.com")
+    expect(filtered("http://example.com")).to be_text("http://example.com")
   end
 end
 
 describe Atig::IFilter::ExpandUrl, "when enable whole url" do
   def filtered(text)
     context = OpenStruct.new(
-                             :log  => double('log'),
-                             :opts => OpenStruct.new(:untiny_whole_urls=>true))
+                             log: double('log'),
+                             opts: OpenStruct.new(untiny_whole_urls:true))
     ifilter = Atig::IFilter::ExpandUrl.new(context)
     ifilter.call status(text)
   end
 
   it "should expand bit.ly" do
-    filtered("This is http://bit.ly/hoge").should be_text("This is [http://bit.ly/hoge]")
+    expect(filtered("This is http://bit.ly/hoge")).to be_text("This is [http://bit.ly/hoge]")
   end
 
   it "should expand other url" do
-    filtered("http://example.com").should be_text("[http://example.com]")
-    filtered("https://example.com").should be_text("[https://example.com]")
+    expect(filtered("http://example.com")).to be_text("[http://example.com]")
+    expect(filtered("https://example.com")).to be_text("[https://example.com]")
   end
 end
 
 describe Atig::IFilter::ExpandUrl, "when has urls entities" do
   def filtered(text, opts)
     context = OpenStruct.new(
-                             :log => double('log'),
-                             :opts => OpenStruct.new)
+                             log: double('log'),
+                             opts: OpenStruct.new)
     ifilter = Atig::IFilter::ExpandUrl.new(context)
     ifilter.call status(text, opts)
   end
@@ -77,9 +76,8 @@ describe Atig::IFilter::ExpandUrl, "when has urls entities" do
         }]
       }
     }
-    filtered("http://t.co/1Vyoux4kB8", opts).should be_text("http://example.com/")
-    filtered("http://t.co/1Vyoux4kB8 http://t.co/V1441ye6g2", opts).should
-      be_text("http://example.com/ http://expmaple.org/")
+    expect(filtered("http://t.co/1Vyoux4kB8", opts)).to be_text("http://example.com/")
+    expect(filtered("http://t.co/1Vyoux4kB8 http://t.co/V1441ye6g2", opts)).to be_text("http://example.com/ http://example.org/")
   end
 
   it "should expand recursive shorten URL" do
@@ -91,6 +89,6 @@ describe Atig::IFilter::ExpandUrl, "when has urls entities" do
         }]
       }
     }
-    filtered("http://t.co/h8sqL5ZMuz", opts).should be_text("[http://bit.ly/1LM4fW]")
+    expect(filtered("http://t.co/h8sqL5ZMuz", opts)).to be_text("[http://bit.ly/1LM4fW]")
   end
 end