ruby-mysql 2.9.6 → 2.9.7

data/lib/mysql.rb

@@ -10,13 +10,17 @@
 #  end
 class Mysql
 
-  dir = File.dirname __FILE__
-  require "#{dir}/mysql/constants"
-  require "#{dir}/mysql/error"
-  require "#{dir}/mysql/charset"
-  require "#{dir}/mysql/protocol"
+  require "mysql/constants"
+  require "mysql/error"
+  require "mysql/charset"
+  require "mysql/protocol"
+  begin
+    require "mysql/packet.so"
+  rescue LoadError
+    require "mysql/packet.rb"
+  end
 
-  VERSION            = 20906               # Version number of this library
+  VERSION            = 20907               # Version number of this library
   MYSQL_UNIX_PORT    = "/tmp/mysql.sock"   # UNIX domain socket filename
   MYSQL_TCP_PORT     = 3306                # TCP socket port number
 
@@ -577,7 +581,7 @@ class Mysql
     attr_reader :decimals       # number of decimals
     attr_reader :default        # defualt value
     alias :def :default
-    attr_accessor :max_length   # maximum width of the field for the result set
+    attr_accessor :result       # :nodoc:
 
     # === Argument
     # [Protocol::FieldPacket]
@@ -585,6 +589,7 @@ class Mysql
       @db, @table, @org_table, @name, @org_name, @charsetnr, @length, @type, @flags, @decimals, @default =
         packet.db, packet.table, packet.org_table, packet.name, packet.org_name, packet.charsetnr, packet.length, packet.type, packet.flags, packet.decimals, packet.default
       @flags |= NUM_FLAG if is_num_type?
+      @max_length = nil
     end
 
     def hash
@@ -594,7 +599,7 @@ class Mysql
         "def"        => @default,
         "type"       => @type,
         "length"     => @length,
-        "max_length" => @max_length,
+        "max_length" => max_length,
         "flags"      => @flags,
         "decimals"   => @decimals
       }
@@ -619,6 +624,16 @@ class Mysql
       @flags & PRI_KEY_FLAG != 0
     end
 
+    # maximum width of the field for the result set
+    def max_length
+      return @max_length if @max_length
+      @max_length = 0
+      @result.calculate_field_max_length if @result
+      @max_length
+    end
+
+    attr_writer :max_length
+
     private
 
     def is_num_type?
@@ -661,10 +676,10 @@ class Mysql
     def fetch
       @fetched_record = nil
       return nil if @index >= @records.size
-      rec = @records[@index]
+      @records[@index] = @records[@index].to_a unless @records[@index].is_a? Array
+      @fetched_record = @records[@index]
       @index += 1
-      @fetched_record = rec
-      return rec
+      return @fetched_record
     end
     alias fetch_row fetch
 
@@ -750,13 +765,22 @@ class Mysql
     def initialize(fields, protocol=nil)
       super fields
       return unless protocol
-      @records = protocol.retr_all_records @fields
-      # for Field#max_length
-      @records.each do |rec|
-        rec.zip(fields) do |v, f|
-          f.max_length = [v ? v.length : 0, f.max_length || 0].max
+      @records = protocol.retr_all_records fields.size
+      fields.each{|f| f.result = self}  # for calculating max_field
+    end
+
+    # calculate max_length of all fields
+    def calculate_field_max_length
+      max_length = Array.new(@fields.size, 0)
+      @records.each_with_index do |rec, i|
+        rec = @records[i] = rec.to_a if rec.is_a? RawRecord
+        max_length.each_index do |i|
+          max_length[i] = rec[i].length if rec[i] && rec[i].length > max_length[i]
         end
       end
+      max_length.each_with_index do |len, i|
+        @fields[i].max_length = len
+      end
     end
 
     # Return current field

data/lib/mysql/charset.rb

@@ -1,8 +1,6 @@
 # Copyright (C) 2008-2010 TOMITA Masahiro
 # mailto:tommy@tmtm.org
 
-require "#{File.dirname __FILE__}/error"
-
 class Mysql
   class Charset
     def initialize(number, name, csname)
@@ -238,7 +236,7 @@ class Mysql
       }
 
       def self.to_binary(value)
