bencodr 1.2.0 → 2.0.0

data/lib/bencodr/version.rb

@@ -0,0 +1,3 @@
+module BEncodr
+  VERSION = "2.0.0"
+end

data/spec/bencode_spec.rb

@@ -1,45 +1,40 @@
 # encoding: UTF-8
-
-require "spec"
 require "spec_helper"
 
 describe BEncodr do
-  describe "#decode" do
-    # Most of this is covered in other tests. Only difference is this accepts string instead of scanner.
+  describe "#bdecode" do
     it "should parse a bencoded string" do
-      BEncodr.decode("6:string").should == "string"
+      BEncodr.bdecode("6:string").should == "string"
     end
 
     it "should parse a bencoded integer" do
-      BEncodr.decode("i4e").should == 4
+      BEncodr.bdecode("i4e").should == 4
     end
 
     it "should parse a bencoded list" do
-      BEncodr.decode("l6:stringeeeee").should == ["string"]
+      BEncodr.bdecode("l6:stringeeeee").should == ["string"]
     end
 
     it "should parse a bencoded dictionary containing a key value pair" do
-      BEncodr.decode("d6:stringi1ee").should == {"string" => 1}
+      BEncodr.bdecode("d6:stringi1ee").should == {"string" => 1}
     end
 
     it "should raise an error when the type is not recognized" do
-      lambda{BEncodr.decode("freak out!")}.should raise_error BEncodr::BEncodeError
+      lambda{BEncodr.bdecode("freak out!")}.should raise_error BEncodr::BEncodeError
     end
   end
 
-  describe "#decode_file" do
+  describe "#bdecode_file" do
     it "should parse a bencoded file" do
       dirname = File.dirname(__FILE__)
-      BEncodr.decode_file("#{dirname}/samples/mini.bencode").should == {"ba" => 3}
+      BEncodr.bdecode_file("#{dirname}/samples/mini.bencode").should == {"ba" => 3}
     end
   end
 
-  describe "#encode" do
-    # Covered in other tests so only simple stuff here. 
-    it "should bencodr an object" do
-      BEncodr.encode("string").should == "6:string"
-    end
-  end
+  it_behaves_like "BEncodr::String", BEncodr
+  it_behaves_like "BEncodr::Integer", BEncodr
+  it_behaves_like "BEncodr::List", BEncodr
+  it_behaves_like "BEncodr::Dictionary", BEncodr
 
   describe "#encode_file" do
     context "when an object gets bencoded and written to a file" do
@@ -51,7 +46,7 @@ describe BEncodr do
       before :each do
         @file = File.join(@path, 'test.bencodr')
         @object = "string"
-        BEncodr.encode_file(@file, @object)
+        BEncodr.bencode_file(@file, @object)
       end
 
       it "should actually write a file" do
@@ -59,7 +54,7 @@ describe BEncodr do
       end
 
       it "should properly encode the file" do
-        BEncodr.decode_file(@file).should == @object
+        BEncodr.bdecode_file(@file).should == @object
       end
 
       after :each do
@@ -73,14 +68,14 @@ describe BEncodr do
 
     it "should read a torrent with newlines as part of a string without raising an error" do
       file = File.join(File.dirname(__FILE__), 'samples', 'python.torrent')
-      lambda{BEncodr.decode_file file}.should_not raise_error
+      lambda{BEncodr.bdecode_file file}.should_not raise_error
     end
   end
 
   context "when parsing and then encoding" do
     it "should be equal to the pre-parsed and encoded bencoded string" do
       file = File.dirname(__FILE__) + "/samples/bencode.rb.torrent"
-      BEncodr.decode_file(file).bencode.should == File.open(file, "rb") {|f| f.read}
+      BEncodr.bencode(BEncodr.bdecode_file(file)).should == File.open(file, "rb") {|f| f.read}
     end
   end
-end
+end

data/spec/bencodr/dictionary_spec.rb

@@ -1,79 +1,6 @@
 # encoding: UTF-8
