digest-ed2k 1.0.0

data/Rakefile

@@ -0,0 +1,29 @@
+require 'rake/testtask'
+require 'rdoc/task'
+
+spec = eval(File.read("digest-ed2k.gemspec"))
+source = FileList["lib/**/*.rb"]
+
+begin
+    # why is require documented to return true/false
+    # if it raises LoadError when it should return false
+    require 'yard'
+
+    YARD::Rake::YardocTask.new do |yd|
+        yd.files = source
+    end
+
+    task :doc => :yard
+rescue LoadError
+    task :doc => :rdoc
+end
+
+RDoc::Task.new do |rd|
+    rd.rdoc_files = source
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 't'
+  t.test_files = spec.test_files
+  t.verbose = false
+end

data/digest-ed2k.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+    s.name         = 'digest-ed2k'
+    s.version      = '1.0.0'
+    s.date         = '2012-04-11'
+    s.license      = 'ISC'
+    s.summary      = 'Digest module for calculating ED2K hashes.'
+    s.description  = s.summary + ' Uses openssl for MD4 hashing.'
+    s.authors      = ['Kovensky']
+    s.email        = ['diogomfranco@gmail.com']
+    s.test_files   = Dir["t/*.rb"]
+    s.files        = Dir["lib/**/*.rb"] + s.test_files +
+                     ["#{s.name}.gemspec","Rakefile", ".gemtest"]
+    s.require_path = 'lib'
+    s.homepage     = 'https://github.com/Kovensky/digest-ed2k'
+
+    s.add_development_dependency 'yard'
+end

data/lib/digest/ed2k.rb

@@ -0,0 +1,193 @@
+# Implementation of the ed2k hash algorithm.
+
+# @author Kovensky (mailto:diogomfranco@gmail.com)
+
+require 'openssl'
+require 'digest'
+
+# {Digest::Class Digest} subclass that calculates an ed2k hash.
+#
+# The implemented algorithm is as described on http://wiki.anidb.net/w/Ed2k,
+# using the "red code" method (appending null to hashlist).
+#
+# Uses {OpenSSL::Digest OpenSSL::Digest::MD4} internally for the MD4 hashing.
+#
+# @note Due to ed2k's use of 9500KB chunks, this object can be up to around
+#       10MB large in memory, not counting OpenSSL::Digest::MD4's state.
+class Digest::ED2k < Digest::Class
+    # The version
+    VERSION = '1.0.0'
+
+    # Chunk size of the ed2k hash, 9500KB.
+    CHUNK_SIZE = 9728000
+
+    # Creates a reset object.
+    # @param initial_chunk optionally appends data to the new object
+    def initialize (initial_chunk = nil)
+        @md4 = OpenSSL::Digest::MD4.new
+        self.reset
+        self << initial_chunk if initial_chunk
+    end
+
+    # Reads the contents of `io`, 9500KB at a time,
+    # until EOF, and add to the digest.
+    #
+    # @param [IO] io the {IO} to be read
+    # @return self for convenient chaining.
+    def io (io)
+        # why do I have to use a while instead of an each_chunk or sth
+        buf = ""
+        while io.read CHUNK_SIZE, buf
+            self << buf
+        end
+        return self
+    end
+
+    # Opens the file pointed by path and calls {#io} with it.
+    #
+    # @param [String] path path to a file that will be read
+    # @return self for convenient chaining.
+    def file (path)
+        File.open(path) do |f|
+            return self.io f
+        end
+    end
+
+    # Resets the state; effectively the same as constructing a new object.
+    # @return self for convenient chaining.
+    def reset
+        @md4.reset
+        @buf = ""
+        @rounds = 0
+        @finalized = false
+        return self
+    end
+
+    # Append `data` to the digest. Will raise an {ArgumentError}
+    # if the object has been {#finalize}d before.
+    #
+    # Every 9500KB of accumulated data will be hashed as per the ed2k algorithm.
+    #
+    # @param [String] data the string to be appended to the digest
+    # @return self for convenient chaining.
+    def update (data)
+        if @finalized
+            raise ArgumentError.new("Can't add to an ed2k hash after finalizing. Call reset if you want to calculate a new hash.")
+        end
+        @buf += data
+        _sync
+        return self
+    end
+    alias << update
+
+    # {#finalize}s the digest and returns it.
+    #
+    # @note Due to how ed2k hashes work, once the digest has been obtained,
+    #       the object must be {#reset} before being reused. The {#digest!} family
+    #       of methods automatically resets the object after being called.
+    #
+    # @param str if present and non-nil, will cause digest to reset self,
+    #            update it with `str` and return the new digest.
+    # @return [String] the raw digest
+    def digest(str = nil)
+        unless str
+            self.finalize
+            @md4.digest
+        else
+            reset
+            self << str
+            digest
+        end
+    end
+
+    # (see #digest)
+    # @note calls {#reset} on self after obtaining digest
+    def digest!
+        ret = digest
+        reset
+        return ret
+    end
+
+    # {include:#digest}
+    # @note (see #digest)
+    # @param (see #digest)
+    # @return [String] the digest as a hexadecimal string
+    def hexdigest(str = nil)
+        unless str
+            self.finalize
+            @md4.hexdigest
+        else
+            reset
+            self << str
+            hexdigest
+        end
+    end
+
+    # {include:#hexdigest}
+    # @param (see #hexdigest)
+    # @return (see #hexdigest)
+    # @note (see #digest!)
+    def hexdigest!
+        ret = hexdigest
+        reset
+        return ret
+    end
+
+    # Finalizes the digest and prevents any new data from being added
+    # to it. This is automatically called by the {#digest} family of methods.
+    # The only way to unlock the object is to {#reset} it.
+    #
+    # @return self for convenient chaining.
+    def finalize
+        unless @finalized
+            if @rounds > 0
+                @md4 << OpenSSL::Digest::MD4.digest(@buf)
+            else
+                @md4.reset
+                @md4 << @buf
+            end
+            @buf = nil
+            @finalized = true
+        end
+        return self
+    end
+
+    # Override for {Object#inspect Object's inspect}
+    def inspect
+        return "#<ed2k unfinalized>" unless @finalized
+        return "#<ed2k hash=\"#{digest}\">"
+    end
+
+    private
+    # When the internal buffer exceeds {CHUNK_SIZE}, feed CHUNK_SIZE chunks
+    # to the MD4 hashing function until the buffer is below CHUNK_SIZE
+    # of length.
+    def _sync
+        while @buf.length >= CHUNK_SIZE
+            @md4 << OpenSSL::Digest::MD4.digest(@buf[0...CHUNK_SIZE])
+            @buf = @buf[CHUNK_SIZE...@buf.length] || ""
+            @rounds += 1
+        end
+    end
+
+    public
+    # Calculates and returns the {#digest} on data.
+    def self.digest (data)
+        return new(data).digest
+    end
+
+    # Calculates and returns the {#hexdigest} on data.
+    def self.hexdigest (data)
+        return new(data).hexdigest
+    end
+
+    # The same as calling {#io}(io) on a new object.
+    def self.io(io)
+        return new.io io
+    end
+
+    # The same as calling {#file}(path) on a new object.
+    def self.file(path)
+        return new.file path
+    end
+end

