pg_array_parser 0.0.1 → 0.0.2

data/.gitignore

@@ -16,3 +16,5 @@ test/tmp
 test/version_tmp
 tmp
 benchmark.rb
+bin/*
+.rbenv-version

data/.travis.yml

@@ -2,6 +2,10 @@ rvm:
   - 1.8.7
   - 1.9.2
   - 1.9.3
+  - jruby-18mode
+  - jruby-19mode
+before_script:
+  - rake install
 
 notifications:
   email: false

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+# 0.0.2
+ * Refactored C extension - [jeremyevans](https://github.com/jeremyevens) - Merged at [ad4987](https://github.com/dockyard/pg_array_parser/commit/ad4987dba411decca4aebd0750c990212dc81039)  
+ * Adds JRuby support - thanks to [tychobrailleur](https://github.com/tychobrailleur) for help with the java class
+
+# 0.0.1
+ * Initial release

data/README.md

@@ -18,9 +18,24 @@ Or install it yourself as:
 
 ## Usage
 
-Include the `PgArrayParser` module. Call `PgArrayParser#parse_pg_array`
-method to return a multi-dimensional array of strings from a PostgreSQL
-array value 
+Include the `PgArrayParser` module, which provides the `parse_pg_array`
+method.
+
+```ruby
+class MyPostgresParser
+  include PgArrayParser
+end
+
+parser = MyPostgresParser.new
+parser.parse_pg_array '{}'
+# => []
+parser.parse_pg_array '{1,2,3,4}'
+# => ["1", "2", "3", "4"]
+parser.parse_pg_array '{1,{2,3},4}'
+# => ["1", ["2", "3"], "4"]
+parser.parse_pg_array '{some,strings that,"May have some ,\'s"}'
+# => ["some", "strings that", "May have some ,'s"]
+```
 
 ## Authors
 

data/Rakefile

@@ -3,6 +3,13 @@ require 'bundler/gem_tasks'
 
 require 'rspec/core/rake_task'
 
+spec = Gem::Specification.load('pg_array_parser.gemspec')
+
+if RUBY_PLATFORM =~ /java/
+    require 'rake/javaextensiontask'
+    Rake::JavaExtensionTask.new('pg_array_parser', spec)
+end
+
 task :spec => :install
 
 RSpec::Core::RakeTask.new(:spec)

data/ext/pg_array_parser/PgArrayParserEngine.java

@@ -0,0 +1,113 @@
+package pgarrayparser;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyString;
+import org.jruby.RubyNil;
+import org.jruby.RubyModule;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.anno.JRubyClass;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.BasicLibraryService;
+
+  @JRubyClass(name = "PgArrayParser::PgArrayParserEngine")
+  public class PgArrayParserEngine extends RubyObject {
+    public PgArrayParserEngine(final Ruby runtime, RubyClass rubyClass) {
+      super(runtime, rubyClass);
+    }
+
+    private Ruby runtime;
+    private int index;
+    private String arrayString;
+    @JRubyMethod(name = "parse_pg_array")
+    public IRubyObject parse_pg_array(ThreadContext context, IRubyObject value) {
+      runtime = context.getRuntime();
+      index = 1;
+      arrayString = value.asJavaString();
+      IRubyObject returnValue = readArray();
+      return returnValue;
+
+    }
+
+    private RubyArray readArray()
+    {
+      RubyArray array = RubyArray.newArray(runtime, 1);
+
+      int openQuote = 0;
+      boolean escapeNext = false;
+      char currentChar;
+      StringBuilder word = new StringBuilder();
+
+      if(index < arrayString.length() && arrayString.charAt(index) == '}')
+      {
+        return array;
+      }
+
+      for(;index < arrayString.length(); ++index)
+      {
+        currentChar = arrayString.charAt(index);
+        if(openQuote < 1)
+        {
+          if(currentChar == ',' || currentChar == '}')
+          {
+            if(!escapeNext)
+            {
+              if(openQuote == 0 && word.length() == 4 && word.toString().equals("NULL"))
+              {
+                array.append(runtime.getNil());
+              }
+              else
+              {
+                array.append(RubyString.newString(runtime, word.toString()));
+              }
+            }
+            if(currentChar == '}')
+            {
+              return array;
+            }
+            escapeNext = false;
+            openQuote = 0;
+            word = new StringBuilder();
+          }
+          else if(currentChar == '"')
+          {
+            openQuote = 1;
+          }
+          else if(currentChar == '{')
+          {
+            index++;
+            array.append(readArray());
+            escapeNext = true;
+          } 
+          else
+          {
+            word.append(String.valueOf(currentChar));
+          }
+        }
+        else if(escapeNext)
+        {
+          word.append(String.valueOf(currentChar));
+          escapeNext = false;
+        }
+        else if(currentChar == '\\')
+        {
+          escapeNext = true;
+        }
+        else if(currentChar == '"')
+        {
+          openQuote = -1;
+        }
+        else
+        {
+          word.append(String.valueOf(currentChar));
+        }
+      }
+
+      return array;
+    }
+  }

data/ext/pg_array_parser/PgArrayParserEngineService.java

@@ -0,0 +1,32 @@
+package pgarrayparser;
+
+import java.lang.Long;
+import java.io.IOException;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyModule;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.BasicLibraryService;
+
+public class PgArrayParserEngineService implements BasicLibraryService {
+
+  public boolean basicLoad(Ruby runtime) throws IOException {
+
+    RubyModule pgArrayParser = runtime.defineModule("PgArrayParser");
+    RubyClass pgArrayParserEngine = pgArrayParser.defineClassUnder("PgArrayParserEngine", runtime.getObject(), new ObjectAllocator() {
+      public IRubyObject allocate(Ruby runtime, RubyClass rubyClass) {
+        return new PgArrayParserEngine(runtime, rubyClass);
+      }
+    });
+
+    pgArrayParserEngine.defineAnnotatedMethods(PgArrayParserEngine.class);
+    return true;
+  }
+}

data/ext/pg_array_parser/pg_array_parser.c

@@ -1,90 +1,109 @@
 #include <ruby.h>
 
-VALUE PgArrayParser = Qnil;
-
-//Prototypes
-VALUE read_array(int *index, char *string, int *length, char *word);
-VALUE parse_pg_array(VALUE self, VALUE pg_array_string);
+/* Prototype */
+VALUE read_array(int *index, char *string, int length, char *word);
 
 VALUE parse_pg_array(VALUE self, VALUE pg_array_string) {
 
-  //convert to c-string, create a buffer of the same length, as that will be the worst case
+  /* convert to c-string, create a buffer of the same length, as that will be the worst case */
   char *c_pg_array_string = StringValueCStr(pg_array_string);
   int array_string_length = RSTRING_LEN(pg_array_string);
-  char *word = malloc(sizeof(char) * (array_string_length + 1));
+  char *word = malloc(array_string_length + 1);
 
   int index = 1;
 
-  VALUE return_value = read_array(&index, c_pg_array_string, &array_string_length, word);
+  VALUE return_value = read_array(&index, c_pg_array_string, array_string_length, word);
   free(word);
   return return_value;
 }
 
