ivanvc-logstash-input-s3 3.1.1.2

data/vendor/local/gems/jrjackson-0.4.2-java/src/main/java/com/jrjackson/SajParse.java

@@ -0,0 +1,169 @@
+package com.jrjackson;
+
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.JsonStreamContext;
+import com.fasterxml.jackson.core.JsonLocation;
+
+import java.io.IOException;
+
+import org.jruby.internal.runtime.methods.DynamicMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.exceptions.RaiseException;
+
+/**
+ *
+ * @author Guy Boertje
+ */
+public class SajParse extends StreamParse {
+    
+    protected DynamicMethod _error;
+    protected boolean _no_error;
+
+    public SajParse(ThreadContext ctx, IRubyObject handler)
+            throws RaiseException {
+        super(ctx, handler);
+        
+        if (_no_add_value) {
+            throw ParseError.newParseError(_ruby, "Handler does not implement public API");
+        }        
+        _error = _meta.searchMethod("error");
+        _no_error = _error.isUndefined();
+    
+    }
+    
+    @Override
+    public IRubyObject deserialize(JsonParser jp) {
+
+        try {
+            while(jp.nextValue() != null) {
+                handleCurrentToken(jp);
+            }
+        }
+        catch (JsonProcessingException e) {
+            if(!_no_error) {
+                JsonLocation location = e.getLocation();
+                IRubyObject message = RubyUtils.rubyString(_ruby, e.getMessage());
+                IRubyObject line = RubyUtils.rubyFixnum(_ruby, location.getLineNr());
+                IRubyObject column = RubyUtils.rubyFixnum(_ruby, location.getColumnNr());
+                
+                _error.call(_ctx, _handler, _meta, "error", message, line, column);
+            }
+        }
+        catch (IOException e) {
+            if(!_no_error) {
+                IRubyObject message = RubyUtils.rubyString(_ruby, e.getMessage());
+                IRubyObject line = RubyUtils.rubyFixnum(_ruby, 1);
+                IRubyObject column = RubyUtils.rubyFixnum(_ruby, 1);
+                
+                _error.call(_ctx, _handler, _meta, "error", message, line, column);
+            }
+        }
+
+        return _ctx.nil;
+    }
+    
+    private void callAddValue(IRubyObject val, IRubyObject key) {
+        _add_value.call(_ctx, _handler, _meta, "add_value", val, key);
+    }
+    
+    private IRubyObject getParentName(JsonStreamContext x) {
+        String parentName = x.getCurrentName();
+        IRubyObject parent = _ctx.nil;
+        
+        if (!x.inRoot()) {
+            parentName = x.getParent().getCurrentName();
+        }
+        if (parentName != null) {
+            parent = RubyUtils.rubyString(_ruby, parentName);
+        }
+        return parent;
+    }
+    
+    private IRubyObject getFieldName(JsonStreamContext x) {
+        String currentName = x.getCurrentName();
+        IRubyObject name = _ctx.nil;
+
+        if (currentName != null) {
+            name = RubyUtils.rubyString(_ruby, currentName);
+        }
+        return name;
+    }
+    
+    private void handleCurrentToken(JsonParser jp)
+            throws IOException, JsonProcessingException {
+        
+        JsonStreamContext cx = jp.getParsingContext();
+  
+        IRubyObject value;
+        
+        switch (jp.getCurrentToken()) {
+            case START_OBJECT:
+                if (!_no_hash_start) {
+                    _hash_start.call(_ctx, _handler, _meta, "hash_start", getParentName(cx));
+                }
+                break;
+                
+            case START_ARRAY:
+                if (!_no_array_start) {
+                    _array_start.call(_ctx, _handler, _meta, "array_start", getParentName(cx));
+                }
+                break;
+
+            case FIELD_NAME:
+                break;
+                
+            case VALUE_EMBEDDED_OBJECT:
+                value = RubyUtils.rubyObject(_ruby, jp.getEmbeddedObject());
+                callAddValue(value, getFieldName(cx));
+                break;
+                
+            case VALUE_STRING:
+                value = keyConverter.convert(_ruby, jp);
+                callAddValue(value, getFieldName(cx));
+                break;
+                
+            case VALUE_NUMBER_INT:
+                /* [JACKSON-100]: caller may want to get all integral values
+                * returned as BigInteger, for consistency
+                */
+                JsonParser.NumberType numberType = jp.getNumberType();
+                value = RubyUtils.rubyBignum(_ruby, jp.getBigIntegerValue());
+                callAddValue(value, getFieldName(cx));
+                break;
+                
+            case VALUE_NUMBER_FLOAT:
+                value = RubyUtils.rubyBigDecimal(_ruby, jp.getDecimalValue());
+                callAddValue(value, getFieldName(cx));
+                break;
+                
+            case VALUE_TRUE:
+                value = _ruby.newBoolean(Boolean.TRUE);
+                callAddValue(value, getFieldName(cx));
+                break;
+                
+            case VALUE_FALSE:
+                value = _ruby.newBoolean(Boolean.FALSE);
+                callAddValue(value, getFieldName(cx));
+                break;
+                
+            case VALUE_NULL: // should not get this but...
+                value = _ctx.nil;
+                callAddValue(value, getFieldName(cx));
+                break;
+               
+            case END_ARRAY:
+                if (!_no_array_end) {
+                    _array_end.call(_ctx, _handler, _meta, "array_end", getFieldName(cx));
+                }
+                break;
+                
+            case END_OBJECT:
+                if (!_no_hash_end) {
+                    _hash_end.call(_ctx, _handler, _meta, "hash_end", getFieldName(cx));
+                }
+                break;
+        }
+    }
+}

