type_array 0.1 → 0.2

data/README.rdoc

@@ -131,7 +131,6 @@ Running tests
 == Todo
 
 * Support Marshal dump / load
-* Low level API for math operations on array elements without creating any Ruby objects
 * Support structs / records
 * Handle edges where coercion to and from Bignum is more appropriate
 

data/ext/type_array/type_array.c

@@ -29,6 +29,14 @@ static ID rb_type_array_intern_aset;
 */
 DefineTypeArraySetter(int8, (signed char)NUM2CHR(item));
 
+/*
+ * :nodoc:
+ *  Defines operator functions for int8s at given offsets, according to host endianness.
+ *
+*/
+DefineTypeArrayOperators(int8, signed char, TACHR2FIX(val));
+DefineTypeArrayOperator(eql, ==, int8, signed char, (val == 0 ? Qfalse : Qtrue));
+
 /*
  * :nodoc:
  *  Coerces an int8 at a given offset to a Ruby object, according to host endianness.
@@ -50,6 +58,14 @@ DefineTypeArraySetter(uint8, (unsigned char)NUM2CHR(item));
 */
 DefineTypeArrayGetter(uint8, unsigned char, TACHR2FIX(val));
 
+/*
+ * :nodoc:
+ *  Defines operator functions for uint8s at given offsets, according to host endianness.
+ *
+*/
+DefineTypeArrayOperators(uint8, unsigned char, TACHR2FIX(val));
+DefineTypeArrayOperator(eql, ==, uint8, unsigned char, (val == 0 ? Qfalse : Qtrue));
+
 /*
  * :nodoc:
  *  Coerces a Ruby object to an int16 at a given offset, according to host endianness.
@@ -64,6 +80,14 @@ DefineTypeArraySetter(int16, (short)NUM2INT(item));
 */
 DefineTypeArrayGetter(int16, short, INT2FIX(val));
 
+/*
+ * :nodoc:
+ *  Defines operator functions for int16s at given offsets, according to host endianness.
+ *
+*/
+DefineTypeArrayOperators(int16, short, INT2FIX(val));
+DefineTypeArrayOperator(eql, ==, int16, short, (val == 0 ? Qfalse : Qtrue));
+
 /*
  * :nodoc:
  *  Coerces a Ruby object to an unsigned int16 at a given offset, according to host endianness.
@@ -78,6 +102,14 @@ DefineTypeArraySetter(uint16, (unsigned short)NUM2INT(item));
 */
 DefineTypeArrayGetter(uint16, unsigned short, INT2FIX(val));
 
+/*
+ * :nodoc:
+ *  Defines operator functions for uint16s at given offsets, according to host endianness.
+ *
+*/
+DefineTypeArrayOperators(uint16, unsigned short, INT2FIX(val));
+DefineTypeArrayOperator(eql, ==, uint16, unsigned short, (val == 0 ? Qfalse : Qtrue));
+
 /*
  * :nodoc:
  *  Coerces a Ruby object to an int32 at a given offset, according to host endianness.
@@ -92,6 +124,14 @@ DefineTypeArraySetter(int32, NUM2INT(item));
 */
 DefineTypeArrayGetter(int32, int, INT2FIX(val));
 
+/*
+ * :nodoc:
+ *  Defines operator functions for int32s at given offsets, according to host endianness.
+ *
+*/
+DefineTypeArrayOperators(int32, int, INT2FIX(val));
+DefineTypeArrayOperator(eql, ==, int32, int, (val == 0 ? Qfalse : Qtrue));
+
 /*
  * :nodoc:
  *  Coerces a Ruby object to an unsigned int32 at a given offset, according to host endianness.
@@ -106,6 +146,14 @@ DefineTypeArraySetter(uint32, NUM2UINT(item));
 */
 DefineTypeArrayGetter(uint32, unsigned int, UINT2NUM(val));
 
+/*
+ * :nodoc:
+ *  Defines operator functions for uint32s at given offsets, according to host endianness.
+ *
+*/
+DefineTypeArrayOperators(uint32, unsigned int, UINT2NUM(val));
+DefineTypeArrayOperator(eql, ==, uint32, unsigned int, (val == 0 ? Qfalse : Qtrue));
+
 /*
  * :nodoc:
  *  Coerces a Ruby object to a float32 (float) at a given offset, according to host endianness.
@@ -137,6 +185,14 @@ static void rb_type_array_aset_float32(rb_array_buffer_t *buf, long index, VALUE
 */
 DefineTypeArrayGetter(float32, float, rb_float_new((double)val));
 
