bencode_blatyo 1.0.0

data/lib/bencode/string.rb

@@ -0,0 +1,58 @@
+# encoding: UTF-8
+
+require 'uri'
+
+module BEncode
+  module String
+    module Generic
+      module InstanceMethods
+        # Encodes object into a bencoded string. BEncoded strings are length-prefixed base ten followed by a colon and
+        # the string.
+        #
+        #   :symbol.bencode #=> "6:symbol"
+        #
+        # @return [String] the bencoded string
+        def bencode
+          (respond_to?(:to_s) ? to_s : to_str).bencode
+        end
+      end
+    end
+
+    # Registers a class as an object that can be converted into a bencoded string. Class must have instance method to_s
+    # or to_str.
+    #
+    #   class MyClass
+    #     def to_s
+    #       "string"
+    #     end
+    #   end
+    #
+    #   BEncode::String.register MyClass
+    #   my_class = MyClass.new
+    #   my_class.bencode  #=> "6:string"
+    #
+    # @param [Class#to_s, Class#to_str] type the class to add the bencode instance method to
+    def self.register(type)
+      type.send :include, Generic::InstanceMethods
+    end
+
+    register Symbol
+    register URI::Generic
+
+    module String
+      module InstanceMethods
+        # Encodes a string into a bencoded string. BEncoded strings are length-prefixed base ten followed by a colon and
+        # the string.
+        #
+        #   "string".bencode #=> "6:string"
+        #
+        # @return [String] the bencoded string
+        def bencode
+          [length, ':', self].join
+        end
+      end
+
+      ::String.send :include, InstanceMethods
+    end
+  end
+end

data/lib/bencode.rb

@@ -0,0 +1,56 @@
+# encoding: UTF-8
+
+path = File.expand_path(File.dirname(__FILE__)) + "/bencode"
+
+require path + "/string"
+require path + "/integer"
+require path + "/list"
+require path + "/dictionary"
+require path + "/parser"
+
+module BEncode
+  class BEncodeError < StandardError; end
+
+  class << self
+    # This method decodes a bencoded string.
+    #
+    #   BEncode.decode("6:string") #=> "string"
+    #
+    # @param [String] string the bencoded string to decode
+    # @return [String, Integer, Hash, Array] the decoded object
+    def decode(string)
+      scanner = StringScanner.new(string)
+      Parser.parse_object(scanner) or raise BEncodeError, "Invalid bencoding"
+    end
+
+    # This method decodes a bencoded file.
+    #
+    #   BEncode.decode_file("simple.torrent") #=> "d8:announce32:http://www..."
+    #
+    # @param [String] file the file to decode
+    # @return [String, Integer, Hash, Array] the decoded object
+    def decode_file(file)
+      decode(File.open(file, 'rb') {|f| f.read})
+    end
+
+    # This method encodes a bencoded object.
+    #
+    #   BEncode.encode("string") #=> "6:string"
+    #
+    # @param [#bencode] object the object to encode
+    # @return [String] the bencoded object
+    def encode(object)
+      object.bencode
+    end
+
+    # This method encodes a bencoded object.
+    #
+    #   BEncode.encode("string") #=> "6:string"
+    #
+    # @param [String] file the file to write the bencoded object to
+    # @param [#bencode] object the object to encode
+    def encode_file(file, object)
+      File.open(file, 'wb') {|f| f.write encode(object)}
+    end
+  end
+end

data/spec/bencode/dictionary_spec.rb

@@ -0,0 +1,79 @@
+# encoding: UTF-8
+
+require "spec"
+require "spec_helper"
+
+describe Hash do
+  describe "#bencode" 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 BEncode::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
+        BEncode::Dictionary.register klass
+        @instance = klass.new
+      end
+
+      context "an instance of that object" do
+        it "should respond to bencode" 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
+end

data/spec/bencode/integer_spec.rb

