atig 0.4.5 → 0.5.0

data/spec/ifilter/retweet_spec.rb

@@ -1,6 +1,5 @@
 # -*- mode:ruby; coding:utf-8 -*-
 
-require File.expand_path( '../../spec_helper', __FILE__ )
 require 'atig/ifilter/retweet'
 require 'atig/twitter_struct'
 
@@ -14,15 +13,15 @@ describe Atig::IFilter::Retweet do
   end
 
   it "should throw normal status" do
-    filtered("hello").should be_text("hello")
+    expect(filtered("hello")).to be_text("hello")
   end
 
   it "should prefix RT for Retweet" do
-    filtered("RT: hello...",
+    expect(filtered("RT: hello...",
              'retweeted_status'=>{ 'text' => 'hello',
                'user' => {
                  'screen_name' => 'mzp'
-               } }).
-      should be_text("#{@rt}RT @mzp: hello")
+               } })).
+      to be_text("#{@rt}RT @mzp: hello")
   end
 end

data/spec/ifilter/retweet_time_spec.rb

@@ -1,6 +1,5 @@
 # -*- mode:ruby; coding:utf-8 -*-
 
-require File.expand_path( '../../spec_helper', __FILE__ )
 require 'atig/ifilter/retweet_time'
 require 'atig/twitter_struct'
 
@@ -10,16 +9,16 @@ describe Atig::IFilter::RetweetTime do
   end
 
   it "should throw normal status" do
-    filtered("hello").should be_text("hello")
+    expect(filtered("hello")).to be_text("hello")
   end
 
   it "should prefix RT for Retweet" do
-    filtered("RT @mzp: hello",
+    expect(filtered("RT @mzp: hello",
              'retweeted_status'=>{ 'text' => 'hello',
                'created_at' => 'Sat Sep 25 14:33:19 +0000 2010',
                'user' => {
                  'screen_name' => 'mzp'
-               } }).
-      should be_text("#{@rt}RT @mzp: hello \x0310[2010-09-25 23:33]\x0F")
+               } })).
+      to be_text("#{@rt}RT @mzp: hello \x0310[2010-09-25 14:33]\x0F")
   end
 end

data/spec/ifilter/sanitize_spec.rb

@@ -1,6 +1,5 @@
 # -*- mode:ruby; coding:utf-8 -*-
 
-require File.expand_path( '../../spec_helper', __FILE__ )
 require 'atig/ifilter/sanitize'
 require 'atig/twitter_struct'
 
@@ -10,16 +9,16 @@ describe Atig::IFilter::Sanitize do
   end
 
   it "should convert escape html" do
-    filtered("&lt; &gt; &quot;").should be_text("< > \"")
+    expect(filtered("&lt; &gt; &quot;")).to be_text("< > \"")
   end
 
   it "should convert whitespace" do
-    filtered("\r\n").should be_text(" ")
-    filtered("\r").should be_text(" ")
-    filtered("\n").should be_text(" ")
+    expect(filtered("\r\n")).to be_text(" ")
+    expect(filtered("\r")).to be_text(" ")
+    expect(filtered("\n")).to be_text(" ")
   end
 
   it "should delete \\000\\001 sequence" do
-    filtered("\000\001").should be_text("")
+    expect(filtered("\000\001")).to be_text("")
   end
 end

data/spec/ifilter/sid_spec.rb

@@ -1,29 +1,28 @@
 # -*- mode:ruby; coding:utf-8 -*-
 
-require File.expand_path( '../../spec_helper', __FILE__ )
 require 'atig/ifilter/xid'
 require 'atig/twitter_struct'
 
 describe Atig::IFilter::Sid, "when disable tid" do
   def filtered(text)
-    ifilter = Atig::IFilter::Sid.new(OpenStruct.new(:log=>double('log'),
-                                                    :opts=>OpenStruct.new))
+    ifilter = Atig::IFilter::Sid.new(OpenStruct.new(log:double('log'),
+                                                    opts:OpenStruct.new))
     ifilter.call status(text,'sid'=>1)
   end
 
   it "should through text" do