-VALUE read_array(int *index, char *c_pg_array_string, int *array_string_length, char *word)
+VALUE read_array(int *index, char *c_pg_array_string, int array_string_length, char *word)
 {
-  // Return value: array
+  /* Return value: array */
   VALUE array;
-  array = rb_ary_new();
   int word_index = 0;
+
+  /* The current character in the input string. */
+  char c;
+
+  /*  0: Currently outside a quoted string, current word never quoted
+   *  1: Currently inside a quoted string
+   * -1: Currently outside a quoted string, current word previously quoted */
   int openQuote = 0;
-  for(;(*index) < (*array_string_length); ++(*index))
+
+  /* Inside quoted input means the next character should be treated literally,
+   * instead of being treated as a metacharacter.
+   * Outside of quoted input, means that the word shouldn't be pushed to the array,
+   * used when the last entry was a subarray (which adds to the array itself). */
+  int escapeNext = 0;
+
+  array = rb_ary_new();
+
+  /* Special case the empty array, so it doesn't need to be handled manually inside
+   * the loop. */
+  if(((*index) < array_string_length) && c_pg_array_string[(*index)] == '}') 
+  {
+    return array;
+  }
+
+  for(;(*index) < array_string_length; ++(*index))
   {
-    if(!openQuote && (c_pg_array_string[*index] == ','))
+    c = c_pg_array_string[*index];
+    if(openQuote < 1)
     {
-      if(c_pg_array_string[(*index) - 1] != '"' && c_pg_array_string[(*index) - 1] != '}')
+      if(c == ',' || c == '}')
       {
-        word[word_index] = '\0';
-        if (word_index == 4 && !strcmp(word,"NULL"))
+        if(!escapeNext)
         {
-          rb_ary_push(array, Qnil);
+          if(openQuote == 0 && word_index == 4 && !strncmp(word, "NULL", word_index))
+          {
+            rb_ary_push(array, Qnil);
+          }
+          else
+          {
+            rb_ary_push(array, rb_str_new(word, word_index));
+          }
         }
-        else
+        if(c == '}')
         {
-          rb_ary_push(array, rb_str_new2(word));
+          return array;
         }
+        escapeNext = 0;
+        openQuote = 0;
         word_index = 0;
       }
-    }
-    else if(!openQuote && c_pg_array_string[*index] == '}')
-    {
-      if(word_index > 0 && c_pg_array_string[(*index) - 1] != '"')
+      else if(c == '"')
       {
-        word[word_index] = '\0';
-        if (word_index == 4 && !strcmp(word,"NULL"))
-        {
-          rb_ary_push(array, Qnil);
-        }
-        else
-        {
-          rb_ary_push(array, rb_str_new2(word));
-        }
-        word_index = 0;
+        openQuote = 1;
+      }
+      else if(c == '{')
+      {
+        (*index)++;
+        rb_ary_push(array, read_array(index, c_pg_array_string, array_string_length, word));
+        escapeNext = 1;
+      }
+      else
+      {
+        word[word_index] = c;
+        word_index++;
       }
-      return array;
-    }
-    else if (openQuote && c_pg_array_string[*index] == '"' && c_pg_array_string[(*index) - 1] == '\\')
-    {
-      word[word_index - 1] = '"';
     }
-    else if (openQuote && c_pg_array_string[*index] == '"' && c_pg_array_string[(*index) - 1] != '\\')
-    {
-      word[word_index] = '\0';
-      word_index = 0;
-      openQuote = 0;
-      rb_ary_push(array, rb_str_new2(word));
+    else if (escapeNext) {
+      word[word_index] = c;
+      word_index++;
+      escapeNext = 0;
     }
-    else if(c_pg_array_string[*index] == '"')
+    else if (c == '\\')
     {
-      openQuote = 1;
+      escapeNext = 1;
     }
-    else if(!openQuote && c_pg_array_string[*index] == '{')
+    else if (c == '"')
     {
-      (*index)++;
-      rb_ary_push(array, read_array(index, c_pg_array_string, array_string_length, word));
+      openQuote = -1;
     }
     else
     {
-      word[word_index] = c_pg_array_string[*index];
+      word[word_index] = c;
       word_index++;
     }
   }
@@ -93,9 +112,6 @@ VALUE read_array(int *index, char *c_pg_array_string, int *array_string_length,
 }
 
 void Init_pg_array_parser(void) {
-  PgArrayParser = rb_define_module("PgArrayParser");
-  rb_define_method(PgArrayParser, "parse_pg_array", parse_pg_array, 1);
-
+  rb_define_method(rb_define_module("PgArrayParser"), "parse_pg_array", parse_pg_array, 1);
 }
 
-

data/lib/pg_array_parser.rb

@@ -1,2 +1,18 @@
-require "pg_array_parser/version"
-require 'pg_array_parser/pg_array_parser'
+require File.expand_path('../pg_array_parser/version', __FILE__)
+require File.expand_path('../pg_array_parser', __FILE__)
+
+if RUBY_PLATFORM =~ /java/
+  module PgArrayParser
+    require 'jruby'
+    require File.expand_path('../pg_array_parser.jar', __FILE__)
+    require 'pgArrayParser/pg_array_parser_engine'
+
+    def parse_pg_array(value)
+      @parser ||= PgArrayParserEngine.new
+      @parser.parse_pg_array(value)
+    end
+  end
+else
+  require 'pg_array_parser/pg_array_parser'
+end
+

data/lib/pg_array_parser/version.rb

@@ -1,3 +1,3 @@
 module PgArrayParser
-  VERSION = "0.0.1"
+  VERSION = '0.0.2'
 end

data/pg_array_parser.gemspec

@@ -3,19 +3,24 @@ require File.expand_path('../lib/pg_array_parser/version', __FILE__)
 
 Gem::Specification.new do |gem|
   gem.authors       = ["Dan McClain"]
-  gem.email         = ["git@danseaver.com"]
+  gem.email         = ["git@danmcclain.net"]
   gem.description   = %q{Simple library to parse PostgreSQL arrays into a array of strings}
   gem.summary       = %q{Converts PostgreSQL array strings into arrays of strings}
   gem.homepage      = ""
 
   gem.files         = `git ls-files`.split($\)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.extensions    = ['ext/pg_array_parser/extconf.rb']
+  if RUBY_PLATFORM =~ /java/
+    gem.files << 'lib/pg_array_parser.jar'
+  else
+    gem.extensions    = ['ext/pg_array_parser/extconf.rb']
+  end
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = "pg_array_parser"
   gem.require_paths = ["lib"]
   gem.version       = PgArrayParser::VERSION
 
-  gem.add_development_dependency 'rspec', '~> 2.10.0'
+  gem.add_development_dependency 'rspec', '~> 2.11.0'
   gem.add_development_dependency 'rake', '~> 0.9.2.2'
+  gem.add_development_dependency 'rake-compiler'
 end

data/spec/parser_spec.rb

@@ -9,6 +9,12 @@ describe 'PgArrayParser' do
 
   describe '#parse_pg_array' do
     context 'one dimensional arrays' do
+      context 'empty' do
+        it 'returns an empty array' do
+          parser.parse_pg_array(%[{}]).should eq []
+        end
+      end
+
       context 'no strings' do
         it 'returns an array of strings' do
           parser.parse_pg_array(%[{1,2,3}]).should eq ['1','2','3']
@@ -35,10 +41,21 @@ describe 'PgArrayParser' do
         it 'returns an array of strings when containing an escaped quote' do
           parser.parse_pg_array(%[{1,"2\\",3",4}]).should eq ['1','2",3','4']
         end
+
+        it 'returns an array of strings when containing an escaped backslash' do
+          parser.parse_pg_array(%[{1,"2\\\\",3,4}]).should eq ['1','2\\','3','4']
+          parser.parse_pg_array(%[{1,"2\\\\\\",3",4}]).should eq ['1','2\\",3','4']
+        end
       end
     end
 
     context 'two dimensional arrays' do
+      context 'empty' do
+        it 'returns an empty array' do
+          parser.parse_pg_array(%[{{}}]).should eq [[]]
+          parser.parse_pg_array(%[{{},{}}]).should eq [[],[]]
+        end
+      end
       context 'no strings' do
         it 'returns an array of strings with a sub array' do
           parser.parse_pg_array(%[{1,{2,3},4}]).should eq ['1',['2','3'],'4']
@@ -60,6 +77,12 @@ describe 'PgArrayParser' do
       end
     end
     context 'three dimensional arrays' do
+      context 'empty' do
+        it 'returns an empty array' do
+          parser.parse_pg_array(%[{{{}}}]).should eq [[[]]]
+          parser.parse_pg_array(%[{{{},{}},{{},{}}}]).should eq [[[],[]],[[],[]]]
+        end
+      end
       it 'returns an array of strings with sub arrays' do
         parser.parse_pg_array(%[{1,{2,{3,4}},{NULL,6},7}]).should eq ['1',['2',['3','4']],[nil,'6'],'7']
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg_array_parser
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-11 00:00:00.000000000 Z
+date: 2012-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.10.0
+        version: 2.11.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.10.0
+        version: 2.11.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -43,9 +43,25 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 0.9.2.2
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Simple library to parse PostgreSQL arrays into a array of strings
 email:
-- git@danseaver.com
+- git@danmcclain.net
 executables: []
 extensions:
 - ext/pg_array_parser/extconf.rb
@@ -53,13 +69,16 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .travis.yml
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
+- ext/pg_array_parser/PgArrayParserEngine.java
+- ext/pg_array_parser/PgArrayParserEngineService.java
 - ext/pg_array_parser/extconf.rb
 - ext/pg_array_parser/pg_array_parser.c
-- lib/pg_array_parser.bundle
+- lib/pg_array_parser.jar
 - lib/pg_array_parser.rb
 - lib/pg_array_parser/version.rb
 - pg_array_parser.gemspec
@@ -92,3 +111,4 @@ summary: Converts PostgreSQL array strings into arrays of strings
 test_files:
 - spec/parser_spec.rb
 - spec/spec_helper.rb
+has_rdoc: