digest-kangarootwelve 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d66d4525e67457535b7ab5b8232c3c44955e147a
-  data.tar.gz: 6aca633b39fef2afba603e14aa37095e10b1fb7f
+  metadata.gz: 30d451f9dc1fc4f3e7e87a42fc2c0d3c21339300
+  data.tar.gz: a8ac32cff2303adf783383fcfaace5fd6ab27e3e
 SHA512:
-  metadata.gz: 4ba12fd8c227b4d5384456adc00b5326828e82c792dd967516b41b20b09885c62f19a133a8e2f3c028160ac822686e35db00a9a60ba8fc6eb967a8e0d5dc2eca
-  data.tar.gz: 96fcb84f82a6025bbed1b30ed5e295ac8432e51d3fd3d4c047cb1a351f214516facd2d358022f396ca75972a10ad65fc44df19baf8ecafbc973cf4599c7fa3dd
+  metadata.gz: 32e3bd67264b5eb97b781f403da7501237cd63cc2e10ac2f1e214998143a7cf6b070ecf2ee416c6a443827fb5867b4c4c8569d56ec715e5dc561034165bddc4c
+  data.tar.gz: 7ff11f64ed95a86df337e4518416ce0b27178f545a5b90d9c1192eaf7b5bca5f5f95aa2feb6266877e83424f9f7d40e94880db5d9905b5738c6930e1420889a5

data/README.md

@@ -1,6 +1,7 @@
 # digest-kangarootwelve-ruby
 
-An implementation of KangarooTwelve for Ruby that works on top of Digest::Base.
+The digest-kangarootwelve gem is an implementation of KangarooTwelve for Ruby
+that works on top of Digest::Base.
 
 It allows hashing with different digest lengths and different customization
 strings.
@@ -29,51 +30,40 @@ Or install it yourself as:
 
 ## Example Usage
 
-    require 'digest/kangarootwelve'
+    Digest::KangarooTwelve[32].digest("abc")
+    => "\xAB\x17O2\x8CU\xA5Q\v\v \x97\x91\xBF\x8B`\xE8\x01\xA7\xCF\xC2\xAAB\x04-\xCB\x8FT\x7F\xBE:}"
 
-    klass = Digest::KangarooTwelve[32]
-    => Digest::KangarooTwelve_32
-
-    hash = klass.new
-    => #<Digest::KangarooTwelve_32|32|65536||1ac2d450fc3b4205d19da7bfca1b37513c0803577ac7167f06fe2ce1f0ef39e5>
-
-    hash.hexdigest("abc")
+    Digest::KangarooTwelve[32].hexdigest("abc")
     => "ab174f328c55a5510b0b209791bf8b60e801a7cfc2aa42042dcb8f547fbe3a7d"
 
-    Digest::KangarooTwelve[32].new.hexdigest("abc")
+    Digest::KangarooTwelve[32].new.update("a").update("b").update("c").hexdigest
     => "ab174f328c55a5510b0b209791bf8b60e801a7cfc2aa42042dcb8f547fbe3a7d"
 
-    Digest::KangarooTwelve.default
-    => Digest::KangarooTwelve_64
-
-    Digest::KangarooTwelve.implement(digest_length: 32, customization: "secret")
-    => Digest::KangarooTwelve_32_65536_736563726574
-
     Digest::KangarooTwelve.implement(name: "SecretHash", digest_length: 32, customization: "secret")
     => Digest::SecretHash
 
     Digest::KangarooTwelve.implement(n: "SecretHash", d: 32, c: "secret")
     => Digest::SecretHash
 
-    Digest::SecretHash.new.hexdigest("abc")
+    Digest::SecretHash.hexdigest("abc")
     => "dc1fd53f85402e2b34fa92bd87593dd9c3fe6cc49d9db6c05dc0cf26c6a7e03f"
 
-    Digest::KangarooTwelve.implement(name: nil, digest_length: 48)
-    => #<Class:0x000000015fe8e8>
+    Digest::KangarooTwelve.default
+    => Digest::KangarooTwelve_64
 
 ## Details
 
-For details on how to use the methods, please examine the comments in
-`ext/digest/kangarootwelve/ext.c`, or try to run
-`ri 'Digest::KangarooTwelve'` or
-`ri 'Digest::KangarooTwelve::<method_name>'`.  I'll try to provide a more
-readable format of the documentation for the API soon.
-
-You can use the implementation classes produced by `[]`, `default` or
-`implement`, just like any other implementation class in `Digest`
-(e.g. `Digest::SHA1`, `Digest::SHA512`), since they are also derived from
-`Digest::Base`, and are programmed to work the way an implementation class
-that's based on the `Digest` framework should.
+The implementation classes produced by `[]`, `default` or
+`implement` can be used just like any other implementation class in `Digest`
+(like `Digest::SHA1` or `Digest::SHA512`), since the implementation classes are
+based on `Digest::Base`.
+
+For details on how to use these methods, please examine the comments in
+`ext/digest/kangarootwelve/ext.c`, or run `ri` with
+`ri 'Digest::KangarooTwelve'`, or `ri 'Digest::KangarooTwelve::<method_name>'`.
+
+You can also visit the automatically generated API documentation pages provided
+by RubyDoc.info in http://www.rubydoc.info/gems/digest-kangarootwelve/.
 
 ## Contributing
 

data/digest-kangarootwelve.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["konsolebox"]
   spec.email         = ["konsolebox@gmail.com"]
   spec.summary       = "KangarooTwelve for Ruby"
