efficient_join 1.4.0 → 2.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e67d8cd6098b472380780f923955d25c1dc2777afa768f22552e780823ac63ab
-  data.tar.gz: 3d0d6057ee163ef3498f3e9563097489cd04ae074c88fa43a1b35356b156e955
+  metadata.gz: 5901b92dc6e259cbf76193da6107a3c3dde02c6dddcf66812e9d449322eae6fc
+  data.tar.gz: d9f11fbf636346979abc3654cdfb1e7518b9891532732905404ab2ca08e4617c
 SHA512:
-  metadata.gz: c3c1f9456f986b2cba749b351a8646fd1476ee825bf47c18bf78061a4c070f350980f40ecb31ef9b4ede1d77be01eed71e82cd3b8f3ab1c87edf37f3112129dc
-  data.tar.gz: 24d0e958eeff1ed02f7bc5cb37c831de6d5f27253e3da4885db9b6ad728b489e64db0111981281d5e7d1ae1bc8c5d2b66c6bc446d2860bda2f8bc699de08fca4
+  metadata.gz: f7d39e4ad25fb936ab6213e8d582f2bd9fd3e2a53bf7f24c33452839e473dc984773b8998d880db1a89d602ddd4fc9d45e47eafc39d202b579fad234a2231b8a
+  data.tar.gz: 0c90ce377ad5ed1bd0483cdaaef14702bd743005052833d120f9c813445ff2b92fbfdd204aed18c0576e8b05fb359e6b1e3515b3a9fbdf43c5d35ea12548e85f

data/README.md

@@ -1,6 +1,6 @@
 # EfficientJoin
 
-Very fast and memory-efficient way to join a list of ruby numbers.
+Very fast and memory-efficient way to join ruby lists of numbers and strings.
 
 Joins are performed with a constant number of ruby object allocations,
 compared to `Array#join`, `PG:TextEncoder::Array.new.encode`, etc, where at least `n` object
@@ -11,8 +11,8 @@ usage and execution time improvements:
 
 | EfficientJoin function | Equivalent ruby function          | Memory usage | Time         |
 | ---------------------- | --------------------------------- | ------------ | ------------ |
-| join                   | Array#join                        | 30%          | 2.5x faster  |
-| join_pg_array          | PG::TextEncoder::Array.new.encode | 18%          | 2.1x faster  |
+| join                   | Array#join                        | 30%          | 7.0x faster  |
+| join_pg_array          | PG::TextEncoder::Array.new.encode | 18%          | 7.4x faster  |
 
 ## Installation
 
@@ -64,6 +64,13 @@ EfficientJoin.join_pg_array([1,2,3,4])
  => "{1,2,3,4}"
 ```
 
+Which is equivalent to:
+
+```
+EfficientJoin.join([1,2,3,4], header: '{', footer: '}')
+ => "{1,2,3,4}"
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/efficient_join.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.email         = ["tomm8086@googlemail.com"]
 
   spec.summary       = %q{.}
-  spec.description   = %q{Very fast and memory-efficient way to join a list of ruby numbers.}
+  spec.description   = %q{Very fast and memory-efficient way to join ruby lists of numbers and strings.}
   spec.homepage      = "https://github.com/tomm/efficient_join"
   spec.license       = "MIT"
 
@@ -30,6 +30,6 @@ Gem::Specification.new do |spec|
   spec.extensions    = ["ext/efficient_join/extconf.rb"]
 
   spec.add_development_dependency "bundler", "~> 2.0"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rake-compiler"
+  spec.add_development_dependency "rake", "~> 12.3.3"
+  spec.add_development_dependency "rake-compiler", "~> 1.0"
 end

data/ext/efficient_join/efficient_join.c

@@ -1,60 +1,114 @@
 #include "efficient_join.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
 