data/vendor/local/gems/jrjackson-0.4.2-java/src/main/java/com/jrjackson/SchParse.java

@@ -0,0 +1,209 @@
+package com.jrjackson;
+
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.JsonStreamContext;
+import java.io.IOException;
+import java.util.HashMap;
+
+import org.jruby.internal.runtime.methods.DynamicMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.RubyString;
+import org.jruby.exceptions.RaiseException;
+
+/**
+ *
+ * @author Guy Boertje
+ */
+public class SchParse  extends StreamParse {
+
+    protected final DynamicMethod _hash_key;
+    protected final boolean _no_hash_key;
+    
+    protected final DynamicMethod _hash_set;
+    protected final boolean _no_hash_set;
+    
+    protected final DynamicMethod _array_append;
+    protected final boolean _no_array_append;
+    
+    protected final HashMap<JsonStreamContext, IRubyObject> _objectMap = new HashMap<JsonStreamContext, IRubyObject>();
+    protected JsonStreamContext _deepestContext;
+    
+    public SchParse(ThreadContext ctx, IRubyObject handler)
+            throws RaiseException {
+        super(ctx, handler);
+        
+        _hash_key = _meta.searchMethod("hash_key");
+        _no_hash_key = _hash_key.isUndefined();
+        
+        _hash_set = _meta.searchMethod("hash_set");
+        _no_hash_set = _hash_set.isUndefined();
+
+        _array_append = _meta.searchMethod("array_append");
+        _no_array_append = _array_append.isUndefined();
+        
+        //_hash_key is optional
+        if (
+            _no_hash_start || _no_hash_end ||
+            _no_array_start || _no_array_end ||
+            _no_add_value || _no_hash_set || _no_array_append
+        ) {
+            throw ParseError.newParseError(_ruby, "Handler does not implement public API");
+        }
+    }
+
+    @Override
+    public IRubyObject deserialize(JsonParser jp) throws RaiseException {
+        try {
+            
+            while (jp.nextValue() != null) {
+                handleCurrentToken(jp);
+            }
+            return _ctx.nil;
+            
+        } catch (JsonProcessingException e) {
+            throw ParseError.newParseError(_ruby, e.getLocalizedMessage());
+        } catch (IOException e) {
+            throw _ruby.newIOError(e.getLocalizedMessage());
+        }
+    }
+
+    private void callAddValue(JsonStreamContext x) {
+        JsonStreamContext px = x.getParent();
+        IRubyObject target = _objectMap.get(x);
+        IRubyObject dtarget = _objectMap.get(_deepestContext);
+
+        if (px == null) {
+            _add_value.call(_ctx, _handler, _meta, "add_value", dtarget);
+            return;
+        }
+        
+        if (x.inArray()) {
+            _array_append.call(_ctx, _handler, _meta, "array_append", target, dtarget);
+        } else if (x.inObject()) {
+            IRubyObject treatedKey = callHashKey(x);
+            _hash_set.call(_ctx, _handler, _meta, "hash_set", target, treatedKey, dtarget);
+        } else {
+            _add_value.call(_ctx, _handler, _meta, "add_value", target);
+        }
+    }
+
+    private void callAddValue(JsonStreamContext x, IRubyObject val) {
+        IRubyObject target = _objectMap.get(x);
+
+        if (x.inArray()) {
+            _array_append.call(_ctx, _handler, _meta, "array_append", target, val);
+        } else if (x.inObject()) {
+            IRubyObject treatedKey = callHashKey(x);
+            _hash_set.call(_ctx, _handler, _meta, "hash_set", target, treatedKey, val);
+        } else {
+            _add_value.call(_ctx, _handler, _meta, "add_value", val);
+        }
+    }
+    
+    private IRubyObject callHashKey(JsonStreamContext x) {
+        String k = x.getCurrentName();
+        if (k == null) {
+            return _ctx.nil;
+        }
+        RubyString key =  RubyUtils.rubyString(_ruby, k);
+        if (_no_hash_key) {
+            return key;
+        }
+        return _hash_key.call(_ctx, _handler, _meta, "hash_key", key);
+    }
+
+    private void handleCurrentToken(JsonParser jp)
+            throws IOException, JsonProcessingException {
+        
+        JsonStreamContext cx = jp.getParsingContext();
+        IRubyObject value;
+        IRubyObject rubyObject;
+
+        switch (jp.getCurrentToken()) {
+            case START_OBJECT:
+                _deepestContext = cx;
+                rubyObject = _hash_start.call(_ctx, _handler, _meta, "hash_start");
+                _objectMap.put(cx, rubyObject);
+                break;
+
+            case START_ARRAY:
+                _deepestContext = cx;
+                rubyObject = _array_start.call(_ctx, _handler, _meta, "array_start");
+                _objectMap.put(cx, rubyObject);
+                break;
+
+            case FIELD_NAME:
+                break;
+
+            case VALUE_EMBEDDED_OBJECT:
+                value = RubyUtils.rubyObject(_ruby, jp.getEmbeddedObject());
+                callAddValue(cx, value);
+                break;
+
+            case VALUE_STRING:
+                value = keyConverter.convert(_ruby, jp);
+                callAddValue(cx, value);
+                break;
+
+            case VALUE_NUMBER_INT:
+                /* [JACKSON-100]: caller may want to get all integral values
+                 * returned as BigInteger, for consistency
+                 */
+                JsonParser.NumberType numberType = jp.getNumberType();
+                value = RubyUtils.rubyBignum(_ruby, jp.getBigIntegerValue());
+                callAddValue(cx, value);
+                break;
+
+            case VALUE_NUMBER_FLOAT:
+                value = RubyUtils.rubyBigDecimal(_ruby, jp.getDecimalValue());
+                callAddValue(cx, value);
+                break;
+
+            case VALUE_TRUE:
+                value = _ruby.newBoolean(Boolean.TRUE);
+                callAddValue(cx, value);
+                break;
+
+            case VALUE_FALSE:
+                value = _ruby.newBoolean(Boolean.FALSE);
+                callAddValue(cx, value);
+                break;
+
+            case VALUE_NULL: // should not get this but...
+                value = _ctx.nil;
+                callAddValue(cx, value);
+                break;
+
+            case END_ARRAY:
+                _array_end.call(_ctx, _handler, _meta, "array_end");
+                callAddValue(cx);
+                _deepestContext = cx;
+                break;
+
+            case END_OBJECT:
+                _hash_end.call(_ctx, _handler, _meta, "hash_end");
+                callAddValue(cx);
+                _deepestContext = cx;
+                break;
+        }
+        
+    }
+    
+}
+//        System.out.println("--- addRubyValue final ---");
+//        if (px != null) {
+//            System.out.println("-------- parent --------");
+//            System.out.println(px.getTypeDesc());
+//            System.out.println(px.getCurrentName());
+//        }
+//        System.out.println("-------- current --------");
+//        System.out.println(x.getTypeDesc());
+//        System.out.println(x.getCurrentName());
+//        System.out.println(target);
+//        
+//        System.out.println("-------- deepest --------");
+//        System.out.println(_deepestContext.getTypeDesc());
+//        System.out.println(_deepestContext.getCurrentName());
+//        System.out.println(dtarget);

