activerecord-jdbc-adapter-ficoh 1.3.21-java

data/src/java/arjdbc/util/NumberUtils.java

@@ -0,0 +1,50 @@
+/*
+ * The MIT License
+ *
+ * Copyright 2015 Karol Bucek.
+ *
+ * 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.
+ */
+package arjdbc.util;
+
+import org.jruby.util.ByteList;
+
+/**
+ *
+ * @author kares
+ */
+public abstract class NumberUtils {
+
+    public static ByteList appendLong(final long value, final ByteList bytes) {
+        final String str = Long.toString(value);
+        for ( int i = 0; i < str.length(); i++ ) {
+            bytes.append( str.charAt(i) );
+        }
+        return bytes;
+    }
+
+    public static ByteList appendInteger(final int value, final ByteList bytes) {
+        final String str = Integer.toString(value);
+        for ( int i = 0; i < str.length(); i++ ) {
+            bytes.append( str.charAt(i) );
+        }
+        return bytes;
+    }
+
+}

data/src/java/arjdbc/util/ObjectSupport.java

@@ -0,0 +1,65 @@
+
+package arjdbc.util;
+
+import java.util.List;
+import org.jruby.Ruby;
+import org.jruby.RubyBasicObject;
+import org.jruby.RubyString;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.builtin.Variable;
+
+public abstract class ObjectSupport {
+
+    @SuppressWarnings("unchecked")
+    public static RubyString inspect(final RubyBasicObject self) {
+        return inspect(self, (List) self.getInstanceVariableList());
+    }
+
+    public static RubyString inspect(final RubyBasicObject self, final List<Variable> variableList) {
+        final Ruby runtime = self.getRuntime();
+        return RubyString.newString(runtime, inspect(runtime, self, variableList));
+    }
+
+    private static StringBuilder inspect(final Ruby runtime, final RubyBasicObject self,
+        final List<Variable> variableList) {
+        final StringBuilder part = new StringBuilder();
+        String cname = self.getMetaClass().getRealClass().getName();
+        part.append("#<").append(cname).append(":0x");
+        part.append(Integer.toHexString(System.identityHashCode(self)));
+
+        if (runtime.isInspecting(self)) {
+            /* 6:tags 16:addr 1:eos */
+            part.append(" ...>");
+            return part;
+        }
+        try {
+            runtime.registerInspecting(self);
+            final ThreadContext context = runtime.getCurrentContext();
+            return inspectObj(context, variableList, part);
+        } finally {
+            runtime.unregisterInspecting(self);
+        }
+    }
+
+    private static StringBuilder inspectObj(final ThreadContext context,
+        final List<Variable> variableList,
+        final StringBuilder part) {
+        String sep = "";
+
+        for ( final Variable ivar : variableList ) {
+            part.append(sep).append(' ').append( ivar.getName() ).append('=');
+            final Object ival = ivar.getValue();
+            if ( ival instanceof IRubyObject ) {
+                part.append( ((IRubyObject) ival).callMethod(context, "inspect") );
+            }
+            else { // allow the variable to come formatted (as is) already :
+                part.append( ival ); // ival == null ? "nil" : ival.toString()
+            }
+            sep = ",";
+        }
+        part.append('>');
+        return part;
+    }
+
+}

data/src/java/arjdbc/util/QuotingUtils.java

@@ -0,0 +1,139 @@
+/*
+ * The MIT License
+ *
+ * Copyright 2013 Karol Bucek.
+ *
+ * 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.
+ */
+package arjdbc.util;
+
+import org.jruby.RubyString;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
+
+/**
+ * Shared (common) quoting helpers.
+ *
+ * <br>
+ * NOTE: This is internal API !
+ * <br>
+ *
+ * @author kares
+ */
+public abstract class QuotingUtils {
+
+    public static final ByteList BYTES_0 = new ByteList(new byte[] { '0' }, false);
+
+    public static final ByteList BYTES_1 = new ByteList(new byte[] { '1' }, false);
+
+    // e.g. string.gsub("'", "''") -> quoteCharWith(string, '\'', '\'');
+    public static RubyString quoteCharWith(
+            final ThreadContext context,
+            final RubyString string,
+            final char value, final char quote) {
+        return quoteCharWith(context, string, value, quote, 0, 8);
+    }
+
+    @SuppressWarnings("deprecation")
+    public static RubyString quoteCharWith(
+            final ThreadContext context,
+            final RubyString string,
+            final char value, final char quote,
+            final int newOffset, final int newSizeDiff) {
+
+        final ByteList stringBytes = string.getByteList();
+        final byte[] bytes = stringBytes.unsafeBytes();
+        final int begin = stringBytes.getBegin();
+        final int realSize = stringBytes.getRealSize();
+
+        ByteList quotedBytes = null; int appendFrom = begin;
+        for ( int i = begin; i < begin + realSize; i++ ) {
+            if ( bytes[i] == value ) {
+                if ( quotedBytes == null ) {
+                    quotedBytes = new ByteList(
+                        new byte[realSize + newOffset + newSizeDiff],
+                        stringBytes.getEncoding(), false
+                    );
+                    quotedBytes.begin = newOffset;
+                    quotedBytes.realSize = 0;
+                }
+                quotedBytes.append(bytes, appendFrom, i - appendFrom);
+                quotedBytes.append(quote).append(value); // e.g. "'" => "''"
+                appendFrom = i + 1;
+            }
+        }
+        if ( quotedBytes != null ) { // append what's left in the end :
+            quotedBytes.append(bytes, appendFrom, begin + realSize - appendFrom);
+        }
+        else return string; // nothing changed, can return original
+
+        return context.runtime.newString(quotedBytes);
+    }
+
+    @SuppressWarnings("deprecation")
+    public static RubyString quoteCharAndDecorateWith(
+        final ThreadContext context, final RubyString string,
+        final char value, final char quote,
+        final byte prefix, final byte suffix) {
+
+        final ByteList str = string.getByteList();
+        final RubyString quotedString = // part.gsub('v', 'vv')
+            quoteCharWith(context, string, value, quote, 1, 4 + 1);
+        if ( quotedString == string ) {
+            final int realSize = str.getRealSize();
+            final ByteList quoted = new ByteList(
+                new byte[realSize + 2], string.getEncoding(), false
+            );
+            quoted.begin = 0; quoted.realSize = 0;
+            quoted.append(prefix);
+            quoted.append(str.unsafeBytes(), str.getBegin(), realSize);
+            quoted.append(suffix);
+            return context.runtime.newString(quoted);
+        }
+        // we got a new string with a reserve of 1 byte front and back :
+        final ByteList quoted = quotedString.getByteList();
+        quoted.begin = 0; // setBegin invalidates
+        quoted.bytes[0] = prefix; quoted.realSize++;
+        quoted.append(suffix);
+        return quotedString;
+    }
+
+    public static final ByteList BYTES_SINGLE_Q = new ByteList(new byte[] { '\'' }, false);
+    public static final ByteList BYTES_SINGLE_Q_x2 = new ByteList(new byte[] { '\'', '\'' }, false);
+
+    // string.gsub("'", "''") :
+    public static IRubyObject quoteSingleQuotesWithFallback(
+        final ThreadContext context, final IRubyObject string) {
+        // string.gsub("'", "''") :
+        if ( string instanceof RubyString ) {
+            final char single = '\'';
+            return quoteCharWith(context, (RubyString) string, single, single);
+        }
+        else { // ActiveSupport::Multibyte::Chars
+            return string.callMethod(context, "gsub",
+                new IRubyObject[] {
+                    context.runtime.newString(BYTES_SINGLE_Q),
+                    context.runtime.newString(BYTES_SINGLE_Q_x2)
+                }
+            );
+        }
+    }
+
+}

data/src/java/arjdbc/util/StringCache.java

@@ -0,0 +1,60 @@
+/*
+ * The MIT License
+ *
+ * Copyright 2014 Karol Bucek.
+ *
+ * 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.
+ */
+package arjdbc.util;
+
+import java.util.WeakHashMap;
+
+import org.jruby.Ruby;
+import org.jruby.RubyString;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.util.ByteList;
+
+/**
+ * Cache of _unicode_ strings.
+ *
+ * @author kares
+ */
+public final class StringCache {
+
+    final WeakHashMap<String, ByteList> cache = new WeakHashMap<String, ByteList>(64);
+
+    public RubyString get(final ThreadContext context, final String key) {
+        final ByteList bytes = cache.get(key);
+        if ( bytes == null ) return store(context, key);
+        final Ruby runtime = context.runtime;
+        return (RubyString) RubyString.newString(runtime, bytes).freeze(context);
+    }
+
+    private RubyString store(final ThreadContext context, final String key) {
+        final Ruby runtime = context.runtime;
+        final RubyString str = RubyString.newUnicodeString(runtime, key);
+        synchronized (cache) { cache.put(key, str.getByteList()); }
+        return (RubyString) str.freeze(context);
+    }
+
+    public void clear() {
+        cache.clear();
+    }
+
+}

data/src/java/arjdbc/util/StringHelper.java

@@ -0,0 +1,155 @@
+/*
+ * The MIT License
+ *
+ * Copyright 2014 Karol Bucek.
+ *
+ * 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.
+ */
+package arjdbc.util;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+import org.jcodings.Encoding;
+import org.jcodings.specific.UTF16BEEncoding;
+import org.jcodings.specific.UTF8Encoding;
+import org.jruby.Ruby;
+import org.jruby.RubyString;
+import org.jruby.util.ByteList;
+
+/**
+ * Some (Ruby) byte string helpers.
+ *
+ * @author kares
+ */
+public abstract class StringHelper {
+
+    public static byte decByte(final int digit) {
+        switch (digit) {
+            case 0 : return '0';
+            case 1 : return '1';
+            case 2 : return '2';
+            case 3 : return '3';
+            case 4 : return '4';
+            case 5 : return '5';
+            case 6 : return '6';
+            case 7 : return '7';
+            case 8 : return '8';
+            case 9 : return '9';
+        }
+        throw new IllegalStateException("unexpected digit: " + digit);
+    }
+
+    public static RubyString newString(final Ruby runtime, final CharSequence str) {
+        return new RubyString(runtime, runtime.getString(), str, UTF8Encoding.INSTANCE);
+    }
+
+    public static RubyString newString(final Ruby runtime, final byte[] bytes) {
+        final ByteList byteList = new ByteList(bytes, false);
+        return new RubyString(runtime, runtime.getString(), byteList);
+    }
+
+    public static RubyString newUTF8String(final Ruby runtime, final byte[] bytes) {
+        final ByteList byteList = new ByteList(bytes, false);
+        return new RubyString(runtime, runtime.getString(), byteList, UTF8Encoding.INSTANCE);
+    }
+
+    public static RubyString newUTF8String(final Ruby runtime, final CharSequence str) {
+        return new RubyString(runtime, runtime.getString(), str, UTF8Encoding.INSTANCE);
+    }
+
+    public static RubyString newEmptyUTF8String(final Ruby runtime) {
+        return newUTF8String(runtime, ByteList.NULL_ARRAY);
+    }
+
+    public static RubyString newUnicodeString(final Ruby runtime, final CharSequence str) {
+        Encoding defaultInternal = runtime.getDefaultInternalEncoding();
+        if (defaultInternal == UTF16BEEncoding.INSTANCE) {
+            return RubyString.newUTF16String(runtime, str);
+        }
+        return newUTF8String(runtime, str);
+    }
+
+    public static int readBytes(final ByteList output, final InputStream input)
+        throws IOException {
+        @SuppressWarnings("deprecation") // capacity :
+        final int buffSize = output.bytes.length - output.begin;
+        return readBytes(output, input, buffSize);
+    }
+
+    public static int readBytes(final ByteList output, final InputStream input, int buffSize)
+        throws IOException {
+        int read = 0;
+        while ( true ) {
+            output.ensure( output.getRealSize() + buffSize );
+            final int begin = output.getBegin();
+            final int size = output.getRealSize();
+            int n = input.read(output.unsafeBytes(), begin + size, buffSize);
+            if ( n == -1 ) break;
+            output.setRealSize( size + n ); read += n;
+        }
+        return read;
+    }
+
+    public static boolean startsWithIgnoreCase(final ByteList bytes, final byte[] start) {
+        int p = nonWhitespaceIndex(bytes, bytes.getBegin());
+        final byte[] stringBytes = bytes.unsafeBytes();
+        if ( stringBytes[p] == '(' ) {
+            p = nonWhitespaceIndex(bytes, p + 1);
+        }
+
+        for ( int i = 0; i < bytes.getRealSize() && i < start.length; i++ ) {
+            if ( Character.toLowerCase(stringBytes[p + i]) != start[i] ) return false;
+        }
+        return true;
+    }
+
+    public static int nonWhitespaceIndex(final ByteList string, final int off) {
+        final int end = string.getBegin() + string.getRealSize();
+        final byte[] stringBytes = string.unsafeBytes();
+        for ( int i = off; i < end; i++ ) {
+            if ( ! Character.isWhitespace( stringBytes[i] ) ) return i;
+        }
+        return end;
+    }
+
+    @SuppressWarnings("deprecation")
+    private static int nonSpaceIndex(final byte[] str, int beg, int len) {
+        for ( int i = beg; i < len; i++ ) {
+            if ( ! Character.isSpace( (char) str[i] ) ) return i;
+        }
+        return len;
+    }
+
+    private static int nonDigitIndex(final byte[] str, int beg, int len) {
+        for ( int i = beg; i < len; i++ ) {
+            if ( ! Character.isDigit( (char) str[i] ) ) return i;
+        }
+        return len;
+    }
+
+    private static int extractIntValue(final byte[] str, int beg, int end) {
+        int n = 0;
+        for ( int i = beg; i < end; i++ ) {
+            n = 10 * n + ( str[i] - '0' );
+        }
+        return n;
+    }
+
+}