-static VALUE _join(const char *header, const char *footer, const char *item_prefix, const char *item_suffix, const char *join, VALUE number_array) {
+struct strbuf_t {
+    char *buf;
+    size_t pos;
+    size_t len;
+};
+
+static struct strbuf_t strbuf_new(size_t initial_size) {
+    struct strbuf_t strbuf = { (char *)malloc(initial_size), 0, initial_size };
+    return strbuf;
+}
+
+static void strbuf_free(struct strbuf_t *strbuf) {
+    free(strbuf->buf);
+}
+
+static inline void strbuf_expand(struct strbuf_t *strbuf) {
+    strbuf->buf = (char *)realloc(strbuf->buf, strbuf->len * 2);
+    strbuf->len *= 2;
+}
+
+static inline void strbuf_write_str(struct strbuf_t *strbuf, const char *str, size_t len)
+{
+    if (strbuf->len < strbuf->pos + len) {
+        strbuf_expand(strbuf);
+    }
+
+    memcpy(strbuf->buf + strbuf->pos, str, len);
+    strbuf->pos += len;
+}
+
+static inline void strbuf_write_int64(struct strbuf_t *strbuf, int64_t value)
+{
+    int bytes_written;
+   
+    // 22: maximum length of string representation of 64-bit int
+    if (strbuf->len <= strbuf->pos + 22) {
+        strbuf_expand(strbuf);
+    }
+
+    bytes_written = snprintf(strbuf->buf + strbuf->pos, 22, "%ld", value);
+    strbuf->pos += bytes_written;
+}
+
+VALUE rb_efficient_join(VALUE self, VALUE _header, VALUE _footer, VALUE _item_prefix, VALUE _item_suffix, VALUE _join, VALUE number_array) {
     VALUE out;
     const long array_len = RARRAY_LEN(number_array);
-    char *buf;
-    size_t buf_len;
-    FILE *stream = open_memstream(&buf, &buf_len);
+    const char* header = StringValuePtr(_header);
+    const char* footer = StringValuePtr(_footer);
+    const char* item_prefix = StringValuePtr(_item_prefix);
+    const char* item_suffix = StringValuePtr(_item_suffix);
+    const char* join = StringValuePtr(_join);
+    VALUE *c_array = RARRAY_PTR(number_array);
+    const size_t prefix_len = RSTRING_LEN(_item_prefix);
+    const size_t suffix_len = RSTRING_LEN(_item_suffix);
+    const size_t join_len = RSTRING_LEN(_join);
 
-    fputs(header, stream);
+    struct strbuf_t join_buf = strbuf_new(suffix_len + join_len + prefix_len);
+    // estimate likely maximum buffer size, to avoid reallocs
+    struct strbuf_t buf = strbuf_new((array_len + 1) * (join_buf.pos + 10));
+
+    // build joining string
+    strbuf_write_str(&join_buf, item_suffix, suffix_len);
+    strbuf_write_str(&join_buf, join, join_len);
+    strbuf_write_str(&join_buf, item_prefix, prefix_len);
+
+    strbuf_write_str(&buf, header, RSTRING_LEN(_header));
+    strbuf_write_str(&buf, item_prefix, prefix_len);
 
     for (long i=0; i<array_len; ++i) {
-        const VALUE v = RARRAY_PTR(number_array)[i];
-        
-        if (TYPE(v) != T_FIXNUM) {
-            // rb_raise does not return control, so clean up first
-            fclose(stream);
-            free(buf);
-            rb_raise(rb_eTypeError, "array must contain only integers");
-        }
+        VALUE v = c_array[i];
 
-        fprintf(stream, "%s%ld%s", item_prefix, FIX2LONG(v), item_suffix);
+        switch (TYPE(v)) {
+            case T_FIXNUM:
+                strbuf_write_int64(&buf, FIX2LONG(v));
+                break;
+            case T_BIGNUM:
+                strbuf_write_int64(&buf, rb_big2ll(v));
+                break;
+            case T_STRING:
+                strbuf_write_str(&buf, StringValuePtr(v), RSTRING_LEN(v));
+                break;
+            default:
+                // rb_raise does not return control, so clean up first
+                strbuf_free(&join_buf);
+                strbuf_free(&buf);
+                rb_raise(rb_eTypeError, "array must contain only strings and integers");
+        }
 
         if (i < array_len - 1) {
-            fputs(join, stream);
-        } 
+            strbuf_write_str(&buf, join_buf.buf, join_buf.pos);
+        }
     }
+    strbuf_write_str(&buf, item_suffix, suffix_len);
+    strbuf_write_str(&buf, footer, RSTRING_LEN(_footer));
 
-    fputs(footer, stream);
-
-    fclose(stream);
+    out = rb_str_new(buf.buf, buf.pos);
 
-    out = rb_str_new_cstr(buf);
-    free(buf);
+    strbuf_free(&join_buf);
+    strbuf_free(&buf);
 
     return out;
 }
 
-VALUE rb_efficient_join(VALUE self, VALUE prefix, VALUE suffix, VALUE join, VALUE number_array) {
-    return _join(
-        "", "",
-        StringValueCStr(prefix),
-        StringValueCStr(suffix),
-        StringValueCStr(join),
-        number_array
-    );
-}
-
-VALUE rb_efficient_join_pg_array(VALUE self, VALUE number_array) {
-    return _join("{", "}", "", "", ",", number_array);
-}
-
 void Init_efficient_join()
 {
     VALUE mod = rb_define_module("EfficientJoinCExt");
 
-    rb_define_method(mod, "_join", rb_efficient_join, 4);
-    rb_define_method(mod, "_join_pg_array", rb_efficient_join_pg_array, 1);
+    rb_define_method(mod, "_join", rb_efficient_join, 6);
 }
-

data/lib/efficient_join.rb

@@ -7,12 +7,12 @@ module EfficientJoin
   class << self
     include EfficientJoinCExt
 
-    def join(array, separator: ',', item_prefix: '', item_suffix: '')
-      _join(item_prefix, item_suffix, separator, array)
+    def join(array, header: '', footer: '', separator: ',', item_prefix: '', item_suffix: '')
+      _join(header, footer, item_prefix, item_suffix, separator, array)
     end
 
     def join_pg_array(array)
-      _join_pg_array(array)
+      _join('{', '}', '', '', ',', array)
     end
   end
 end

data/lib/efficient_join/version.rb

@@ -1,3 +1,3 @@
 module EfficientJoin
-  VERSION = "1.4.0"
+  VERSION = "2.1.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: efficient_join
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 2.1.3
 platform: ruby
 authors:
 - Tom Morton
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-19 00:00:00.000000000 Z
+date: 2020-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -30,29 +30,30 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 12.3.3
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-description: Very fast and memory-efficient way to join a list of ruby numbers.
+        version: '1.0'
+description: Very fast and memory-efficient way to join ruby lists of numbers and
+  strings.
 email:
 - tomm8086@googlemail.com
 executables: []