data/vendor/local/gems/jrjackson-0.4.2-java/src/main/java/com/jrjackson/StreamParse.java

@@ -0,0 +1,66 @@
+package com.jrjackson;
+
+import com.fasterxml.jackson.core.JsonParser;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.internal.runtime.methods.DynamicMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.exceptions.RaiseException;
+
+/**
+ *
+ * @author Guy Boertje
+ */
+public abstract class StreamParse {
+
+    protected final ThreadContext _ctx;
+    protected final Ruby _ruby;
+    protected final IRubyObject _handler;
+    protected final RubyClass _meta;
+    protected final RubyStringConverter keyConverter = new RubyStringConverter();
+    
+    protected final DynamicMethod _hash_start;
+    protected final boolean _no_hash_start;
+
+    protected final DynamicMethod _hash_end;
+    protected final boolean _no_hash_end;
+
+    protected final DynamicMethod _array_start;
+    protected final boolean _no_array_start;
+
+    protected final DynamicMethod _array_end;
+    protected final boolean _no_array_end;
+    
+    protected final DynamicMethod _add_value;
+    protected final boolean _no_add_value;
+
+    public StreamParse(ThreadContext ctx, IRubyObject handler)
+            throws RaiseException {
+
+        _ctx = ctx;
+        _ruby = ctx.runtime;
+        _handler = handler;
+        _meta = _handler.getMetaClass();
+        
+        _add_value = _meta.searchMethod("add_value");
+        _no_add_value = _add_value.isUndefined();
+
+        _hash_start = _meta.searchMethod("hash_start");
+        _no_hash_start = _hash_start.isUndefined();
+
+        _hash_end = _meta.searchMethod("hash_end");
+        _no_hash_end = _hash_end.isUndefined();
+
+        _array_start = _meta.searchMethod("array_start");
+        _no_array_start = _array_start.isUndefined();
+
+        _array_end = _meta.searchMethod("array_end");
+        _no_array_end = _array_end.isUndefined();
+
+    }
+    
+    public abstract IRubyObject deserialize(JsonParser jp) 
+            throws RaiseException;
+}

