bencodr 1.2.0 → 2.0.0

data/lib/bencodr/dictionary.rb

@@ -2,56 +2,28 @@
 
 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
+    def bencode
+      Dictionary.bencode(self)
     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
+    
+    def self.bencode(hashable)
+      hash = coerce(hashable)
+      
+      hash.keys.sort{|a, b| a.to_s <=> b.to_s}.collect do |key|
+        BEncodr::String.bencode(key.to_s) + Object.bencode(hash[key])
+      end.unshift(:d).push(:e).join
     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
+    
+    private
+    
+    def self.coerce(hashable)
+      if hashable.respond_to?(:to_h)
+        hashable.to_h
+      elsif hashable.respond_to?(:to_hash)
+        hashable.to_hash
+      else
+        raise BEncodeError, "BEncodr::Dictionary.bencode can only be called on an object that provides a to_h or to_hash method."
       end
-
-      ::Hash.send :include, InstanceMethods
     end
   end
 end

data/lib/bencodr/ext.rb

@@ -0,0 +1,38 @@
+module BEncodr
+  module Ext
+    def self.include!
+      include_string!
+      include_integer!
+      include_list!
+      include_dictionary!
+      include_io!
+    end
+    
+    private
+    
+    def self.include_string!
+      ::String.send :include, Object
+      [::String, Symbol, URI::Generic].each do |stringable|
+        stringable.send :include, String
+      end
+    end
+    
+    def self.include_integer!
+      [Numeric, Time].each do |intable|
+        intable.send :include, Integer
+      end
+    end
+    
+    def self.include_list!
+      Array.send :include, List
+    end
+    
+    def self.include_dictionary!
+      Hash.send :include, Dictionary
+    end
+    
+    def self.include_io!
+      ::IO.send :include, IO
+    end
+  end
+end

data/lib/bencodr/integer.rb

@@ -2,56 +2,26 @@
 
 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
+    def bencode
+      Integer.bencode(self)
     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
+    
+    def self.bencode(intable)
+      int = coerce(intable)
+      
+      [:i, int, :e].join
     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
+    
+    private
+    
+    def self.coerce(intable)
+      if intable.respond_to?(:to_i)
+        intable.to_i
+      elsif intable.respond_to?(:to_int)
+        intable.to_int
+      else
+        raise BEncodeError, "BEncodr::Integer.bencode can only be called on an object that provides a to_i or to_int method."
       end
-
-      ::Integer.send :include, InstanceMethods
     end
   end
 end

data/lib/bencodr/io.rb

@@ -1,60 +1,25 @@
-class IO
-  class << self
-    # This method encodes the object and writes it to the specified output.
-    #
-    #   # write to standard out
-    #   IO.bencode(1, "string")             #=> "6:string" to stdout
-    #
-    #   # write to file
-    #   File.bencode("a.bencode", "string") #=> "6:string" to a.bencode
-    #
-    # @param [Object] fd the file descriptor to use for output
-    # @param [Object] object the object to write
-    def bencode(fd, object)
-      open(fd, "wb") {|file| file.bencode object }
+module BEncodr
+  module IO
+    module ClassMethods
+      def bencode(fd, object)
+        open(fd, "wb") {|file| file.bencode(object)}
+      end
+      
+      def bdecode(fd)
+        open(fd, "rb") {|file| file.bdecode}
+      end
     end
-
-    # This method reads from the specified input and decodes the object.
-    #
-    #   # read from standard in
-    #   IO.bdecode(0)             #=> "string"
-    #
-    #   # read from file
-    #   File.bdecode("a.bencode") #=> "string"
-    #
-    # @param [Object] fd the file descriptor to use for input
-    # @param [Object] object the object to write
-    def bdecode(fd)
-      open(fd, "rb") {|file| file.bdecode}
+    
+    def bencode(object)
+      write(Object.bencode(object))
+    end
+    
+    def bdecode
+      Object.bdecode(read)
+    end
+    
+    def self.included(base)
+      base.extend ClassMethods
     end