-        value.dup.force_encoding Encoding::ASCII_8BIT
+        value.force_encoding Encoding::ASCII_8BIT
       end
 
       # convert raw to encoding and convert to Encoding.default_internal
@@ -248,7 +246,7 @@ class Mysql
       # === Return
       # result [String]
       def self.convert_encoding(raw, encoding)
-        raw.dup.force_encoding(encoding).encode
+        raw.force_encoding(encoding).encode
       end
 
       # retrun corresponding Ruby encoding

data/lib/mysql/packet.rb

@@ -0,0 +1,77 @@
+class Mysql
+  class Packet
+    # convert Numeric to LengthCodedBinary
+    def self.lcb(num)
+      return "\xfb" if num.nil?
+      return [num].pack("C") if num < 251
+      return [252, num].pack("Cv") if num < 65536
+      return [253, num&0xffff, num>>16].pack("CvC") if num < 16777216
+      return [254, num&0xffffffff, num>>32].pack("CVV")
+    end
+
+    # convert String to LengthCodedString
+    def self.lcs(str)
+      str = Charset.to_binary str
+      lcb(str.length)+str
+    end
+
+    def initialize(data)
+      @data = data
+    end
+
+    def lcb
+      return nil if @data.empty?
+      case v = utiny
+      when 0xfb
+        return nil
+      when 0xfc
+        return ushort
+      when 0xfd
+        c, v = utiny, ushort
+        return (v << 8)+c
+      when 0xfe
+        v1, v2 = ulong, ulong
+        return (v2 << 32)+v1
+      else
+        return v
+      end
+    end
+
+    def lcs
+      len = self.lcb
+      return nil unless len
+      @data.slice!(0, len)
+    end
+
+    def read(len)
+      @data.slice!(0, len)
+    end
+
+    def string
+      str = @data.unpack('Z*').first
+      @data.slice!(0, str.length+1)
+      str
+    end
+
+    def utiny
+      @data.slice!(0, 1).unpack('C').first
+    end
+
+    def ushort
+      @data.slice!(0, 2).unpack('v').first
+    end
+
+    def ulong
+      @data.slice!(0, 4).unpack('V').first
+    end
+
+    def eof?
+      @data[0] == ?\xfe && @data.length == 5
+    end
+
+    def to_s
+      @data
+    end
+
+  end
+end

data/lib/mysql/protocol.rb

@@ -13,107 +13,55 @@ class Mysql
     VERSION = 10
     MAX_PACKET_LENGTH = 2**24-1
 
-    # convert Numeric to LengthCodedBinary
-    def self.lcb(num)
-      return "\xfb" if num.nil?
-      return [num].pack("C") if num < 251
-      return [252, num].pack("Cv") if num < 65536
-      return [253, num&0xffff, num>>16].pack("CvC") if num < 16777216
-      return [254, num&0xffffffff, num>>32].pack("CVV")
-    end
-
-    # convert String to LengthCodedString
-    def self.lcs(str)
-      str = Charset.to_binary str
-      lcb(str.length)+str
-    end
-
-    # convert LengthCodedBinary to Integer
-    # === Argument
-    # lcb :: [String] LengthCodedBinary. This value will be broken.
-    # === Return
-    # Integer or nil
-    def self.lcb2int!(lcb)
-      return nil if lcb.empty?
-      case v = lcb.slice!(0)
-      when ?\xfb
-        return nil
-      when ?\xfc
-        return lcb.slice!(0,2).unpack("v").first
-      when ?\xfd
-        c, v = lcb.slice!(0,3).unpack("Cv")
-        return (v << 8)+c
-      when ?\xfe
-        v1, v2 = lcb.slice!(0,8).unpack("VV")
-        return (v2 << 32)+v1
-      else
-        return v.ord
-      end
-    end
-
-    # convert LengthCodedString to String
-    # === Argument
-    # lcs :: [String] LengthCodedString. This value will be broken.
-    # === Return
-    # String or nil
-    def self.lcs2str!(lcs)
-      len = lcb2int! lcs
-      return len && lcs.slice!(0, len)
-    end
-
-    def self.eof_packet?(data)
-      data[0] == ?\xfe && data.length == 5
-    end
-
     # Convert netdata to Ruby value
     # === Argument
-    # data :: [String] packet data. This will be broken.
+    # data :: [Packet] packet data
     # type :: [Integer] field type
     # unsigned :: [true or false] true if value is unsigned
     # === Return
     # Object :: converted value.
-    def self.net2value(data, type, unsigned)
+    def self.net2value(pkt, type, unsigned)
       case type
       when Field::TYPE_STRING, Field::TYPE_VAR_STRING, Field::TYPE_NEWDECIMAL, Field::TYPE_BLOB
-        return lcs2str!(data)
+        return pkt.lcs
       when Field::TYPE_TINY
-        v = data.slice!(0).ord
+        v = pkt.utiny
         return unsigned ? v : v < 128 ? v : v-256
       when Field::TYPE_SHORT
-        v = data.slice!(0,2).unpack("v").first
+        v = pkt.ushort
         return unsigned ? v : v < 32768 ? v : v-65536
       when Field::TYPE_INT24, Field::TYPE_LONG
-        v = data.slice!(0,4).unpack("V").first
+        v = pkt.ulong
         return unsigned ? v : v < 2**32/2 ? v : v-2**32
       when Field::TYPE_LONGLONG
-        n1, n2 = data.slice!(0,8).unpack("VV")
+        n1, n2 = pkt.ulong, pkt.ulong
         v = (n2 << 32) | n1
         return unsigned ? v : v < 2**64/2 ? v : v-2**64
       when Field::TYPE_FLOAT
-        return data.slice!(0,4).unpack("e").first
+        return pkt.read(4).unpack('e').first
       when Field::TYPE_DOUBLE
-        return data.slice!(0,8).unpack("E").first
+        return pkt.read(8).unpack('E').first
       when Field::TYPE_DATE
-        len = data.slice!(0).ord
-        y, m, d = data.slice!(0,len).unpack("vCC")
+        len = pkt.utiny
+        y, m, d = pkt.read(len).unpack("vCC")
         t = Mysql::Time.new(y, m, d)
         def t.to_s
           sprintf "%04d-%02d-%02d", year, mon ,day
         end
         return t
       when Field::TYPE_DATETIME, Field::TYPE_TIMESTAMP
-        len = data.slice!(0).ord
-        y, m, d, h, mi, s, bs = data.slice!(0,len).unpack("vCCCCCV")
+        len = pkt.utiny
+        y, m, d, h, mi, s, bs = pkt.read(len).unpack("vCCCCCV")
         return Mysql::Time.new(y, m, d, h, mi, s, bs)
       when Field::TYPE_TIME
-        len = data.slice!(0).ord
-        sign, d, h, mi, s, sp = data.slice!(0,len).unpack("CVCCCV")
+        len = pkt.utiny
+        sign, d, h, mi, s, sp = pkt.read(len).unpack("CVCCCV")
         h = d.to_i * 24 + h.to_i
         return Mysql::Time.new(0, 0, 0, h, mi, s, sign!=0, sp)
       when Field::TYPE_YEAR
-        return data.slice!(0,2).unpack("v").first
+        return pkt.ushort
       when Field::TYPE_BIT
-        return lcs2str!(data)
+        return pkt.lcs
       else
         raise "not implemented: type=#{type}"
       end
@@ -171,7 +119,7 @@ class Mysql
         val = [v].pack("E")
       when String
         type = Field::TYPE_STRING
-        val = lcs(v)
+        val = Packet.lcs(v)
       when Mysql::Time, ::Time
         type = Field::TYPE_DATETIME
         val = [7, v.year, v.month, v.day, v.hour, v.min, v.sec].pack("CvCCCCC")
@@ -261,7 +209,7 @@ class Mysql
       end
       netpw = encrypt_password passwd, init_packet.scramble_buff
       write AuthenticationPacket.serialize(client_flags, 1024**3, @charset.number, user, netpw, db)
-      raise ProtocolError, 'The old style password is not supported' if read == "\xfe"
+      raise ProtocolError, 'The old style password is not supported' if read.to_s == "\xfe"
       set_state :READY
     end
 