data/vendor/local/gems/jrjackson-0.4.2-java/src/test/java/com/jrjackson/RubyAnySerializerTest.java

@@ -0,0 +1,56 @@
+package com.jrjackson;
+
+import com.fasterxml.jackson.core.JsonEncoding;
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.databind.SerializerProvider;
+import org.jcodings.specific.UTF8Encoding;
+import org.jruby.CompatVersion;
+import org.jruby.Ruby;
+import org.jruby.RubyHash;
+import org.jruby.RubyInstanceConfig;
+import org.jruby.ext.bigdecimal.RubyBigDecimal;
+import org.jruby.util.ByteList;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.ByteArrayOutputStream;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+public class RubyAnySerializerTest {
+    private static boolean setupDone = false;
+    public static Ruby ruby;
+
+    @Before
+    public void setUp() throws Exception {
+        if (setupDone) return;
+
+        RubyInstanceConfig config_19 = new RubyInstanceConfig();
+        config_19.setCompatVersion(CompatVersion.RUBY1_9);
+        ruby = Ruby.newInstance(config_19);
+        RubyBigDecimal.createBigDecimal(ruby); // we need to do 'require "bigdecimal"'
+//        JrubyTimestampExtLibrary.createTimestamp(ruby);
+        setupDone = true;
+    }
+
+
+    @Test
+    public void testSerialize() throws Exception {
+        RubyHash rh = RubyHash.newHash(ruby);
+        rh.put("somekey", 123);
+
+        SerializerProvider provider = RubyJacksonModule.createProvider();
+
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        JsonGenerator jgen = RubyJacksonModule.factory.createGenerator(
+                baos, JsonEncoding.UTF8);
+
+        RubyAnySerializer.instance.serialize(rh, jgen, provider);
+        jgen.close();
+        ByteList bl = new ByteList(baos.toByteArray(),
+                UTF8Encoding.INSTANCE);
+        assertThat(bl.toString(), is(equalTo("{\"somekey\":123}")));
+    }
+}