-  end
-
-  # This method encodes the object and writes.
-  #
-  #   # write to standard out
-  #   $stdout.bencode("string") #=> "6:string" to stdout
-  #
-  #   # write to file
-  #   file = File.open("a.bencode", "wb")
-  #   file.bencode("string")    #=> "6:string" to a.bencode
-  #
-  # @param [Object] object the object to write
-  def bencode(object)
-    write object.bencode
-  end
-
-  # This method reads from the specified input and decodes the object.
-  #
-  #   # read from standard in
-  #   $stdin.bdecode  #=> "string"
-  #
-  #   # read from file
-  #   file = File.open("a.bencode", "wb")
-  #   file.bdecode    #=> "string"
-  #
-  # @param [Object] fd the file descriptor to use for input
-  # @param [Object] object the object to write
-  def bdecode
-    read.bdecode
   end
 end

data/lib/bencodr/list.rb

@@ -2,54 +2,28 @@
 
 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
+    def bencode
+      List.bencode(self)
     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
+    
+    def self.bencode(arrayable)
+      ary = coerce(arrayable)
+      
+      ary.collect do |element|
+        Object.bencode(element)
+      end.unshift(:l).push(:e).join
     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
+    
+    private
+    
+    def self.coerce(arrayable)
+      if arrayable.respond_to?(:to_a)
+        arrayable.to_a
+      elsif arrayable.respond_to?(:to_ary)
+        arrayable.to_ary
+      else
+        raise BEncodeError, "BEncodr::List.bencode can only be called on an object that provides a to_a or to_ary method."
       end
-
-      ::Array.send :include, InstanceMethods
     end
   end
 end

data/lib/bencodr/object.rb

@@ -0,0 +1,36 @@
+module BEncodr
+  module Object
+    def self.bencode(object)
+      return object.bencode if object.respond_to?(:bencode)
+      
+      case object
+      when ::String, Symbol, URI::Generic
+        return String.bencode(object)
+      when Numeric, Time
+        return Integer.bencode(object)
+      when Array
+        return List.bencode(object)
+      when Hash
+        return Dictionary.bencode(object)
+      else
+        [String, Integer, List, Dictionary].each do |type|
+          begin
+            return type.bencode(object)
+          rescue
+          end
+        end
+      end
+      
+      raise BEncodeError, "BEncodr::Object.bencode was unable to infer the type of the object passed in."
+    end
+    
+    def self.bdecode(string)
+      object = Parser.parse_object(StringScanner.new(string))
+      object or raise BEncodeError, "BEncodr::Object.bdecode was unable to parse the string passed in."
+    end
+    
+    def bdecode
+      Object.bdecode(self)
+    end
+  end
+end

data/lib/bencodr/parser.rb

@@ -110,18 +110,4 @@ module BEncodr
       private :parse_key_value
     end
   end
-end
-
-class String
-  # This method decodes a bencoded string into a ruby object.
-  #
-  #   "6:string".bdecode  #=> "string"
-  #   "i-1e".bdecode      #=> -1
-  #   "le".bdecode        #=> []
-  #   "de".bdecode        #=> {}
-  #
-  # @return [::String, ::Integer, ::Array, ::Hash] the decoded object
-  def bdecode
-    BEncodr::Parser.parse_object(StringScanner.new self) or raise BEncodr::BEncodeError, "Invalid bencoding"
-  end
 end

data/lib/bencodr/string.rb

@@ -4,55 +4,26 @@ require 'uri'
 
 module BEncodr
   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.bencodr #=> "6:symbol"
-        #
-        # @return [::String] the bencoded string
-        def bencode
-          (respond_to?(:to_s) ? to_s : to_str).bencode
-        end
-      end
+    def bencode
+      String.bencode(self)
     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.bencodr  #=> "6:string"
-    #
-    # @param [Class#to_s, Class#to_str] type the class to add the bencodr instance method to
-    def self.register(type)
-      type.send :include, Generic::InstanceMethods
+    
+    def self.bencode(stringable)
+      string = coerce(stringable)
+      
+      [string.length, ':', string].join
     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".bencodr #=> "6:string"
-        #
-        # @return [::String] the bencoded string
-        def bencode
-          [length, ':', self].join
-        end
+    
+    private
+    
+    def self.coerce(stringable)
+      if stringable.respond_to?(:to_s)
+        stringable.to_s
+      elsif stringable.respond_to?(:to_str)
+        stringable.to_str
+      else
+        raise BEncodeError, "BEncodr::String.bencode can only be called on an object that provides a to_s or to_str method."
       end
-
-      ::String.send :include, InstanceMethods
     end
   end
 end