@@ -337,21 +285,19 @@ class Mysql
 
     # Retrieve all records for simple query
     # === Argument
-    # fields :: [Array of Mysql::Field] field list
+    # nfields :: [Integer] number of fields
     # === Return
     # [Array of Array of String] all records
-    def retr_all_records(fields)
+    def retr_all_records(nfields)
       check_state :RESULT
+      enc = charset.encoding
       begin
         all_recs = []
-        until self.class.eof_packet?(data = read)
-          rec = fields.map do
-            s = self.class.lcs2str!(data)
-            s && Charset.convert_encoding(s, charset.encoding)
-          end
-          all_recs.push rec
+        until (pkt = read).eof?
+          all_recs.push RawRecord.new(pkt, nfields, enc)
         end
-        @server_status = data[3].ord
+        pkt.read(3)
+        @server_status = pkt.utiny
         all_recs
       ensure
         set_state :READY
@@ -369,7 +315,7 @@ class Mysql
         reset
         write [COM_FIELD_LIST, table, 0, field].pack("Ca*Ca*")
         fields = []
-        until self.class.eof_packet?(data = read)
+        until (data = read).eof?
           fields.push Field.new(FieldPacket.parse(data))
         end
         return fields
@@ -384,7 +330,7 @@ class Mysql
       begin
         reset
         write [COM_PROCESS_INFO].pack("C")
-        field_count = self.class.lcb2int!(read)
+        field_count = read.lcb
         fields = field_count.times.map{Field.new FieldPacket.parse(read)}
         read_eof_packet
         set_state :RESULT
@@ -479,8 +425,8 @@ class Mysql
       check_state :RESULT
       begin
         all_recs = []
-        until self.class.eof_packet?(data = read)
-          all_recs.push stmt_parse_record_packet(data, fields, charset)
+        until (data = read).eof?
+          all_recs.push StmtRawRecord.new(data, fields, charset.encoding)
         end
         all_recs
       ensure
@@ -504,34 +450,6 @@ class Mysql
 
     private
 
-    # Parse statement result packet
-    # === Argument
-    # data    :: [String]
-    # fields  :: [Array of Fields]
-    # charset :: [Mysql::Charset]
-    # === Return
-    # [Array of Object] one record
-    def stmt_parse_record_packet(data, fields, charset)
-      data.slice!(0)  # skip first byte
-      null_bit_map = data.slice!(0, (fields.length+7+2)/8).unpack("b*").first
-      rec = fields.each_with_index.map do |f, i|
-        if null_bit_map[i+2] == ?1
-          nil
-        else
-          unsigned = f.flags & Field::UNSIGNED_FLAG != 0
-          v = self.class.net2value(data, f.type, unsigned)
-          if v.is_a? Numeric or v.is_a? Mysql::Time
-            v
-          elsif f.type == Field::TYPE_BIT or f.charsetnr == Charset::BINARY_CHARSET_NUMBER
-            Charset.to_binary(v)
-          else
-            Charset.convert_encoding(v, charset.encoding)
-          end
-        end
-      end
-      rec
-    end
-
     def check_state(st)
       raise 'command out of sync' unless @state == st
     end
@@ -567,7 +485,7 @@ class Mysql
 
     # Read one packet data
     # === Return
-    # [String] packet data
+    # [Packet] packet data
     # === Exception
     # [ProtocolError] invalid packet sequence number
     def read
@@ -575,17 +493,14 @@ class Mysql
       len = nil
       begin
         Timeout.timeout @read_timeout do
-          header = @sock.sysread(4)
+          header = @sock.read(4)
+          raise EOFError unless header.length == 4
           len1, len2, seq = header.unpack("CvC")
           len = (len2 << 8) + len1
           raise ProtocolError, "invalid packet: sequence number mismatch(#{seq} != #{@seq}(expected))" if @seq != seq
           @seq = (@seq + 1) % 256
-          l = len
-          while l > 0
-            buf = @sock.sysread l
-            ret.concat buf
-            l -= buf.bytesize
-          end
+          ret = @sock.read(len)
+          raise EOFError unless ret.length == len
         end
       rescue EOFError
         raise ClientError::ServerGoneError, 'The MySQL server has gone away'
@@ -607,7 +522,7 @@ class Mysql
         end
         raise Mysql::ServerError.new(message, @sqlstate)
       end
-      ret
+      Packet.new(ret)
     end
 
     # Write one packet data
@@ -646,8 +561,7 @@ class Mysql
     # === Exception
     # [ProtocolError] packet is not EOF
     def read_eof_packet
-      data = read
-      raise ProtocolError, "packet is not EOF" unless self.class.eof_packet? data
+      raise ProtocolError, "packet is not EOF" unless read.eof?
     end
 
     # Send simple command
@@ -659,7 +573,7 @@ class Mysql
       synchronize do
         reset
         write packet
-        read
+        read.to_s
       end
     end
 
@@ -678,10 +592,17 @@ class Mysql
 
     # Initial packet
     class InitialPacket
-      def self.parse(data)
-        protocol_version, server_version, thread_id, scramble_buff, f0,
-        server_capabilities, server_charset, server_status, f1,
-        rest_scramble_buff = data.unpack("CZ*Va8CvCva13Z13")
+      def self.parse(pkt)
+        protocol_version = pkt.utiny
+        server_version = pkt.string
+        thread_id = pkt.ulong
+        scramble_buff = pkt.read(8)
+        f0 = pkt.utiny
+        server_capabilities = pkt.ushort
+        server_charset = pkt.utiny
+        server_status = pkt.ushort
+        f1 = pkt.read(13)
+        rest_scramble_buff = pkt.string
         raise ProtocolError, "unsupported version: #{protocol_version}" unless protocol_version == VERSION
         raise ProtocolError, "invalid packet: f0=#{f0}" unless f0 == 0
         scramble_buff.concat rest_scramble_buff
@@ -697,15 +618,17 @@ class Mysql
 
     # Result packet
     class ResultPacket
-      def self.parse(data)
-        field_count = Protocol.lcb2int! data
+      def self.parse(pkt)
+        field_count = pkt.lcb
         if field_count == 0
-          affected_rows = Protocol.lcb2int! data
-          insert_id = Protocol.lcb2int!(data)
-          server_status, warning_count, message = data.unpack("vva*")
-          return self.new(field_count, affected_rows, insert_id, server_status, warning_count, Protocol.lcs2str!(message))
+          affected_rows = pkt.lcb
+          insert_id = pkt.lcb
+          server_status = pkt.ushort
+          warning_count = pkt.ushort
+          message = pkt.lcs
+          return self.new(field_count, affected_rows, insert_id, server_status, warning_count, message)
         elsif field_count.nil?   # LOAD DATA LOCAL INFILE
-          return self.new(nil, nil, nil, nil, nil, data)
+          return self.new(nil, nil, nil, nil, nil, pkt.to_s)
         else
           return self.new(field_count)
         end
@@ -720,16 +643,23 @@ class Mysql
 
     # Field packet
     class FieldPacket
-      def self.parse(data)
-        first = Protocol.lcs2str! data
-        db = Protocol.lcs2str! data
-        table = Protocol.lcs2str! data
-        org_table = Protocol.lcs2str! data
-        name = Protocol.lcs2str! data
-        org_name = Protocol.lcs2str! data
-        f0, charsetnr, length, type, flags, decimals, f1, data = data.unpack("CvVCvCva*")
+      def self.parse(pkt)
+        first = pkt.lcs
+        db = pkt.lcs
+        table = pkt.lcs
+        org_table = pkt.lcs
+        name = pkt.lcs
+        org_name = pkt.lcs
+        f0 = pkt.utiny
+        charsetnr = pkt.ushort
+        length = pkt.ulong
+        type = pkt.utiny
+        flags = pkt.ushort
+        decimals = pkt.utiny
+        f1 = pkt.ushort
+
         raise ProtocolError, "invalid packet: f1=#{f1}" unless f1 == 0
-        default = Protocol.lcs2str! data
+        default = pkt.lcs
         return self.new(db, table, org_table, name, org_name, charsetnr, length, type, flags, decimals, default)
       end
 
@@ -742,9 +672,13 @@ class Mysql
 
     # Prepare result packet
     class PrepareResultPacket
-      def self.parse(data)
-        raise ProtocolError, "invalid packet" unless data.slice!(0) == ?\0
-        statement_id, field_count, param_count, f, warning_count = data.unpack("VvvCv")
+      def self.parse(pkt)
+        raise ProtocolError, "invalid packet" unless pkt.utiny == 0
+        statement_id = pkt.ulong
+        field_count = pkt.ushort
+        param_count = pkt.ushort
+        f = pkt.utiny
+        warning_count = pkt.ushort
         raise ProtocolError, "invalid packet" unless f == 0x00
         self.new statement_id, field_count, param_count, warning_count
       end
@@ -762,10 +696,10 @@ class Mysql
         [
           client_flags,
           max_packet_size,
-          Protocol.lcb(charset_number),
+          Packet.lcb(charset_number),
           "",                   # always 0x00 * 23
           username,
-          Protocol.lcs(scrambled_password),
+          Packet.lcs(scrambled_password),
           databasename
         ].pack("VVa*a23Z*A*Z*")
       end
@@ -796,4 +730,56 @@ class Mysql
 
     end
   end
+
+  class RawRecord
+    def initialize(packet, nfields, encoding)
+      @packet, @nfields, @encoding = packet, nfields, encoding
+    end
+
+    def to_a
+      @nfields.times.map do
+        if s = @packet.lcs
+          s = Charset.convert_encoding(s, @encoding)
+        end
+        s
+      end
+    end
+  end
+
+  class StmtRawRecord
+    # === Argument
+    # pkt     :: [Packet]
+    # fields  :: [Array of Fields]
+    # encoding:: [Encoding]
+    def initialize(packet, fields, encoding)
+      @packet, @fields, @encoding = packet, fields, encoding
+    end
+
+    # Parse statement result packet
+    # === Return
+    # [Array of Object] one record
+    def parse_record_packet
+      @packet.utiny  # skip first byte
+      null_bit_map = @packet.read((@fields.length+7+2)/8).unpack("b*").first
+      rec = @fields.each_with_index.map do |f, i|
+        if null_bit_map[i+2] == ?1
+          nil
+        else
+          unsigned = f.flags & Field::UNSIGNED_FLAG != 0
+          v = Protocol.net2value(@packet, f.type, unsigned)
+          if v.is_a? Numeric or v.is_a? Mysql::Time
+            v
+          elsif f.type == Field::TYPE_BIT or f.charsetnr == Charset::BINARY_CHARSET_NUMBER
+            Charset.to_binary(v)
+          else
+            Charset.convert_encoding(v, @encoding)
+          end
+        end
+      end
+      rec
+    end
+
+    alias to_a parse_record_packet
+
+  end
 end

data/spec/mysql/packet_spec.rb

@@ -0,0 +1,118 @@
+# coding: binary
+describe Mysql::Packet do
+  def self._(s)
+    s.unpack('H*').first
+  end
+  subject{Mysql::Packet.new(data)}
+  describe '#lcb' do
+    [
+      ["\xfb",                                 nil],
+      ["\xfc\x01\x02",                         0x0201],
+      ["\xfd\x01\x02\x03",                     0x030201],
+      ["\xfe\x01\x02\x03\x04\x05\x06\x07\x08", 0x0807060504030201],
+      ["\x01",                                 0x01],
+    ].each do |data, result|
+      context "for '#{_ data}'" do
+        let(:data){data}
+      it{subject.lcb.should == result}
+      end
+    end
+  end
+
+  describe '#lcs' do
+    [
+      ["\x03\x41\x42\x43", 'ABC'],
+      ["\x01",             ''],
+      ["",                 nil],
+    ].each do |data, result|
+      context "for '#{_ data}'" do
+        let(:data){data}
+        it{subject.lcs.should == result}
+      end
+    end
+  end
+
+  describe '#read' do
+    let(:data){'ABCDEFGHI'}
+    it{subject.read(7).should == 'ABCDEFG'}
+  end
+
+  describe '#string' do
+    let(:data){"ABC\0DEF"}
+    it 'should NUL terminated String' do
+      subject.string.should == 'ABC'
+    end
+  end
+
+  describe '#utiny' do
+    [
+      ["\x01", 0x01],
+      ["\xFF", 0xff],
+    ].each do |data, result|
+      context "for '#{_ data}'" do
+        let(:data){data}
+        it{subject.utiny.should == result}
+      end
+    end
+  end
+
+  describe '#ushort' do
+    [
+      ["\x01\x02", 0x0201],
+      ["\xFF\xFE", 0xfeff],
+    ].each do |data, result|
+      context "for '#{_ data}'" do
+        let(:data){data}
+        it{subject.ushort.should == result}
+      end
+    end
+  end
+
+  describe '#ulong' do
+    [
+      ["\x01\x02\x03\x04", 0x04030201],
+      ["\xFF\xFE\xFD\xFC", 0xfcfdfeff],
+    ].each do |data, result|
+      context "for '#{_ data}'" do
+        let(:data){data}
+        it{subject.ulong.should == result}
+      end
+    end
+  end
+
+  describe '#eof?' do
+    [
+      ["\xfe\x00\x00\x00\x00", true],
+      ["ABCDE", false],
+    ].each do |data, result|
+      context "for '#{_ data}'" do
+        let(:data){data}
+        it{subject.eof?.should == result}
+      end
+    end
+  end
+
+end
+
+describe 'Mysql::Packet.lcb' do
+  [
+    [nil,      "\xfb"],
+    [1,        "\x01"],
+    [250,      "\xfa"],
+    [251,      "\xfc\xfb\x00"],
+    [65535,    "\xfc\xff\xff"],
+    [65536,    "\xfd\x00\x00\x01"],
+    [16777215, "\xfd\xff\xff\xff"],
+    [16777216, "\xfe\x00\x00\x00\x01\x00\x00\x00\x00"],
+    [0xffffffffffffffff, "\xfe\xff\xff\xff\xff\xff\xff\xff\xff"],
+  ].each do |val, result|
+    context "with #{val}" do
+      it{Mysql::Packet.lcb(val).should == result}
+    end
+  end
+end
+
+describe 'Mysql::Packet.lcs' do
+  it{Mysql::Packet.lcs("hoge").should == "\x04hoge"}
+  it{Mysql::Packet.lcs("あいう".force_encoding("UTF-8")).should == "\x09\xe3\x81\x82\xe3\x81\x84\xe3\x81\x86"}
+end

data/spec/mysql_spec.rb

@@ -1,8 +1,6 @@
 # -*- coding: utf-8 -*-
 require "tempfile"
 
-$LOAD_PATH.unshift "#{File.dirname __FILE__}/../lib"
-
 require "mysql"
 
 # MYSQL_USER must have ALL privilege for MYSQL_DATABASE.* and RELOAD privilege for *.*
@@ -15,7 +13,7 @@ MYSQL_SOCKET   = ENV['MYSQL_SOCKET']
 
 describe 'Mysql::VERSION' do
   it 'returns client version' do
-    Mysql::VERSION.should == 20906
+    Mysql::VERSION.should == 20907
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-mysql
 version: !ruby/object:Gem::Version
-  version: 2.9.6
+  version: 2.9.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,9 +9,9 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-19 00:00:00.000000000 Z
+date: 2012-04-22 00:00:00.000000000 Z
 dependencies: []
-description: This is pure Ruby MySQL connector.
+description: This is MySQL connector. pure Ruby version
 email: tommy@tmtm.org
 executables: []
 extensions: []
@@ -24,7 +24,9 @@ files:
 - lib/mysql/protocol.rb
 - lib/mysql/charset.rb
 - lib/mysql/error.rb
+- lib/mysql/packet.rb
 - spec/mysql_spec.rb
+- spec/mysql/packet_spec.rb
 homepage: http://github.com/tmtm/ruby-mysql
 licenses:
 - Ruby's
@@ -49,7 +51,8 @@ rubyforge_project:
 rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
-summary: pure Ruby MySQL connector
+summary: MySQL connector
 test_files:
 - spec/mysql_spec.rb
+- spec/mysql/packet_spec.rb
 has_rdoc: true