@@ -0,0 +1,72 @@
+# encoding: UTF-8
+
+require "spec"
+require "spec_helper"
+
+describe Integer do
+  describe "#bencode" 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 "#bencode" 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 "#bencode" do
+    it "should encode to bencoding" do
+      Time.at(4).bencode.should == "i4e"
+    end
+  end
+end
+
+describe BEncode::Integer do
+  describe "#register" do
+    context "once an object has been registered as a BEncode integer" do
+      before :all do
+        BEncode::Integer.register NilClass
+      end
+
+      context "an instance of that object" do
+        it "should respond to bencode" do
+          nil.should respond_to :bencode
+        end
+
+        it "should encode to a bencoded integer" do
+          nil.bencode.should == "i0e"
+        end
+      end
+    end
+  end
+end

data/spec/bencode/list_spec.rb

@@ -0,0 +1,36 @@
+# encoding: UTF-8
+
+require "spec"
+require "spec_helper"
+
+describe Array do
+  describe "#bencode" 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 BEncode::List do
+  describe "#register" do
+    context "once an object has been registered as a BEncode list" do
+      before :all do
+        BEncode::List.register Range
+      end
+
+      context "an instance of that object" do
+        it "should respond to bencode" 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
+end

data/spec/bencode/parser_spec.rb

@@ -0,0 +1,176 @@
+# encoding: UTF-8
+
+require "spec"
+
+describe BEncode::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")
+      BEncode::Parser.parse_object(scanner).should == "string"
+    end
+
+    it "should parse a bencoded integer" do
+      scanner = StringScanner.new("i4e")
+      BEncode::Parser.parse_object(scanner).should == 4
+    end
+
+    it "should parse a bencoded list" do
+      scanner = StringScanner.new("l6:stringeeeee")
+      BEncode::Parser.parse_object(scanner).should == ["string"]
+    end
+
+    it "should parse a bencoded dictionary containing a key value pair" do
+      scanner = StringScanner.new("d6:stringi1ee")
+      BEncode::Parser.parse_object(scanner).should == {"string" => 1}
+    end
+
+    it "should return nil when the type is not recognized" do
+      scanner = StringScanner.new("freak out!")
+      BEncode::Parser.parse_object(scanner).should == nil
+    end
+  end
+
+  describe "#parse_stirng" do
+    it "should parse a bencoded string" do
+      scanner = StringScanner.new("6:string")
+      BEncode::Parser.parse_string(scanner).should == "string"
+    end
+
+    it "should parse a zero length bencoded string" do
+      scanner = StringScanner.new("0:")
+      BEncode::Parser.parse_string(scanner).should == ""
+    end
+
+    it "should raise an error if the length is invalid" do
+      scanner = StringScanner.new("fail:")
+      lambda {BEncode::Parser.parse_string(scanner)}.should raise_error BEncode::BEncodeError
+    end
+
+    it "should raise an error if length is too long" do
+      scanner = StringScanner.new("3:a")
+      lambda {BEncode::Parser.parse_string(scanner)}.should raise_error BEncode::BEncodeError
+    end
+
+    it "should raise an error if the colon is missing" do
+      scanner = StringScanner.new("3aaa")
+      lambda {BEncode::Parser.parse_string(scanner)}.should raise_error BEncode::BEncodeError
+    end
+  end
+
+  describe "#parse_integer" do
+    it "should parse a bencoded integer" do
+      scanner = StringScanner.new("i4e")
+      BEncode::Parser.parse_integer(scanner).should == 4
+    end
+
+    it "should raise an error if there is no starting i" do
+      scanner = StringScanner.new("4e")
+      lambda{BEncode::Parser.parse_integer(scanner)}.should raise_error BEncode::BEncodeError
+    end
+
+    it "should raise an error if there is no integer" do
+      scanner = StringScanner.new("ie")
+      lambda{BEncode::Parser.parse_integer(scanner)}.should raise_error BEncode::BEncodeError
+    end
+
+    it "should raise an error if there is no closing e" do
+      scanner = StringScanner.new("i4")
+      lambda{BEncode::Parser.parse_integer(scanner)}.should raise_error BEncode::BEncodeError
+    end
+  end
+
+  describe "#parse_list" do
+    it "should parse an empty bencoded list" do
+      scanner = StringScanner.new("le")
+      BEncode::Parser.parse_list(scanner).should == []
+    end
+
+    it "should parse a bencoded list containing a string" do
+      scanner = StringScanner.new("l6:stringeeeee")
+      BEncode::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")
+      BEncode::Parser.parse_list(scanner).should == ["string", "string"]
+    end
+
+    it "should parse a bencoded list containing an integer" do
+      scanner = StringScanner.new("li1ee")
+      BEncode::Parser.parse_list(scanner).should == [1]
+    end
+
+    it "should parse a bencoded list containing more than one integer" do
+      scanner = StringScanner.new("li1ei2ee")
+      BEncode::Parser.parse_list(scanner).should == [1, 2]
+    end
+
+    it "should parse a bencoded list containing a list" do
+      scanner = StringScanner.new("llee")
+      BEncode::Parser.parse_list(scanner).should == [[]]
+    end
+
+    it "should parse a bencoded list containing more than one list" do
+      scanner = StringScanner.new("llelee")
+      BEncode::Parser.parse_list(scanner).should == [[], []]
+    end
+
+    it "should parse a bencoded list containing a dictionary" do
+      scanner = StringScanner.new("ldee")
+      BEncode::Parser.parse_list(scanner).should == [{}]
+    end
+
+    it "should parse a bencoded list containing more than one dictionary" do
+      scanner = StringScanner.new("ldedee")
+      BEncode::Parser.parse_list(scanner).should == [{}, {}]
+    end
+
+    it "should raise an error if there is no starting l" do
+      scanner = StringScanner.new("e")
+      lambda{BEncode::Parser.parse_list(scanner)}.should raise_error BEncode::BEncodeError
+    end
+
+    it "should raise an error if there is no closing e" do
+      scanner = StringScanner.new("l")
+      lambda{BEncode::Parser.parse_list(scanner)}.should raise_error BEncode::BEncodeError
+    end
+  end
+
+  describe "#parse_dictionary" do
+    it "should parse an empty bencoded dictionary" do
+      scanner = StringScanner.new("de")
+      BEncode::Parser.parse_dictionary(scanner).should == {}
+    end
+
+    it "should parse a bencoded dictionary containing a key value pair" do
+      scanner = StringScanner.new("d6:stringi1ee")
+      BEncode::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")
+      BEncode::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{BEncode::Parser.parse_dictionary(scanner)}.should raise_error BEncode::BEncodeError
+    end
+
+    it "should raise an error if the key is not a string" do
+      scanner = StringScanner.new("di1ei1ee")
+      lambda{BEncode::Parser.parse_dictionary(scanner)}.should raise_error BEncode::BEncodeError
+    end
+
+    it "should raise an error if there is no closing e" do
+      scanner = StringScanner.new("d")
+      lambda{BEncode::Parser.parse_dictionary(scanner)}.should raise_error BEncode::BEncodeError
+    end
+
+    it "should raise an error if there is a key with no value" do
+      scanner = StringScanner.new("d1:ae")
+      lambda{BEncode::Parser.parse_dictionary(scanner)}.should raise_error BEncode::BEncodeError
+    end
+  end
+end

data/spec/bencode/string_spec.rb

