b_encode 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 03f9d43b091e021486f8290606ff0d11f032bc2d
+  data.tar.gz: fffa952a1d86fcbbe34d4fe5339019d507aaca02
+SHA512:
+  metadata.gz: 7fd573cfe2a7162fc4733b70e04389294bb4e3250c3fdf4fc6b3bf31e1083efa5fbd988db4c4424694588411aa67d617715ad09fccabd33ed715b108e8a8f0f3
+  data.tar.gz: c6bdadc918f6d09a1adc27a90d2135277bc4be655dc8527a2dd5a2f3038b707ce8829ed97fa887462984040405f30b90152eb97ee7be61de839fc6305b3c59df

data/.gitignore

@@ -0,0 +1,17 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+
+*.gem
+*.my

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in b_encode.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 August
+
+MIT License
+
+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.md

@@ -0,0 +1,38 @@
+# BEncode
+
+A bencode encoder/decoder.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'b_encode'
+```
+
+Or install it yourself:
+
+```sh
+$ gem install b_encode
+```
+
+## Usage
+
+#### Encoding
+
+```ruby
+"foo".bencode # => "3:foo"
+123.bencode   # => "i123e"
+
+["foo", 123].bencode   # => "l3:fooi123ee"
+{"foo" => 123}.bencode # => "d3:fooi123ee"
+```
+
+#### Decoding
+```ruby
+BEncode.decode "3:foo" # => "foo"
+BEncode.decode "i123e" # => 123
+
+BEncode.decode "l3:fooi123ee" # => ["foo", 123]
+BEncode.decode "d3:fooi123ee" # => {"foo" => 123}
+```

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+
+require "rake/extensiontask"
+
+Rake::ExtensionTask.new("b_encode") do |ext|
+  ext.lib_dir = "lib/b_encode"
+end

data/b_encode.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'b_encode/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "b_encode"
+  spec.version       = BEncode::VERSION
+  spec.authors       = ["August"]
+  spec.email         = ["augustt198@gmail.com"]
+  spec.extensions    = ["ext/b_encode/extconf.rb"]
+  spec.summary       = %q{Bencode encoder/decoder}
+  spec.homepage      = "http://github.com/augustt198/b_encode"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake-compiler"
+end

data/benchmark.rb

@@ -0,0 +1,77 @@
+require "b_encode"
+require "benchmark"
+
+TESTS = 1_000_000
+
+Benchmark.bm(30) do |bm|
+  bm.report("b_encode: encoding integers") do
+    TESTS.times { |x| x.bencode }
+  end
+  bm.report("b_encode: encoding strings") do
+    TESTS.times { |x| x.to_s.bencode }
+  end
+  bm.report("b_encode: encoding lists") do
+    TESTS.times { |x| [x, x.to_s, [], {}].bencode }
+  end
+  bm.report("b_encode: encoding dicts") do
+    TESTS.times { |x| {x.to_s => x}.bencode }
+  end
+  bm.report("b_encode: decoding integers") do
+    TESTS.times { |x| BEncode.decode "i#{x}e" }
+  end
+  bm.report("b_encode: decoding strings") do
+    TESTS.times do |x|
+      s = x.to_s
+      BEncode.decode "#{s.length}:#{s}"
+    end
+  end
+  bm.report("b_encode: decoding lists") do
+    TESTS.times do |x|
+      BEncode.decode "li123e3:fooli10eed1:a1:bee"
+    end
+  end
+  bm.report("b_encode: decoding hashes") do
+    TESTS.times do |x|
+      BEncode.decode "d3:fooi123e1:ali123ed3:abc3:defeee"
+    end
+  end 
+end
+
+# suppress warnings
+$VERBOSE = nil
+
+require "bencode"
+
+Benchmark.bm(30) do |bm|
+  bm.report("bencode: encoding integers") do
+    TESTS.times { |x| x.bencode }
+  end
+  bm.report("bencode: encoding strings") do
+    TESTS.times { |x| x.to_s.bencode }
+  end
+  bm.report("bencode: encoding lists") do
+    TESTS.times { |x| [x, x.to_s, [], {}].bencode }
+  end
+  bm.report("bencode: encoding dicts") do
+    TESTS.times { |x| {x.to_s => x}.bencode }
+  end
+  bm.report("bencode: decoding integers") do
+    TESTS.times { |x| BEncode.load "i#{x}e" }
+  end
+  bm.report("bencode: decoding strings") do
+    TESTS.times do |x|
+      s = x.to_s
+      BEncode.load "#{s.length}:#{s}"
+    end
+  end
+  bm.report("bencode: decoding lists") do
+    TESTS.times do |x|
+      BEncode.load "li123e3:fooli10eed1:a1:bee"
+    end
+  end
+  bm.report("bencode: decoding hashes") do
+    TESTS.times do |x|
+      BEncode.load "d3:fooi123e1:ali123ed3:abc3:defeee"
+    end
+  end 
+end

data/ext/b_encode/b_encode.c

@@ -0,0 +1,317 @@
+#include "b_encode.h"
+
+VALUE rb_mBEncode;
+
+int digit_count(int n) {
+    if (n == 0)
+        return 1;
+
+    n = abs(n);
+    int c = 0;
+    for (; n > 0; c++)
+        n /= 10;
+
+    return c;
+}
+
+static VALUE
+rb_str_bencode_bang(VALUE str) {
+    int strlen = RSTRING_LEN(str);
+    // length prefix + ":" + str
+    int dc     = digit_count(strlen);
+    int newlen = dc + 1 + strlen;
+
+    rb_str_resize(str, newlen);
+
+    char *ptr = RSTRING_PTR(str);
+
+    memmove(ptr + dc + 1, ptr, strlen);
+    if (strlen == 0) {
+        ptr[0] = '0';
+    } else {
+        int n = strlen;
+        for (int i = 0; n > 0; n /= 10, i++)
+            ptr[dc - i - 1] = (n % 10) + '0';
+    }
+    ptr[dc] = ':';
+
+    return str;
+}
+
+static VALUE
+rb_str_bencode(VALUE str) {
+    str = rb_str_dup(str);
+    rb_str_bencode_bang(str);
+    return str;
+}
+
+static VALUE
+rb_integer_bencode(VALUE rb_num) {
+    long num = NUM2LONG(rb_num);
+    int c = 0;
+    if (num == 0) {
+        c = 1;
+    } else {
+        if (num < 0)
+            c++; // minus sign
+        for (int n = labs(num); n > 0; c++)
+            n /= 10;
+    }
+
+    // "i"<integer>"e"
+    int strlen = c + 2;
+    VALUE str = rb_str_new(NULL, strlen);
+    char *ptr = RSTRING_PTR(str);
+
+    ptr[0] = 'i';
+    if (num == 0) {
+        ptr[1] = '0';
+    } else {
+        if (num < 0) {
+            ptr[1] = '-';
+        }
+        int i = 0;
+        for (int n = labs(num); n > 0; n /= 10, i++)
+            ptr[c - i] = (n % 10) + '0';
+    }
+    ptr[c + 1] = 'e';
+
+    return str;
+}
+
+static VALUE
+rb_ary_bencode(VALUE ary) {
+    long len = RARRAY_LEN(ary);
+    VALUE b_entries[len];
+
+    int total_len = 0;
+    ID bencode_method_sym = rb_intern("bencode");
+    for (int i = 0; i < len; i++) {
+        VALUE val      = rb_ary_entry(ary, i);
+        VALUE bencoded = rb_funcall(val, bencode_method_sym, 0);
+        total_len      += RSTRING_LEN(bencoded);
+        b_entries[i]   = bencoded;
+    }
+
+    // "l"<contents>"e"
+    VALUE str = rb_str_new(NULL, total_len + 2);
+    char *ptr = RSTRING_PTR(str);
+
+    ptr[0] = 'l';
+    
+    int offset = 1;
+    for (int i = 0; i < len; i++) {
+        VALUE entry = b_entries[i];
+        int e_len   = RSTRING_LEN(entry);
+        memcpy(ptr + offset, RSTRING_PTR(entry), e_len);
+        offset += e_len;
+    }
+    
+    ptr[total_len + 1] = 'e';
+
+    return str;
+}
+
+struct foreach_info {
+    int *idx_ptr;
+    VALUE *base;
+};
+
+static int
+rb_hash_bencode_entry(VALUE key, VALUE value, VALUE arg) {
+    if (!RB_TYPE_P(key, T_STRING))
+        rb_raise(rb_eTypeError, "All hash keys must be strings");
+
+    VALUE key_bencode = rb_str_bencode(key);
+
+    ID bencode_method_sym = rb_intern("bencode");
+    VALUE val_bencode     = rb_funcall(value, bencode_method_sym, 0);
+
+    struct foreach_info *info = (struct foreach_info*) arg;
+
+    int idx     = *(info->idx_ptr);
+    VALUE *base = info->base;
+
+    *((VALUE*) base + idx)     = key_bencode;
+    *((VALUE*) base + idx + 1) = val_bencode;
+
+    *info->idx_ptr += 2;
+
+    return ST_CONTINUE;
+}
+
+static VALUE
+rb_hash_bencode(VALUE hash) {
+    int hash_size = RHASH_SIZE(hash);
+    VALUE pieces[hash_size * 2];
+    
+    int idx = 0;
+    struct foreach_info info = {&idx, pieces};
+
+    rb_hash_foreach(hash, rb_hash_bencode_entry, (VALUE) &info);
+
+    int total_len = 0;
+    for (int i = 0; i < hash_size * 2; i++) {
+        total_len += RSTRING_LEN(pieces[i]);
+    }
+
+    VALUE str = rb_str_new(NULL, total_len + 2);
+    char *ptr = RSTRING_PTR(str);
+
+    ptr[0] = 'd';
+
+    int offset = 1;
+    for (int i = 0; i < hash_size * 2; i++) {
+        int entry_len = RSTRING_LEN(pieces[i]);
+        memcpy(ptr + offset, RSTRING_PTR(pieces[i]), entry_len);
+        offset += entry_len;
+    }
+
+    ptr[total_len + 1] = 'e';
+
+    return str;
+}
+
+#define EOF_CHECK(ptr, len)\
+    if (*(ptr) >= (len))\
+        rb_raise(rb_eIOError, "Unexpected EOF");
+
+VALUE decode_any(char *str, int *idx_ptr, int len);
+
+VALUE decode_integer(char *str, int *idx_ptr, int len) {
+    int strlen = 2; // "i"<integer>"e"
+
+    EOF_CHECK(idx_ptr, len);
+    int neg = 0; // bool
+    if (str[*idx_ptr] == '-') {
+        neg = 1;
+        
+        strlen++;
+        *idx_ptr += 1;
+        EOF_CHECK(idx_ptr, len);
+    }
+
+    long num = 0;
+    while (rb_isdigit(str[*idx_ptr])) {
+        num = num * 10 + (str[*idx_ptr] - '0');
+        strlen++;
+        
+        *idx_ptr += 1;
+        EOF_CHECK(idx_ptr, len);
+    }
+
+    if (neg)
+        num = -num;
+
+    if (str[*idx_ptr] != 'e')
+        rb_raise(rb_eRuntimeError, "Expected 'e'");
+    *idx_ptr += 1;
+
+    return LONG2NUM(num);
+}
+
+VALUE decode_string(char *str, int *idx_ptr, int len, char dig) {
+    EOF_CHECK(idx_ptr, len);
+    int strlen = dig - '0';
+
+    while (rb_isdigit(str[*idx_ptr])) {
+        strlen = strlen * 10 + (str[*idx_ptr] - '0');
+        strlen++;
+        *idx_ptr += 1;
+        EOF_CHECK(idx_ptr, len);
+    }
+
+    if (str[*idx_ptr] != ':')
+        rb_raise(rb_eRuntimeError, "Expected ':', got '%c'", str[*idx_ptr]);
+    *idx_ptr += 1;
+
+    if (*idx_ptr + strlen > len)
+        rb_raise(rb_eIOError, "Unexpected EOF");
+
+    VALUE rb_str = rb_str_new(NULL, strlen);
+
+    memcpy(RSTRING_PTR(rb_str), str + *idx_ptr, strlen);
+    *idx_ptr += strlen;
+
+    return rb_str;
+}
+
+VALUE decode_list(char *str, int *idx_ptr, int len) {
+    EOF_CHECK(idx_ptr, len);
+
+    VALUE ary = rb_ary_new();
+
+    while (str[*idx_ptr] != 'e') {
+        VALUE elem = decode_any(str, idx_ptr, len);
+        rb_ary_push(ary, elem);
+        EOF_CHECK(idx_ptr, len);
+    }
+    *idx_ptr += 1;
+
+    return ary;
+}
+
+VALUE decode_dict(char *str, int *idx_ptr, int len) {
+    EOF_CHECK(idx_ptr, len);
+
+    VALUE hash = rb_hash_new();
+
+    while (str[*idx_ptr] != 'e') {
+        VALUE key = decode_any(str, idx_ptr, len);
+        EOF_CHECK(idx_ptr, len);
+        VALUE val = decode_any(str, idx_ptr, len);
+        EOF_CHECK(idx_ptr, len);
+
+        rb_hash_aset(hash, key, val);
+    }
+    *idx_ptr += 1;
+
+    return hash;
+}
+
+VALUE decode_any(char *str, int *idx_ptr, int len) {
+    EOF_CHECK(idx_ptr, len);
+    char prefix = str[*idx_ptr];
+    *idx_ptr += 1;
+
+    switch (prefix) {
+        case 'i':
+            return decode_integer(str, idx_ptr, len);
+        case 'l':
+            return decode_list(str, idx_ptr, len);
+        case 'd':
+            return decode_dict(str, idx_ptr, len);
+        default:
+            if (rb_isdigit(prefix)) {
+                return decode_string(str, idx_ptr, len, prefix);
+            }
+        rb_raise(rb_eRuntimeError, "Unexpected character '%c'", prefix);            
+    }
+
+    return Qnil;
+}
+
+VALUE rb_bencode_decode(VALUE mod, VALUE str) {
+    int idx = 0;
+
+    return decode_any(RSTRING_PTR(str), &idx, RSTRING_LEN(str));
+}
+
+void Init_b_encode(void) {
+    rb_mBEncode = rb_define_module("BEncode");
+    
+    // String#bencode and String#bencode!
+    rb_define_method(rb_cString, "bencode", rb_str_bencode, 0);
+    rb_define_method(rb_cString, "bencode!", rb_str_bencode_bang, 0);
+    
+    // Integer#bencode
+    rb_define_method(rb_cInteger, "bencode", rb_integer_bencode, 0);
+    
+    // Array#bencode
+    rb_define_method(rb_cArray, "bencode", rb_ary_bencode, 0);
+
+    // Hash#bencode
+    rb_define_method(rb_cHash, "bencode", rb_hash_bencode, 0);
+
+    rb_define_singleton_method(rb_mBEncode, "decode", rb_bencode_decode, 1);
+}

data/ext/b_encode/b_encode.h

@@ -0,0 +1,6 @@
+#ifndef B_ENCODE_H
+#define B_ENCODE_H 1
+
+#include "ruby.h"
+
+#endif /* B_ENCODE_H */

data/ext/b_encode/extconf.rb

@@ -0,0 +1,3 @@
+require "mkmf"
+
+create_makefile("b_encode/b_encode")

data/lib/b_encode/version.rb

@@ -0,0 +1,3 @@
+module BEncode
+  VERSION = "0.0.1"
+end

data/lib/b_encode.rb

@@ -0,0 +1,5 @@
+require "b_encode/version"
+require "b_encode/b_encode"
+
+module BEncode
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: b_encode
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- August
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- augustt198@gmail.com
+executables: []
+extensions:
+- ext/b_encode/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- b_encode.gemspec
+- benchmark.rb
+- ext/b_encode/b_encode.c
+- ext/b_encode/b_encode.h
+- ext/b_encode/extconf.rb
+- lib/b_encode.rb
+- lib/b_encode/version.rb
+homepage: http://github.com/augustt198/b_encode
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.3
+signing_key: 
+specification_version: 4
+summary: Bencode encoder/decoder
+test_files: []