bencodr 1.0.1

data/.autotest

@@ -0,0 +1,34 @@
+module Autotest::GnomeNotify
+
+  # Time notification will be displayed before disappearing automatically
+  EXPIRATION_IN_SECONDS = 2
+  ERROR_STOCK_ICON = "gtk-dialog-error"
+  SUCCESS_STOCK_ICON = "gtk-dialog-info"
+
+  # Convenience method to send an error notification message
+  #
+  # [stock_icon]   Stock icon name of icon to display
+  # [title]        Notification message title
+  # [message]      Core message for the notification
+  def self.notify stock_icon, title, message
+    options = "-t #{EXPIRATION_IN_SECONDS * 1000} -i #{stock_icon}"
+    system "notify-send #{options} '#{title}' \"#{message}\""
+  end
+
+  Autotest.add_hook :red do |at|
+    example_text = ""
+    num_examples = 0
+    examples = at.files_to_test.each_pair do |key, values|
+      example_text += "- #{key}\n"
+      values.each do |value|
+        num_examples += 1
+        example_text += "  * #{value}\n"
+      end
+    end
+    notify ERROR_STOCK_ICON, "Tests failed", "<b>#{num_examples} examples failed in #{at.files_to_test.size} files</b>\n#{example_text}"
+  end
+
+  Autotest.add_hook :green do |at|
+    notify SUCCESS_STOCK_ICON, "All tests passed, good job!", ""
+  end
+end

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,25 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC
+.idea
+doc
+.yardoc
+tmp/*

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 blatyo
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,147 @@
+= BEncodr
+* *Author* Allen Madsen (blatyo)
+* *My* *Site* http://www.allenmadsen.com
+* *Gem* http://gemcutter.org/gems/bencodr
+* *Source* http://github.com/blatyo/bencodr
+* *Documentation* http://blatyo.github.com/bencodr
+* *Issue* *Tracker* http://github.com/blatyo/bencodr/issues 
+
+== Synopsis
+This gem provides a way to encode and parse bencodings used by the Bit Torrent protocol.
+
+== Installation
+
+    # install the gem
+    > gem install bencodr
+    Successfully installed bencodr
+    1 gem installed
+    Installing ri documentation for bencodr...
+    Building YARD (yri) index for bencodr...
+    Installing RDoc documentation for bencodr
+
+    # somefile.rb
+    require 'bencodr'
+
+== Examples
+=== String
+BEncoded strings are length-prefixed base ten followed by a colon and the string.
+
+    # strings
+    "".bencode              #=> "0:"
+    "string".bencode        #=> "6:string"
+
+    # symbols
+    :symbol.bencode         #=> "6:symbol"
+
+    # URIs
+    uri = URI.parse("http://github.com/blatyo/bencode")
+    uri.bencode             #=> "32:http://github.com/blatyo/bencode"
+
+=== Integer
+Bencoded integers are represented by an 'i' followed by the number in base 10 followed by an 'e'.
+
+    # integers
+    1.bencode               #=> "i1e"
+    -1.bencode              #=> "i-1e"
+    10_000_000_000.bencode  #=> "i10000000000e"
+
+    # other numerics
+    1.1.bencode             #=> "i1e"
+    -1e10.bencode           #=> "i-10000000000e"
+
+    # times
+    Time.at(4).bencode      #=> "i4e"
+
+=== List
+Bencoded lists are encoded as an 'l' followed by their elements (also bencoded) followed by an 'e'.
+
+    # arrays
+    [].bencode                        #=> "le"
+    [:e, "a", 1, Time.at(11)].bencode #=> "l1:e1:ai1ei11ee"
+
+=== Dictionary
+Bencoded dictionaries are encoded as a 'd' followed by a list of alternating keys and their corresponding values
+followed by an 'e'. Keys appear in sorted order (sorted as raw strings, not alphanumerics) and are always strings.
+
+    # hashes
+    {}.bencode                          #=> "de"
+    {"string" => "string"}.bencode      #=> "d6:string6:stringe"
+    {:symbol => :symbol}.bencode        #=> "d6:symbol6:symbole"
+    {1 => 1}.bencode                    #=> "d1:1i1ee"
+    {1.1 => 1.1}.bencode                #=> "d3:1.1i1ee"
+    {{} => {}}.bencode                  #=> "d2:{}dee"
+
+    time = Time.utc(0)
+    {time => time}.bencode              #=> "d23:2000-01-01 00:00:00 UTCi946684800ee"
+
+    array = (1..4).to_a
+    {array => array}.bencode            #=> "d12:[1, 2, 3, 4]li1ei2ei3ei4eee"
+
+    # Note: keys are sorted as raw strings.
+    {:a => 1, "A" => 1, 1=> 1}.bencode  #=> "d1:1i1e1:Ai1e1:ai1ee"
+
+=== Encoding and Decoding
+
+    # encoding is just like calling bencode on the object
+    BEncodr.encode("string")    #=> "6:string"
+
+    # decoding takes a string and return either a String, Integer, Array, or Hash
+    BEncodr.decode("6:string")  #=> "string"
+    BEncodr.decode("i1e")       #=> 1
+    BEncodr.decode("le")        #=> []
+    BEncodr.decode("de")        #=> {}
+
+    # you can work directly with files too
+    BEncodr.encode_file("my_awesome.torrent", {:announce => "http://www.sometracker.com/announce:80"})
+    BEncodr.decode_file("my_awesome.torrent") #=> {:announce => "http://www.sometracker.com/announce:80"}
+
+=== Registering Types
+When using bencodings it may be useful to translate your own objects into bencoded strings. You can do that with the
+register methods on each BEncode type. All register does is define a bencode instance method for the class that
+internally uses type conversion. That means if you want to specify a String type then your class must have a to_s or
+to_str instance method. The same goes for all the other types.
+
+Keep in mind when registering that if you register a class for two separate types it will only retain the bencode method
+of the last type registered for.
+
+    # register string type
+    BEncodr::String.register Range
+    (1..2).bencode      #=> "4:1..2"
+
+    # register integer type
+    BEncodr::Integer.register NilClass
+    nil.bencode         #=> "i0e"
+
+    # register list type
+    BEncodr::List.register Range
+    (1..2).bencode      #=> "li1ei2ee"
+
+    #register dictionary type
+    MyClass = Class.new do
+      def to_h
+        {:a => "a", :b => "b"}
+      end
+    end
+    BEncodr::Dictionary.register MyClass
+    MyClass.new.bencode #=> "d1:a1:a1:b1:be"
+
+== Note on Reporting Issues
+
+* Try to make a failing test case
+* Tell me which version of ruby you're using
+* Tell me which OS you are using
+* Provide me with any extra files if necessary
+
+== Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 blatyo. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "bencodr"
+    gem.summary = "This gem provides a way to encode and parse bencodings used by the Bit Torrent protocol."
+    gem.description = "This gem provides a way to encode and parse bencodings used by the Bit Torrent protocol."
+    gem.email = "blatyo@gmail.com"
+    gem.homepage = "http://github.com/blatyo/bencodr"
+    gem.authors = ["Allen Madsen"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_development_dependency "yard", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yardoc do
+    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
+  end
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.1

data/autotest/discover.rb

@@ -0,0 +1,3 @@
+Autotest.add_discovery do
+  "rspec"
+end

data/bencode_blatyo.gemspec

@@ -0,0 +1,78 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{bencode_blatyo}
+  s.version = "1.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Allen Madsen"]
+  s.date = %q{2010-02-02}
+  s.description = %q{This gem has been renamed to bencodr. Use that one instead.}
+  s.email = %q{blatyo@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".autotest",
+     ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "autotest/discover.rb",
+     "bencode_blatyo.gemspec",
+     "lib/bencodr.rb",
+     "lib/bencodr/dictionary.rb",
+     "lib/bencodr/integer.rb",
+     "lib/bencodr/list.rb",
+     "lib/bencodr/parser.rb",
+     "lib/bencodr/string.rb",
+     "spec/bencodr/dictionary_spec.rb",
+     "spec/bencodr/integer_spec.rb",
+     "spec/bencodr/list_spec.rb",
+     "spec/bencodr/parser_spec.rb",
+     "spec/bencodr/string_spec.rb",
+     "spec/bencode_spec.rb",
+     "spec/samples/bencodr.rb.torrent",
+     "spec/samples/mini.bencodr",
+     "spec/samples/python.torrent",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/blatyo/bencodr}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{This gem has been renamed to bencodr. Use that one instead.}
+  s.test_files = [
+    "spec/bencodr/dictionary_spec.rb",
+     "spec/bencodr/integer_spec.rb",
+     "spec/bencodr/list_spec.rb",
+     "spec/bencodr/parser_spec.rb",
+     "spec/bencodr/string_spec.rb",
+     "spec/bencode_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+      s.add_development_dependency(%q<yard>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, [">= 1.2.9"])
+      s.add_dependency(%q<yard>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    s.add_dependency(%q<yard>, [">= 0"])
+  end
+end
+

data/lib/bencodr/dictionary.rb

@@ -0,0 +1,57 @@
+# encoding: UTF-8
+
+module BEncodr
+  module Dictionary
+    module Generic
+      module InstanceMethods
+        # Encodes an array into a bencoded dictionary. Bencoded dictionaries are encoded as a 'd' followed by a list of
+        # alternating keys and their corresponding values followed by an 'e'. Keys appear in sorted order (sorted as raw
+        # strings, not alphanumerics).
+        #
+        #   {:cow => "moo", :seven => 7}.bencodr #=> "d3:cow3:moo5:seveni7ee"
+        #
+        # @return [::String] the bencoded dictionary
+        def bencode
+          (respond_to?(:to_h) ? to_h : to_hash).bencode
+        end
+      end
+    end
+
+    # Registers a class as an object that can be converted into a bencoded dictionary. Class must have instance method
+    # to_h or to_hash.
+    #
+    #   class MyClass
+    #     def to_h
+    #       {:a => :a, :b => 1}
+    #     end
+    #   end
+    #
+    #   BEncodr::String.register MyClass
+    #   my_class = MyClass.new
+    #   my_class.bencodr  #=> "d1:a1:a1:bi1ee"
+    #
+    # @param [Class#to_h, Class#to_hash] type the class to add the bencodr instance method to
+    def self.register(type)
+      type.send :include, Generic::InstanceMethods
+    end
+
+    module Hash
+      module InstanceMethods
+        # Encodes an array into a bencoded dictionary. Bencoded dictionaries are encoded as a 'd' followed by a list of
+        # alternating keys and their corresponding values followed by an 'e'. Keys appear in sorted order (sorted as raw
+        # strings, not alphanumerics).
+        #
+        #   {:cow => "moo", :seven => 7}.bencodr #=> "d3:cow3:moo5:seveni7ee"
+        #
+        # @return [::String] the bencoded dictionary 
+        def bencode
+          keys.sort{|a, b| a.to_s <=> b.to_s}.collect do |key|
+            key.to_s.bencode + self[key].bencode
+          end.unshift(:d).push(:e).join
+        end
+      end
+
+      ::Hash.send :include, InstanceMethods
+    end
+  end
+end

data/lib/bencodr/integer.rb

@@ -0,0 +1,57 @@
+# encoding: UTF-8
+
+module BEncodr
+  module Integer
+    module Generic
+      module InstanceMethods
+        # Encodes object into a bencoded integer. BEncoded strings are length-prefixed base ten followed by a colon and
+        # the string. Object must implement to_i or to_int.
+        #
+        #   1.bencodr #=> "i1e"
+        #
+        # @return [::String] the bencoded integer
+        def bencode
+          (respond_to?(:to_i) ? to_i : to_int).bencode
+        end
+      end
+    end
+
+    # Registers a class as an object that can be converted into a bencoded integer. Class must have instance method to_i
+    # or to_int.
+    #
+    #   class MyClass
+    #     def to_i
+    #       1
+    #     end
+    #   end
+    #
+    #   BEncodr::Integer.register MyClass
+    #   my_class = MyClass.new
+    #   my_class.bencodr  #=> "i1e"
+    #
+    # @param [Class#to_i, Class#to_int] type the class to add the bencodr instance method to
+    def self.register(type)
+      type.send :include, Generic::InstanceMethods
+    end
+
+    register Numeric
+    register Time
+
+    module Integer
+      module InstanceMethods
+        # Encodes an integer into a bencoded integer. Bencoded integers are represented by an 'i' followed by the number
+        # in base 10 followed by an 'e'.
+        #
+        #   3.bencodr #=> "i3e"
+        #   -3.bencodr #=> "i-3e"
+        #
+        # @return [::String] the bencoded integer
+        def bencode
+          [:i, self, :e].join
+        end
+      end
+
+      ::Integer.send :include, InstanceMethods
+    end
+  end
+end

data/lib/bencodr/list.rb

@@ -0,0 +1,55 @@
+# encoding: UTF-8
+
+module BEncodr
+  module List
+    module Generic
+      module InstanceMethods
+        # Encodes object into a bencoded list. BEncoded strings are length-prefixed base ten followed by a colon and
+        # the string. Object must implement to_a or to_ary.
+        #
+        #   [].bencodr #=> "le"
+        #
+        # @return [::String] the bencoded list
+        def bencode
+          (respond_to?(:to_ary) ? to_ary : to_a).bencode
+        end
+      end
+    end
+
+    # Registers a class as an object that can be converted into a bencoded list. Class must have instance method to_a
+    # or to_ary.
+    #
+    #   class MyClass
+    #     def to_a
+    #       [1, :cat]
+    #     end
+    #   end
+    #
+    #   BEncodr::Integer.register MyClass
+    #   my_class = MyClass.new
+    #   my_class.bencodr  #=> "li1e3:cate"
+    #
+    # @param [Class#to_a, Class#to_ary] type the class to add the bencodr instance method to
+    def self.register(type)
+      type.send :include, Generic::InstanceMethods
+    end
+
+    module Array
+      module InstanceMethods
+        # Encodes an array into a bencoded list. Bencoded lists are encoded as an 'l' followed by their elements (also
+        # bencoded) followed by an 'e'.
+        #
+        #   [:eggs, "ham", 3, 4.1].bencodr #=> "l4:eggs3:hami3ei4ee"
+        #
+        # @return [::String] the bencoded list
+        def bencode
+          collect do |element|
+            element.bencode
+          end.unshift(:l).push(:e).join
+        end
+      end
+
+      ::Array.send :include, InstanceMethods
+    end
+  end
+end

data/lib/bencodr/parser.rb

@@ -0,0 +1,113 @@
+# encoding: UTF-8
+
+require 'strscan'
+
+module BEncodr
+  module Parser
+    class << self
+      # This method parases a bencoded object.
+      #
+      #   scanner = StringScanner.new("6:string")
+      #   BEncodr::Parser.parse_object(scanner) #=> "string"
+      #
+      # @param [StringScanner] scanner the scanner of a bencoded object
+      # @return [::String, ::Integer, ::Hash, ::Array, nil] an object if type is recognized or nil
+      def parse_object(scanner)
+        case scanner.peek(1)[0]
+          when ?0..?9
+            parse_string(scanner)
+          when ?i
+            parse_integer(scanner)
+          when ?l
+            parse_list(scanner)
+          when ?d
+            parse_dictionary(scanner)
+          else
+            nil
+        end
+      end
+
+      # This method parases a bencoded string.
+      #
+      #   scanner = StringScanner.new("6:string")
+      #   BEncodr::Parser.parse_string(scanner) #=> "string"
+      #
+      # @param [StringScanner] scanner the scanner of a bencoded string
+      # @return [::String] the parsed string
+      def parse_string(scanner)
+        length = scanner.scan(/[1-9][0-9]*|0/)    or raise BEncodeError, "Invalid string: length invalid. #{scanner.pos}"
+        scanner.scan(/:/)                         or raise BEncodeError, "Invalid string: missing colon(:). #{scanner.pos}"
+        scanner.scan(/.{#{length}}/m)             or raise BEncodeError, "Invalid string: length too long(#{length}) #{scanner.pos}."
+      end
+
+      # This method parases a bencoded integer.
+      #
+      #   scanner = StringScanner.new("i1e")
+      #   BEncodr::Parser.parse_integer(scanner) #=> 1
+      #
+      # @param [StringScanner] scanner the scanner of a bencoded integer
+      # @return [::Integer] the parsed integer
+      def parse_integer(scanner)
+        scanner.scan(/i/)                         or raise BEncodeError, "Invalid integer: missing opening i. #{scanner.pos}"
+        integer = scanner.scan(/-?[1-9][0-9]*|0/) or raise BEncodeError, "Invalid integer: valid integer not found. #{scanner.pos}"
+        scanner.scan(/e/)                         or raise BEncodeError, "Invalid integer: missing closing e. #{scanner.pos}"
+        integer.to_i
+      end
+
+      # This method parases a bencoded list.
+      #
+      #   scanner = StringScanner.new("le")
+      #   BEncodr::Parser.parse_list(scanner) #=> []
+      #
+      # @param [StringScanner] scanner the scanner of a bencoded list
+      # @return [::Array] the parsed array
+      def parse_list(scanner)
+        list = []
+
+        scanner.scan(/l/) or raise BEncodeError, "Invalid list: missing opening l. #{scanner.pos}"
+        while true
+          object = parse_object(scanner)
+          break unless object
+          list << object
+        end
+        scanner.scan(/e/) or raise BEncodeError, "Invalid list: missing closing e. #{scanner.pos}"
+
+        list
+      end
+
+      # This method parases a bencoded dictionary.
+      #
+      #   scanner = StringScanner.new("de")
+      #   BEncodr::Parser.parse_dictionary(scanner) #=> {}
+      #
+      # @param [StringScanner] scanner the scanner of a bencoded dictionary
+      # @return [::Hash] the parsed hash
+      def parse_dictionary(scanner)
+        dictionary = {}
+
+        scanner.scan(/d/) or raise BEncodeError, "Invalid dictionary: missing opening d. #{scanner.pos}"
+        while true
+          key_value = parse_key_value(scanner)
+          break unless key_value
+          dictionary.store(*key_value)
+        end
+        scanner.scan(/e/) or raise BEncodeError, "Invalid dictionary: missing closing e. #{scanner.pos}"
+
+        dictionary
+      end
+
+
+      def parse_key_value(scanner) # :nodoc:
+        key = parse_object(scanner)
+        return key unless key
+        raise BEncodeError, "Invalid dictionary: key is not a string. #{scanner.pos}" unless key.is_a?(::String)
+
+        value = parse_object(scanner)
+        raise BEncodeError, "Invalid dictionary: missing value for key (#{key}). #{scanner.pos}" unless value
+
+        [key, value]
+      end
+      private :parse_key_value
+    end
+  end
+end