mochilo 1.3.0 → 2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 0b97afc4fd9e2920c58c61e96065c377681018aefe07c15cc072e59922157997
-  data.tar.gz: ab5665e26e73884dd6e6faf2fe4df2ca1ca9ba421283f996d59c9b16dfa9509b
+SHA1:
+  metadata.gz: c4c966c5decea51dbb2f53f1af2dc07a12daef8b
+  data.tar.gz: cbe013f48186036d3b4c3b4fcad9763bf9876139
 SHA512:
-  metadata.gz: 05f5f210fcd4052a278ca9344f37ee1c00a9e9a966ac843843d6deeaacd61aac8d58fbf83886719e241f90d12d9cc852d3a5819b2f3cc10124c105d71d761e5e
-  data.tar.gz: f129d81959c7173d1eb2fa82e14f7271c2cbb585d9f18728fe1fb05cbcaaf3b6fbc10a871139674427c5c252d631ed457d82ce9201039f7495aa6d5e021a9e27
+  metadata.gz: 09471508db65b21a62d5aaaa602667c087245fd8cb4cd4987d2e9402d15b5dd9baedc2dfdc664f76a13fc10f1dbf583d70c3e71a567953f3936915738147d026
+  data.tar.gz: 75df812168f9ba8abcfcb8e5326c8b466b6ce1b1bd480373debde2b8886f87dc01cdcc95209079b85c5fa59340a23acf3892ed8ec1e23b2e3ea666f1859fb42a

data/.travis.yml

@@ -1,10 +1,7 @@
 language: ruby
 script:
   - bundle exec rake test
-install: ./script/bootstrap
 rvm:
-  - 2.3.0
-  - 2.2
-  - 2.1
+  - 1.9.3
   - 2.0.0
-  - ruby-head
+  - 2.1.2

data/Gemfile

@@ -3,7 +3,3 @@ source "https://rubygems.org"
 gemspec
 
 gem "pry"
-
-group :benchmark do
-  gem "msgpack"
-end

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    mochilo (1.2.1)
+    mochilo (2.0)
 
 GEM
   remote: https://rubygems.org/

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Brian Lopez
+
+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

@@ -1,43 +1,30 @@
 # Mochilo
 
-Mochilo is a Ruby library implementing the BananaPack protocol. BananaPack is a superset of MessagePack. It adds three new types to the protocol: Symbol and String in 16 and 32 bit lengths.
+Mochilo is a Ruby library implementing the BananaPack protocol. BananaPack is a superset of MessagePack. It takes advantage of the new `ext` types to extend the protocol, adding 3 new
+types which are used for serializing strings with an encoding other than UTF-8.
 
-The Symbol type is a String of text composed of ASCII characters with a maximum length of (2^8)-1 bytes.
+The mapping of the `ext` types are:
 
