tnetstrings 0.0.1

data/ext/tnetstrings.c

@@ -0,0 +1,202 @@
+#include "tnetstrings.h"
+
+static TNETS_VALUE
+eTnetsParserError;
+
+#define TNETS_PARSER_ERROR(msg) rb_raise(eTnetsParserError, msg)
+
+TNETS_VALUE tnets_render_number(char* payload, size_t len);
+TNETS_VALUE tnets_render_string(char* payload, size_t len);
+TNETS_VALUE tnets_render_bool  (char* payload, size_t len);
+TNETS_VALUE tnets_render_null  (char* payload, size_t len);
+TNETS_VALUE tnets_render_list  (char* payload, size_t len);
+TNETS_VALUE tnets_render_dict  (char* payload, size_t len);
+
+size_t tnets_size_spec(char* data, size_t len, char** payload);
+
+TNETS_VALUE tnets_parse_dict_key(char* data, size_t len, char** remain);
+TNETS_VALUE tnets_parse(char* data, size_t len, char** remain);
+
+TNETS_VALUE rb_tnets_parse(TNETS_VALUE self, TNETS_VALUE rbstr);
+
+// since no checking is done on strings, just pass it right along
+// to the wrapper.
+#define tnets_render_string TNETS_WRAP_STRING
+
+TNETS_VALUE
+tnets_render_number(char* payload, size_t len) {
+  size_t i;
+  int number = 0; // TODO: use a type that can handle
+                  // larger numbers without wrapping.
+  unsigned short int negative = 0;
+
+  if (payload[0] == '-') {
+    negative = 1;
+    payload++;
+    len--;
+  }
+
+  for(i = 0; i < len; i++) {
+    if (IS_NUMERIC(payload[i])) {
+      number *= 10;
+      number += CTOI(payload[i]);
+    }
+    else {
+      TNETS_PARSER_ERROR("Non-numeric character in a tnets number");
+    }
+  }
+
+  if (negative) {
+    number *= -1;
+  }
+
+  return TNETS_WRAP_NUMBER(number);
+}
+
+TNETS_VALUE
+tnets_render_bool(char* payload, size_t len) {
+  // TODO: do this better.
+  if (len != 4) return TNETS_WRAP_FALSE;
+  size_t i;
+  for (i = 0; i < len; i++) {
+    if (payload[i] != "true"[i]) {
+      return TNETS_WRAP_FALSE;
+    }
+  }
+
+  return TNETS_WRAP_TRUE;
+}
+
+TNETS_VALUE
+tnets_render_null(char* payload, size_t len) {
+  if (len != 0) TNETS_PARSER_ERROR("null must have an empty payload.");
+
+  return TNETS_WRAP_NULL;
+}
+
+TNETS_VALUE
+tnets_render_list(char* payload, size_t len) {
+  char *tmp_payload = payload;
+  size_t sub_len;
+  TNETS_VALUE list = TNETS_NEW_LIST();
+
+  while (len > 0) {
+    TNETS_LIST_PUSH(
+      list,
+      tnets_parse(payload, len, &tmp_payload)
+    );
+
+    len -= (tmp_payload - payload);
+    payload = tmp_payload;
+  }
+
+  return list;
+}
+
+#define tnets_render_dict_key TNETS_WRAP_DICT_KEY
+
+TNETS_VALUE
+tnets_render_dict(char* payload, size_t len) {
+  char *tmp_payload = payload;
+  TNETS_VALUE dict = TNETS_NEW_DICT();
+  while(len > 0) {
+    TNETS_VALUE key = tnets_parse_dict_key(payload, len, &tmp_payload);
+    len -= (tmp_payload - payload);
+    payload = tmp_payload;
+
+    TNETS_DICT_SET(dict, key,
+      tnets_parse(payload, len, &tmp_payload)
+    );
+
+    len -= (tmp_payload - payload);
+    payload = tmp_payload;
+  }
+
+  return dict;
+}
+
+size_t
+tnets_size_spec(char *data, size_t len, char **payload) {
+  size_t i;
+  size_t size = 0;
+
+  // only scan 11 characters (10 for length spec + 1 for colon)
+  size_t scan_limit = (len < 11) ? len : 11;
+
+  for (i = 0; i < scan_limit; i++) {
+    if (IS_NUMERIC(data[i])) {
+      size *= 10;
+      size += CTOI(data[i]);
+    }
+    else if (data[i] == ':') {
+      if (i + size > len + 1) {
+        TNETS_PARSER_ERROR("length spec longer than given string");
+      }
+
+      if (payload != NULL) {
+        *payload = data + i + 1; // add one to skip over the colon
+      }
+      return size;
+    }
+    else {
+      TNETS_PARSER_ERROR("non-numeric character in length spec");
+    }
+  }
+
+  TNETS_PARSER_ERROR("length spec more than 10 characters");
+
+  return 0;
+}
+
+TNETS_VALUE
+tnets_parse_dict_key(char* data, size_t len, char** remain) {
+  char* payload;
+  size_t payload_len = tnets_size_spec(data, len, &payload);
+  if (remain != NULL) *remain = payload + payload_len + 1;
+
+  if (payload[payload_len] != tnets_tag_string) {
+    TNETS_PARSER_ERROR("non-string dict keys are not supported");
+  }
+
+  return tnets_render_dict_key(payload, payload_len);
+}
+
+TNETS_VALUE
+tnets_parse(char *data, size_t len, char** remain) {
+  char *payload = NULL;
+  size_t payload_len;
+  tnets_type_tag type = tnets_tag_invalid;
+
+  payload_len = tnets_size_spec(data, len, &payload);
+
+  if (remain != NULL) *remain = payload + payload_len + 1;
+
+  type = payload[payload_len];
+
+  switch(type) {
+    case tnets_tag_string: return tnets_render_string(payload, payload_len);
+    case tnets_tag_number: return tnets_render_number(payload, payload_len);
+    case tnets_tag_null:   return tnets_render_null(payload, payload_len);
+    case tnets_tag_bool:   return tnets_render_bool(payload, payload_len);
+    case tnets_tag_list:   return tnets_render_list(payload, payload_len);
+    case tnets_tag_dict:   return tnets_render_dict(payload, payload_len);
+    default:
+      TNETS_PARSER_ERROR("Invalid type tag");
+  }
+}
+
+VALUE
+rb_tnets_parse(VALUE self, VALUE rbstr) {
+  char* data = RSTRING_PTR(rbstr);
+  size_t len = RSTRING_LEN(rbstr);
+  return tnets_parse(data, len, NULL);
+}
+
+void
+Init_tnetstrings() {
+  VALUE mTnetstrings = rb_define_module("TNETS");
+
+  rb_define_method(mTnetstrings, "c_parse", rb_tnets_parse, 1);
+  eTnetsParserError =
+    rb_define_class_under(mTnetstrings, "ParserError", rb_eIOError);
+}