-    filtered("hello").should be_text("hello")
+    expect(filtered("hello")).to be_text("hello")
   end
 end
 
 describe Atig::IFilter::Sid, "when enable tid" do
   def filtered(text)
-    ifilter = Atig::IFilter::Sid.new(OpenStruct.new(:log=>double('log'),
-                                                    :opts=>OpenStruct.new(:sid=>true)))
+    ifilter = Atig::IFilter::Sid.new(OpenStruct.new(log:double('log'),
+                                                    opts:OpenStruct.new(sid:true)))
     ifilter.call status(text,'sid'=>1)
   end
 
   it "should append sid" do
-    filtered("hello").should be_text("hello \x0310[1]\x0F")
+    expect(filtered("hello")).to be_text("hello \x0310[1]\x0F")
   end
 end

data/spec/ifilter/strip_spec.rb

@@ -1,6 +1,5 @@
 # -*- mode:ruby; coding:utf-8 -*-
 
-require File.expand_path( '../../spec_helper', __FILE__ )
 require 'atig/ifilter/strip'
 require 'atig/twitter_struct'
 
@@ -10,14 +9,14 @@ describe Atig::IFilter::Strip do
   end
 
   it "should strip *tw*" do
-    @ifilter.call(status("hoge *tw*")).should be_text("hoge")
+    expect(@ifilter.call(status("hoge *tw*"))).to be_text("hoge")
   end
 
   it "should strip _" do
-    @ifilter.call(status("hoge _")).should be_text("hoge")
+    expect(@ifilter.call(status("hoge _"))).to be_text("hoge")
   end
 
   it "should strip white-space" do
-    @ifilter.call(status("  hoge  ")).should be_text("hoge")
+    expect(@ifilter.call(status("  hoge  "))).to be_text("hoge")
   end
 end

data/spec/ifilter/tid_spec.rb

@@ -1,29 +1,28 @@
 # -*- mode:ruby; coding:utf-8 -*-
 
-require File.expand_path( '../../spec_helper', __FILE__ )
 require 'atig/ifilter/xid'
 require 'atig/twitter_struct'
 
 describe Atig::IFilter::Tid, "when disable tid" do
   def filtered(text)
-    ifilter = Atig::IFilter::Tid.new(OpenStruct.new(:log=>double('log'),
-                                                    :opts=>OpenStruct.new))
+    ifilter = Atig::IFilter::Tid.new(OpenStruct.new(log:double('log'),
+                                                    opts:OpenStruct.new))
     ifilter.call status(text,'tid'=>1)
   end
 
   it "should through text" do
-    filtered("hello").should be_text("hello")
+    expect(filtered("hello")).to be_text("hello")
   end
 end
 
 describe Atig::IFilter::Tid, "when enable tid" do
   def filtered(text)
-    ifilter = Atig::IFilter::Tid.new(OpenStruct.new(:log=>double('log'),
-                                                    :opts=>OpenStruct.new(:tid=>true)))
+    ifilter = Atig::IFilter::Tid.new(OpenStruct.new(log:double('log'),
+                                                    opts:OpenStruct.new(tid:true)))
     ifilter.call status(text,'tid'=>1)
   end
 
   it "should append tid" do
-    filtered("hello").should be_text("hello \x0310[1]\x0F")
+    expect(filtered("hello")).to be_text("hello \x0310[1]\x0F")
   end
 end

data/spec/levenshtein_spec.rb

@@ -1,6 +1,5 @@
 # -*- mode:ruby; coding:utf-8 -*-
 
-require File.expand_path( '../spec_helper', __FILE__ )
 require 'atig/levenshtein'
 
 target = [Atig::Levenshtein, Atig::Levenshtein::PureRuby]
@@ -16,8 +15,8 @@ target.each do |m|
        ["", "foo", 3],
        ["あああ", "ああい", 1],
       ].each do |a, b, expected|