-
-require "spec"
 require "spec_helper"
 
-describe Hash do
-  describe "#bencodr" do
-    it "should encode an empty hash" do
-      {}.bencode.should == "de"
-    end
-
-    context "a key should always be encoded as a string" do
-      it "should encode a string key as a string" do
-        {"string" => "string"}.bencode.should == "d6:string6:stringe"
-      end
-
-      it "should encode a symbol key as a string" do
-        {:symbol => :symbol}.bencode.should == "d6:symbol6:symbole"
-      end
-
-      it "should encode a uri key as a string" do
-        uri = URI.parse("http://github.com/blatyo/bencode")
-        {uri => uri}.bencode.should == "d32:http://github.com/blatyo/bencode32:http://github.com/blatyo/bencodee"
-      end
-
-      it "should encode an integer key as a string" do
-        {1 => 1}.bencode.should == "d1:1i1ee"
-      end
-
-      it "should encode a float key as a string" do
-        {1.1 => 1.1}.bencode.should == "d3:1.1i1ee"
-      end
-
-      it "should encode a time key as a string" do
-        time = Time.utc(0)
-        {time => time}.bencode.should == "d23:2000-01-01 00:00:00 UTCi946684800ee"
-      end
-
-      it "should encode an array key as a string" do
-        array = (1..4).to_a
-        {array => array}.bencode.should == "d12:[1, 2, 3, 4]li1ei2ei3ei4eee"
-      end
-
-      it "should encode a hash key as a string" do
-        {{} => {}}.bencode.should == "d2:{}dee"
-      end
-    end
-
-    it "should encode keys in sorted (as raw strings) order" do
-      {:a => 1, "A" => 1, 1=> 1}.bencode.should == "d1:1i1e1:Ai1e1:ai1ee"
-    end
-  end
-end
-
 describe BEncodr::Dictionary do
-  describe "#register" do
-    context "once an object has been registered as a BEncode dictionary" do
-      before :all do
-        klass = Class.new do
-          def to_h
-            {:a => "a", :b => "b"}
-          end
-        end
-        BEncodr::Dictionary.register klass
-        @instance = klass.new
-      end
-
-      context "an instance of that object" do
-        it "should respond to bencodr" do
-          @instance.should respond_to :bencode
-        end
-
-        it "should encode to a bencoded dictionary" do
-          @instance.bencode.should == "d1:a1:a1:b1:be"
-        end
-      end
-    end
-  end
+  it_behaves_like "BEncodr::Dictionary", BEncodr::Dictionary
 end

data/spec/bencodr/ext_spec.rb

@@ -0,0 +1,66 @@
+# encoding: UTF-8
+require "spec_helper"
+
+describe BEncodr::Ext do
+  describe "#include!" do
+    before :all do
+      BEncodr::Ext.include!
+    end
+    
+    context BEncodr::String do
+      context ::String do
+        it_behaves_like "a BEncodr extension", "", BEncodr::String
+        
+        subject{ "" }
+        it { should be_a(BEncodr::Object) }
+        it { should respond_to(:bdecode) }
+      end
+    
+      context Symbol do
+        it_behaves_like "a BEncodr extension", :a, BEncodr::String
+      end
+    
+      context URI::Generic do
+        it_behaves_like "a BEncodr extension", URI.parse("www.google.com"), BEncodr::String
+      end
+    end
+    
+    context BEncodr::Integer do
+      context Numeric do
+        it_behaves_like "a BEncodr extension", 1, BEncodr::Integer
+      end
+      
+      context Time do
+        it_behaves_like "a BEncodr extension", Time.at(0), BEncodr::Integer
+      end
+    end
+    
+    context BEncodr::List do
+      context Array do
+        it_behaves_like "a BEncodr extension", [], BEncodr::List
+      end
+    end
+    
+    context BEncodr::Dictionary do
+      context Hash do
+        it_behaves_like "a BEncodr extension", {}, BEncodr::Dictionary
+      end
+    end
+    
+    context BEncodr::IO do
+      context IO do
+        subject{IO}
+        it{ should respond_to(:bencode) }
+                
+        it_behaves_like "a BEncodr extension", IO.new(0), BEncodr::IO
+      end
+      
+      context File do
+        subject{File}
+        it{ should respond_to(:bencode) }
+        
+        it_behaves_like "a BEncodr extension", File.open(File.dirname(__FILE__)), BEncodr::IO
+      end
+    end
+  end
+end