data/ext/tnetstrings.h

@@ -0,0 +1,44 @@
+#include <ruby/ruby.h>
+// #include <stdlib.h>
+// #include <string.h>
+#include <stdio.h>
+#include <ruby/ruby.h>
+
+typedef enum tnets_type_tag_e {
+  tnets_tag_string  = ',',
+  tnets_tag_number  = '#',
+  // tnets_tag_float   = '^', // coming soon
+  tnets_tag_bool    = '!',
+  tnets_tag_null    = '~',
+  tnets_tag_dict    = '}',
+  tnets_tag_list    = ']',
+  tnets_tag_invalid = 'Z',
+} tnets_type_tag;
+
+#define IS_NUMERIC(ch) ('0' <= ch && ch <= '9')
+#define CTOI(ch) (ch - '0');
+
+#define TNETS_VALUE VALUE
+
+#define TNETS_WRAP_STRING(s,l) (rb_str_new(s,l))
+#define TNETS_WRAP_NUMBER INT2FIX
+#define TNETS_WRAP_NULL Qnil
+#define TNETS_WRAP_TRUE Qtrue
+#define TNETS_WRAP_FALSE Qfalse
+// TODO: find a better way to symbolize length-specified
+// strings.
+#define TNETS_WRAP_DICT_KEY(k,size) (ID2SYM(rb_to_id(TNETS_WRAP_STRING(k,size))))
+
+#define TNETS_NEW_LIST rb_ary_new
+#define TNETS_LIST_PUSH(a,v) rb_ary_push(a,v)
+#define TNETS_NEW_DICT rb_hash_new
+#define TNETS_DICT_SET(dict,key,val) (rb_hash_aset(dict,key,val))
+
+/**
+*  Parse an object off the front of a tnetstring.
+*  Returns a pointer to the parsed object, or NULL if an error occurs.
+*  The third argument is an output parameter; if non-NULL it will
+*  receive the unparsed remainder of the string.
+*/
+TNETS_VALUE
+tnets_parse(char *data, size_t len, char** remain);