-  spec.description   = "An implementation of KangarooTwelve for Ruby that works on top of Digest::Base."
+  spec.description   = "A KangarooTwelve library that works on top of Digest::Base."
   spec.homepage      = "https://github.com/konsolebox/digest-kangarootwelve-ruby"
   spec.license       = "MIT"
 

data/ext/digest/kangarootwelve/ext.c

@@ -23,14 +23,15 @@
  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#include "KangarooTwelve.h"
 #include <ruby.h>
 #include <ruby/digest.h>
 
+#include "KangarooTwelve.h"
+#include "utils.h"
+
 #define KT_DEFAULT_DIGEST_LENGTH 64 /* 512 bits */
-#define KT_DEFAULT_BLOCK_LENGTH 8192 * 8 /* chunkSize * Parallellism */
+#define KT_BLOCK_LENGTH 8192 /* chunkSize */
 #define KT_MIN_DIGEST_LENGTH 1
-#define KT_MIN_BLOCK_LENGTH 64
 
 #define KT_DIGEST_API_VERSION_IS_SUPPORTED(version) (version == 3)
 
@@ -44,7 +45,9 @@ static ID _id_auto;
 static ID _id_block_length;
 static ID _id_b;
 static ID _id_customization;
+static ID _id_customization_hex;
 static ID _id_c;
+static ID _id_ch;
 static ID _id_default;
 static ID _id_digest_length;
 static ID _id_d;
@@ -55,11 +58,10 @@ static ID _id_new;
 static ID _id_n;
 static ID _id_unpack;
 
-static VALUE _module_Digest;
-static VALUE _class_Digest_Base;
-static VALUE _module_Digest_KangarooTwelve;
-static VALUE _class_Digest_KangarooTwelve_Impl;
-static VALUE _class_Digest_KangarooTwelve_Metadata;
+static VALUE _Digest;
+static VALUE _Digest_KangarooTwelve;
+static VALUE _Digest_KangarooTwelve_Impl;
+static VALUE _Digest_KangarooTwelve_Metadata;
 
 typedef struct {
 	KangarooTwelve_Instance instance;
@@ -75,10 +77,25 @@ static void check_digest_length(int digest_length)
 		rb_raise(rb_eArgError, "Digest length lesser than minimum (%d): %d", KT_MIN_DIGEST_LENGTH, digest_length);
 }
 
-static void check_block_length(int block_length)
+static VALUE hex_encode_str(VALUE str)
 {
-	if (!(block_length >= KT_MIN_BLOCK_LENGTH))
-		rb_raise(rb_eArgError, "Block length lesser than minimum (%d): %d", KT_MIN_BLOCK_LENGTH, block_length);
+	int len = RSTRING_LEN(str);
+	VALUE hex = rb_str_new(0, len * 2);
+	hex_encode_str_implied(RSTRING_PTR(str), len, RSTRING_PTR(hex));
+	return hex;
+}
+
+static VALUE hex_decode_str(VALUE str)
+{
+	int len = RSTRING_LEN(str);
+	VALUE decoded = rb_str_new(0, calc_hex_decoded_str_length(len));
+
+	if (! hex_decode_str_implied(RSTRING_PTR(str), len, RSTRING_PTR(decoded))) {
+		VALUE inspect = rb_inspect(str);
+		rb_raise(rb_eArgError, "Failed to decode hex string %s.", RSTRING_PTR(inspect));
+	}
+
+	return decoded;
 }
 
 static int kangarootwelve_init(void *ctx)
@@ -88,7 +105,7 @@ static int kangarootwelve_init(void *ctx)
 
 	VALUE klass_or_instance = rb_current_receiver();
 
-	if (TYPE(klass_or_instance) == T_CLASS && klass_or_instance == _class_Digest_KangarooTwelve_Impl)
+	if (TYPE(klass_or_instance) == T_CLASS && klass_or_instance == _Digest_KangarooTwelve_Impl)
 		rb_raise(rb_eStandardError, "Digest::KangarooTwelve::Impl is a base class and cannot be instantiated.");
 
 	VALUE digest_length = rb_funcall(klass_or_instance, _id_digest_length, 0);
@@ -143,17 +160,12 @@ static int kangarootwelve_finish(void *ctx, unsigned char *data)
 	}
 }
 
