stomp_parser 1.0.0-universal-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dc2d9bd4c0e92423027543f02348d68441534536
+  data.tar.gz: a16e1abf7f2eda5f48932fe148e72e7e14d3f88e
+SHA512:
+  metadata.gz: 67fb331703eb2b68e2aa70fc38f50883a09f0016c20210ff8aa5f7a9242a76162493f5535d371eb192563693215387ca3590ff7ebd6baa324e05242e6cbf223a
+  data.tar.gz: 59585100cab11f493bd3063905c543928e8d2abe4eb80217bd133771cfc257b0ff5c151769d7ef0718e4c135bab993e1cb02a14741d7ee166785b425f225cede

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,60 @@
+# StompParser
+
+[![Build Status](https://travis-ci.org/stompede/stomp_parser.png?branch=master)](https://travis-ci.org/stompede/stomp_parser)
+[![Code Climate](https://codeclimate.com/github/stompede/stomp_parser.png)](https://codeclimate.com/github/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,134 @@
+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]
+
+# JRuby do not like C extensions to even exist.
+if %w[rbx ruby].include?(RUBY_ENGINE)
+  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
+end
+
+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
+
+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
+
+desc "Build gem in preparation for release"
+task :build, [:everything_compiled?] => :compile do |task, args|
+  unless args[:everything_compiled?] == "all_compiled"
+    puts "Hi there. This is a safeguard to stop you from doing mistakes."
+    puts
+    puts "Make sure that the lib/stomp_parser/java_parser.jar is up to"
+    puts "date by switching to JRuby and running `rake compile`. This is"
+    puts "because JRuby cannot build native extensions on gem installation,"
+    puts "so we must bundle the .jar with the gem."
+    puts
+    puts "To do this, switch to JRuby and issue `rake compile`."
+    puts
+    puts "Once you've compiled the parser, run `rake build[all_compiled]`"
+    puts "to build gems for all platforms!"
+    abort
+  end
+
+  require "rubygems/package"
+
+  root = File.dirname(__FILE__)
+  pkgs = File.join(root, "pkg/")
+  mkdir_p(pkgs, verbose: true)
+
+  gemspec = Gem::Specification.load("stomp_parser.gemspec")
+
+  # For all the rubies. Except JRuby.
+  ruby_gemspec = gemspec.dup
+  ruby_gemspec.platform = Gem::Platform::RUBY
+  ruby_gemname = Gem::Package.build(ruby_gemspec)
+  ruby_gempath = File.join(pkgs, File.basename(ruby_gemname))
+  mv(ruby_gemname, ruby_gempath, verbose: true)
+
+  # JRuby don't like C extensions.
+  java_gemspec = gemspec.dup
+  java_gemspec.files += ["lib/stomp_parser/java_parser.jar"]
+  java_gemspec.extensions = []
+  java_gemspec.platform = "universal-java"
+  java_gemname = Gem::Package.build(java_gemspec)
+  java_gempath = File.join(pkgs, File.basename(java_gemname))
+  mv(java_gemname, java_gempath, verbose: true)
+
+  puts
+  puts "Now you may push the gems:"
+  puts
+  puts "  gem push #{ruby_gempath}"
+  puts "  gem push #{java_gempath}"
+  puts
+  puts "Do not forget to tag and push the versions to GitHub!"
+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;
+  }
+}