data/lib/tnetstrings.rb

@@ -0,0 +1,108 @@
+require File.expand_path('../ext/tnetstrings', File.dirname(__FILE__))
+
+module TNETS
+  extend self
+
+  def load(str)
+    c_parse(str)
+  end
+
+  def dump(obj, *a)
+    obj.to_tnets(*a)
+  end
+
+  class StreamParser
+    attr_reader :io
+    def initialize(io)
+      @io = io
+    end
+
+    include Enumerable
+    def each(&blk)
+      c_tnets_stream(io, &blk)
+    end
+  end
+end
+
+class TrueClass
+  TO_TNETS = '4:true!'
+
+  def to_tnets(*)
+    TO_TNETS
+  end
+end
+
+class FalseClass
+  TO_TNETS = '5:false!'
+  def to_tnets(*)
+    TO_TNETS
+  end
+end
+
+class NilClass
+  TO_TNETS = '0:~'
+  def to_tnets(*)
+    TO_TNETS
+  end
+end
+
+class String
+  def to_tnets(*)
+    "#{size}:#{self},"
+  end
+end
+
+class Fixnum
+  def to_tnets(*)
+    "#{to_s.size}:#{self}#"
+  end
+end
+
+module Enumerable
+  def to_tnets(*a, &b)
+    return each_tnets(&b) if block_given?
+
+    out = ''
+    each { |x| out << x.to_tnets(*a) }
+    "#{out.size}:#{out}]"
+  end
+
+  def stream_tnets(io=$stdout)
+    each_tnets { |x| io << x }
+  end
+
+  def each_tnets
+    each { |x| yield x.to_tnets }
+  end
+end
+
+class Hash
+  def to_tnets(*)
+    out = ''
+    each do |k, v|
+      # symbols don't respond to :to_str for some reason
+      k = k.to_s if k.is_a? Symbol
+
+      unless k.respond_to? :to_str
+        raise TNETS::DumpError, "only string-like objects are allowed as keys"
+      end
+
+      out << k.to_str.to_tnets
+      out << v.to_tnets
+    end
+
+    "#{out.size}:#{out}}"
+  end
+end
+
+class Object
+  def to_tnets(*a, &b)
+    if respond_to? :as_tnets
+      as_tnets(*a).to_tnets
+    elsif respond_to? :as_json
+      as_json(*a).to_tnets
+    else
+      method_missing(:to_tnets, *a, &b)
+    end
+  end
+end

data/lib/tnetstrings/version.rb

@@ -0,0 +1,7 @@
+module TNETS
+  VERSION = '0.0.1'
+
+  def self.version
+    VERSION
+  end
+end

data/spec/tnetstrings_spec.rb