-static VALUE do_nothing(VALUE self)
-{
-	return Qnil;
-}
-
-static VALUE implement(VALUE name, VALUE digest_length, VALUE block_length, VALUE customization)
+static VALUE implement(VALUE name, VALUE digest_length, VALUE customization)
 {
 	if (!KT_DIGEST_API_VERSION_IS_SUPPORTED(RUBY_DIGEST_API_VERSION))
 		rb_raise(rb_eRuntimeError, "Digest API version is not supported.");
 
-	int digest_length_int, block_length_int;
+	int digest_length_int;
 
 	switch (TYPE(digest_length)) {
 	case T_NIL:
@@ -167,18 +179,6 @@ static VALUE implement(VALUE name, VALUE digest_length, VALUE block_length, VALU
 		rb_raise(rb_eTypeError, "Invalid value type for digest length.");
 	}
 
-	switch (TYPE(block_length)) {
-	case T_NIL:
-		block_length_int = KT_DEFAULT_BLOCK_LENGTH;
-		break;
-	case T_FIXNUM:
-		block_length_int = FIX2INT(block_length);
-		check_block_length(block_length_int);
-		break;
-	default:
-		rb_raise(rb_eTypeError, "Invalid value type for block length.");
-	}
-
 	switch (TYPE(customization)) {
 	case T_NIL:
 	case T_STRING:
@@ -198,12 +198,7 @@ static VALUE implement(VALUE name, VALUE digest_length, VALUE block_length, VALU
 
 		if (id == _id_auto) {
 			if (customization != Qnil) {
-				VALUE customization_hex_in_array = rb_funcall(customization, _id_unpack, 1, rb_str_new_literal("H*"));
-				VALUE customization_hex = rb_ary_pop(customization_hex_in_array);
-				impl_class_name = rb_sprintf("KangarooTwelve_%d_%d_%s", digest_length_int, block_length_int,
-						StringValueCStr(customization_hex));
-			} else if (block_length_int != KT_DEFAULT_BLOCK_LENGTH) {
-				impl_class_name = rb_sprintf("KangarooTwelve_%d_%d", digest_length_int, block_length_int);
+				impl_class_name = hex_encode_str(customization);
 			} else {
 				impl_class_name = rb_sprintf("KangarooTwelve_%d", digest_length_int);
 			}
@@ -231,10 +226,10 @@ static VALUE implement(VALUE name, VALUE digest_length, VALUE block_length, VALU
 	VALUE impl_class;
 
 	if (impl_class_name == Qnil) {
-		impl_class = rb_funcall(rb_cClass, _id_new, 1, _class_Digest_KangarooTwelve_Impl);
+		impl_class = rb_funcall(rb_cClass, _id_new, 1, _Digest_KangarooTwelve_Impl);
 	} else {
-		if (rb_const_defined(_module_Digest, impl_class_name_id)) {
-			impl_class = rb_const_get(_module_Digest, impl_class_name_id);
+		if (rb_const_defined(_Digest, impl_class_name_id)) {
+			impl_class = rb_const_get(_Digest, impl_class_name_id);
 
 			if (TYPE(impl_class) != T_CLASS) {
 				rb_raise(rb_eTypeError,
@@ -242,7 +237,7 @@ static VALUE implement(VALUE name, VALUE digest_length, VALUE block_length, VALU
 						StringValueCStr(impl_class_name));
 			}
 
-			if (rb_class_superclass(impl_class) != _class_Digest_KangarooTwelve_Impl) {
+			if (rb_class_superclass(impl_class) != _Digest_KangarooTwelve_Impl) {
 				rb_raise(rb_eTypeError,
 						"Digest::%s was already defined but not derived from Digest::KangarooTwelve::Impl.",
 						StringValueCStr(impl_class_name));
@@ -266,37 +261,19 @@ static VALUE implement(VALUE name, VALUE digest_length, VALUE block_length, VALU
 						digest_length_int);
 			}
 
-			VALUE prev_block_length = rb_ivar_get(impl_class, _id_block_length);
-
-			if (TYPE(prev_block_length) != T_FIXNUM) {
-				rb_raise(rb_eRuntimeError,
-						"Previous definition of Digest::%s has invalid block length value type.",
-						StringValueCStr(impl_class_name));
-			}
-
-			int prev_block_length_int = FIX2INT(prev_block_length);
-
-			if (prev_block_length_int != block_length_int) {
-				rb_raise(rb_eTypeError,
-						"Digest::%s was already defined but has different block length (%d instead of %d).",
-						StringValueCStr(impl_class_name),
-						prev_block_length_int,
-						block_length_int);
-			}
-
 			return impl_class;
 		}
 
-		impl_class = rb_define_class_id_under(_module_Digest, impl_class_name_id, _class_Digest_KangarooTwelve_Impl);
+		impl_class = rb_define_class_id_under(_Digest, impl_class_name_id, _Digest_KangarooTwelve_Impl);
 	}
 
 	VALUE metadata_obj;
 	rb_digest_metadata_t *metadata;
-	metadata_obj = Data_Make_Struct(_class_Digest_KangarooTwelve_Metadata, rb_digest_metadata_t, 0, -1, metadata);
+	metadata_obj = Data_Make_Struct(_Digest_KangarooTwelve_Metadata, rb_digest_metadata_t, 0, -1, metadata);
 
 	metadata->api_version = RUBY_DIGEST_API_VERSION;
 	metadata->digest_len = digest_length_int;
-	metadata->block_len = block_length_int;
+	metadata->block_len = KT_BLOCK_LENGTH;
 	metadata->ctx_size = sizeof(KT_CONTEXT);
 	metadata->init_func = kangarootwelve_init;
 	metadata->update_func = kangarootwelve_update;
@@ -304,7 +281,7 @@ static VALUE implement(VALUE name, VALUE digest_length, VALUE block_length, VALU
 
 	rb_ivar_set(impl_class, _id_metadata, metadata_obj);
 	rb_ivar_set(impl_class, _id_digest_length, INT2FIX(digest_length_int));
-	rb_ivar_set(impl_class, _id_block_length, INT2FIX(block_length_int));
+	rb_ivar_set(impl_class, _id_block_length, INT2FIX(KT_BLOCK_LENGTH));
 	rb_ivar_set(impl_class, _id_customization, customization);
 
 	return impl_class;
@@ -314,16 +291,25 @@ static VALUE implement(VALUE name, VALUE digest_length, VALUE block_length, VALU
  * Document-module: Digest::KangarooTwelve
  *
  * The Digest::KangarooTwelve module is the main component of the KangarooTwelve
- * extension.
+ * extension for Ruby.
+ *
+ * It contains singleton methods that can be used to create implementation
+ * classes.  These implementation classes can then be used to create instances
+ * for producing hashes.
+ *
+ * Example:
  *
- * To create a hashing object, one must use one of the singleton methods in this
- * module to produce an implementation class, which can then be used to create
- * the hashing object.
+ * <tt>Digest::KangarooTwelve[32].new.update("one").update("two").digest</tt>
  *
- * An example to this is <code>hash = Digest::KangarooTwelve[32].new</code>.
+ * The implementation classes can also be used to directly produce hashes.
  *
- * The produced implementation class and the hash object can be used just like
- * any other implementation classes and instances in Digest.
+ * Example:
+ *
+ * <tt>Digest::KangarooTwelve[32].hexdigest("1234")</tt>
+ *
+ * The produced implementation classes and their instances can be used just like
+ * any other classes and instances in the Digest namespace that's based on
+ * Digest::Base.
  */
 
 /*
@@ -332,12 +318,12 @@ static VALUE implement(VALUE name, VALUE digest_length, VALUE block_length, VALU
  * Returns the default implementation class which has a digest length of 64
  * bytes, and doesn't have a customization string.
  */
-VALUE rbx_Digest_KangarooTwelve_singleton_default(VALUE self)
+static VALUE _Digest_KangarooTwelve_singleton_default(VALUE self)
 {
 	VALUE default_ = rb_ivar_get(self, _id_default);
 
 	if (NIL_P(default_)) {
-		default_ = implement(ID2SYM(_id_auto), INT2FIX(KT_DEFAULT_DIGEST_LENGTH), Qnil, Qnil);
+		default_ = implement(ID2SYM(_id_auto), INT2FIX(KT_DEFAULT_DIGEST_LENGTH), Qnil);
 		rb_ivar_set(self, _id_default, default_);
 	}
 
@@ -360,15 +346,12 @@ VALUE rbx_Digest_KangarooTwelve_singleton_default(VALUE self)
  *   module.
  *
  *   The default value for this option is +:auto+, and it implies automatic
- *   generation of the name.  The generated name is in the format of
- *   Digest::KangarooTwelve_<digest_length> if neither a customization string
- *   nor a custom block length is specified.
+ *   generation of the name.  The generated name is in the form of
+ *   Digest::KangarooTwelve_<digest_length> if a customization string is not
+ *   specified.
  *
- *   If a customization string is specified, the format would become
- *   Digest::KangarooTwelve_<digest_length>_<block_length>_<cust_str_hex>.
- *
- *   If no customization string is specified but a custom block is, the format
- *   would be Digest::KangarooTwelve_<digest_length>_<block_length>.
+ *   If a customization string is specified, the format would be
+ *   Digest::KangarooTwelve_<digest_length>_<cust_str_hex>.
  *
  *   Specifying a string would make the method produce Digest::<string>.
  *
@@ -381,30 +364,25 @@ VALUE rbx_Digest_KangarooTwelve_singleton_default(VALUE self)
  *
  *   See Digest::KangarooTwelve::DEFAULT_DIGEST_LENGTH for the default value.
  *
- * :b, :block_length ::
- *   Specifies a custom block length.  This doesn't affect the digest results
- *   and is mostly just used for tweaking performance or memory usage.  Examine
- *   the update function in KangarooTwelve.c to know if this is needed to be
- *   configured.
- *
- *   See Digest::KangarooTwelve::DEFAULT_BLOCK_LENGTH for the default value.
- *
  * :c, :customization ::
  *   Specifies the customization string.  Adding a customization string changes
  *   the resulting digest of every input.
  *
- * Calling the method with no argument would be the same as calling the
+ * :ch, :customization_hex ::
+ *   Specifies the customization string in hex mode.
+ *
+ * Calling the method with no argument is the same as calling the
  * Digest::KangarooTwelve::default method.
  */
-VALUE rbx_Digest_KangarooTwelve_singleton_implement(int argc, VALUE *argv, VALUE self)
+static VALUE _Digest_KangarooTwelve_singleton_implement(int argc, VALUE *argv, VALUE self)
 {
-	VALUE opts, name, digest_length, block_length, customization;
+	VALUE opts, name, digest_length, customization;
 
 	rb_scan_args(argc, argv, "0:", &opts);
 
 	if (NIL_P(opts)) {
 		name = ID2SYM(_id_auto);
-		digest_length = block_length = customization = Qnil;
+		digest_length = customization = Qnil;
 	} else {
 		name = rb_hash_lookup2(opts, ID2SYM(_id_n), Qundef);
 
@@ -416,18 +394,29 @@ VALUE rbx_Digest_KangarooTwelve_singleton_implement(int argc, VALUE *argv, VALUE
 		if (digest_length == Qundef)
 			digest_length = rb_hash_lookup2(opts, ID2SYM(_id_digest_length), Qnil);
 
-		block_length = rb_hash_lookup2(opts, ID2SYM(_id_b), Qundef);
-
-		if (block_length == Qundef)
-			block_length = rb_hash_lookup2(opts, ID2SYM(_id_block_length), Qnil);
-
 		customization = rb_hash_lookup2(opts, ID2SYM(_id_c), Qundef);
 
 		if (customization == Qundef)
-			customization = rb_hash_lookup2(opts, ID2SYM(_id_customization), Qnil);
+			customization = rb_hash_lookup2(opts, ID2SYM(_id_customization), Qundef);
+
+		if (customization == Qundef) {
+			VALUE customization_hex = rb_hash_lookup2(opts, ID2SYM(_id_customization_hex), Qundef);
+
+			if (customization_hex == Qundef)
+				customization_hex = rb_hash_lookup2(opts, ID2SYM(_id_ch), Qundef);
+
+			if (customization_hex == Qundef) {
+				customization = Qnil;
+			} else {
+				if (TYPE(customization_hex) != T_STRING)
+					rb_raise(rb_eTypeError, "Customization argument not a string.");
+
+				customization = hex_decode_str(customization_hex);
+			}
+		}
 	}
 
-	return implement(name, digest_length, block_length, customization);
+	return implement(name, digest_length, customization);
 }
 
 /*
@@ -440,9 +429,9 @@ VALUE rbx_Digest_KangarooTwelve_singleton_implement(int argc, VALUE *argv, VALUE
  * Digest::KangarooTwelve_<digest_length>, and can be directly referenced after
  * this method is called.
  */
-VALUE rbx_Digest_KangarooTwelve_singleton_implement_simple(VALUE self, VALUE digest_length)
+static VALUE _Digest_KangarooTwelve_singleton_implement_simple(VALUE self, VALUE digest_length)
 {
-	return implement(ID2SYM(_id_auto), digest_length, Qnil, Qnil);
+	return implement(ID2SYM(_id_auto), digest_length, Qnil);
 }
 
 /*
@@ -459,12 +448,12 @@ VALUE rbx_Digest_KangarooTwelve_singleton_implement_simple(VALUE self, VALUE dig
  *
  * Creates a new object instance of the implementation class.
  */
-VALUE rbx_Digest_KangarooTwelve_Impl_singleton_new(VALUE self)
+static VALUE _Digest_KangarooTwelve_Impl_singleton_new(VALUE self)
 {
-	if (self == _class_Digest_KangarooTwelve_Impl)
+	if (self == _Digest_KangarooTwelve_Impl)
 		rb_raise(rb_eRuntimeError, "Digest::KangarooTwelve::Impl is an abstract class.");
 
-	if (rb_obj_class(rb_ivar_get(self, _id_metadata)) != _class_Digest_KangarooTwelve_Metadata)
+	if (rb_obj_class(rb_ivar_get(self, _id_metadata)) != _Digest_KangarooTwelve_Metadata)
 		rb_raise(rb_eRuntimeError, "Metadata not set or invalid.  Please do not manually inherit KangarooTwelve.");
 
 	return rb_call_super(0, 0);
@@ -475,9 +464,9 @@ VALUE rbx_Digest_KangarooTwelve_Impl_singleton_new(VALUE self)
  *
  * Returns configured digest length of the implementation class.
  */
-VALUE rbx_Digest_KangarooTwelve_Impl_singleton_digest_length(VALUE self)
+static VALUE _Digest_KangarooTwelve_Impl_singleton_digest_length(VALUE self)
 {
-	if (self == _class_Digest_KangarooTwelve_Impl)
+	if (self == _Digest_KangarooTwelve_Impl)
 		rb_raise(rb_eRuntimeError, "Digest::KangarooTwelve::Impl is an abstract class.");
 
 	return rb_ivar_get(self, _id_digest_length);
@@ -486,14 +475,11 @@ VALUE rbx_Digest_KangarooTwelve_Impl_singleton_digest_length(VALUE self)
 /*
  * call-seq: block_length -> int
  *
- * Returns configured block length of the implementation class.
+ * Returns 8192.
  */
-VALUE rbx_Digest_KangarooTwelve_Impl_singleton_block_length(VALUE self)
+static VALUE _Digest_KangarooTwelve_Impl_singleton_block_length(VALUE self)
 {
-	if (self == _class_Digest_KangarooTwelve_Impl)
-		rb_raise(rb_eRuntimeError, "Digest::KangarooTwelve::Impl is an abstract class.");
-
-	return rb_ivar_get(self, _id_block_length);
+	return INT2FIX(KT_BLOCK_LENGTH);
 }
 
 /*
@@ -501,20 +487,34 @@ VALUE rbx_Digest_KangarooTwelve_Impl_singleton_block_length(VALUE self)
  *
  * Returns configured customization string of the implementation class.
  */
-VALUE rbx_Digest_KangarooTwelve_Impl_singleton_customization(VALUE self)
+static VALUE _Digest_KangarooTwelve_Impl_singleton_customization(VALUE self)
 {
-	if (self == _class_Digest_KangarooTwelve_Impl)
+	if (self == _Digest_KangarooTwelve_Impl)
 		rb_raise(rb_eRuntimeError, "Digest::KangarooTwelve::Impl is an abstract class.");
 
 	return rb_ivar_get(self, _id_customization);
 }
 
+/*
+ * call-seq: customization_hex -> string or nil
+ *
+ * Returns configured customization string of the implementation class in hex.
+ */
+static VALUE _Digest_KangarooTwelve_Impl_singleton_customization_hex(VALUE self)
+{
+	if (self == _Digest_KangarooTwelve_Impl)
+		rb_raise(rb_eRuntimeError, "Digest::KangarooTwelve::Impl is an abstract class.");
+
+	VALUE customization = rb_ivar_get(self, _id_customization);
+	return hex_encode_str(customization);
+}
+
 /*
  * call-seq: customization -> string or nil
  *
  * Returns configured customization string of the implementation object.
  */
-VALUE rbx_Digest_KangarooTwelve_Impl_customization(VALUE self)
+static VALUE _Digest_KangarooTwelve_Impl_customization(VALUE self)
 {
 	VALUE customization;
 
@@ -529,12 +529,23 @@ VALUE rbx_Digest_KangarooTwelve_Impl_customization(VALUE self)
 	return customization;
 }
 
+/*
+ * call-seq: customization_hex -> string or nil
+ *
+ * Returns configured customization string of the implementation object in hex.
+ */
+static VALUE _Digest_KangarooTwelve_Impl_customization_hex(VALUE self)
+{
+	VALUE customization = rb_funcall(self, _id_customization, 0);
+	return hex_encode_str(customization);
+}
+
 /*
  * call-seq: inspect -> string
  *
- * Returns a string in the format of #<implementation_class_name|digest_length|block_length|customization_string|digest>
+ * Returns a string in the form of #<impl_class_name|digest_length|hex_cust_string|hex_digest>
  */
-VALUE rbx_Digest_KangarooTwelve_inspect(VALUE self)
+static VALUE _Digest_KangarooTwelve_Impl_inspect(VALUE self)
 {
 	VALUE klass = rb_obj_class(self);
 	VALUE klass_name = rb_class_name(klass);
@@ -543,12 +554,11 @@ VALUE rbx_Digest_KangarooTwelve_inspect(VALUE self)
 		klass_name = rb_inspect(klass);
 
 	VALUE digest_length = rb_funcall(self, _id_digest_length, 0);
-	VALUE block_length = rb_funcall(self, _id_block_length, 0);
-	VALUE customization = rb_funcall(self, _id_customization, 0);
+	VALUE customization_hex = rb_funcall(self, _id_customization_hex, 0);
 	VALUE hexdigest = rb_funcall(self, _id_hexdigest, 0);
 
-	VALUE args[] = { klass_name, digest_length, block_length, customization, hexdigest };
-	return rb_str_format(sizeof(args), args, rb_str_new_literal("#<%s|%d|%d|%s|%s>"));
+	VALUE args[] = { klass_name, digest_length, customization_hex, hexdigest };
+	return rb_str_format(sizeof(args), args, rb_str_new_literal("#<%s:%d|%s|%s>"));
 }
 
 /*
@@ -562,7 +572,9 @@ void Init_kangarootwelve()
 	DEFINE_ID(auto)
 	DEFINE_ID(block_length)
 	DEFINE_ID(b)
+	DEFINE_ID(ch)
 	DEFINE_ID(customization)
+	DEFINE_ID(customization_hex)
 	DEFINE_ID(c)
 	DEFINE_ID(default)
 	DEFINE_ID(digest_length)
@@ -575,66 +587,77 @@ void Init_kangarootwelve()
 	DEFINE_ID(unpack)
 
 	rb_require("digest");
-	_module_Digest = rb_path2class("Digest");
-	_class_Digest_Base = rb_path2class("Digest::Base");
+	_Digest = rb_path2class("Digest");
 
 	#if 0
-	_module_Digest = rb_define_module("Digest"); /* Tell RDoc about Digest since it doesn't recognize rb_path2class. */
+	_Digest = rb_define_module("Digest"); /* Tell RDoc about Digest since it doesn't recognize rb_path2class. */
 	#endif
 
 	/*
-	 * module Digest::KangarooTwelve
+	 * Document-module: Digest::KangarooTwelve
 	 */
 
-	_module_Digest_KangarooTwelve = rb_define_module_under(_module_Digest, "KangarooTwelve");
+	_Digest_KangarooTwelve = rb_define_module_under(_Digest, "KangarooTwelve");
 
-	rb_define_singleton_method(_module_Digest_KangarooTwelve, "default",
-			rbx_Digest_KangarooTwelve_singleton_default, 0);
-	rb_define_singleton_method(_module_Digest_KangarooTwelve, "implement",
-			rbx_Digest_KangarooTwelve_singleton_implement, -1);
-	rb_define_singleton_method(_module_Digest_KangarooTwelve, "[]",
-			rbx_Digest_KangarooTwelve_singleton_implement_simple, 1);
+	rb_define_singleton_method(_Digest_KangarooTwelve, "default",
+			_Digest_KangarooTwelve_singleton_default, 0);
+	rb_define_singleton_method(_Digest_KangarooTwelve, "implement",
+			_Digest_KangarooTwelve_singleton_implement, -1);
+	rb_define_singleton_method(_Digest_KangarooTwelve, "[]",
+			_Digest_KangarooTwelve_singleton_implement_simple, 1);
 
 	/*
-	 * Currently 65536 bytes (8192 x 8)
+	 * Document-const: Digest::KangarooTwelve::BLOCK_LENGTH
+	 *
+	 * 8192 bytes
 	 */
 
-	rb_define_const(_module_Digest_KangarooTwelve, "DEFAULT_BLOCK_LENGTH", INT2FIX(KT_DEFAULT_BLOCK_LENGTH));
+	/* 8192 bytes */
+
+	rb_define_const(_Digest_KangarooTwelve, "BLOCK_LENGTH", INT2FIX(KT_BLOCK_LENGTH));
 
 	/*
+	 * Document-const: Digest::KangarooTwelve::DEFAULT_DIGEST_LENGTH
+	 *
 	 * 64 bytes (512 bits)
 	 */
 
-	rb_define_const(_module_Digest_KangarooTwelve, "DEFAULT_DIGEST_LENGTH", INT2FIX(KT_DEFAULT_DIGEST_LENGTH));
+	/* 64 bytes (512 bits) */
+
+	rb_define_const(_Digest_KangarooTwelve, "DEFAULT_DIGEST_LENGTH", INT2FIX(KT_DEFAULT_DIGEST_LENGTH));
 
 	/*
-	 * class Digest::KangarooTwelve::Impl < Digest::Base
+	 * Document-class: Digest::KangarooTwelve::Impl
 	 */
 
-	_class_Digest_KangarooTwelve_Impl = rb_define_class_under(_module_Digest_KangarooTwelve, "Impl",
-			_class_Digest_Base);
-
-	rb_define_singleton_method(_class_Digest_KangarooTwelve_Impl, "new",
-			rbx_Digest_KangarooTwelve_Impl_singleton_new, 0);
-	rb_define_singleton_method(_class_Digest_KangarooTwelve_Impl, "block_length",
-			rbx_Digest_KangarooTwelve_Impl_singleton_block_length, 0);
-	rb_define_singleton_method(_class_Digest_KangarooTwelve_Impl, "digest_length",
-			rbx_Digest_KangarooTwelve_Impl_singleton_digest_length, 0);
-	rb_define_singleton_method(_class_Digest_KangarooTwelve_Impl, "customization",
-			rbx_Digest_KangarooTwelve_Impl_singleton_customization, 0);
-
-	rb_define_method(_class_Digest_KangarooTwelve_Impl, "customization",
-			rbx_Digest_KangarooTwelve_Impl_customization, 0);
-	rb_define_method(_class_Digest_KangarooTwelve_Impl, "inspect",
-			rbx_Digest_KangarooTwelve_inspect, 0);
+	_Digest_KangarooTwelve_Impl = rb_define_class_under(_Digest_KangarooTwelve, "Impl",
+			rb_path2class("Digest::Base"));
+
+	rb_define_singleton_method(_Digest_KangarooTwelve_Impl, "new",
+			_Digest_KangarooTwelve_Impl_singleton_new, 0);
+	rb_define_singleton_method(_Digest_KangarooTwelve_Impl, "block_length",
+			_Digest_KangarooTwelve_Impl_singleton_block_length, 0);
+	rb_define_singleton_method(_Digest_KangarooTwelve_Impl, "digest_length",
+			_Digest_KangarooTwelve_Impl_singleton_digest_length, 0);
+	rb_define_singleton_method(_Digest_KangarooTwelve_Impl, "customization",
+			_Digest_KangarooTwelve_Impl_singleton_customization, 0);
+	rb_define_singleton_method(_Digest_KangarooTwelve_Impl, "customization_hex",
+			_Digest_KangarooTwelve_Impl_singleton_customization_hex, 0);
+
+	rb_define_method(_Digest_KangarooTwelve_Impl, "customization",
+			_Digest_KangarooTwelve_Impl_customization, 0);
+	rb_define_method(_Digest_KangarooTwelve_Impl, "customization_hex",
+			_Digest_KangarooTwelve_Impl_customization_hex, 0);
+	rb_define_method(_Digest_KangarooTwelve_Impl, "inspect",
+			_Digest_KangarooTwelve_Impl_inspect, 0);
 
 	/*
-	 * class Digest::KangarooTwelve::Metadata < Data
+	 * Document-class: Digest::KangarooTwelve::Metadata
 	 *
 	 * This class represents the internal metadata produced for the
 	 * implementation classes.
 	 */
 
-	_class_Digest_KangarooTwelve_Metadata = rb_define_class_under(_module_Digest_KangarooTwelve, "Metadata",
+	_Digest_KangarooTwelve_Metadata = rb_define_class_under(_Digest_KangarooTwelve, "Metadata",
 			rb_path2class("Data"));
 }

data/ext/digest/kangarootwelve/utils.h

@@ -0,0 +1,99 @@
+/*
+ * These works are licensed under the Creative Commons Attribution-ShareAlike
+ * 3.0 Unported License.  To view a copy of this license, visit
+ * http://creativecommons.org/licenses/by-sa/3.0/ or send a letter to Creative
+ * Commons, PO Box 1866, Mountain View, CA 94042, USA.
+ */
+
+#ifndef UTILS_H
+#define UTILS_H
+
+/*
+ * A simplified hex encoder based on Yannuth's answer in StackOverflow
+ * (https://stackoverflow.com/a/17147874/445221).
+ *
+ * Length of `dest[]` is implied to be twice of `len`.
+ */
+static void hex_encode_str_implied(const unsigned char *src, size_t len, unsigned char *dest)
+{
+	static const unsigned char table[] = "0123456789abcdef";
+
+	for (; len > 0; --len) {
+		unsigned char c = *src++;
+		*dest++ = table[c >> 4];
+		*dest++ = table[c & 0x0f];
+	}
+}
+
+/*
+ * Decodes hex string.
+ *
+ * Length of `dest[]` is implied to be calculated with calc_hex_decoded_str_length.
+ *
+ * Returns nonzero is successful.
+ */
+static int hex_decode_str_implied(const unsigned char *src, size_t len, unsigned char *dest)
+{
+	if (len % 2) {
+		unsigned char low = *src++;
+
+		if (low >= '0' && low <= '9') {
+			low -= '0';
+		} else if (low >= 'A' && low <= 'F') {
+			low -= 'A' - 10;
+		} else if (low >= 'a' && low <= 'f') {
+			low -= 'a' - 10;
+		} else {
+			return 0;
+		}
+
+		*dest++ = low;
+		--len;
+	}
+
+	for (; len > 0; len -= 2) {
+		unsigned char high = *src++;
+
+		if (high >= '0' && high <= '9') {
+			high -= '0';
+		} else if (high >= 'A' && high <= 'F') {
+			high -= 'A' - 10;
+		} else if (high >= 'a' && high <= 'f') {
+			high -= 'a' - 10;
+		} else {
+			return 0;
+		}
+
+		unsigned char low = *src++;
+
+		if (low >= '0' && low <= '9') {
+			low -= '0';
+		} else if (low >= 'A' && low <= 'F') {
+			low -= 'A' - 10;
+		} else if (low >= 'a' && low <= 'f') {
+			low -= 'a' - 10;
+		} else {
+			return 0;
+		}
+
+		*dest++ = high << 4 | low;
+	}
+
+	return -1;
+}
+
+/*
+ * Calculates length of string that would store decoded hex.
+ */
+static size_t calc_hex_decoded_str_length(size_t hex_encoded_length)
+{
+	if (hex_encoded_length == 0)
+		return 0;
+
+	if (hex_encoded_length % 2)
+		++hex_encoded_length;
+
+	return hex_encoded_length / 2;
+}
+
+#endif

data/lib/digest/kangarootwelve/version.rb

@@ -1,5 +1,5 @@
 module Digest
   class KangarooTwelve
-    VERSION = "0.0.2"
+    VERSION = "0.1.0"
   end
 end

data/test/test.rb

@@ -1,5 +1,4 @@
 require 'minitest/autorun'
-require 'yaml'
 
 TEST_DIR = File.dirname(__FILE__)
 require File.join(TEST_DIR, %w{ .. lib digest kangarootwelve })
@@ -17,6 +16,10 @@ def get_repeated_0xff(length)
   [str].cycle(cycles).to_a.join[0...length]
 end
 
+def hex_encode(str)
+  str.unpack('H*').pop
+end
+
 describe Digest::KangarooTwelve do
   it "produces implementation classes" do
     Digest::KangarooTwelve[32].superclass.must_equal Digest::KangarooTwelve::Impl
@@ -42,25 +45,50 @@ describe Digest::KangarooTwelve do
     Digest::KangarooTwelve.implement(digest_length: 48).new.digest_length.must_equal Digest::KangarooTwelve_48.digest_length
   end
 
-  it "produces a hash" do
-    Digest::KangarooTwelve.default.new.digest("")
+  it "produces hashes" do
+    Digest::KangarooTwelve.default.digest("").class.must_equal String
+    Digest::KangarooTwelve.default.hexdigest("").class.must_equal String
+    Digest::KangarooTwelve.default.new.digest("").class.must_equal String
+    Digest::KangarooTwelve.default.new.hexdigest("").class.must_equal String
+  end
+
+  it "produces similar output with its digest and hexdigest methods" do
+    digest_a = Digest::KangarooTwelve[32].digest("abcd")
+    digest_a.class.must_equal String
+    digest_b = Digest::KangarooTwelve[32].new.digest("abcd")
+    digest_b.class.must_equal String
+    digest_a.must_equal digest_b
+    hex_digest_a = Digest::KangarooTwelve[32].hexdigest("abcd")
+    hex_digest_a.class.must_equal String
+    hex_digest_b = Digest::KangarooTwelve[32].new.hexdigest("abcd")
+    hex_digest_b.class.must_equal String
+    hex_digest_a.must_equal hex_digest_b
+    hex_digest_a.must_equal hex_encode(digest_a)
   end
 
   it "works with customization strings" do
-    Digest::KangarooTwelve.implement(customization: "abc").new.digest("")
+    Digest::KangarooTwelve.implement(customization: "abcd").new.digest("")
   end
 
   it "produces implementations with small and long option names" do
-    a = Digest::KangarooTwelve.implement(n: "KangarooTwelveTestA", d: 48, b: 512, c: "abc")
-    b = Digest::KangarooTwelve.implement(name: "KangarooTwelveTestB", digest_length: 48, block_length: 512, customization: "abc")
+    a = Digest::KangarooTwelve.implement(n: "KangarooTwelveTestA", d: 48, c: "abcd")
+    b = Digest::KangarooTwelve.implement(name: "KangarooTwelveTestB", digest_length: 48, customization: "abcd")
+    c = Digest::KangarooTwelve.implement(name: "KangarooTwelveTestC", digest_length: 48, customization_hex: "61626364")
+    d = Digest::KangarooTwelve.implement(name: "KangarooTwelveTestD", digest_length: 48, ch: "61626364")
     a.name.must_equal "Digest::KangarooTwelveTestA"
     b.name.must_equal "Digest::KangarooTwelveTestB"
     a.digest_length.must_equal 48
-    a.digest_length.must_equal b.digest_length
-    a.block_length.must_equal 512
-    a.block_length.must_equal b.block_length
-    a.customization.must_equal "abc"
-    a.customization.must_equal b.customization
+    b.digest_length.must_equal a.digest_length
+    a.customization.must_equal "abcd"
+    b.customization.must_equal a.customization
+    c.customization.must_equal a.customization
+    d.customization.must_equal a.customization
+  end
+
+  it "has a declared block length of 8192 bytes" do
+    Digest::KangarooTwelve::BLOCK_LENGTH == 8192
+    Digest::KangarooTwelve.default.block_length == 8192
+    Digest::KangarooTwelve.default.new.block_length == 8192
   end
 
   it "produces valid hashes" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: digest-kangarootwelve
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - konsolebox
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-12 00:00:00.000000000 Z
+date: 2017-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -52,7 +52,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.8'
-description: An implementation of KangarooTwelve for Ruby that works on top of Digest::Base.
+description: A KangarooTwelve library that works on top of Digest::Base.
 email:
 - konsolebox@gmail.com
 executables: []
@@ -86,6 +86,7 @@ files:
 - ext/digest/kangarootwelve/brg_endian.h
 - ext/digest/kangarootwelve/ext.c
 - ext/digest/kangarootwelve/extconf.rb
+- ext/digest/kangarootwelve/utils.h
 - lib/digest/kangarootwelve/version.rb
 - test/test.rb
 homepage: https://github.com/konsolebox/digest-kangarootwelve-ruby
@@ -108,7 +109,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: KangarooTwelve for Ruby