stomp_parser 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5a04a9e96b78143103517610d026fe12603b2ebe
+  data.tar.gz: 660c92162ef6ad5cdc05f321ced1f36ce52999ab
+SHA512:
+  metadata.gz: f20b1607fbba7e6f3a6be6a736c0bf5a63e90ef4e2f76d086cc617a3f564166b0b61523bdecb7d5a5748bfef0f164d1ccb8fbddd0c744da9991bf9e51c3a1096
+  data.tar.gz: c4f7189b20e941cb84547c970d9a3d4b8c3e118d15539ef3387c8bbda60ebd6cc98f7a1efab3560f65f624cf778e9b30515bb435f564818ceb74258bd1c3d3c3

data/.gitignore

@@ -0,0 +1,33 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+spec/profile
+
+# C extension
+*.o
+*.bundle
+mkmf.log
+Makefile
+tmp/
+spec/spec.log
+
+# Ragel
+lib/stomp_parser/ruby_parser.rb
+lib/stomp_parser/c_parser.rb
+ext/stomp_parser/c_parser.c
+ext/java/stomp_parser/JavaParser.java
+lib/stomp_parser/java_parser.jar

data/.rspec

@@ -0,0 +1 @@
+-r spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+cache: bundler
+rvm:
+  - 2.0.0
+  - 2.1.0
+  - rbx-2
+  - jruby

data/Brewfile

@@ -0,0 +1,2 @@
+install ragel
+install graphviz

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem "perftools.rb", platform: :mri
+gem "benchmark-ips"
+
+platforms :rbx do
+  gem "rb-readline"
+  gem "rubysl-singleton"
+end

data/MIT-LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Kim Burgestrand, Jonas Nicklas
+
+MIT License
+
+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

