pg_array_parser 0.0.8-java

data/CHANGELOG.md

@@ -0,0 +1,22 @@
+# 0.0.7
+ * Trying to not break the C extension now
+
+# 0.0.6
+ * Excludes C extension files in JRuby
+
+# 0.0.5
+ * Prevents attempt to build C extension in JRuby
+
+# 0.0.4
+ * Fixes bad release
+
+# 0.0.3
+ * Refactored Java to ensure thread safety - [mauricio](https://github.com/mauricio) -
+   Merged at [a30aba](https://github.com/dockyard/pg_array_parser/commit/a30aba4885812290f83c693e6b68c697b0dac675)
+
+# 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/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in pg_array_parser.gemspec
+gemspec

data/README.md

@@ -0,0 +1,70 @@
+# PgArrayParser
+[![Build Status](http://travis-ci.org/dockyard/easy_auth.png)](http://travis-ci.org/dockyard/pg_array_parser)
+[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/dockyard/pg_array_parser)
+
+Fast PostreSQL array parsing.
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'pg_array_parser'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pg_array_parser
+
+## Usage
+
+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
+
+[Dan McClain](http://github.com/danmcclain) [twitter](http://twitter.com/_danmcclain) 
+
+## Versioning ##
+
+This gem follows [Semantic Versioning](http://semver.org)
+
+## Want to help? ##
+
+Stable branches are created based upon each minor version. Please make
+pull requests to specific branches rather than master.
+
+Please make sure you include tests!
+
+Unles Rails drops support for Ruby 1.8.7 we will continue to use the
+hash-rocket syntax. Please respect this.
+
+Don't use tabs to indent, two spaces are the standard.
+
+## Legal ##
+
+[DockYard](http://dockyard.com), LLC © 2012
+
+[@dockyard](http://twitter.com/dockyard)
+
+[Licensed under the MIT
+license](http://www.opensource.org/licenses/mit-license.php)

data/Rakefile

@@ -0,0 +1,21 @@
+#!/usr/bin/env rake
+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)
+else
+  require 'rake/extensiontask'
+  Rake::ExtensionTask.new('pg_array_parser', spec)
+end
+
+task :install => :compile
+task :spec => :install
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/ext/pg_array_parser/PgArrayParserEngine.java

@@ -0,0 +1,118 @@
+package pgarrayparser;
+
+import org.jruby.*;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+@JRubyClass(name = "PgArrayParser::PgArrayParserEngine")
+public class PgArrayParserEngine extends RubyObject {
+
+    public PgArrayParserEngine(final Ruby runtime, RubyClass rubyClass) {
+        super(runtime, rubyClass);
+    }
+
+    @JRubyMethod(name = "parse_pg_array")
+    public RubyArray parse_pg_array( ThreadContext context, IRubyObject value) {
+        String content = value.asJavaString();
+        return parseData(context, content, 0);
+    }
+
+    private static RubyArray parseData( ThreadContext context, String content, int index)
+    {
+        RubyArray items = RubyArray.newArray(context.getRuntime());
+
+        for( int x = index; x < content.length(); x++ ) {
+
+            char token = content.charAt(x);
+
+            switch (token) {
+                case '{':
+                    x = parseArrayContents( context, items, content, x + 1 );
+                    break;
+                case '}':
+                    return items;
+            }
+
+        }
+
+        return items;
+    }
+
+    private static int parseArrayContents( ThreadContext context, RubyArray items, String content, int index ) {
+
+        StringBuilder currentItem = new StringBuilder();
+        boolean isEscaping = false;
+        boolean isQuoted = false;
+        boolean wasQuoted = false;
+
+        int x = index;
+
+        for(; x < content.length(); x++ ) {
+
+            char token = content.charAt(x);
+
+            if ( isEscaping ) {
+                currentItem.append( token );
+                isEscaping = false;
+            } else {
+                if ( isQuoted ) {
+                    switch (token) {
+                        case '"':
+                            isQuoted = false;
+                            wasQuoted = true;
+                            break;
+                        case '\\':
+                            isEscaping = true;
+                            break;
+                        default:
+                            currentItem.append(token);
+                    }
+                } else {
+                    switch (token) {
+                        case '\\':
+                            isEscaping = true;
+                            break;
+                        case ',':
+                            addItem(context, items, currentItem, wasQuoted);
+                            currentItem = new StringBuilder();
+                            wasQuoted = false;
+                            break;
+                        case '"':
+                            isQuoted = true;
+                            break;
+                        case '{':
+                            RubyArray internalItems = RubyArray.newArray(context.getRuntime());
+                            x = parseArrayContents( context, internalItems, content, x + 1 );
+                            items.add(internalItems);
+                            break;
+                        case '}':
+                            addItem(context, items, currentItem, wasQuoted);
+                            return x;
+                        default:
+                            currentItem.append(token);
+                    }
+                }
+            }
+
+        }
+
+        return x;
+    }
+
+    private static void addItem( ThreadContext context, RubyArray items, StringBuilder builder, boolean quoted ) {
+        String value = builder.toString();
+
+        if ( !quoted && value.length() == 0 ) {
+            return;
+        }
+
+        if ( !quoted && "NULL".equalsIgnoreCase( value ) ) {
+            items.add(context.getRuntime().getNil());
+        } else {
+            items.add(RubyString.newString( context.getRuntime(), value ));
+        }
+    }
+
+}

data/ext/pg_array_parser/PgArrayParserEngineService.java

@@ -0,0 +1,26 @@
+package pgarrayparser;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.BasicLibraryService;
+
+import java.io.IOException;
+
+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/lib/pg_array_parser.rb

@@ -0,0 +1,25 @@
+require File.expand_path('../pg_array_parser/version', __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
+  begin
+    require 'pg_array_parser/pg_array_parser'
+  rescue LoadError
+    begin
+      require "pg_array_parser/pg_array_parser.#{RbConfig::CONFIG['DLEXT']}"
+    rescue LoadError
+      require "pg_array_parser.#{RbConfig::CONFIG['DLEXT']}"
+    end
+  end
+end
+

data/lib/pg_array_parser/version.rb

@@ -0,0 +1,3 @@
+module PgArrayParser
+  VERSION = '0.0.8'
+end

data/pg_array_parser.gemspec

@@ -0,0 +1,40 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/pg_array_parser/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Dan McClain"]
+  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      = "https://github.com/dockyard/pg_array_parser"
+
+  gem.files         = [ 'CHANGELOG.md',
+                        'Gemfile',
+                        'README.md',
+                        'Rakefile',
+                        'lib/pg_array_parser.rb',
+                        'lib/pg_array_parser/version.rb',
+                        'pg_array_parser.gemspec',
+                        'spec/parser_spec.rb',
+                        'spec/spec_helper.rb'
+                      ]
+
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  if RUBY_PLATFORM =~ /java/
+    gem.platform = 'java'
+    gem.files << 'ext/pg_array_parser/PgArrayParserEngine.java'
+    gem.files << 'ext/pg_array_parser/PgArrayParserEngineService.java'
+    gem.files << 'lib/pg_array_parser.jar'
+  else
+    gem.files << 'ext/pg_array_parser/pg_array_parser.c'
+    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.11.0'
+  gem.add_development_dependency 'rake', '~> 0.9.2.2'
+  gem.add_development_dependency 'rake-compiler'
+end

data/spec/parser_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+class Parser
+  include PgArrayParser
+end
+
+describe 'PgArrayParser' do
+  let!(:parser) { Parser.new }
+
+  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']
+        end
+      end
+
+      context 'NULL values' do
+        it 'returns an array of strings, with nils replacing NULL characters' do
+          parser.parse_pg_array(%[{1,NULL,NULL}]).should eq ['1',nil,nil]
+        end
+      end
+
+      context 'quoted NULL' do
+        it 'returns an array with the word NULL' do
+          parser.parse_pg_array(%[{1,"NULL",3}]).should eq ['1','NULL','3']
+        end
+      end
+
+      context 'strings' do
+        it 'returns an array of strings when containing commas in a quoted string' 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 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
+
+        it 'returns an array containing empty strings' do
+          parser.parse_pg_array(%[{1,"",3,""}]).should eq ['1', '', '3', '']
+        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']
+        end
+      end
+      context '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']
+        end
+        it 'returns an array of strings with a sub array and a quoted }' do
+          parser.parse_pg_array(%[{1,{"2,}3",NULL},4}]).should eq ['1',['2,}3',nil],'4']
+        end
+        it 'returns an array of strings with a sub array and a quoted {' do
+          parser.parse_pg_array(%[{1,{"2,{3"},4}]).should eq ['1',['2,{3'],'4']
+        end
+        it 'returns an array of strings with a sub array and a quoted { and escaped quote' do
+          parser.parse_pg_array(%[{1,{"2\\",{3"},4}]).should eq ['1',['2",{3'],'4']
+        end
+        it 'returns an array of strings with a sub array with empty strings' do
+          parser.parse_pg_array(%[{1,{""},4,{""}}]).should eq ['1',[''],'4',['']]
+        end
+      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
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'pg_array_parser'

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: pg_array_parser
+version: !ruby/object:Gem::Version
+  prerelease:
+  version: 0.0.8
+platform: java
+authors:
+- Dan McClain
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2012-09-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.11.0
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.11.0
+    none: false
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2.2
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2.2
+    none: false
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  prerelease: false
+  type: :development
+description: Simple library to parse PostgreSQL arrays into a array of strings
+email:
+- git@danmcclain.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Gemfile
+- README.md
+- Rakefile
+- lib/pg_array_parser.rb
+- lib/pg_array_parser/version.rb
+- pg_array_parser.gemspec
+- spec/parser_spec.rb
+- spec/spec_helper.rb
+- ext/pg_array_parser/PgArrayParserEngine.java
+- ext/pg_array_parser/PgArrayParserEngineService.java
+- lib/pg_array_parser.jar
+homepage: https://github.com/dockyard/pg_array_parser
+licenses: []
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+requirements: []
+rubyforge_project:
+rubygems_version: 1.8.24
+signing_key:
+specification_version: 3
+summary: Converts PostgreSQL array strings into arrays of strings
+test_files:
+- spec/parser_spec.rb
+- spec/spec_helper.rb
+has_rdoc:
+...