@@ -0,0 +1,182 @@
+require './lib/tnetstrings'
+
+describe TNETS do
+  context "parsing" do
+    context "successful examples" do
+      it "parses a string" do
+        TNETS.load("3:abc,").should == "abc"
+      end
+
+      it "parses null" do
+        TNETS.load("0:~").should == nil
+      end
+
+      it "parses true" do
+        TNETS.load("4:true!").should == true
+      end
+
+      it "parses false" do
+        TNETS.load("5:false!").should == false
+      end
+
+      it "parses a number" do
+        TNETS.load("2:32#").should == 32
+      end
+
+      it "parses a negative number" do
+        TNETS.load("3:-32#").should == -32
+      end
+
+      it "parses an array" do
+        TNETS.load("17:2:32#2:84#4:true!]").should == [32, 84, true]
+      end
+
+      it "parses a dict" do
+        TNETS.load(%[16:1:a,1:1#1:b,1:2#}]).should == {:a => 1, :b => 2}
+      end
+    end
+
+    context "degenerate cases" do
+      it "parses an empty dict" do
+        TNETS.load(%|0:}|).should == {}
+      end
+
+      it "parses an empty array" do
+        TNETS.load(%|0:]|).should == []
+      end
+
+      it "parses an empty string" do
+        TNETS.load(%|0:,|).should == ''
+      end
+
+      it "parses an empty bool" do
+        TNETS.load(%|0:!|).should == false
+      end
+    end
+
+    context "error cases" do
+      def expect_error(str, *args)
+        expect { TNETS.load(str) }
+          .to raise_error(TNETS::ParserError, *args)
+      end
+
+      context "length spec" do
+        it "requires digits at the front" do
+          expect_error("abc:true!")
+        end
+
+        it "requires a colon before the 10th character" do
+          expect_error("12345678901:true!")
+        end
+
+        it "requires a valid symbol at the end" do
+          expect_error("1:f")
+        end
+
+        it "requires the data to be at least as long as the length spec" do
+          expect_error("100:true!")
+        end
+      end
+
+      context "null" do
+        it "requires the length to be zero" do
+          expect_error("1:x~")
+        end
+      end
+
+      context "bool" do
+        it "returns false given anything but true" do
+          TNETS.load("4:trub!").should == false
+          TNETS.load("6:sdflkj!").should == false
+          TNETS.load("4:true!").should == true
+        end
+      end
+
+      context "number" do
+        it "requires digits only" do
+          expect_error("3:1bc#")
+        end
+      end
+
+      context "array" do
+        it "requires sane lengths" do
+          expect_error("5:10:abcde,]")
+        end
+      end
+
+      context "dict" do
+        it "requires sane lengths" do
+          expect_error("13:1:a,10:abcde,}")
+        end
+
+        it "requires keys to be strings" do
+          # { 1 => 2 }
+          expect_error("8:1:1#1:2#}")
+          # { nil => 2 }
+          expect_error("7:0:~1:2#}")
+          # { false => 2 }
+          expect_error("7:0:!1:2#}")
+        end
+
+        it "requires a balanced hash" do
+          # one item only
+          # { :a => }
+          expect_error("4:1:,a}")
+
+          # three items
+          # { :a => 1, :b => }
+          expect_error("12:1:a,1:1#1:b,}")
+        end
+      end
+    end
+  end
+
+  context "dumping" do
+    it "dumps a string" do
+      "abc".to_tnets.should == "3:abc,"
+      TNETS.load(TNETS.dump("abc")).should == "abc"
+    end
+
+    it "dumps a number" do
+      34.to_tnets.should == "2:34#"
+      TNETS.load(TNETS.dump(34)).should == 34
+    end
+
+    it "dumps nil" do
+      nil.to_tnets.should == '0:~'
+      TNETS.load(TNETS.dump(nil)).should == nil
+    end
+
+    it "dumps true and false" do
+      true.to_tnets.should == '4:true!'
+      false.to_tnets.should == '5:false!'
+      TNETS.load(TNETS.dump(true)).should == true
+      TNETS.load(TNETS.dump(false)).should == false
+    end
+
+    it "dumps an array" do
+      arr = [1, true, "three", nil]
+      arr.to_tnets.should == '22:1:1#4:true!5:three,0:~]'
+      TNETS.load(TNETS.dump(arr)).should == arr
+    end
+
+    it "streams an enumerable" do
+      sio = StringIO.new
+      enum = Class.new do
+        include Enumerable
+        def each(&b)
+          [1, true, "three", nil].each(&b)
+        end
+      end.new
+
+      enum.stream_tnets(sio)
+      sio.string.should == enum.map(&:to_tnets).join
+    end
+
+    it "dumps a hash" do
+      hsh = { :a => 1, :b => true, :c => "three", :d => nil }
+      hsh.to_tnets.should == '38:1:a,1:1#1:b,4:true!1:c,5:three,1:d,0:~}'
+      TNETS.load(TNETS.dump(hsh)).should == hsh
+    end
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: tnetstrings
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Jay Adkisson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-27 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "2.0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: A general-purpose tnetstrings library for Ruby
+email: jjmadkisson@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- ext/tnetstrings.c
+- ext/tnetstrings.h
+- ext/tnetstrings.so
+- lib/tnetstrings.rb
+- lib/tnetstrings/version.rb
+- spec/tnetstrings_spec.rb
+has_rdoc: true
+homepage: http://github.com/causes/iplogic
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: A general-purpose tnetstrings library for Ruby
+test_files: 
+- spec/tnetstrings_spec.rb