@@ -0,0 +1,59 @@
+# StompParser
+
+[![Build Status](https://travis-ci.org/stompede/stomp_parser.png?branch=master)](https://travis-ci.org/stompede/stomp_parser)
+[![Gem Version](https://badge.fury.io/rb/stomp_parser.png)](http://badge.fury.io/rb/stomp_parser)
+
+Fast STOMP parser and serializer for Ruby with native extensions in C for MRI
+and Rubinius and in Java for JRuby, as well as a pure Ruby parser.
+
+## Parsing
+
+``` ruby
+parser = StompParser::Parser.new
+parser.parse(chunk) do |frame|
+  puts "We received #{frame.command} frame with #{frame.body} and headers #{frame.headers}!"
+end
+```
+
+The chunks do not have to be complete STOMP frames. The callback will be called
+whenever a complete frame has been parsed. Additionally, StompParser handles
+escape sequences in headers and body encoding for you.
+
+## Serializing
+
+``` ruby
+StompParser::Frame.new("SEND", { some: "header" }, "Hello").to_str
+```
+
+## Development
+
+Development should be ez.
+
+``` bash
+git clone git@github.com:stompede/stomp_parser.git # git, http://git-scm.com/
+cd stomp_parser
+brew bundle # Homebrew, http://brew.sh/
+bundle install # Bundler, http://bundler.io/
+rake # compile state machine, run test suite
+```
+
+A few notes:
+
+- Native dependencies are listed in the Brewfile.
+- The stomp message parser is written in [Ragel](http://www.complang.org/ragel/), see [parser_common.rl](parser_common.rl).
+- Graphviz is used to visualize the Ragel state machine.
+- Most rake tasks will compile the state machine anew if needed.
+
+## Contributing
+
+1. Fork it on GitHub (<http://github.com/stompede/stomp_parser/fork>).
+2. Create your feature branch (`git checkout -b my-new-feature`).
+3. Follow the [Development](#development) instructions in this README.
+4. Create your changes, please add tests.
+5. Commit your changes (`git commit -am 'Add some feature'`).
+6. Push to the branch (`git push origin my-new-feature`).
+7. Create new pull request on GitHub.
+
+## License
+
+[MIT](MIT-LICENSE.txt)

data/Rakefile

@@ -0,0 +1,85 @@
+require "bundler/gem_tasks"
+
+def ragel(*args)
+  sh "ragel", "-I.", *args
+end
+
+# Build state machine before building gem.
+task :build => :compile
+
+file "parser_common.rl"
+
+rule ".rb" => %w[.rb.rl parser_common.rl] do |t|
+  ragel "-F1", "-R", t.source, "-o", t.name
+end
+
+rule ".c" => %w[.c.rl parser_common.rl] do |t|
+  ragel "-G2", "-C", t.source, "-o", t.name
+end
+
+rule ".java" => %w[.java.rl parser_common.rl] do |t|
+  ragel "-T0", "-J", t.source, "-o", t.name
+end
+
+desc "ragel machines"
+task :compile => %w[lib/stomp_parser/ruby_parser.rb]
+
+case RUBY_ENGINE
+when "rbx", "ruby"
+  require "rake/extensiontask"
+  task :compile => %w[ext/stomp_parser/c_parser.c]
+
+  Rake::ExtensionTask.new do |ext|
+    ext.name = "c_parser"
+    ext.ext_dir = "ext/stomp_parser"
+    ext.lib_dir = "lib/stomp_parser"
+  end
+when "jruby"
+  require "rake/javaextensiontask"
+  task :compile => %w[ext/java/stomp_parser/JavaParser.java]
+
+  Rake::JavaExtensionTask.new do |ext|
+    ext.name = "java_parser"
+    ext.lib_dir = "lib/stomp_parser"
+  end
+end
+
+desc "ragel machines"
+task :clean do |t|
+  source_tasks = Rake::Task[:compile].prerequisite_tasks.grep(Rake::FileTask)
+  rm_f source_tasks.map(&:name)
+end
+
+namespace :ragel do
+  desc "Show stomp parser state machine as an image"
+  task :show => "lib/stomp_parser/ruby_parser.rb" do |t|
+    mkdir_p "tmp"
+    ragel "-V", "-p", t.prerequisite_tasks[0].source, "-o", "tmp/parser.dot"
+    sh "dot -Tpng -O tmp/parser.dot"
+    rm "tmp/parser.dot"
+    sh "open tmp/parser.dot.png"
+  end
+end
+
+desc "Start a pry session with the gem loaded."
+task :console => :compile do
+  exec "pry", "-rbundler/setup", "-rstomp_parser"
+end
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec)
+task :spec => :compile
+
+desc "Run all benchmarks."
+task :bench => :compile do
+  sh "ruby", "-I.", *FileList["spec/benchmarks/**/*.rb"].flat_map { |x| ["-r", x] }, "-e", "''"
+end
+
+desc "Run the profiler and show a gif, requires perftools.rb"
+task :profile => :compile do
+  # CPUPROFILE_METHODS=0 CPUPROFILE_OBJECTS=0 CPUPROFILE_REALTIME=1
+  sh "CPUPROFILE_REALTIME=1 ruby spec/profile.rb"
+  sh "pprof.rb --text spec/profile/parser.profile"
+end
+
+task :default => :spec

data/ext/java/stomp_parser/JavaParser.java.rl

@@ -0,0 +1,179 @@
+package stomp_parser;
+
+import org.jruby.Ruby;
+import org.jruby.RubyModule;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyString;
+import org.jruby.RubyNumeric;
+import org.jruby.RubyException;
+import org.jruby.exceptions.RaiseException;
+
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.Block;
+
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+
+%%{
+  machine frame;
+  alphtype byte;
+
+  action mark {
+    mark = p;
+  }
+
+  action mark_frame {
+    mark_frame = context.runtime.getClassFromPath("StompParser::Frame").callMethod("new", context.nil, context.nil);
+    mark_frame_size = 0;
+  }
+
+  action write_command {
+    mark_frame.callMethod(context, "write_command", RubyString.newString(context.runtime, data, mark, p - mark));
+    mark = -1;
+  }
+
+  action mark_key {
+    mark_key = RubyString.newString(context.runtime, data, mark, p - mark);
+    mark = -1;
+  }
+
+  action write_header {
+    IRubyObject args[] = { mark_key, RubyString.newString(context.runtime, data, mark, p - mark) };
+    mark_frame.callMethod(context, "write_header", args);
+    mark_key = null;
+    mark = -1;
+  }
+
+  action finish_headers {
+    IRubyObject content_length = mark_frame.callMethod(context, "content_length");
+
+    if ( ! content_length.isNil()) {
+      mark_content_length = RubyNumeric.num2int(content_length);
+    } else {
+      mark_content_length = -1;
+    }
+  }
+
+  action write_body {
+    mark_frame.callMethod(context, "write_body", RubyString.newString(context.runtime, data, mark, p - mark));
+    mark = -1;
+  }
+
+  action consume_null {
+    ((mark_content_length != -1) && ((p - mark) < mark_content_length))
+  }
+
+  action consume_octet {
+    ((mark_content_length == -1) || ((p - mark) < mark_content_length))
+  }
+
+  action check_frame_size {
+    mark_frame_size += 1;
+    if (mark_frame_size > maxFrameSize) {
+      RubyModule frameSizeExceeded = context.runtime.getClassFromPath("StompParser::FrameSizeExceeded");
+      RubyException error = (RubyException) frameSizeExceeded.callMethod("new");
+      throw new RaiseException(error);
+    }
+  }
+
+  action finish_frame {
+    block.yield(context, mark_frame);
+    mark_frame = null;
+  }
+
+  include frame_common "parser_common.rl";
+}%%
+
+@JRubyClass(name="JavaParser", parent="Object")
+public class JavaParser extends RubyObject {
+  %% write data noprefix;
+
+  private class State {
+    public int cs = JavaParser.start;
+    public byte[] chunk;
+    public int mark = -1;
+    public RubyString mark_key;
+    public IRubyObject mark_frame;
+    public int mark_frame_size = -1;
+    public int mark_content_length = -1;
+  }
+
+  private RubyException parseError;
+  private long maxFrameSize;
+  private State state;
+
+  public JavaParser(Ruby runtime, RubyClass klass) {
+    super(runtime, klass);
+    state = new State();
+    parseError = null;
+  }
+
+  @JRubyMethod
+  public IRubyObject initialize(ThreadContext context) {
+    RubyModule mStompParser = context.runtime.getClassFromPath("StompParser");
+    return initialize(context, mStompParser.callMethod("max_frame_size"));
+  }
+
+  @JRubyMethod(argTypes = {RubyFixnum.class})
+  public IRubyObject initialize(ThreadContext context, IRubyObject maxFrameSize) {
+    this.maxFrameSize = ((RubyFixnum) maxFrameSize).getLongValue();
+    return context.nil;
+  }
+
+  @JRubyMethod(argTypes = {RubyString.class})
+  public IRubyObject parse(ThreadContext context, IRubyObject chunk, Block block) {
+    if (parseError == null) {
+      int p;
+      byte data[] = null;
+      byte bytes[] = ((RubyString) chunk).getBytes();
+
+      if (state.chunk != null) {
+        p = state.chunk.length;
+        data = new byte[state.chunk.length + bytes.length];
+        System.arraycopy(state.chunk, 0, data, 0, state.chunk.length);
+        System.arraycopy(bytes, 0, data, state.chunk.length, bytes.length);
+      } else {
+        p = 0;
+        data = bytes;
+      }
+
+      int pe = data.length;
+
+      int cs = state.cs;
+      int mark = state.mark;
+      RubyString mark_key = state.mark_key;
+      IRubyObject mark_frame = state.mark_frame;
+      int mark_frame_size = state.mark_frame_size;
+      int mark_content_length = state.mark_content_length;
+
+      %% write exec;
+
+      if (mark != -1) {
+        state.chunk = data;
+      } else {
+        state.chunk = null;
+      }
+
+      state.cs = cs;
+      state.mark = mark;
+      state.mark_key = mark_key;
+      state.mark_frame = mark_frame;
+      state.mark_frame_size = mark_frame_size;
+      state.mark_content_length = mark_content_length;
+
+      if (cs == error) {
+        IRubyObject args[] = { RubyString.newString(context.runtime, data), RubyFixnum.newFixnum(context.runtime, (long) p) };
+        parseError = (RubyException) context.runtime.getClassFromPath("StompParser").callMethod(context, "build_parse_error", args);
+      }
+    }
+
+    if (parseError != null) {
+      throw new RaiseException(parseError);
+    }
+
+    return context.nil;
+  }
+}

data/ext/java/stomp_parser/JavaParserService.java

@@ -0,0 +1,23 @@
+package stomp_parser;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.runtime.load.BasicLibraryService;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.ObjectAllocator;
+
+public class JavaParserService implements BasicLibraryService {
+  public boolean basicLoad(Ruby ruby) {
+    RubyModule mStomp = ruby.getClassFromPath("StompParser");
+    RubyClass cJavaParser = ruby.defineClassUnder("JavaParser", ruby.getObject(), JAVA_PARSER_ALLOCATOR, mStomp);
+    cJavaParser.defineAnnotatedMethods(JavaParser.class);
+    return true;
+  }
+
+  private static final ObjectAllocator JAVA_PARSER_ALLOCATOR = new ObjectAllocator() {
+    public IRubyObject allocate(Ruby ruby, RubyClass klass) {
+      return new JavaParser(ruby, klass);
+    }
+  };
+}

data/ext/stomp_parser/c_parser.c.rl

@@ -0,0 +1,225 @@
+#include <ruby.h>
+
+#if DEBUG_H
+#  define DEBUG(fmt, ...) do { fprintf(stderr, fmt "\n", ##__VA_ARGS__); } while(0)
+#else
+#  define DEBUG(...)
+#endif
+
+#define UNUSED(x) (void)(x)
+#define MARK_LEN (p - mark)
+#define MARK_STR_NEW() rb_str_new(mark, MARK_LEN)
+
+#define true 1
+#define false 0
+
+typedef struct {
+  VALUE error;
+  long max_frame_size;
+
+  VALUE chunk;
+  const char *p;
+  int cs;
+  const char *mark;
+  VALUE mark_key;
+  VALUE mark_frame;
+  long mark_frame_size;
+  long mark_content_length;
+} parser_state_t;
+
+VALUE mStompParser = Qnil;
+VALUE cFrame = Qnil;
+VALUE eFrameSizeExceeded = Qnil;
+ID g_new;
+ID g_write_command;
+ID g_write_header;
+ID g_write_body;
+ID g_content_length;
+ID g_build_parse_error;
+ID g_max_frame_size;
+
+%%{
+  machine frame;
+
+  action mark {
+    mark = p;
+  }
+
+  action mark_frame {
+    mark_frame = rb_funcall(cFrame, g_new, 2, Qnil, Qnil);
+    mark_frame_size = 0;
+  }
+
+  action write_command {
+    rb_funcall(mark_frame, g_write_command, 1, MARK_STR_NEW());
+    mark = NULL;
+  }
+
+  action mark_key {
+    mark_key = MARK_STR_NEW();
+    mark = NULL;
+  }
+
+  action write_header {
+    rb_funcall(mark_frame, g_write_header, 2, mark_key, MARK_STR_NEW());
+    mark_key = Qnil;
+    mark = NULL;
+  }
+
+  action finish_headers {
+    VALUE length = rb_funcall(mark_frame, g_content_length, 0);
+    if ( ! NIL_P(length)) {
+      mark_content_length = NUM2LONG(length);
+    } else {
+      mark_content_length = -1;
+    }
+  }
+
+  action write_body {
+    rb_funcall(mark_frame, g_write_body, 1, MARK_STR_NEW());
+    mark = NULL;
+  }
+
+  action consume_null {
+    ((mark_content_length != -1) && (MARK_LEN < mark_content_length))
+  }
+
+  action consume_octet {
+    ((mark_content_length == -1) || (MARK_LEN < mark_content_length))
+  }
+
+  action check_frame_size {
+    mark_frame_size += 1;
+    if (mark_frame_size > max_frame_size) {
+      rb_raise(eFrameSizeExceeded, "");
+    }
+  }
+
+  action finish_frame {
+    rb_yield(mark_frame);
+    mark_frame = Qnil;
+  }
+
+  include frame_common "parser_common.rl";
+
+  write data noprefix;
+}%%
+
+static void parser_free(parser_state_t *state) {
+  // TODO: free memory inside struct!
+  xfree(state);
+}
+
+static void parser_mark(parser_state_t *state) {
+  rb_gc_mark(state->error);
+  rb_gc_mark(state->mark_key);
+  rb_gc_mark(state->mark_frame);
+  rb_gc_mark(state->chunk);
+}
+
+static VALUE parser_alloc(VALUE klass) {
+  parser_state_t *state = ALLOC(parser_state_t);
+  return Data_Wrap_Struct(klass, parser_mark, parser_free, state);
+}
+
+static VALUE parser_initialize(int argc, VALUE *argv, VALUE self) {
+  parser_state_t *state;
+  Data_Get_Struct(self, parser_state_t, state);
+
+  VALUE max_frame_size;
+  rb_scan_args(argc, argv, "01", &max_frame_size);
+
+  if (max_frame_size == Qnil) {
+    max_frame_size = rb_funcall(mStompParser, g_max_frame_size, 0);
+  }
+
+  state->error = Qnil;
+  state->max_frame_size = FIX2LONG(max_frame_size);
+  state->chunk = Qnil;
+  state->cs = start;
+  state->mark = NULL;
+  state->mark_key = Qnil;
+  state->mark_frame = Qnil;
+  state->mark_frame_size = 0;
+  state->mark_content_length = 0;
+
+  return self;
+}
+
+static VALUE parser_parse(VALUE self, VALUE new_chunk) {
+  parser_state_t *state;
+  Data_Get_Struct(self, parser_state_t, state);
+
+  if (NIL_P(state->error)) {
+    VALUE chunk = Qnil;
+    const char *p = NULL;
+    const char *mark = NULL;
+
+    if ( ! NIL_P(state->chunk)) {
+      long offset = RSTRING_LEN(state->chunk);
+      long mark_offset = state->mark - RSTRING_PTR(state->chunk);
+
+      chunk = rb_str_append(state->chunk, new_chunk);
+      p = RSTRING_PTR(chunk) + offset;
+      mark = RSTRING_PTR(chunk) + mark_offset;
+    } else {
+      chunk = new_chunk;
+      p = RSTRING_PTR(chunk);
+    }
+
+    const char *pe = RSTRING_END(chunk);
+    long max_frame_size = state->max_frame_size;
+
+    int cs = state->cs;
+    VALUE mark_key = state->mark_key;
+    VALUE mark_frame = state->mark_frame;
+    long mark_frame_size = state->mark_frame_size;
+    long mark_content_length = state->mark_content_length;
+
+    %% write exec;
+
+    if (mark != NULL) {
+      state->chunk = chunk;
+    } else {
+      state->chunk = Qnil;
+    }
+
+    state->cs = cs;
+    state->mark = mark;
+    state->mark_key = mark_key;
+    state->mark_frame = mark_frame;
+    state->mark_frame_size = mark_frame_size;
+    state->mark_content_length = mark_content_length;
+
+    if (cs == error) {
+      long index = p - RSTRING_PTR(chunk);
+      state->error = rb_funcall(mStompParser, g_build_parse_error, 2, chunk, LONG2NUM(index));
+    }
+  }
+
+  if ( ! NIL_P(state->error)) {
+    rb_exc_raise(state->error);
+  }
+
+  return Qnil;
+}
+
+void Init_c_parser(void) {
+  mStompParser = rb_const_get(rb_cObject, rb_intern("StompParser"));
+  cFrame = rb_const_get(mStompParser, rb_intern("Frame"));
+  eFrameSizeExceeded = rb_const_get(mStompParser, rb_intern("FrameSizeExceeded"));
+
+  g_new = rb_intern("new");
+  g_write_command = rb_intern("write_command");
+  g_write_header = rb_intern("write_header");
+  g_write_body = rb_intern("write_body");
+  g_content_length = rb_intern("content_length");
+  g_build_parse_error = rb_intern("build_parse_error");
+  g_max_frame_size = rb_intern("max_frame_size");
+
+  VALUE cParser = rb_define_class_under(mStompParser, "CParser", rb_cObject);
+  rb_define_alloc_func(cParser, parser_alloc);
+
+  rb_define_method(cParser, "initialize", parser_initialize, -1);
+  rb_define_method(cParser, "parse", parser_parse, 1);
+}