+/*
+ * :nodoc:
+ *  Defines operator functions for float32s at given offsets, according to host endianness.
+ *
+*/
+DefineTypeArrayOperators(float32, float, rb_float_new((double)val));
+DefineTypeArrayOperator(eql, ==, float32, float, (val == 0 ? Qfalse : Qtrue));
+
 /*
  * :nodoc:
  *  Coerces a Ruby object to a float64 (double) at a given offset, according to host endianness.
@@ -168,6 +224,14 @@ static void rb_type_array_aset_float64(rb_array_buffer_t *buf, long index, VALUE
 */
 DefineTypeArrayGetter(float64, double, rb_float_new(val));
 
+/*
+ * :nodoc:
+ *  Defines operator functions for float64s at given offsets, according to host endianness.
+ *
+*/
+DefineTypeArrayOperators(float64, double, rb_float_new(val));
+DefineTypeArrayOperator(eql, ==, float64, double, (val == 0 ? Qfalse : Qtrue));
+
 /*
  * :nodoc:
  *  Asserts type alignment.
@@ -291,27 +355,67 @@ static VALUE rb_type_array_s_new(int argc, VALUE *argv, VALUE klass)
     if (klass == rb_cInt8Array) {
         array->aref_fn = rb_type_array_aref_int8;
         array->aset_fn = rb_type_array_aset_int8;
+        array->mul_fn = rb_type_array_mul_int8;
+        array->plus_fn = rb_type_array_plus_int8;
+        array->minus_fn = rb_type_array_minus_int8;
+        array->div_fn = rb_type_array_div_int8;
+        array->eql_fn = rb_type_array_eql_int8;
     } else if (klass == rb_cUInt8Array) {
         array->aref_fn = rb_type_array_aref_uint8;
         array->aset_fn = rb_type_array_aset_uint8;
+        array->mul_fn = rb_type_array_mul_uint8;
+        array->plus_fn = rb_type_array_plus_uint8;
+        array->minus_fn = rb_type_array_minus_uint8;
+        array->div_fn = rb_type_array_div_uint8;
+        array->eql_fn = rb_type_array_eql_uint8;
     } else if (klass == rb_cInt16Array) {
         array->aref_fn = rb_type_array_aref_int16;
         array->aset_fn = rb_type_array_aset_int16;
+        array->mul_fn = rb_type_array_mul_int16;
+        array->plus_fn = rb_type_array_plus_int16;
+        array->minus_fn = rb_type_array_minus_int16;
+        array->div_fn = rb_type_array_div_int16;
+        array->eql_fn = rb_type_array_eql_int16;
     } else if (klass == rb_cUInt16Array) {
         array->aref_fn = rb_type_array_aref_uint16;
         array->aset_fn = rb_type_array_aset_uint16;
+        array->mul_fn = rb_type_array_mul_uint16;
+        array->plus_fn = rb_type_array_plus_uint16;
+        array->minus_fn = rb_type_array_minus_uint16;
+        array->div_fn = rb_type_array_div_uint16;
+        array->eql_fn = rb_type_array_eql_uint16;
     } else if (klass == rb_cInt32Array) {
         array->aref_fn = rb_type_array_aref_int32;
         array->aset_fn = rb_type_array_aset_int32;
+        array->mul_fn = rb_type_array_mul_int32;
+        array->plus_fn = rb_type_array_plus_int32;
+        array->minus_fn = rb_type_array_minus_int32;
+        array->div_fn = rb_type_array_div_int32;
+        array->eql_fn = rb_type_array_eql_int32;
     } else if (klass == rb_cUInt32Array) {
         array->aref_fn = rb_type_array_aref_uint32;
         array->aset_fn = rb_type_array_aset_uint32;
+        array->mul_fn = rb_type_array_mul_uint32;
+        array->plus_fn = rb_type_array_plus_uint32;
+        array->minus_fn = rb_type_array_minus_uint32;
+        array->div_fn = rb_type_array_div_uint32;
+        array->eql_fn = rb_type_array_eql_uint32;
     } else if (klass == rb_cFloat32Array) {
         array->aref_fn = rb_type_array_aref_float32;
         array->aset_fn = rb_type_array_aset_float32;
+        array->mul_fn = rb_type_array_mul_float32;
+        array->plus_fn = rb_type_array_plus_float32;
+        array->minus_fn = rb_type_array_minus_float32;
+        array->div_fn = rb_type_array_div_float32;
+        array->eql_fn = rb_type_array_eql_float32;
     } else if (klass == rb_cFloat64Array) {
         array->aref_fn = rb_type_array_aref_float64;
         array->aset_fn = rb_type_array_aset_float64;
+        array->mul_fn = rb_type_array_mul_float64;
+        array->plus_fn = rb_type_array_plus_float64;
+        array->minus_fn = rb_type_array_minus_float64;
+        array->div_fn = rb_type_array_div_float64;
+        array->eql_fn = rb_type_array_eql_float64;
     }
 
     if (FIXNUM_P(obj)) {
@@ -382,6 +486,131 @@ static VALUE rb_type_array_byte_length(VALUE obj)
     return ULONG2NUM(ary->byte_length);
 }
 
+/*
+ *  call-seq:
+ *     ary.mul(0,1)                      =>  Fixnum, Bignum or Float
+ *
+ *  Gets two values at given offsets and multiples them - only the result's coerced to a Ruby object.
+ *
+ * === Examples
+ *     buf = ArrayBuffer.new(16)         =>  ArrayBuffer
+ *     ary = Int32Array.new(buf)         =>  Int32Array
+ *     ary[0] = 2                        =>  nil
+ *     ary[1] = 4                        =>  nil
+ *     ary[2] = 8                        =>  nil
+ *
+ *     ary.mul(0,1)                      =>  8
+ *     ary.mul(1,2)                      =>  32
+*/
+static VALUE rb_type_array_mul(VALUE obj, VALUE off1, VALUE off2)
+{
+    GetTypeArray(obj);
+    GetArrayBuffer(ary->buf);
+    long offset1 = rb_type_array_assert_offset(ary, off1);
+    long offset2 = rb_type_array_assert_offset(ary, off2);
+    return ary->mul_fn(buf->buf, offset1, offset2);
+}
+
+/*
+ *  call-seq:
+ *     ary.plus(0,1)                     =>  Fixnum, Bignum or Float
+ *
+ *  Gets two values at given offsets and adds them - only the result's coerced to a Ruby object.
+ *
+ * === Examples
+ *     buf = ArrayBuffer.new(16)         =>  ArrayBuffer
+ *     ary = Int32Array.new(buf)         =>  Int32Array
+ *     ary[0] = 2                        =>  nil
+ *     ary[1] = 4                        =>  nil
+ *     ary[2] = 8                        =>  nil
+ *
+ *     ary.plus(0,1)                     =>  6
+ *     ary.plus(1,2)                     =>  12
+*/
+static VALUE rb_type_array_plus(VALUE obj, VALUE off1, VALUE off2)
+{
+    GetTypeArray(obj);
+    GetArrayBuffer(ary->buf);
+    long offset1 = rb_type_array_assert_offset(ary, off1);
+    long offset2 = rb_type_array_assert_offset(ary, off2);
+    return ary->plus_fn(buf->buf, offset1, offset2);
+}
+
+/*
+ *  call-seq:
+ *     ary.minus(0,1)                    =>  Fixnum, Bignum or Float
+ *
+ *  Gets two values at given offsets and subtracts them - only the result's coerced to a Ruby object.
+ *
+ * === Examples
+ *     buf = ArrayBuffer.new(16)         =>  ArrayBuffer
+ *     ary = Int32Array.new(buf)         =>  Int32Array
+ *     ary[0] = 2                        =>  nil
+ *     ary[1] = 4                        =>  nil
+ *     ary[2] = 8                        =>  nil
+ *
+ *     ary.minus(1, 0)                   =>  2
+ *     ary.minus(2, 1)                   =>  4
+*/
+static VALUE rb_type_array_minus(VALUE obj, VALUE off1, VALUE off2)
+{
+    GetTypeArray(obj);
+    GetArrayBuffer(ary->buf);
+    long offset1 = rb_type_array_assert_offset(ary, off1);
+    long offset2 = rb_type_array_assert_offset(ary, off2);
+    return ary->minus_fn(buf->buf, offset1, offset2);
+}
+
+/*
+ *  call-seq:
+ *     ary.div(0,1)                      =>  Fixnum, Bignum or Float
+ *
+ *  Gets two values at given offsets and divides them - only the result's coerced to a Ruby object.
+ *
+ * === Examples
+ *     buf = ArrayBuffer.new(16)         =>  ArrayBuffer
+ *     ary = Int32Array.new(buf)         =>  Int32Array
+ *     ary[0] = 2                        =>  nil
+ *     ary[1] = 4                        =>  nil
+ *     ary[2] = 8                        =>  nil
+ *
+ *     ary.div(1, 0)                     =>  2
+ *     ary.div(2, 1)                     =>  2
+*/
+static VALUE rb_type_array_div(VALUE obj, VALUE off1, VALUE off2)
+{
+    GetTypeArray(obj);
+    GetArrayBuffer(ary->buf);
+    long offset1 = rb_type_array_assert_offset(ary, off1);
+    long offset2 = rb_type_array_assert_offset(ary, off2);
+    return ary->div_fn(buf->buf, offset1, offset2);
+}
+
+/*
+ *  call-seq:
+ *     ary.div(0,1)                      =>  Fixnum, Bignum or Float
+ *
+ *  Gets two values at given offsets and divides them - only the result's coerced to a Ruby object.
+ *
+ * === Examples
+ *     buf = ArrayBuffer.new(16)         =>  ArrayBuffer
+ *     ary = Int32Array.new(buf)         =>  Int32Array
+ *     ary[0] = 2                        =>  nil
+ *     ary[1] = 4                        =>  nil
+ *     ary[2] = 8                        =>  nil
+ *
+ *     ary.div(1, 0)                     =>  2
+ *     ary.div(2, 1)                     =>  2
+*/
+static VALUE rb_type_array_eql(VALUE obj, VALUE off1, VALUE off2)
+{
+    GetTypeArray(obj);
+    GetArrayBuffer(ary->buf);
+    long offset1 = rb_type_array_assert_offset(ary, off1);
+    long offset2 = rb_type_array_assert_offset(ary, off2);
+    return ary->eql_fn(buf->buf, offset1, offset2);
+}
+
 /*
  *  call-seq:
  *     ary.length                        =>  Fixnum
@@ -537,4 +766,9 @@ void _init_type_array()
     rb_define_method(rb_cTypeArray, "to_s", rb_type_array_to_s, 0);
     rb_define_method(rb_cTypeArray, "[]=", rb_type_array_aset, 2);
     rb_define_method(rb_cTypeArray, "[]", rb_type_array_aget, 1);
+    rb_define_method(rb_cTypeArray, "mul", rb_type_array_mul, 2);
+    rb_define_method(rb_cTypeArray, "plus", rb_type_array_plus, 2);
+    rb_define_method(rb_cTypeArray, "minus", rb_type_array_minus, 2);
+    rb_define_method(rb_cTypeArray, "div", rb_type_array_div, 2);
+    rb_define_method(rb_cTypeArray, "eql", rb_type_array_eql, 2);
 }

data/ext/type_array/type_array.h

@@ -3,6 +3,7 @@
 
 typedef void (type_array_aset_fn) (rb_array_buffer_t *buf, long index, VALUE item);
 typedef VALUE (type_array_aref_fn) (rb_array_buffer_t *buf, long index);
+typedef VALUE (type_array_operator_fn) (rb_array_buffer_t *buf, long off1, long off2);
 
 typedef struct {
     unsigned long size;
@@ -11,6 +12,11 @@ typedef struct {
     unsigned long byte_offset;
     type_array_aset_fn *aset_fn;
     type_array_aref_fn *aref_fn;
+    type_array_operator_fn *mul_fn;
+    type_array_operator_fn *plus_fn;
+    type_array_operator_fn *minus_fn;
+    type_array_operator_fn *div_fn;
+    type_array_operator_fn *eql_fn;
     VALUE buf;
 } rb_type_array_t;
 
@@ -35,4 +41,20 @@ void _init_type_array();
         return coercion; \
     }
 
+#define DefineTypeArrayOperators(name, type, coercion) \
+    DefineTypeArrayOperator(mul, *, name, type, coercion); \
+    DefineTypeArrayOperator(plus, +, name, type, coercion); \
+    DefineTypeArrayOperator(minus, -, name, type, coercion); \
+    DefineTypeArrayOperator(div, /, name, type, coercion); \
+
+#define DefineTypeArrayOperator(op_name, op, name, type, coercion) \
+    VALUE rb_type_array_##op_name##_##name(rb_array_buffer_t *buf, long off1, long off2) \
+    { \
+        type val; \
+        type val1 = rb_type_array_get_##name(buf, off1, TYPE_ARRAY_IS_LITTLE_ENDIAN); \
+        type val2 = rb_type_array_get_##name(buf, off2, TYPE_ARRAY_IS_LITTLE_ENDIAN); \
+        val = val1 op val2; \
+        return coercion; \
+    }
+
 #endif

data/lib/type_array/version.rb

@@ -1,3 +1,3 @@
 class TypeArray
-  VERSION = '0.1'
+  VERSION = '0.2'
 end

data/test/test_type_array.rb

@@ -152,4 +152,77 @@ class TestTypeArray < TypeArrayTestCase
   ensure
     s.close rescue nil
   end
+
+  def test_mul
+    buf = ArrayBuffer.new(16)
+
+    ary = Int32Array.new(buf)
+    ary[0] = 2
+    ary[1] = 4
+    ary[2] = 8
+
+    assert_equal 8, ary.mul(0,1)
+    assert_equal 32, ary.mul(1, 2)
+  end
+
+  def test_plus
+    buf = ArrayBuffer.new(16)
+
+    ary = Int32Array.new(buf)
+    ary[0] = 2
+    ary[1] = 4
+    ary[2] = 8
+
+    assert_equal 6, ary.plus(0,1)
+    assert_equal 12, ary.plus(1, 2)
+  end
+
+  def test_minus
+    buf = ArrayBuffer.new(16)
+
+    ary = Int32Array.new(buf)
+    ary[0] = 2
+    ary[1] = 4
+    ary[2] = 8
+
+    assert_equal 2, ary.minus(1,0)
+    assert_equal 4, ary.minus(2, 1)
+  end
+
+  def test_div
+    buf = ArrayBuffer.new(16)
+
+    ary = Int32Array.new(buf)
+    ary[0] = 2
+    ary[1] = 4
+    ary[2] = 8
+
+    assert_equal 2, ary.div(1,0)
+    assert_equal 2, ary.div(2, 1)
+  end
+
+  def test_eql
+    buf = ArrayBuffer.new(16)
+
+    ary = Int32Array.new(buf)
+    ary[0] = 2
+    ary[1] = 4
+    ary[2] = 4
+    ary[3] = 2
+
+    assert ary.eql(0, 3)
+    assert ary.eql(1, 2)
+    assert !ary.eql(0, 1)
+
+    buf = ArrayBuffer.new(24)
+
+    ary = Float64Array.new(buf)
+
+    ary[0] = 2.33
+    ary[1] = 2.33
+    ary[2] = 7.45
+
+    assert ary.eql(0,1)
+    assert !ary.eql(1,2)
+  end
 end

metadata

@@ -1,112 +1,127 @@
 --- !ruby/object:Gem::Specification 
 name: type_array
 version: !ruby/object:Gem::Version 
+  hash: 15
   prerelease: 
-  version: "0.1"
+  segments: 
+  - 0
+  - 2
+  version: "0.2"
 platform: ruby
 authors: 
-  - "Lourens Naud\xC3\xA9"
+- "Lourens Naud\xC3\xA9"
 autorequire: 
 bindir: bin
 cert_chain: []
 
 date: 2012-07-12 00:00:00 Z
 dependencies: 
-  - !ruby/object:Gem::Dependency 
-    name: rake-compiler
-    prerelease: false
-    requirement: &id001 !ruby/object:Gem::Requirement 
-      none: false
-      requirements: 
-        - - ~>
-          - !ruby/object:Gem::Version 
-            version: 0.8.0
-    type: :development
-    version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake-compiler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 63
+        segments: 
+        - 0
+        - 8
+        - 0
+        version: 0.8.0
+  type: :development
+  version_requirements: *id001
 description: TypeArray - Ruby implementation of the ECMAScript spec ( http://wiki.ecmascript.org/doku.php?id=strawman:typed_arrays )
 email: 
-  - lourens@methodmissing.com
+- lourens@methodmissing.com
 executables: []
 
 extensions: 
-  - ext/type_array/extconf.rb
+- ext/type_array/extconf.rb
 extra_rdoc_files: []
 
 files: 
-  - .gitignore
-  - .travis.yml
-  - CHANGELOG.rdoc
-  - Gemfile
-  - Gemfile.lock
-  - README.rdoc
-  - Rakefile
-  - ext/type_array/array_buffer.c
-  - ext/type_array/array_buffer.h
-  - ext/type_array/data_view.c
-  - ext/type_array/data_view.h
-  - ext/type_array/extconf.rb
-  - ext/type_array/jruby.h
-  - ext/type_array/prelude.h
-  - ext/type_array/rubinius.h
-  - ext/type_array/ruby18.h
-  - ext/type_array/ruby19.h
-  - ext/type_array/type_array.c
-  - ext/type_array/type_array.h
-  - ext/type_array/type_array_ext.c
-  - ext/type_array/type_array_ext.h
-  - lib/type_array.rb
-  - lib/type_array/io.rb
-  - lib/type_array/version.rb
-  - test/helper.rb
-  - test/test_array_buffer.rb
-  - test/test_data_view.rb
-  - test/test_float_32_array.rb
-  - test/test_float_64_array.rb
-  - test/test_int_16_array.rb
-  - test/test_int_32_array.rb
-  - test/test_int_8_array.rb
-  - test/test_type_array.rb
-  - test/test_uint_16_array.rb
-  - test/test_uint_32_array.rb
-  - test/test_uint_8_array.rb
-  - type_array.gemspec
+- .gitignore
+- .travis.yml
+- CHANGELOG.rdoc
+- Gemfile
+- Gemfile.lock
+- README.rdoc
+- Rakefile
+- ext/type_array/array_buffer.c
+- ext/type_array/array_buffer.h
+- ext/type_array/data_view.c
+- ext/type_array/data_view.h
+- ext/type_array/extconf.rb
+- ext/type_array/jruby.h
+- ext/type_array/prelude.h
+- ext/type_array/rubinius.h
+- ext/type_array/ruby18.h
+- ext/type_array/ruby19.h
+- ext/type_array/type_array.c
+- ext/type_array/type_array.h
+- ext/type_array/type_array_ext.c
+- ext/type_array/type_array_ext.h
+- lib/type_array.rb
+- lib/type_array/io.rb
+- lib/type_array/version.rb
+- test/helper.rb
+- test/test_array_buffer.rb
+- test/test_data_view.rb
+- test/test_float_32_array.rb
+- test/test_float_64_array.rb
+- test/test_int_16_array.rb
+- test/test_int_32_array.rb
+- test/test_int_8_array.rb
+- test/test_type_array.rb
+- test/test_uint_16_array.rb
+- test/test_uint_32_array.rb
+- test/test_uint_8_array.rb
+- type_array.gemspec
 homepage: http://github.com/methodmissing/type_array
 licenses: []
 
 post_install_message: 
 rdoc_options: 
-  - --charset=UTF-8
+- --charset=UTF-8
 require_paths: 
-  - lib
+- lib
 required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.9
+rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: Typed Arrays for Ruby
 test_files: 
-  - test/helper.rb
-  - test/test_array_buffer.rb
-  - test/test_data_view.rb
-  - test/test_float_32_array.rb
-  - test/test_float_64_array.rb
-  - test/test_int_16_array.rb
-  - test/test_int_32_array.rb
-  - test/test_int_8_array.rb
-  - test/test_type_array.rb
-  - test/test_uint_16_array.rb
-  - test/test_uint_32_array.rb
-  - test/test_uint_8_array.rb
+- test/helper.rb
+- test/test_array_buffer.rb
+- test/test_data_view.rb
+- test/test_float_32_array.rb
+- test/test_float_64_array.rb
+- test/test_int_16_array.rb
+- test/test_int_32_array.rb
+- test/test_int_8_array.rb
+- test/test_type_array.rb
+- test/test_uint_16_array.rb
+- test/test_uint_32_array.rb
+- test/test_uint_8_array.rb