-        m.levenshtein(a.split(//), b.split(//)).should == expected
-        m.levenshtein(b.split(//), a.split(//)).should == expected
+        expect(m.levenshtein(a.split(//), b.split(//))).to eq(expected)
+        expect(m.levenshtein(b.split(//), a.split(//))).to eq(expected)
       end
     end
   end

data/spec/ofilter/escape_url_spec.rb

@@ -1,6 +1,5 @@
 # -*- mode:ruby; coding:utf-8 -*-
 
-require File.expand_path( '../../spec_helper', __FILE__ )
 require 'atig/ofilter/escape_url'
 
 class Atig::OFilter::EscapeUrl
@@ -10,22 +9,22 @@ end
 describe Atig::OFilter::EscapeUrl do
   before do
     @logger = double('Logger')
-    @logger.should_receive(:info).at_most(:once)
-    @logger.should_receive(:error).at_most(:once)
-    @logger.should_receive(:debug).at_most(:once)
+    expect(@logger).to receive(:info).at_most(:once)
+    expect(@logger).to receive(:error).at_most(:once)
+    expect(@logger).to receive(:debug).at_most(:once)
   end
 
   def filtered(text,opt={})
-    esc = Atig::OFilter::EscapeUrl.new(OpenStruct.new(:log=>@logger,:opts=>nil))
-    esc.call :status => text
+    esc = Atig::OFilter::EscapeUrl.new(OpenStruct.new(log:@logger,:opts=>nil))
+    esc.call status: text
   end
 
   it "through normal url" do
-    filtered("http://example.com").should == { :status => "http://example.com"}
+    expect(filtered("http://example.com")).to eq({ status: "http://example.com"})
   end
 
   it "escape only url" do
-    filtered("あああ http://example.com/あああ").should == { :status => "あああ http://example.com/%E3%81%82%E3%81%82%E3%81%82" }
+    expect(filtered("あああ http://example.com/あああ")).to eq({ status: "あああ http://example.com/%E3%81%82%E3%81%82%E3%81%82" })
   end
 end
 
@@ -33,18 +32,18 @@ if defined? ::Punycode then
   describe Atig::OFilter::EscapeUrl,"when punycode is enabled" do
     before do
       @logger = double('Logger')
-      @logger.should_receive(:info).at_most(:once)
-      @logger.should_receive(:error).at_most(:once)
-      @logger.should_receive(:debug).at_most(:once)
+      expect(@logger).to receive(:info).at_most(:once)
+      expect(@logger).to receive(:error).at_most(:once)
+      expect(@logger).to receive(:debug).at_most(:once)
     end
 
     def filtered(text,opt={})
-      esc = Atig::OFilter::EscapeUrl.new(OpenStruct.new(:log=>@logger,:opts=>nil))
-      esc.call :status => text
+      esc = Atig::OFilter::EscapeUrl.new(OpenStruct.new(log:@logger,:opts=>nil))
+      esc.call status: text
     end
 
     it "escape international URL" do
-      filtered("http://あああ.com").should == {:status => "http://xn--l8jaa.com" }
+      expect(filtered("http://あああ.com")).to eq({status: "http://xn--l8jaa.com" })
     end
   end
 end

data/spec/ofilter/footer_spec.rb

@@ -1,32 +1,31 @@
 # -*- mode:ruby; coding:utf-8 -*-
 
-require File.expand_path( '../../spec_helper', __FILE__ )
 require 'atig/ofilter/footer'
 require 'ostruct'
 
 describe Atig::OFilter::Footer do
   before do
     @opts   = OpenStruct.new
-    @filter = Atig::OFilter::Footer.new(OpenStruct.new(:opts=>@opts))
+    @filter = Atig::OFilter::Footer.new(OpenStruct.new(opts:@opts))
   end
 
   it "should pass through" do
-    @filter.call(:status => 'hi').should == {
-      :status => "hi"
-    }
+    expect(@filter.call(status: 'hi')).to eq({
+      status: "hi"
+    })
   end
 
   it "should append footer" do
     @opts.footer = '*tw*'
-    @filter.call(:status => 'hi').should == {
-      :status => "hi *tw*"
-    }
+    expect(@filter.call(status: 'hi')).to eq({
+      status: "hi *tw*"
+    })
   end
 
   it "should not append footer" do
     @opts.footer = false
-    @filter.call(:status => 'hi').should == {
-      :status => "hi"
-    }
+    expect(@filter.call(status: 'hi')).to eq({
+      status: "hi"
+    })
   end
 end

data/spec/ofilter/geo_spec.rb

@@ -1,33 +1,32 @@
 # -*- mode:ruby; coding:utf-8 -*-
 
-require File.expand_path( '../../spec_helper', __FILE__ )
 require 'atig/ofilter/geo'
 require 'ostruct'
 
 describe Atig::OFilter::Geo,"when disabled" do
   def filtered(text,opt={})
-    geo = Atig::OFilter::Geo.new(OpenStruct.new(:opts=>OpenStruct.new(opt)))
-    geo.call :status => text
+    geo = Atig::OFilter::Geo.new(OpenStruct.new(opts:OpenStruct.new(opt)))
+    geo.call status: text
   end
 
   it "should through" do
-    filtered("hi").should == {
-      :status => "hi"
-    }
+    expect(filtered("hi")).to eq({
+      status: "hi"
+    })
   end
 end
 
 describe Atig::OFilter::Geo,"when enabled" do
   def filtered(text,opt={})
-    geo = Atig::OFilter::Geo.new(OpenStruct.new(:opts=>OpenStruct.new(opt)))
-    geo.call :status => text
+    geo = Atig::OFilter::Geo.new(OpenStruct.new(opts:OpenStruct.new(opt)))
+    geo.call status: text
   end
 
   it "add lat & long" do
-    filtered("hi",:ll=>"42.1,43.1").should == {
-      :status => "hi",
-      :lat  => 42.1,
-      :long => 43.1
-    }
+    expect(filtered("hi",:ll=>"42.1,43.1")).to eq({
+      status: "hi",
+      lat: 42.1,
+      long: 43.1
+    })
   end
 end

data/spec/ofilter/short_url_spec.rb

@@ -1,6 +1,5 @@
 # -*- mode:ruby; coding:utf-8 -*-
 
-require File.expand_path( '../../spec_helper', __FILE__ )
 require 'atig/ofilter/short_url'
 require 'ostruct'
 
@@ -8,17 +7,17 @@ describe Atig::OFilter::ShortUrl,"when no-login bitly" do
   before do
     logger = double('Logger')
     bitly =  double("Bitly")
-    bitly.stub(:shorten).and_return{|s|
+    allow(bitly).to receive(:shorten){|s|
       "[#{s}]"
     }
-    Atig::Bitly.should_receive(:no_login).with(logger).and_return(bitly)
-    @ofilter = Atig::OFilter::ShortUrl.new(OpenStruct.new(:log=>logger, :opts=>OpenStruct.new('bitlify'=>true)))
+    expect(Atig::Bitly).to receive(:no_login).with(logger).and_return(bitly)
+    @ofilter = Atig::OFilter::ShortUrl.new(OpenStruct.new(log:logger, opts:OpenStruct.new('bitlify'=>true)))
   end
 
   it "should shorten url by bitly" do
-    @ofilter.call({:status => "this is http://example.com/a http://example.com/b"}).should == {
-      :status => "this is [http://example.com/a] [http://example.com/b]"
-    }
+    expect(@ofilter.call({status: "this is http://example.com/a http://example.com/b"})).to eq({
+      status: "this is [http://example.com/a] [http://example.com/b]"
+    })
   end
 end
 
@@ -26,17 +25,17 @@ describe Atig::OFilter::ShortUrl,"when no-login bitly with size" do
   before do
     logger = double('Logger')
     bitly =  double("Bitly")
-    bitly.stub(:shorten).and_return{|s|
+    allow(bitly).to receive(:shorten){|s|
       "[#{s}]"
     }
-    Atig::Bitly.should_receive(:no_login).with(logger).and_return(bitly)
-    @ofilter = Atig::OFilter::ShortUrl.new(OpenStruct.new(:log=>logger, :opts=>OpenStruct.new('bitlify'=>13)))
+    expect(Atig::Bitly).to receive(:no_login).with(logger).and_return(bitly)
+    @ofilter = Atig::OFilter::ShortUrl.new(OpenStruct.new(log:logger, opts:OpenStruct.new('bitlify'=>13)))
   end
 
   it "should only shorten large url" do
-    @ofilter.call({:status => "this is http://example.com/a http://a.com"}).should == {
-      :status => "this is [http://example.com/a] http://a.com"
-    }
+    expect(@ofilter.call({status: "this is http://example.com/a http://a.com"})).to eq({
+      status: "this is [http://example.com/a] http://a.com"
+    })
   end
 end
 
@@ -44,17 +43,17 @@ describe Atig::OFilter::ShortUrl,"when login bitly" do
   before do
     logger = double('Logger')
     bitly =  double("Bitly")
-    bitly.stub(:shorten).and_return{|s|
+    allow(bitly).to receive(:shorten){|s|
       "[#{s}]"
     }
-    Atig::Bitly.should_receive(:login).with(logger,"username","api_key").and_return(bitly)
-    @ofilter = Atig::OFilter::ShortUrl.new(OpenStruct.new(:log=>logger, :opts=>OpenStruct.new('bitlify'=>'username:api_key')))
+    expect(Atig::Bitly).to receive(:login).with(logger,"username","api_key").and_return(bitly)
+    @ofilter = Atig::OFilter::ShortUrl.new(OpenStruct.new(log:logger, opts:OpenStruct.new('bitlify'=>'username:api_key')))
   end
 
   it "should only shorten large url" do
-    @ofilter.call({:status => "this is http://example.com/a http://example.com/b"}).should == {
-      :status => "this is [http://example.com/a] [http://example.com/b]"
-    }
+    expect(@ofilter.call({status: "this is http://example.com/a http://example.com/b"})).to eq({
+      status: "this is [http://example.com/a] [http://example.com/b]"
+    })
   end
 end
 
@@ -62,17 +61,17 @@ describe Atig::OFilter::ShortUrl,"when login bitly with size" do
   before do
     logger = double('Logger')
     bitly =  double("Bitly")
-    bitly.stub(:shorten).and_return{|s|
+    allow(bitly).to receive(:shorten){|s|
       "[#{s}]"
     }
-    Atig::Bitly.should_receive(:login).with(logger,"username","api_key").and_return(bitly)
-    @ofilter = Atig::OFilter::ShortUrl.new(OpenStruct.new(:log=>logger, :opts=>OpenStruct.new('bitlify'=>'username:api_key:13')))
+    expect(Atig::Bitly).to receive(:login).with(logger,"username","api_key").and_return(bitly)
+    @ofilter = Atig::OFilter::ShortUrl.new(OpenStruct.new(log:logger, opts:OpenStruct.new('bitlify'=>'username:api_key:13')))
   end
 
   it "should only shorten large url" do
-    @ofilter.call({:status => "this is http://example.com/a http://a.com"}).should == {
-      :status => "this is [http://example.com/a] http://a.com"
-    }
+    expect(@ofilter.call({status: "this is http://example.com/a http://a.com"})).to eq({
+      status: "this is [http://example.com/a] http://a.com"
+    })
   end
 end
 
@@ -80,12 +79,12 @@ describe Atig::OFilter::ShortUrl,"when nop" do
   before do
     logger = double('Logger')
 
-    @ofilter = Atig::OFilter::ShortUrl.new(OpenStruct.new(:log=>logger, :opts=>OpenStruct.new()))
+    @ofilter = Atig::OFilter::ShortUrl.new(OpenStruct.new(log:logger, opts:OpenStruct.new()))
   end
 
   it "should only not do anything" do
-    @ofilter.call({:status => "this is http://example.com/a http://a.com"}).should == {
-      :status => "this is http://example.com/a http://a.com"
-    }
+    expect(@ofilter.call({status: "this is http://example.com/a http://a.com"})).to eq({
+      status: "this is http://example.com/a http://a.com"
+    })
   end
 end