@@ -0,0 +1,73 @@
+# encoding: UTF-8
+
+require "spec"
+require "spec_helper"
+
+describe String do
+  describe "#bencode" do
+    it "should encode a string" do
+      "string".bencode.should == "6:string"
+    end
+
+    it "should encode a zero length string" do
+      "".bencode.should == "0:"
+    end
+  end
+end
+
+describe Symbol do
+  describe "#bencode" do
+    it "should encode a symbol" do
+      :symbol.bencode.should == "6:symbol"
+    end
+  end
+end
+
+describe URI::Generic do
+  describe "#bencode" do
+    it "should encode a http uri" do
+      uri = URI.parse("http://github.com/blatyo/bencode")
+      uri.bencode.should == "32:http://github.com/blatyo/bencode"
+    end
+
+    it "should encode a https uri" do
+      uri = URI.parse("https://github.com/blatyo/bencode")
+      uri.bencode.should == "33:https://github.com/blatyo/bencode"
+    end
+
+    it "should encode a ftp uri" do
+      uri = URI.parse("ftp://github.com/blatyo/bencode")
+      uri.bencode.should == "31:ftp://github.com/blatyo/bencode"
+    end
+
+    it "should encode a ldap uri" do
+      uri = URI.parse("ldap://github.com/blatyo/bencode")
+      uri.bencode.should == "32:ldap://github.com/blatyo/bencode"
+    end
+
+    it "should encode a mailto uri" do
+      uri = URI.parse("mailto:sudo@sudoers.su")
+      uri.bencode.should == "22:mailto:sudo@sudoers.su"
+    end
+  end
+end
+
+describe BEncode::String do
+  describe "#register" do
+    context "once an object has been registered as a BEncode string" do
+      before :all do
+        BEncode::String.register Range
+      end
+
+      context "an instance of that object" do
+        it "should respond to bencode" do
+          (1..2).should respond_to :bencode
+        end
+
+        it "should encode to a bencoded string" do
+          (1..2).bencode.should == "4:1..2"
+        end
+      end
+    end
+  end
+end

data/spec/bencode_spec.rb

@@ -0,0 +1,72 @@
+# encoding: UTF-8
+
+require "spec"
+require "spec_helper"
+
+describe BEncode do
+  describe "#decode" do
+    # Most of this is covered in other tests. Only difference is this accepts string instead of scanner.
+    it "should parse a bencoded string" do
+      BEncode.decode("6:string").should == "string"
+    end
+
+    it "should parse a bencoded integer" do
+      BEncode.decode("i4e").should == 4
+    end
+
+    it "should parse a bencoded list" do
+      BEncode.decode("l6:stringeeeee").should == ["string"]
+    end
+
+    it "should parse a bencoded dictionary containing a key value pair" do
+      BEncode.decode("d6:stringi1ee").should == {"string" => 1}
+    end
+
+    it "should raise an error when the type is not recognized" do
+      lambda{BEncode.decode("freak out!")}.should raise_error BEncode::BEncodeError
+    end
+  end
+
+  describe "#decode_file" do
+    it "should parse a bencoded file" do
+      dirname = File.dirname(__FILE__)
+      BEncode.decode_file("#{dirname}/samples/mini.bencode").should == {"ba" => 3}
+    end
+  end
+
+  describe "#encode" do
+    # Covered in other tests so only simple stuff here. 
+    it "should bencode an object" do
+      BEncode.encode("string").should == "6:string"
+    end
+  end
+
+  describe "#encode_file" do
+    context "when an object gets bencoded and written to a file" do
+      before :each do
+        @file = File.join(File.dirname(__FILE__), '..', 'tmp', 'test.bencode')
+        @object = "string"
+        BEncode.encode_file(@file, @object)
+      end
+
+      it "should actually write a file" do
+        File.exists?(@file).should be_true
+      end
+
+      it "should properly encode the file" do
+        BEncode.decode_file(@file).should == @object
+      end
+
+      after :each do
+        File.delete(@file)
+      end
+    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"
+      BEncode.decode_file(file).bencode.should == File.open(file, "rb") {|f| f.read}
+    end
+  end
+end

data/spec/samples/bencode.rb.torrent

@@ -0,0 +1 @@
+d8:announce42:http://tracker.openbittorrent.com/announce13:announce-listll42:http://tracker.openbittorrent.com/announce44:udp://tracker.openbittorrent.com:80/announceee7:comment28:Best bencoding library ever!10:created by13:uTorrent/185013:creation datei1264866817e8:encoding5:UTF-84:infod6:lengthi526e4:name10:bencode.rb12:piece lengthi65536e6:pieces20:�WiP�2�n�����U��W&��ee

data/spec/samples/mini.bencode

@@ -0,0 +1 @@
+d2:bai3ee

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+# encoding: UTF-8
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'bencode'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end