-The String16 and String32 types are exactly the same as the [Raw16](http://wiki.msgpack.org/display/MSGPACK/Format+specification#Formatspecification-raw16) and [Raw32](http://wiki.msgpack.org/display/MSGPACK/Format+specification#Formatspecification-raw32) types from MessagePack except there is an encoding flag stored along with the bytes. This allows the format to differentiate binary from text.
+* `ext8`  - A String in an encoding other than UTF-8 who's length is between 0 and (2^8)-1 bytes.
+* `ext16` - A String in an encoding other than UTF-8 who's length is between 0 and (2^16)-1 bytes.
+* `ext32` - A String in an encoding other than UTF-8 who's length is between 0 and (2^32)-1 bytes.
 
-Check out docs/format-spec.md for more detailed information on the differences between BananaPack and MessagePack.
+Also check out [docs/format-spec.md](docs/format-spec.md) for more detailed information on these types.
+
+Strings tagged as `ASCII-8BIT` are encoded as the `bin` types in the MessagePack spec. The type that's used depends on the length of the string. Check out the spec [here](https://github.com/msgpack/msgpack/blob/master/spec.md) for more information on those types.
 
 ## Usage
 
 ``` ruby
 require 'mochilo'
-obj = {key: "value"}
-bpack = Mochilo.pack(obj)
+obj = {"key" => "value"}
+packed = Mochilo.pack(obj)
 #=> "\x81\xD8\x00\x03\x01key\xD8\x00\x05\x00value"
 
-hash = Mochilo.unpack(bpack)
+hash = Mochilo.unpack(packed)
 #=> {"key"=>"value"}
 ```
 
-Notice how `key` came back into Ruby as a String instead of a Symbol? This is because the `pack` method of Mochilo only generates "safe" bpack.
-
-bpack without Symbols is considered "safe" for Ruby because in Ruby, Symbols aren't garbage collected. So if you unpack arbitrary bpack from an untrusted or malicious source, you could end up potentially exhausting the memory of your server.
-
-To generate "unsafe" bpack, use `pack_unsafe` and `unpack_unsafe` methods instead:
-
-``` ruby
-require 'mochilo'
-obj = {key: "value"}
-bpack = Mochilo.pack_unsafe(obj)
-#=> "\x81\xD4\x03key\xD8\x00\x05\x00value"
-
-hash = Mochilo.unpack_unsafe(bpack)
-#=> {:key=>"value"}
-```
-
-If you attempt to unpack "unsafe" bpack without using `unpack_unsafe`, an exception is raised.
-
 ## Supported Ruby Types
 
 The following Ruby types are supported. Meaning they will be deserialized into the same Ruby type they were before serialization.
@@ -47,7 +34,6 @@ If any other object type is encountered during serialization, an exception is ra
 * Fixnum
 * Bignum
 * Float
-* Symbol
 * String (with encoding)
 * nil
 * true

data/docs/format-spec.md

@@ -1,72 +1,41 @@
-## String
+## Enc
 
-The String type is nearly identical to the Raw type from MessagePack but is specifically
-aimed at marking a set of bytes as text.
+The Enc type is nearly identical to the Str type from the MessagePack spec but has a flag for specifying an encoding other than UTF-8.
 
 ### Format Specification
 
-#### Symbol
+#### Enc8
 
-For storing symbol names as ASCII text up to (2^8)-1 bytes.
-Length is stored in unsigned 8-bit integer.
+For serializing text up to (2^8)-1 bytes.
 
 ```
-+--------+--------+----------
-|  0xd4  |XXXXXXXX|...N bytes
-+--------+--------+----------
-=> XXXXXXXX (=N) bytes of raw bytes.
++--------+--------+--------+========+
+|  0xc7  |XXXXXXXX|  type  |  data  |
++--------+--------+--------+========+
+=> XXXXXXXX - a 8-bit unsigned integer which represents the legth of data.
+=> type - encoding flag, a signed 8-bit signed integer
 ```
 
-#### Regexp
+#### Enc16
 
-Stores a regular expression, with options and encoding, up to (2^16)-1 bytes long.
+For serializing text up to (2^16)-1 bytes.
 
 ```
-+--------+--------+--------+--------+--------+--------+--------+--------+----------
-|  0xd5  |XXXXXXXX|XXXXXXXX|YYYYYYYY|YYYYYYYY|YYYYYYYY|YYYYYYYY|ZZZZZZZZ|...N bytes
-+--------+--------+--------+--------+--------+--------+--------+--------+----------
-=> XXXXXXXX_XXXXXXXX (=N) bytes of raw bytes.
-=> YYYYYYYY_YYYYYYYY_YYYYYYYY_YYYYYYYY 32-bit int options
-=> ZZZZZZZZ encoding flag
++--------+--------+--------+--------+========+
+|  0xc8  |YYYYYYYY|YYYYYYYY|  type  |  data  |
++--------+--------+--------+--------+========+
+=> YYYYYYYY_YYYYYYYY - a 16-bit big-endian unsigned integer which represents the legth of data.
+=> type - encoding flag, a signed 8-bit signed integer
 ```
 
-#### Time
+#### Enc32
 
-Stores a Ruby time, with usec resolution and UTC offset.
+For serializing text up to (2^32)-1 bytes.
 
 ```
-+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+
-|  0xd6  |XXXXXXXX|XXXXXXXX|XXXXXXXX|XXXXXXXX|XXXXXXXX|XXXXXXXX|XXXXXXXX|XXXXXXXX|YYYYYYYY|YYYYYYYY|YYYYYYYY|YYYYYYYY|YYYYYYYY|YYYYYYYY|YYYYYYYY|YYYYYYYY|ZZZZZZZZ|ZZZZZZZZ|ZZZZZZZZ|ZZZZZZZZ|
-+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+
-=> XXXXXXXX_XXXXXXXX_XXXXXXXX_XXXXXXXX_XXXXXXXX_XXXXXXXX_XXXXXXXX_XXXXXXXX 64-bit unsigned seconds since the epoch
-=> YYYYYYYY_YYYYYYYY_YYYYYYYY_YYYYYYYY_YYYYYYYY_YYYYYYYY_YYYYYYYY_YYYYYYYY 64-bit unsigned microseconds
-=> ZZZZZZZZ_ZZZZZZZZ_ZZZZZZZZ_ZZZZZZZZ 32-bit signed seconds offset from UTC
-```
-
-#### String16
-
-For storing text up to (2^16)-1 bytes.
-Length is stored in unsigned 16-bit big-endian integer.
-Encoding is stored as an int8
-
-```
-+--------+--------+--------+--------+----------
-|  0xd8  |XXXXXXXX|XXXXXXXX|YYYYYYYY|...N bytes
-+--------+--------+--------+--------+----------
-=> XXXXXXXX_XXXXXXXX (=N) bytes of raw bytes.
-=> YYYYYYYY encoding flag
-```
-
-#### String32
-
-For storing text up to (2^32)-1 bytes.
-Length is stored in unsigned 32-bit big-endian integer.
-Encoding is stored as an int8
-
-```
-+--------+--------+--------+--------+--------+--------+----------
-|  0xd9  |XXXXXXXX|XXXXXXXX|XXXXXXXX|XXXXXXXX|YYYYYYYY|...N bytes
-+--------+--------+--------+--------+--------+--------+----------
-=> XXXXXXXX_XXXXXXXX_XXXXXXXX_XXXXXXXX (=N) bytes of raw bytes.
-=> YYYYYYYY encoding flag
++--------+--------+--------+--------+--------+--------+========+
+|  0xc9  |ZZZZZZZZ|ZZZZZZZZ|ZZZZZZZZ|ZZZZZZZZ|  type  |  data  |
++--------+--------+--------+--------+--------+--------+========+
+=> ZZZZZZZZ_ZZZZZZZZ_ZZZZZZZZ_ZZZZZZZZ - a big-endian 32-bit unsigned integer which represents the legth of data.
+=> type - encoding flag, a signed 8-bit signed integer
 ```

data/docs/why-banana-pack.md

@@ -10,11 +10,13 @@ A couple of them that are comparable to BananaPack are MessagePack and JSON. To
 
 JSON has the basic principles of a serialized format that we want. It's only capable of representing primitive data types in common with almost every language. That makes it great for cross-language communication.
 
-The problem is that it's just text. Unicode text to be precise. That means you can't serialize arbitrary binary data without encoding it first. Common practice is to Base64 encode the data first. But then deserialization side *has* to know to unencode it after parsing. There's no need for hacks like this.
+The problem is that it's just text. Unicode text to be precise. That means you can't serialize arbitrary binary data without encoding it first. Common practice is to Base64 encode the data first. But then deserialization side *has* to know to decode it after parsing. There's no need for hacks like this.
 
 ## Why not MessagePack?
 
-MessagePack is nearly perfect for what we want. But text and binary share a single type in the spec, "Raw". That means when deserializing the data you could be reading a contents of a Markdown file, or the contents of a JPEG. There are countless hacks to get around this but there shouldn't be a need for them either.
+MessagePack is nearly perfect for what we want. But it can only differentiate between binary data
+and text that is encoded as UTF-8. We need to support more encodings than that so we can serialize
+it over the wire without the need to put it through potentially lossy transcoding.
 
 ## BananaPack
 
@@ -22,4 +24,4 @@ We wanted something compact and easy to parse. But it also needed to have native
 
 Knowing what encoding text is in is just as important as knowing the timezone of a timestamp. This has been true since the birth of the Internet.
 
-So we used a couple of the "reserved" data type slots in the MessagePack spec to add a String16, String32 and Symbol type. String16 and String32 are exactly the same as the Raw16 and Raw32 types from the MessagePack spec except they have an encoding flag as well. This means that it's possible to serialize text data without hacks. This also means it's possible to serialize the contents of a JPEG without first needing to encode or escape it.
+So we used the new MessagePack spec to add Enc8, Enc16 and Enc32 types. The encoding of the string is stored as a flag in the `type` field of the `ext` type.

data/ext/mochilo/buffer.c

@@ -19,7 +19,7 @@ static mochilo_buf_chunk *init_cur_chunk(mochilo_buf *buf, size_t chunk_size)
 
 	buf->last_alloc = chunk->ptr = malloc(chunk_size);
 	if (!chunk->ptr)
-		rb_raise(rb_eNoMemError, "Failed to allocate new chunk");
+		return NULL;
 
 	chunk->end = chunk->ptr + chunk_size;
 	return chunk;
@@ -38,7 +38,7 @@ static void skip_last_chunk(mochilo_buf *buf)
 
 static void free_buf(mochilo_buf *buf)
 {
-	uint32_t i;
+	uint16_t i;
 
 	for (i = 0; i < buf->cur_chunk; ++i)
 		free(buf->chunks[i].ptr);
@@ -61,7 +61,7 @@ VALUE mochilo_buf_flush(mochilo_buf *buf)
 {
 	VALUE rb_str;
 	char *ptr;
-	uint32_t i;
+	uint16_t i;
 
 	skip_last_chunk(buf);
 
@@ -95,20 +95,15 @@ VALUE mochilo_buf_flush(mochilo_buf *buf)
 
 mochilo_buf_chunk *mochilo_buf_rechunk2(mochilo_buf *buf, size_t chunk_size)
 {
-	mochilo_buf_chunk *chunks;
-
 	skip_last_chunk(buf);
 
 	if (buf->cur_chunk == buf->chunk_count) {
-		if ((buf->chunk_count * 2) < buf->chunk_count)
-			rb_raise(rb_eArgError, "Too many chunks required to serialize");
+		buf->chunk_count *= 2;
 
-		chunks = realloc(buf->chunks, buf->chunk_count * 2 * sizeof(mochilo_buf_chunk));
-		if (!chunks)
-			rb_raise(rb_eNoMemError, "Failed to realloc chunks");
+		buf->chunks = realloc(buf->chunks, buf->chunk_count * sizeof(mochilo_buf_chunk));
+		if (!buf->chunks)
+			return NULL;
 
-		buf->chunks = chunks;
-		buf->chunk_count *= 2;
 	}
 
 	return init_cur_chunk(buf, chunk_size);
@@ -123,8 +118,10 @@ void mochilo_buf_put(mochilo_buf *buf, const char *data, size_t len)
 {
 	mochilo_buf_chunk *chunk = &buf->chunks[buf->cur_chunk];
 
-	if (unlikely(chunk->ptr + len > chunk->end))
-		chunk = mochilo_buf_rechunk2(buf, len);
+	if (unlikely(chunk->ptr + len > chunk->end)) {
+		if (!(chunk = mochilo_buf_rechunk2(buf, len)))
+			return;
+	}
 
 	memmove(chunk->ptr, data, len);
 	chunk->ptr += len;

data/ext/mochilo/buffer.h

@@ -48,7 +48,7 @@ static inline void swap64(const uint8_t *buffer, void *out)
 }
 
 /**
- * Buffer code 
+ * Buffer code
  */
 typedef struct {
 	char *ptr;
@@ -59,13 +59,12 @@ typedef struct {
 	mochilo_buf_chunk *chunks;
 	char *last_alloc;
 	size_t total_size;
-	uint32_t chunk_count, cur_chunk;
+	uint16_t chunk_count, cur_chunk;
 } mochilo_buf;
 
 typedef struct {
 	const char *ptr;
 	const char *end;
-	int trusted;
 } mochilo_src;
 
 void mochilo_buf_init(mochilo_buf *buf);
@@ -81,9 +80,9 @@ const char *mochilo_src_peek(mochilo_src *buf, size_t need);
 #define BUF_ENSURE_AVAIL(b, d) \
 	mochilo_buf_chunk *chunk = &b->chunks[b->cur_chunk]; \
 	if (unlikely(chunk->ptr + (d) > chunk->end)) { \
-		chunk = mochilo_buf_rechunk(b); };
+		if ((chunk = mochilo_buf_rechunk(b)) == NULL) return; };
 
-#define SRC_CHECK_AVAIL(src, bytes) (src->ptr + bytes <= src->end) 
+#define SRC_CHECK_AVAIL(src, bytes) (src->ptr + bytes <= src->end)
 
 #define SRC_ENSURE_AVAIL(src, bytes) \
 	if (unlikely(src->ptr + bytes > src->end)) \

data/ext/mochilo/mochilo.h

@@ -14,30 +14,32 @@
 #define MOAPI static inline
 
 enum msgpack_t {
-	MSGPACK_T_NIL = 0xc0,
-	MSGPACK_T_FALSE = 0xc2,
-	MSGPACK_T_TRUE = 0xc3,
-	MSGPACK_T_FLOAT = 0xca,
-	MSGPACK_T_DOUBLE = 0xcb,
-	MSGPACK_T_UINT8	= 0xcc,
-	MSGPACK_T_UINT16 = 0xcd,
-	MSGPACK_T_UINT32 = 0xce,
-	MSGPACK_T_UINT64 = 0xcf,
-	MSGPACK_T_INT8 = 0xd0,
-	MSGPACK_T_INT16	 = 0xd1,
-	MSGPACK_T_INT32 = 0xd2,
-	MSGPACK_T_INT64	 = 0xd3,
-	MSGPACK_T_SYM = 0xd4,
-	MSGPACK_T_REGEXP = 0xd5,
-	MSGPACK_T_TIME = 0xd6,
-	MSGPACK_T_STR16 = 0xd8, /* reserved in the spec */
-	MSGPACK_T_STR32 = 0xd9, /* reserved in the spec */
-	MSGPACK_T_RAW16	= 0xda,
-	MSGPACK_T_RAW32	 = 0xdb,
+	MSGPACK_T_NIL     = 0xc0,
+	MSGPACK_T_FALSE   = 0xc2,
+	MSGPACK_T_TRUE    = 0xc3,
+	MSGPACK_T_BIN8    = 0xc4,
+	MSGPACK_T_BIN16   = 0xc5,
+	MSGPACK_T_BIN32   = 0xc6,
+	MSGPACK_T_ENC8    = 0xc7,
+	MSGPACK_T_ENC16   = 0xc8,
+	MSGPACK_T_ENC32   = 0xc9,
+	MSGPACK_T_FLOAT   = 0xca,
+	MSGPACK_T_DOUBLE  = 0xcb,
+	MSGPACK_T_UINT8   = 0xcc,
+	MSGPACK_T_UINT16  = 0xcd,
+	MSGPACK_T_UINT32  = 0xce,
+	MSGPACK_T_UINT64  = 0xcf,
+	MSGPACK_T_INT8    = 0xd0,
+	MSGPACK_T_INT16   = 0xd1,
+	MSGPACK_T_INT32   = 0xd2,
+	MSGPACK_T_INT64   = 0xd3,
+	MSGPACK_T_STR8    = 0xd9,
+	MSGPACK_T_STR16   = 0xda,
+	MSGPACK_T_STR32   = 0xdb,
 	MSGPACK_T_ARRAY16 = 0xdc,
 	MSGPACK_T_ARRAY32 = 0xdd,
-	MSGPACK_T_MAP16	= 0xde,
-	MSGPACK_T_MAP32	= 0xdf
+	MSGPACK_T_MAP16   = 0xde,
+	MSGPACK_T_MAP32   = 0xdf
 };
 
 enum msgpack_enc_t {
@@ -145,16 +147,13 @@ enum msgpack_err_t {
 	MSGPACK_EEOF = -1,
 	MSGPACK_EINVALID = -2,
 	MSGPACK_ENOTHING = -3,
-	MSGPACK_EUNSAFE = -4,
 };
 
 typedef void * mo_value;
 typedef uint64_t mo_integer;
 int mochilo_unpack_one(mo_value *_value, mochilo_src *src);
 
-#ifdef HAVE_RUBY_ENCODING_H
-#	include <ruby/encoding.h>
-#	include "encodings.h"
-#endif
+#include <ruby/encoding.h>
+#include "encodings.h"
 
 #endif

data/ext/mochilo/mochilo.rb.c

@@ -23,9 +23,9 @@ static VALUE rb_eMochiloError;
 VALUE rb_eMochiloPackError;
 VALUE rb_eMochiloUnpackError;
 
-extern void mochilo_pack_one(mochilo_buf *buf, VALUE rb_object, int trusted);
+extern void mochilo_pack_one(mochilo_buf *buf, VALUE rb_object);
 
-static VALUE rb_mochilo__unpack(VALUE rb_buffer, int trusted)
+static VALUE rb_mochilo__unpack(VALUE rb_buffer)
 {
 	VALUE rb_result;
 	int error = -1;
@@ -35,11 +35,19 @@ static VALUE rb_mochilo__unpack(VALUE rb_buffer, int trusted)
 
 	source.ptr = RSTRING_PTR(rb_buffer);
 	source.end = source.ptr + RSTRING_LEN(rb_buffer);
-	source.trusted = trusted;
 
 	error = mochilo_unpack_one((mo_value)&rb_result, &source);
-	if (error < 0)
-		rb_raise(rb_eMochiloUnpackError, "unpack failed (%d)", error);
+	if (error < 0) {
+		switch (error) {
+			case MSGPACK_EEOF:
+				rb_raise(rb_eMochiloUnpackError, "more data needed");
+			case MSGPACK_EINVALID:
+				rb_raise(rb_eMochiloUnpackError, "invalid or corrupt data");
+			case MSGPACK_ENOTHING:
+			default:
+				rb_raise(rb_eMochiloUnpackError, "unpack failed");
+		}
+	}
 
 	return rb_result;
 }
@@ -53,21 +61,7 @@ static VALUE rb_mochilo__unpack(VALUE rb_buffer, int trusted)
  */
 static VALUE rb_mochilo_unpack(VALUE self, VALUE rb_buffer)
 {
-	return rb_mochilo__unpack(rb_buffer, 0);
-}
-
-/* Document-method: unpack_unsafe
- *
- * call-seq:
- *     Mochilo.unpack_unsafe(banana_pack_str) -> Object
- *
- * Unpacks a BananaPack stream into a Ruby object, in unsafe mode.
- * Only use this function if +banana_pack_str+ is trusted; otherwise
- * symbol DoS attacks are possible.
- */
-static VALUE rb_mochilo_unpack_unsafe(VALUE self, VALUE rb_buffer)
-{
-	return rb_mochilo__unpack(rb_buffer, 1);
+	return rb_mochilo__unpack(rb_buffer);
 }
 
 /* Document-method: pack
@@ -82,25 +76,7 @@ static VALUE rb_mochilo_pack(VALUE self, VALUE rb_obj)
 	mochilo_buf buf;
 
 	mochilo_buf_init(&buf);
-	mochilo_pack_one(&buf, rb_obj, 0);
-	return mochilo_buf_flush(&buf);
-}
-
-/* Document-method: pack
- *
- * call-seq:
- *     Mochilo.pack_unsafe(obj) -> String
- *
- * Packs a Ruby object into BananaPack format, in unsafe mode.
- * This enables the Symbol type durring serialization and will
- * have to be deserialized in unsafe mode as well.
- */
-static VALUE rb_mochilo_pack_unsafe(VALUE self, VALUE rb_obj)
-{
-	mochilo_buf buf;
-
-	mochilo_buf_init(&buf);
-	mochilo_pack_one(&buf, rb_obj, 1);
+	mochilo_pack_one(&buf, rb_obj);
 	return mochilo_buf_flush(&buf);
 }
 
@@ -108,12 +84,9 @@ void Init_mochilo()
 {
 	rb_mMochilo = rb_define_module("Mochilo");
 	rb_define_method(rb_mMochilo, "unpack", rb_mochilo_unpack, 1);
-	rb_define_method(rb_mMochilo, "unpack_unsafe", rb_mochilo_unpack_unsafe, 1);
 	rb_define_method(rb_mMochilo, "pack", rb_mochilo_pack, 1);
-	rb_define_method(rb_mMochilo, "pack_unsafe", rb_mochilo_pack_unsafe, 1);
 
 	rb_eMochiloError = rb_define_class_under(rb_mMochilo, "Error", rb_eStandardError);
 	rb_eMochiloPackError = rb_define_class_under(rb_mMochilo, "PackError", rb_eMochiloError);
 	rb_eMochiloUnpackError = rb_define_class_under(rb_mMochilo, "UnpackError", rb_eMochiloError);
 }
-

data/ext/mochilo/mochilo_api.h

@@ -4,44 +4,6 @@ MOAPI mo_value moapi_bytes_new(const char *src, size_t len)
 	return (mo_value)rb_str_new(src, len);
 }
 
-MOAPI mo_value moapi_sym_new(const char *src, size_t len)
-{
-	char *symbol;
-
-	if (len > 0xFF)
-		rb_raise(rb_eArgError, "Symbol too long to encode in BananaPack");
-
-	symbol = alloca(len + 1);
-	memcpy(symbol, src, len);
-	symbol[len] = '\0';
-
-	return (mo_value)ID2SYM(rb_intern(symbol));
-}
-
-#ifdef HAVE_RUBY_ENCODING_H
-MOAPI mo_value moapi_regexp_new(const char *src, size_t len, enum msgpack_enc_t encoding, int reg_options)
-{
-	int index = 0;
-	VALUE re;
-
-	if (encoding < sizeof(mochilo_enc_lookup)/sizeof(mochilo_enc_lookup[0]))
-		index = rb_enc_find_index(mochilo_enc_lookup[encoding]);
-
-	re = rb_reg_new(src, len, reg_options);
-	rb_enc_set_index(re, index);
-
-	return (mo_value)re;
-}
-#endif
-
-MOAPI mo_value moapi_time_new(uint64_t sec, uint64_t usec, int32_t utc_offset)
-{
-	VALUE utc_time = rb_time_new(sec, usec);
-	return (mo_value)rb_funcall(utc_time,
-		rb_intern("getlocal"), 1, INT2FIX(utc_offset));
-}
-
-#ifdef HAVE_RUBY_ENCODING_H
 MOAPI mo_value moapi_str_new(const char *src, size_t len, enum msgpack_enc_t encoding)
 {
 	int index = 0;
@@ -55,7 +17,6 @@ MOAPI mo_value moapi_str_new(const char *src, size_t len, enum msgpack_enc_t enc
 
 	return (mo_value)str;
 }
-#endif
 
 MOAPI mo_value moapi_array_new(size_t array_size)
 {