data/spec/bencodr/integer_spec.rb

@@ -1,72 +1,6 @@
 # encoding: UTF-8
-
-require "spec"
 require "spec_helper"
 
-describe Integer do
-  describe "#bencodr" do
-    it "should encode a positive integer" do
-      1.bencode.should == "i1e"
-    end
-
-    it "should encode a negative integer" do
-      -1.bencode.should == "i-1e"
-    end
-
-    it "should encode a positive big integer" do
-      10_000_000_000.bencode.should == "i10000000000e"
-    end
-
-    it "should encode a negative big integer" do
-      -10_000_000_000.bencode.should == "i-10000000000e"
-    end
-  end
-end
-
-describe Numeric do
-  describe "#bencodr" do
-    it "should encode a positive float with precision loss" do
-      1.1.bencode.should == "i1e"
-    end
-
-    it "should encode a negative float with precision loss" do
-      -1.1.bencode.should == "i-1e"
-    end
-
-    it "should encode an positive exponential float" do
-      1e10.bencode.should == "i10000000000e"
-    end
-
-    it "should encode an negative exponential float" do
-      -1e10.bencode.should == "i-10000000000e"
-    end
-  end
-end
-
-describe Time do
-  describe "#bencodr" do
-    it "should encode to bencoding" do
-      Time.at(4).bencode.should == "i4e"
-    end
-  end
-end
-
 describe BEncodr::Integer do
-  describe "#register" do
-    context "once an object has been registered as a BEncode integer" do
-      before :all do
-        BEncodr::Integer.register NilClass
-      end
-
-      context "an instance of that object" do
-        it "should respond to bencodr" do
-          nil.should respond_to :bencode
-        end
-
-        it "should encode to a bencoded integer" do
-          nil.bencode.should == "i0e"
-        end
-      end
-    end
-  end
+  it_behaves_like "BEncodr::Integer", BEncodr::Integer
 end

data/spec/bencodr/io_spec.rb

@@ -1,36 +1,34 @@
-require "spec"
+require "spec_helper"
 
 describe File do
-  describe "#bencode" do
-    context "when an object gets bencoded and written to a file" do
-      before :all do
-        @path = "tmp"
-        Dir.mkdir(@path) unless File.exists? @path
-      end
-
-      before :each do
-        @file = File.join(@path, 'test.bencodr')
-        @object = "string"
-        File.bencode(@file, @object)
-      end
-
-      it "should actually write a file" do
-        File.exists?(@file).should be_true
-      end
-
-      describe "#bdecode" do
-        it "should properly encode the file" do
-          File.bdecode(@file).should == @object
-        end
-      end
+  before :all do
+    @path = "tmp"
+    Dir.mkdir(@path) unless File.exists? @path
+    BEncodr.include!
+  end
 
-      after :each do
-        File.delete(@file)
-      end
+  before :each do
+    @file = File.join(@path, 'test.bencodr')
+    @object = "string"
+    File.bencode(@file, @object)
+  end
+  
+  describe "#bencode" do
+    subject{ File }
+    
+    it{ File.should exist(@file) }
+  end
+  
+  describe "#bdecode" do
+    subject{ File }
+    it{ should bdecode(@file).to(@object) }
+  end
+  
+  after :each do
+    File.delete(@file)
+  end
 
-      after :all do
-        Dir.delete(@path) if File.exists? @path
-      end
-    end
+  after :all do
+    Dir.delete(@path) if File.exists? @path
   end
 end

data/spec/bencodr/list_spec.rb

@@ -1,36 +1,6 @@
 # encoding: UTF-8
-
-require "spec"
 require "spec_helper"
 
-describe Array do
-  describe "#bencodr" do
-    it "should encode an empty array" do
-      [].bencode.should == "le"
-    end
-
-    it "should encode an array filled with bencodable objects" do
-      [:e, "a", 1, Time.at(11)].bencode.should == "l1:e1:ai1ei11ee"
-    end
-  end
-end
-
 describe BEncodr::List do
-  describe "#register" do
-    context "once an object has been registered as a BEncode list" do
-      before :all do
-        BEncodr::List.register Range
-      end
-
-      context "an instance of that object" do
-        it "should respond to bencodr" do
-          (1..2).should respond_to :bencode
-        end
-
-        it "should encode to a bencoded list" do
-          (1..2).bencode.should == "li1ei2ee"
-        end
-      end
-    end
-  end
+  it_behaves_like "BEncodr::List", BEncodr::List
 end

data/spec/bencodr/object_spec.rb

@@ -0,0 +1,9 @@
+# encoding: UTF-8
+require "spec_helper"
+
+describe BEncodr::Object do
+  it_behaves_like "BEncodr::String", BEncodr::Object
+  it_behaves_like "BEncodr::Integer", BEncodr::Object
+  it_behaves_like "BEncodr::List", BEncodr::Object
+  it_behaves_like "BEncodr::Dictionary", BEncodr::Object
+end

data/spec/bencodr/parser_spec.rb

@@ -1,196 +1,61 @@
 # encoding: UTF-8
 
-require "spec"
+require "spec_helper"
 
 describe BEncodr::Parser do
   describe "#parse_object" do
-    # Most of this functionality is covered with other tests. So minimal stuff here.
-    it "should parse a bencoded string" do
-      scanner = StringScanner.new("6:string")
-      BEncodr::Parser.parse_object(scanner).should == "string"
-    end
-
-    it "should parse a bencoded integer" do
-      scanner = StringScanner.new("i4e")
-      BEncodr::Parser.parse_object(scanner).should == 4
-    end
-
-    it "should parse a bencoded list" do
-      scanner = StringScanner.new("l6:stringeeeee")
-      BEncodr::Parser.parse_object(scanner).should == ["string"]
-    end
-
-    it "should parse a bencoded dictionary containing a key value pair" do
-      scanner = StringScanner.new("d6:stringi1ee")
-      BEncodr::Parser.parse_object(scanner).should == {"string" => 1}
-    end
-
-    it "should return nil when the type is not recognized" do
-      scanner = StringScanner.new("freak out!")
-      BEncodr::Parser.parse_object(scanner).should == nil
-    end
+    it{ should parse("6:string").as(:object).to("string") }
+    it{ should parse("i4e").as(:object).to(4) }
+    it{ should parse("l6:stringeeeee").as(:object).to(["string"]) }
+    it{ should parse("d6:stringi1ee").as(:object).to({"string" => 1}) }
+    it{ should parse("freak out!").as(:object).to(nil) }
   end
 
-  describe "#parse_stirng" do
-    it "should parse a bencoded string" do
-      scanner = StringScanner.new("6:string")
-      BEncodr::Parser.parse_string(scanner).should == "string"
-    end
-
-    it "should parse a zero length bencoded string" do
-      scanner = StringScanner.new("0:")
-      BEncodr::Parser.parse_string(scanner).should == ""
-    end
-
-    it "should raise an error if the length is invalid" do
-      scanner = StringScanner.new("fail:")
-      lambda {BEncodr::Parser.parse_string(scanner)}.should raise_error BEncodr::BEncodeError
-    end
-
-    it "should raise an error if length is too long" do
-      scanner = StringScanner.new("3:a")
-      lambda {BEncodr::Parser.parse_string(scanner)}.should raise_error BEncodr::BEncodeError
-    end
-
-    it "should raise an error if the colon is missing" do
-      scanner = StringScanner.new("3aaa")
-      lambda {BEncodr::Parser.parse_string(scanner)}.should raise_error BEncodr::BEncodeError
-    end
+  describe "#parse_string" do
+    it{ should parse("6:string").as(:string).to("string") }
+    it{ should parse("0:").as(:string).to("") }
+    it{ should generate_parse_error(BEncodr::BEncodeError).for(:string).with("fail:") }
+    it{ should generate_parse_error(BEncodr::BEncodeError).for(:string).with("3:a") }
+    it{ should generate_parse_error(BEncodr::BEncodeError).for(:string).with("3aaa") }
   end
 
   describe "#parse_integer" do