data/t/zeroes.rb

@@ -0,0 +1,41 @@
+#require 'minitest/autorun'
+require 'test/unit'
+require 'digest/ed2k'
+
+class Zeroes < Test::Unit::TestCase
+    def test_zero_length_file
+        assert_equal '31d6cfe0d16ae931b73c59d7e0c089c0',
+            Digest::ED2k.hexdigest('')
+    end
+
+    def add_by_random_chunks (str, ed2k = Digest::ED2k.new)
+        loops = 2000 # don't let bad random numbers freeze the test
+        while str.length > 1 && loops > 0
+            r = rand(str.length)
+            ed2k << str[0...r]
+            str = str[r...str.length]
+            loops -= 1
+        end
+        ed2k << str
+    end
+
+    def test_single_chunk_zero_file
+        assert_equal 'fc21d9af828f92a8df64beac3357425d',
+            add_by_random_chunks("\0" * Digest::ED2k::CHUNK_SIZE).hexdigest
+    end
+
+    def test_two_chunk_zero_file
+        assert_equal '114b21c63a74b6ca922291a11177dd5c',
+            add_by_random_chunks("\0" * (2 * Digest::ED2k::CHUNK_SIZE)).hexdigest
+    end
+
+    def test_two_and_half_chunk_zero_file
+        assert_equal 'a4b0b40d5b13bb045b0ce2a8fad8b393',
+             add_by_random_chunks("\0" * (5 * Digest::ED2k::CHUNK_SIZE / 2)).hexdigest
+    end
+
+    def test_three_and_half_chunk_by_object_random
+        assert_equal '57d514e8e464257aca18e50e47194e42',
+            add_by_random_chunks("\0" * (7 * Digest::ED2k::CHUNK_SIZE / 2)).hexdigest
+    end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: digest-ed2k
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Kovensky
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Digest module for calculating ED2K hashes. Uses openssl for MD4 hashing.
+email:
+- diogomfranco@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/digest/ed2k.rb
+- t/zeroes.rb
+- digest-ed2k.gemspec
+- Rakefile
+- .gemtest
+homepage: https://github.com/Kovensky/digest-ed2k
+licenses:
+- ISC
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: Digest module for calculating ED2K hashes.
+test_files:
+- t/zeroes.rb
+has_rdoc: