cipherstash-pg 1.0.0.beta.1-x86_64-linux → 1.0.0.beta.4-x86_64-linux

data/lib/cipherstash-pg/connection.rb

@@ -0,0 +1,467 @@
+require("cipherstash-pg") unless defined? CipherStashPG
+require("uri")
+require("io/wait")
+require("socket")
+class CipherStashPG::Connection
+  CONNECT_ARGUMENT_ORDER = ["host", "port", "options", "tty", "dbname", "user", "password"]
+  
+  def self.quote_connstr(value)
+    return (("'" + value.to_s.gsub(/[\\']/) { |m| ("\\" + m) }) + "'")
+  end
+  
+  def self.connect_hash_to_string(hash)
+    hash.map { |k, v| "#{k}=#{quote_connstr(v)}" }.join(" ")
+  end
+  
+  def self.parse_connect_args(*args)
+    hash_arg = args.last.is_a?(Hash) ? (args.pop.transform_keys(&:to_sym)) : ({})
+    iopts = {}
+    if (args.length == 1) then
+      case args.first
+      when URI, /=/, /:\/\// then
+        conn_string = args.first.to_s
+        iopts = CipherStashPG::Connection.conninfo_parse(conn_string).each_with_object({}) do |h, o|
+          o[h[:keyword].to_sym] = h[:val] if h[:val]
+        end
+      else
+        iopts[CONNECT_ARGUMENT_ORDER.first.to_sym] = args.first
+      end
+    else
+      max = CONNECT_ARGUMENT_ORDER.length
+      if (args.length > max) then
+        raise(ArgumentError, ("Extra positional parameter %d: %p" % [(max + 1), args[max]]))
+      end
+      CONNECT_ARGUMENT_ORDER.zip(args) { |(k, v)| iopts[k.to_sym] = v if v }
+      iopts.delete(:tty)
+    end
+    iopts.merge!(hash_arg)
+    unless iopts[:fallback_application_name] then
+      iopts[:fallback_application_name] = $0.sub(/^(.{30}).{4,}(.{30})$/) { (($1 + "...") + $2) }
+    end
+    return connect_hash_to_string(iopts)
+  end
+  
+  def inspect
+    str = self.to_s
+    str[-1, 0] = if finished? then
+      " finished"
+    else
+      stats = []
+      if (status != CONNECTION_OK) then
+        (stats << " status=#{CipherStashPG.constants.grep(/CONNECTION_/).find do |c|
+          (CipherStashPG.const_get(c) == status)
+        end}")
+      end
+      if (transaction_status != CipherStashPG::PQTRANS_IDLE) then
+        (stats << " transaction_status=#{CipherStashPG.constants.grep(/PQTRANS_/).find do |c|
+          (CipherStashPG.const_get(c) == transaction_status)
+        end}")
+      end
+      (stats << " nonblocking=#{isnonblocking}") if isnonblocking
+      if respond_to?(:pipeline_status) and (pipeline_status != CipherStashPG::PQ_PIPELINE_OFF) then
+        (stats << " pipeline_status=#{CipherStashPG.constants.grep(/PQ_PIPELINE_/).find do |c|
+          (CipherStashPG.const_get(c) == pipeline_status)
+        end}")
+      end
+      if (get_client_encoding != "UTF8") then
+        (stats << " client_encoding=#{get_client_encoding}")
+      end
+      unless type_map_for_results.is_a?(CipherStashPG::TypeMapAllStrings) then
+        (stats << " type_map_for_results=#{type_map_for_results.to_s}")
+      end
+      unless type_map_for_queries.is_a?(CipherStashPG::TypeMapAllStrings) then
+        (stats << " type_map_for_queries=#{type_map_for_queries.to_s}")
+      end
+      if encoder_for_put_copy_data then
+        (stats << " encoder_for_put_copy_data=#{encoder_for_put_copy_data.to_s}")
+      end
+      if decoder_for_get_copy_data then
+        (stats << " decoder_for_get_copy_data=#{decoder_for_get_copy_data.to_s}")
+      end
+      " host=#{host} port=#{port} user=#{user}#{stats.join}"
+    end
+    return str
+  end
+  
+  def copy_data(sql, coder = nil)
+    if nonblocking? then
+      raise(CipherStashPG::NotInBlockingMode.new("copy_data can not be used in nonblocking mode", :connection => (self)))
+    end
+    res = exec(sql)
+    case res.result_status
+    when PGRES_COPY_IN then
+      begin
+        (if coder then
+          old_coder = self.encoder_for_put_copy_data
+          self.encoder_for_put_copy_data = coder
+        end
+        yield(res))
+      rescue Exception => err
+        errmsg = ("%s while copy data: %s" % [err.class.name, err.message])
+        begin
+          put_copy_end(errmsg)
+        rescue CipherStashPG::Error
+          # do nothing
+        end
+        discard_results
+        raise(err)
+      else
+        (begin
+          put_copy_end
+        rescue CipherStashPG::Error => err
+          raise(CipherStashPG::LostCopyState.new("#{err} (probably by executing another SQL query while running a COPY command)", :connection => (self)))
+        end
+        get_last_result)
+      ensure
+        self.encoder_for_put_copy_data = old_coder if coder
+      end
+    when PGRES_COPY_OUT then
+      begin
+        (if coder then
+          old_coder = self.decoder_for_get_copy_data
+          self.decoder_for_get_copy_data = coder
+        end
+        yield(res))
+      rescue Exception
+        cancel
+        discard_results
+        raise
+      else
+        (res = get_last_result
+        if res then
+          if (res.result_status != PGRES_COMMAND_OK) then
+            discard_results
+            raise(CipherStashPG::NotAllCopyDataRetrieved.new("Not all COPY data retrieved", :connection => (self)))
+          end
+        else
+          discard_results
+          raise(CipherStashPG::LostCopyState.new("Lost COPY state (probably by executing another SQL query while running a COPY command)", :connection => (self)))
+        end
+        res)
+      ensure
+        self.decoder_for_get_copy_data = old_coder if coder
+      end
+    else
+      raise(ArgumentError, "SQL command is no COPY statement: #{sql}")
+    end
+  end
+  
+  class << self
+    define_method(:isthreadsafe, &CipherStashPG.method(:isthreadsafe))
+  end
+  
+  def transaction
+    (rollback = false
+    exec("BEGIN")
+    yield(self))
+  rescue Exception
+    rollback = true
+    cancel if (transaction_status == CipherStashPG::PQTRANS_ACTIVE)
+    block
+    exec("ROLLBACK")
+    raise
+  ensure
+    exec("COMMIT") unless rollback
+  end
+  
+  def conndefaults
+    return self.class.conndefaults
+  end
+  
+  def self.conndefaults_hash
+    return self.conndefaults.each_with_object({}) do |info, hash|
+      hash[info[:keyword].to_sym] = info[:val]
+    end
+  end
+  
+  def conndefaults_hash
+    return self.class.conndefaults_hash
+  end
+  
+  def conninfo_hash
+    return self.conninfo.each_with_object({}) do |info, hash|
+      hash[info[:keyword].to_sym] = info[:val]
+    end
+  end
+  
+  if self.instance_methods.find { |m| (m.to_sym == :ssl_attribute) } then
+    def ssl_attributes
+      ssl_attribute_names.each.with_object({}) { |n, h| h[n] = ssl_attribute(n) }
+    end
+  end
+  
+  def get_result
+    block
+    sync_get_result
+  end
+  
+  alias :async_get_result :get_result
+  
+  def get_copy_data(async = false, decoder = nil)
+    if async then
+      return sync_get_copy_data(async, decoder)
+    else
+      while ((res = sync_get_copy_data(true, decoder)) == false) do
+        socket_io.wait_readable
+        consume_input
+      end
+      return res
+    end
+  end
+  
+  alias :async_get_copy_data :get_copy_data
+  
+  def setnonblocking(enabled)
+    singleton_class.async_send_api = (not enabled)
+    self.flush_data = (not enabled)
+    sync_setnonblocking(true)
+  end
+  
+  alias :async_setnonblocking :setnonblocking
+  
+  def isnonblocking
+    false
+  end
+  
+  alias :async_isnonblocking :isnonblocking
+  
+  alias :nonblocking? :isnonblocking
+  
+  def put_copy_data(buffer, encoder = nil)
+    until res = sync_put_copy_data(buffer, encoder) do
+      res = flush
+    end
+    if (@calls_to_put_copy_data = (@calls_to_put_copy_data + 1) > 100) then
+      @calls_to_put_copy_data = 0
+      res = flush
+    end
+    res
+  end
+  
+  alias :async_put_copy_data :put_copy_data
+  
+  def put_copy_end(*args)
+    until sync_put_copy_end(*args) do
+      flush
+    end
+    @calls_to_put_copy_data = 0
+    flush
+  end
+  
+  alias :async_put_copy_end :put_copy_end
+  
+  if method_defined?(:sync_encrypt_password) then
+    def encrypt_password(password, username, algorithm = nil)
+      algorithm ||= exec("SHOW password_encryption").getvalue(0, 0)
+      sync_encrypt_password(password, username, algorithm)
+    end
+    (alias :async_encrypt_password :encrypt_password)
+  end
+  
+  def reset
+    reset_start
+    async_connect_or_reset(:reset_poll)
+    self
+  end
+  
+  alias :async_reset :reset
+  
+  def cancel
+    (be_pid = backend_pid
+    be_key = backend_key
+    cancel_request = [16, 1234, 5678, be_pid, be_key].pack("NnnNN")
+    if Fiber.respond_to?(:scheduler) and (Fiber.scheduler and RUBY_PLATFORM =~ /mingw|mswin/) then
+      cl = Thread.new(socket_io.remote_address) { |ra| ra.connect }.value
+      begin
+        cl.write_nonblock(cancel_request)
+      rescue IO::WaitReadable, Errno::EINTR
+        cl.wait_writable
+        retry
+      end
+      begin
+        cl.read_nonblock(1)
+      rescue IO::WaitReadable, Errno::EINTR
+        cl.wait_readable
+        retry
+      rescue EOFError
+        # do nothing
+      end
+    else
+      if (RUBY_ENGINE == "truffleruby") then
+        begin
+          cl = socket_io.remote_address.connect
+        rescue NotImplementedError
+          cl2 = Socket.for_fd(socket_io.fileno)
+          cl2.autoclose = false
+          adr = cl2.remote_address
+          if adr.ip? then
+            cl = TCPSocket.new(adr.ip_address, adr.ip_port)
+            cl.autoclose = false
+          else
+            cl = UNIXSocket.new(adr.unix_path)
+            cl.autoclose = false
+          end
+        end
+        cl.write(cancel_request)
+        cl.read(1)
+      else
+        cl = socket_io.remote_address.connect
+        cl.write(cancel_request)
+        cl.read(1)
+      end
+    end
+    cl.close
+    nil)
+  rescue SystemCallError => err
+    err.to_s
+  end
+  
+  alias :async_cancel :cancel
+  
+  private(def async_connect_or_reset(poll_meth)
+    if timeo = conninfo_hash[:connect_timeout].to_i and (timeo > 0) then
+      timeo = [timeo, 2].max
+      host_count = (conninfo_hash[:host].to_s.count(",") + 1)
+      stop_time = ((timeo * host_count) + Process.clock_gettime(Process::CLOCK_MONOTONIC))
+    end
+    poll_status = CipherStashPG::PGRES_POLLING_WRITING
+    until ((poll_status == CipherStashPG::PGRES_POLLING_OK) or (poll_status == CipherStashPG::PGRES_POLLING_FAILED)) do
+      (if stop_time then
+        timeout = [timeo, (stop_time - Process.clock_gettime(Process::CLOCK_MONOTONIC))].min
+      end
+      event = if ((not timeout) or (timeout >= 0)) then
+        case poll_status
+        when CipherStashPG::PGRES_POLLING_READING then
+          if defined? IO::READABLE then
+            socket_io.wait((IO::READABLE | IO::PRIORITY), timeout)
+          else
+            IO.select([socket_io], nil, [socket_io], timeout)
+          end
+        when CipherStashPG::PGRES_POLLING_WRITING then
+          if defined? IO::WRITABLE then
+            socket_io.wait((IO::WRITABLE | IO::PRIORITY), timeout)
+          else
+            IO.select(nil, [socket_io], [socket_io], timeout)
+          end
+        end
+      end
+      unless event then
+        if self.class.send(:host_is_named_pipe?, host) then
+          connhost = "on socket \"#{host}\""
+        else
+          if respond_to?(:hostaddr) then
+            connhost = "at \"#{host}\" (#{hostaddr}), port #{port}"
+          else
+            connhost = "at \"#{host}\", port #{port}"
+          end
+        end
+        raise(CipherStashPG::ConnectionBad.new("connection to server #{connhost} failed: timeout expired", :connection => (self)))
+      end
+      poll_status = send(poll_meth))
+    end
+    unless (status == CipherStashPG::CONNECTION_OK) then
+      msg = error_message
+      finish
+      raise(CipherStashPG::ConnectionBad.new(msg, :connection => (self)))
+    end
+    sync_setnonblocking(true)
+    self.flush_data = true
+    set_default_encoding
+  end)
+  
+  class << self
+    def new(*args)
+      conn = connect_to_hosts(*args)
+      if block_given? then
+        begin
+          return yield(conn)
+        ensure
+          conn.finish
+        end
+      end
+      conn
+    end
+    alias :async_connect :new
+    alias :connect :new
+    alias :open :new
+    alias :setdb :new
+    alias :setdblogin :new
+    private(def connect_to_hosts(*args)
+      option_string = parse_connect_args(*args)
+      iopts = CipherStashPG::Connection.conninfo_parse(option_string).each_with_object({}) do |h, o|
+        o[h[:keyword].to_sym] = h[:val] if h[:val]
+      end
+      iopts = CipherStashPG::Connection.conndefaults.each_with_object({}) do |h, o|
+        o[h[:keyword].to_sym] = h[:val] if h[:val]
+      end.merge(iopts)
+      unless iopts[:hostaddr] then
+        if iopts[:host] and ((not iopts[:host].empty?) and (CipherStashPG.library_version >= 100000)) then
+          ihosts = iopts[:host].split(",", -1)
+          iports = iopts[:port].split(",", -1)
+          iports = [nil] if (iports.size == 0)
+          iports = (iports * ihosts.size) if (iports.size == 1)
+          if (iports.size != ihosts.size) then
+            raise(CipherStashPG::ConnectionBad, "could not match #{iports.size} port numbers to #{ihosts.size} hosts")
+          end
+          dests = ihosts.each_with_index.flat_map do |mhost, idx|
+            if host_is_named_pipe?(mhost) then
+              hostaddrs = [nil]
+            else
+              if Fiber.respond_to?(:scheduler) and (Fiber.scheduler and (RUBY_VERSION < "3.1.")) then
+                hostaddrs = Thread.new do
+                  Addrinfo.getaddrinfo(mhost, nil, nil, :STREAM).map(&:ip_address) rescue [""]
+                end.value
+              else
+                hostaddrs = Addrinfo.getaddrinfo(mhost, nil, nil, :STREAM).map(&:ip_address) rescue [""]
+              end
+            end
+            hostaddrs.map { |hostaddr| [hostaddr, mhost, iports[idx]] }
+          end
+          iopts.merge!(:hostaddr => dests.map { |d| d[0] }.join(","), :host => dests.map { |d| d[1] }.join(","), :port => dests.map { |d| d[2] }.join(","))
+        end
+      end
+      (conn = self.connect_start(iopts) or raise(CipherStashPG::Error, "Unable to create a new connection"))
+      if (conn.status == CipherStashPG::CONNECTION_BAD) then
+        raise(CipherStashPG::ConnectionBad, conn.error_message)
+      end
+      conn.send(:async_connect_or_reset, :connect_poll)
+      conn
+    end)
+    private(def host_is_named_pipe?(host_string)
+      (host_string.empty? or (host_string.start_with?("/") or (host_string.start_with?("@") or (RUBY_PLATFORM =~ /mingw|mswin/ and host_string =~ /\A([\/\\]|\w:[\/\\])/))))
+    end)
+    def ping(*args)
+      if Fiber.respond_to?(:scheduler) and Fiber.scheduler then
+        Thread.new { sync_ping(*args) }.value
+      else
+        sync_ping(*args)
+      end
+    end
+    alias :async_ping :ping
+    REDIRECT_CLASS_METHODS = { :new => ([:async_connect, :sync_connect]), :connect => ([:async_connect, :sync_connect]), :open => ([:async_connect, :sync_connect]), :setdb => ([:async_connect, :sync_connect]), :setdblogin => ([:async_connect, :sync_connect]), :ping => ([:async_ping, :sync_ping]) }
+    REDIRECT_SEND_METHODS = { :isnonblocking => ([:async_isnonblocking, :sync_isnonblocking]), :nonblocking? => ([:async_isnonblocking, :sync_isnonblocking]), :put_copy_data => ([:async_put_copy_data, :sync_put_copy_data]), :put_copy_end => ([:async_put_copy_end, :sync_put_copy_end]), :flush => ([:async_flush, :sync_flush]) }
+    REDIRECT_METHODS = { :exec => ([:async_exec, :sync_exec]), :query => ([:async_exec, :sync_exec]), :exec_params => ([:async_exec_params, :sync_exec_params]), :prepare => ([:async_prepare, :sync_prepare]), :exec_prepared => ([:async_exec_prepared, :sync_exec_prepared]), :describe_portal => ([:async_describe_portal, :sync_describe_portal]), :describe_prepared => ([:async_describe_prepared, :sync_describe_prepared]), :setnonblocking => ([:async_setnonblocking, :sync_setnonblocking]), :get_result => ([:async_get_result, :sync_get_result]), :get_last_result => ([:async_get_last_result, :sync_get_last_result]), :get_copy_data => ([:async_get_copy_data, :sync_get_copy_data]), :reset => ([:async_reset, :sync_reset]), :set_client_encoding => ([:async_set_client_encoding, :sync_set_client_encoding]), :client_encoding= => ([:async_set_client_encoding, :sync_set_client_encoding]), :cancel => ([:async_cancel, :sync_cancel]) }
+    if CipherStashPG::Connection.instance_methods.include?(:async_encrypt_password) then
+      REDIRECT_METHODS.merge!(:encrypt_password => ([:async_encrypt_password, :sync_encrypt_password]))
+    end
+    def async_send_api=(enable)
+      REDIRECT_SEND_METHODS.each do |ali, (async, sync)|
+        undef_method(ali) if method_defined?(ali)
+        alias_method(ali, (enable ? (async) : (sync)))
+      end
+    end
+    def async_api=(enable)
+      self.async_send_api = enable
+      REDIRECT_METHODS.each do |ali, (async, sync)|
+        remove_method(ali) if method_defined?(ali)
+        alias_method(ali, (enable ? (async) : (sync)))
+      end
+      REDIRECT_CLASS_METHODS.each do |ali, (async, sync)|
+        singleton_class.remove_method(ali) if method_defined?(ali)
+        singleton_class.alias_method(ali, (enable ? (async) : (sync)))
+      end
+    end
+  end
+  
+  self.async_api = true
+end

data/lib/cipherstash-pg/constants.rb

@@ -0,0 +1,3 @@
+require("cipherstash-pg") unless defined? CipherStashPG
+module CipherStashPG::Constants
+end

data/lib/cipherstash-pg/exceptions.rb

@@ -0,0 +1,19 @@
+require("cipherstash-pg") unless defined? CipherStashPG
+module CipherStashPG
+  class Error < StandardError
+    def initialize(msg = nil, connection: nil, result: nil)
+      @connection = connection
+      @result = result
+      super(msg)
+    end
+  end
+  
+  class NotAllCopyDataRetrieved < CipherStashPG::Error
+  end
+  
+  class LostCopyState < CipherStashPG::Error
+  end
+  
+  class NotInBlockingMode < CipherStashPG::Error
+  end
+end

data/lib/cipherstash-pg/result.rb

@@ -0,0 +1,22 @@
+require("cipherstash-pg") unless defined? CipherStashPG
+class CipherStashPG::Result
+  def map_types!(type_map)
+    self.type_map = type_map
+    return self
+  end
+  
+  def field_names_as(type)
+    self.field_name_type = type
+    return self
+  end
+  
+  def inspect
+    str = self.to_s
+    str[-1, 0] = if cleared? then
+      " cleared"
+    else
+      " status=#{res_status(result_status)} ntuples=#{ntuples} nfields=#{nfields} cmd_tuples=#{cmd_tuples}"
+    end
+    return str
+  end
+end

data/lib/cipherstash-pg/text_decoder.rb

@@ -0,0 +1,43 @@
+require("date")
+require("json")
+module CipherStashPG
+  module TextDecoder
+    class Date < SimpleDecoder
+      def decode(string, tuple = nil, field = nil)
+        if string =~ /\A(\d{4})-(\d\d)-(\d\d)\z/ then
+          ::Date.new($1.to_i, $2.to_i, $3.to_i)
+        else
+          string
+        end
+      end
+    end
+    
+    class JSON < SimpleDecoder
+      def decode(string, tuple = nil, field = nil)
+        ::JSON.parse(string, :quirks_mode => true)
+      end
+    end
+    
+    class TimestampUtc < Timestamp
+      def initialize(params = {})
+        super(params.merge(:flags => (CipherStashPG::Coder::TIMESTAMP_DB_UTC | CipherStashPG::Coder::TIMESTAMP_APP_UTC)))
+      end
+    end
+    
+    class TimestampUtcToLocal < Timestamp
+      def initialize(params = {})
+        super(params.merge(:flags => (CipherStashPG::Coder::TIMESTAMP_DB_UTC | CipherStashPG::Coder::TIMESTAMP_APP_LOCAL)))
+      end
+    end
+    
+    class TimestampLocal < Timestamp
+      def initialize(params = {})
+        super(params.merge(:flags => (CipherStashPG::Coder::TIMESTAMP_DB_LOCAL | CipherStashPG::Coder::TIMESTAMP_APP_LOCAL)))
+      end
+    end
+    
+    TimestampWithoutTimeZone = TimestampLocal
+    
+    TimestampWithTimeZone = Timestamp
+  end
+end

data/lib/cipherstash-pg/text_encoder.rb

@@ -0,0 +1,67 @@
+require("json")
+require("ipaddr")
+module CipherStashPG
+  module TextEncoder
+    class Date < SimpleEncoder
+      def encode(value)
+        value.respond_to?(:strftime) ? (value.strftime("%Y-%m-%d")) : (value)
+      end
+    end
+    
+    class TimestampWithoutTimeZone < SimpleEncoder
+      def encode(value)
+        if value.respond_to?(:strftime) then
+          value.strftime("%Y-%m-%d %H:%M:%S.%N")
+        else
+          value
+        end
+      end
+    end
+    
+    class TimestampUtc < SimpleEncoder
+      def encode(value)
+        if value.respond_to?(:utc) then
+          value.utc.strftime("%Y-%m-%d %H:%M:%S.%N")
+        else
+          value
+        end
+      end
+    end
+    
+    class TimestampWithTimeZone < SimpleEncoder
+      def encode(value)
+        if value.respond_to?(:strftime) then
+          value.strftime("%Y-%m-%d %H:%M:%S.%N %:z")
+        else
+          value
+        end
+      end
+    end
+    
+    class JSON < SimpleEncoder
+      def encode(value)
+        ::JSON.generate(value, :quirks_mode => true)
+      end
+    end
+    
+    class Inet < SimpleEncoder
+      def encode(value)
+        case value
+        when IPAddr then
+          default_prefix = (value.family == Socket::AF_INET) ? (32) : (128)
+          s = value.to_s
+          if value.respond_to?(:prefix) then
+            prefix = value.prefix
+          else
+            range = value.to_range
+            prefix = (default_prefix - Math.log(((range.end.to_i - range.begin.to_i) + 1), 2).to_i)
+          end
+          ((s << "/") << prefix.to_s) if (prefix != default_prefix)
+          s
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/cipherstash-pg/tuple.rb

@@ -0,0 +1,24 @@
+require("cipherstash-pg") unless defined? CipherStashPG
+class CipherStashPG::Tuple
+  def inspect
+    "#<#{self.class} #{self.map { |k, v| "#{k}: #{v.inspect}" }.join(", ")}>"
+  end
+  
+  def has_key?(key)
+    field_map.has_key?(key)
+  end
+  
+  alias :key? :has_key?
+  
+  def keys
+    (field_names or field_map.keys.freeze)
+  end
+  
+  def each_key(&block)
+    if fn = field_names then
+      fn.each(&block)
+    else
+      field_map.each_key(&block)
+    end
+  end
+end

data/lib/cipherstash-pg/type_map_by_column.rb

@@ -0,0 +1,11 @@
+require("cipherstash-pg") unless defined? CipherStashPG
+class CipherStashPG::TypeMapByColumn
+  def oids
+    coders.map { |c| c.oid if c }
+  end
+  
+  def inspect
+    type_strings = coders.map { |c| c ? (c.inspect_short) : ("nil") }
+    "#<#{self.class} #{type_strings.join(" ")}>"
+  end
+end

data/lib/cipherstash-pg/version.rb

@@ -0,0 +1,3 @@
+module CipherStashPG
+  VERSION = "1.0.0.beta.4"
+end