-    it "should parse a bencoded integer" do
-      scanner = StringScanner.new("i4e")
-      BEncodr::Parser.parse_integer(scanner).should == 4
-    end
-
-    it "should raise an error if there is no starting i" do
-      scanner = StringScanner.new("4e")
-      lambda{BEncodr::Parser.parse_integer(scanner)}.should raise_error BEncodr::BEncodeError
-    end
-
-    it "should raise an error if there is no integer" do
-      scanner = StringScanner.new("ie")
-      lambda{BEncodr::Parser.parse_integer(scanner)}.should raise_error BEncodr::BEncodeError
-    end
-
-    it "should raise an error if there is no closing e" do
-      scanner = StringScanner.new("i4")
-      lambda{BEncodr::Parser.parse_integer(scanner)}.should raise_error BEncodr::BEncodeError
-    end
+    it{ should parse("i4e").as(:integer).to(4) }
+    it{ should generate_parse_error(BEncodr::BEncodeError).for(:integer).with("4e") }
+    it{ should generate_parse_error(BEncodr::BEncodeError).for(:integer).with("ie") }
+    it{ should generate_parse_error(BEncodr::BEncodeError).for(:integer).with("i4") }
   end
 
   describe "#parse_list" do
-    it "should parse an empty bencoded list" do
-      scanner = StringScanner.new("le")
-      BEncodr::Parser.parse_list(scanner).should == []
-    end
-
-    it "should parse a bencoded list containing a string" do
-      scanner = StringScanner.new("l6:stringeeeee")
-      BEncodr::Parser.parse_list(scanner).should == ["string"]
-    end
-
-    it "should parse a bencoded list containing more than one string" do
-      scanner = StringScanner.new("l6:string6:stringe")
-      BEncodr::Parser.parse_list(scanner).should == ["string", "string"]
-    end
-
-    it "should parse a bencoded list containing an integer" do
-      scanner = StringScanner.new("li1ee")
-      BEncodr::Parser.parse_list(scanner).should == [1]
-    end
-
-    it "should parse a bencoded list containing more than one integer" do
-      scanner = StringScanner.new("li1ei2ee")
-      BEncodr::Parser.parse_list(scanner).should == [1, 2]
-    end
-
-    it "should parse a bencoded list containing a list" do
-      scanner = StringScanner.new("llee")
-      BEncodr::Parser.parse_list(scanner).should == [[]]
-    end
-
-    it "should parse a bencoded list containing more than one list" do
-      scanner = StringScanner.new("llelee")
-      BEncodr::Parser.parse_list(scanner).should == [[], []]
-    end
-
-    it "should parse a bencoded list containing a dictionary" do
-      scanner = StringScanner.new("ldee")
-      BEncodr::Parser.parse_list(scanner).should == [{}]
-    end
-
-    it "should parse a bencoded list containing more than one dictionary" do
-      scanner = StringScanner.new("ldedee")
-      BEncodr::Parser.parse_list(scanner).should == [{}, {}]
-    end
-
-    it "should raise an error if there is no starting l" do
-      scanner = StringScanner.new("e")
-      lambda{BEncodr::Parser.parse_list(scanner)}.should raise_error BEncodr::BEncodeError
-    end
-
-    it "should raise an error if there is no closing e" do
-      scanner = StringScanner.new("l")
-      lambda{BEncodr::Parser.parse_list(scanner)}.should raise_error BEncodr::BEncodeError
-    end
+    it{ should parse("le").as(:list).to([]) }
+    it{ should parse("l6:stringeeeee").as(:list).to(["string"]) }
+    it{ should parse("l6:string6:stringe").as(:list).to(["string", "string"]) }
+    it{ should parse("li1ee").as(:list).to([1]) }
+    it{ should parse("li1ei-2ee").as(:list).to([1, -2]) }
+    it{ should parse("llee").as(:list).to([[]]) }
+    it{ should parse("llelee").as(:list).to([[], []]) }
+    it{ should parse("ldee").as(:list).to([{}]) }
+    it{ should parse("ldedee").as(:list).to([{}, {}]) }
+    it{ should generate_parse_error(BEncodr::BEncodeError).for(:list).with("e") }
+    it{ should generate_parse_error(BEncodr::BEncodeError).for(:list).with("l") }
   end
 
   describe "#parse_dictionary" do
-    it "should parse an empty bencoded dictionary" do
-      scanner = StringScanner.new("de")
-      BEncodr::Parser.parse_dictionary(scanner).should == {}
-    end
-
-    it "should parse a bencoded dictionary containing a key value pair" do
-      scanner = StringScanner.new("d6:stringi1ee")
-      BEncodr::Parser.parse_dictionary(scanner).should == {"string" => 1}
-    end
-
-    it "should parse a bencoded dictionary containing more than one key value pair" do
-      scanner = StringScanner.new("d7:anotherle6:stringi1ee")
-      BEncodr::Parser.parse_dictionary(scanner).should == {"string" => 1, "another" => []}
-    end
-
-    it "should raise an error if there is no starting d" do
-      scanner = StringScanner.new("e")
-      lambda{BEncodr::Parser.parse_dictionary(scanner)}.should raise_error BEncodr::BEncodeError
-    end
-
-    it "should raise an error if the key is not a string" do
-      scanner = StringScanner.new("di1ei1ee")
-      lambda{BEncodr::Parser.parse_dictionary(scanner)}.should raise_error BEncodr::BEncodeError
-    end
-
-    it "should raise an error if there is no closing e" do
-      scanner = StringScanner.new("d")
-      lambda{BEncodr::Parser.parse_dictionary(scanner)}.should raise_error BEncodr::BEncodeError
-    end
-
-    it "should raise an error if there is a key with no value" do
-      scanner = StringScanner.new("d1:ae")
-      lambda{BEncodr::Parser.parse_dictionary(scanner)}.should raise_error BEncodr::BEncodeError
-    end
+    it{ should parse("de").as(:dictionary).to({}) }
+    it{ should parse("d6:stringi1ee").as(:dictionary).to({"string" => 1}) }
+    it{ should parse("d7:anotherle6:stringi1ee").as(:dictionary).to({"string" => 1, "another" => []}) }
+    it{ should generate_parse_error(BEncodr::BEncodeError).for(:dictionary).with("e") }
+    it{ should generate_parse_error(BEncodr::BEncodeError).for(:dictionary).with("di1ei1ee") }
+    it{ should generate_parse_error(BEncodr::BEncodeError).for(:dictionary).with("d") }
+    it{ should generate_parse_error(BEncodr::BEncodeError).for(:dictionary).with("d1:ae") }
   end
 end
 
 describe String do
   describe "#bdecode" do
-    it "should decode a bencoded string into a ruby string" do
-      "6:string".bdecode.should == "string"
-    end
-
-    it "should decode a bencoded integer into a ruby integer" do
-      "i-1e".bdecode.should == -1
-    end
-
-    it "should decode a bencoded list into a ruby array" do
-      "le".bdecode.should == []
-    end
-
-    it "should decode a bencoded dictionary into a ruby hash" do
-      "de".bdecode.should == {}
-    end
+    it{ "6:string".should bdecode_to("string") }
+    it{ "i-1e".should bdecode_to(-1) }
+    it{ "le".should bdecode_to([]) }
+    it{ "de".should bdecode_to({}) }
   end
 end