rubydb 0.1.4 → 0.1.6

data/lib/rubydb/types/bigint.rb

@@ -1,36 +1,36 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module Types
-    # 64-bit signed integer
-    class BigInt < Type
-      RANGE = (-9_223_372_036_854_775_808..9_223_372_036_854_775_807).freeze
-      SIZE = 8
-
-      def initialize
-        super(:bigint, size: SIZE)
-      end
-
-      def serialize(value)
-        validate(value)
-        [value.to_i].pack("q>")  # Big-endian 64-bit signed
-      end
-
-      def deserialize(bytes)
-        return nil if bytes.nil? || bytes.empty?
-        bytes.unpack("q>").first
-      end
-
-      def validate(value)
-        return true if value.nil?
-        raise ConstraintError, "Invalid bigint: #{value}" unless value.is_a?(::Integer)
-        raise ConstraintError, "BigInt out of range: #{value}" unless RANGE.include?(value)
-        true
-      end
-
-      def default
-        0
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module Types
+    # 64-bit signed integer
+    class BigInt < Type
+      RANGE = (-9_223_372_036_854_775_808..9_223_372_036_854_775_807)
+      SIZE = 8
+
+      def initialize
+        super(:bigint, size: SIZE)
+      end
+
+      def serialize(value)
+        validate(value)
+        [value.to_i].pack("q>")  # Big-endian 64-bit signed
+      end
+
+      def deserialize(bytes)
+        return nil if bytes.nil? || bytes.empty?
+        bytes.unpack1("q>")
+      end
+
+      def validate(value)
+        return true if value.nil?
+        raise ConstraintError, "Invalid bigint: #{value}" unless value.is_a?(::Integer)
+        raise ConstraintError, "BigInt out of range: #{value}" unless RANGE.include?(value)
+        true
+      end
+
+      def default
+        0
+      end
+    end
+  end
+end

data/lib/rubydb/types/blob.rb

@@ -1,37 +1,37 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module Types
-    # Binary large object (arbitrary binary data)
-    class Blob < Type
-      def initialize
-        super(:blob)
-      end
-
-      def serialize(value)
-        validate(value)
-        return "".b if value.nil?
-        value.is_a?(String) ? value.b : value.to_s.b
-      end
-
-      def deserialize(bytes)
-        return nil if bytes.nil? || bytes.empty?
-        bytes.b
-      end
-
-      def validate(value)
-        return true if value.nil?
-        raise ConstraintError, "Invalid blob: #{value}" unless value.respond_to?(:to_s)
-        true
-      end
-
-      def default
-        "".b
-      end
-
-      def storage_size
-        nil  # Variable length
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module Types
+    # Binary large object (arbitrary binary data)
+    class Blob < Type
+      def initialize
+        super(:blob)
+      end
+
+      def serialize(value)
+        validate(value)
+        return "".b if value.nil?
+        value.is_a?(String) ? value.b : value.to_s.b
+      end
+
+      def deserialize(bytes)
+        return nil if bytes.nil? || bytes.empty?
+        bytes.b
+      end
+
+      def validate(value)
+        return true if value.nil?
+        raise ConstraintError, "Invalid blob: #{value}" unless value.respond_to?(:to_s)
+        true
+      end
+
+      def default
+        "".b
+      end
+
+      def storage_size
+        nil  # Variable length
+      end
+    end
+  end
+end

data/lib/rubydb/types/boolean.rb

@@ -1,34 +1,34 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module Types
-    # Boolean type (true/false)
-    class Boolean < Type
-      SIZE = 1
-
-      def initialize
-        super(:boolean, size: SIZE)
-      end
-
-      def serialize(value)
-        validate(value)
-        value ? "\x01".b : "\x00".b
-      end
-
-      def deserialize(bytes)
-        return nil if bytes.nil? || bytes.empty?
-        bytes.unpack("C").first == 1
-      end
-
-      def validate(value)
-        return true if value.nil?
-        raise ConstraintError, "Invalid boolean: #{value}" unless [true, false].include?(value)
-        true
-      end
-
-      def default
-        false
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module Types
+    # Boolean type (true/false)
+    class Boolean < Type
+      SIZE = 1
+
+      def initialize
+        super(:boolean, size: SIZE)
+      end
+
+      def serialize(value)
+        validate(value)
+        value ? "\x01".b : "\x00".b
+      end
+
+      def deserialize(bytes)
+        return nil if bytes.nil? || bytes.empty?
+        bytes.unpack1("C") == 1
+      end
+
+      def validate(value)
+        return true if value.nil?
+        raise ConstraintError, "Invalid boolean: #{value}" unless [true, false].include?(value)
+        true
+      end
+
+      def default
+        false
+      end
+    end
+  end
+end

data/lib/rubydb/types/date.rb

@@ -1,39 +1,39 @@
-# frozen_string_literal: true
-
-require "date"
-
-module RubyDB
-  module Types
-    # Date type (year, month, day)
-    class Date < Type
-      SIZE = 4  # Days since epoch (stored as integer)
-
-      def initialize
-        super(:date, size: SIZE)
-      end
-
-      def serialize(value)
-        validate(value)
-        return "\x00" * SIZE if value.nil?
-        days = value - Date.new(1970, 1, 1)
-        [days.to_i].pack("l>")
-      end
-
-      def deserialize(bytes)
-        return nil if bytes.nil? || bytes.empty?
-        days = bytes.unpack("l>").first
-        Date.new(1970, 1, 1) + days
-      end
-
-      def validate(value)
-        return true if value.nil?
-        raise ConstraintError, "Invalid date: #{value}" unless value.is_a?(::Date) || value.is_a?(::DateTime)
-        true
-      end
-
-      def default
-        Date.today
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "date"
+
+module RubyDB
+  module Types
+    # Date type (year, month, day)
+    class Date < Type
+      SIZE = 4  # Days since epoch (stored as integer)
+
+      def initialize
+        super(:date, size: SIZE)
+      end
+
+      def serialize(value)
+        validate(value)
+        return "\x00" * SIZE if value.nil?
+        days = value - Date.new(1970, 1, 1)
+        [days.to_i].pack("l>")
+      end
+
+      def deserialize(bytes)
+        return nil if bytes.nil? || bytes.empty?
+        days = bytes.unpack1("l>")
+        Date.new(1970, 1, 1) + days
+      end
+
+      def validate(value)
+        return true if value.nil?
+        raise ConstraintError, "Invalid date: #{value}" unless value.is_a?(::Date) || value.is_a?(::DateTime)
+        true
+      end
+
+      def default
+        Date.today
+      end
+    end
+  end
+end

data/lib/rubydb/types/decimal.rb

@@ -1,48 +1,48 @@
-# frozen_string_literal: true
-
-require "bigdecimal"
-
-module RubyDB
-  module Types
-    # Arbitrary precision decimal
-    class Decimal < Type
-      attr_reader :precision, :scale
-
-      def initialize(precision: 10, scale: 2)
-        super(:decimal, precision: precision, scale: scale)
-        @precision = precision
-        @scale = scale
-      end
-
-      def serialize(value)
-        validate(value)
-        bd = value.is_a?(BigDecimal) ? value : BigDecimal(value.to_s)
-        bd.to_s("F").encode("UTF-8")
-      end
-
-      def deserialize(bytes)
-        return nil if bytes.nil? || bytes.empty?
-        str = bytes.force_encoding("UTF-8")
-        BigDecimal(str)
-      end
-
-      def validate(value)
-        return true if value.nil?
-        bd = value.is_a?(BigDecimal) ? value : BigDecimal(value.to_s)
-        raise ConstraintError, "Invalid decimal: #{value}" unless bd
-        true
-      rescue ArgumentError, TypeError
-        raise ConstraintError, "Invalid decimal: #{value}"
-      end
-
-      def default
-        BigDecimal("0")
-      end
-
-      def storage_size
-        # Variable length, stored as string
-        nil
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module RubyDB
+  module Types
+    # Arbitrary precision decimal
+    class Decimal < Type
+      attr_reader :precision, :scale
+
+      def initialize(precision: 10, scale: 2)
+        super(:decimal, precision: precision, scale: scale)
+        @precision = precision
+        @scale = scale
+      end
+
+      def serialize(value)
+        validate(value)
+        bd = value.is_a?(BigDecimal) ? value : BigDecimal(value.to_s)
+        bd.to_s("F").encode("UTF-8")
+      end
+
+      def deserialize(bytes)
+        return nil if bytes.nil? || bytes.empty?
+        str = bytes.force_encoding("UTF-8")
+        BigDecimal(str)
+      end
+
+      def validate(value)
+        return true if value.nil?
+        bd = value.is_a?(BigDecimal) ? value : BigDecimal(value.to_s)
+        raise ConstraintError, "Invalid decimal: #{value}" unless bd
+        true
+      rescue ArgumentError, TypeError
+        raise ConstraintError, "Invalid decimal: #{value}"
+      end
+
+      def default
+        BigDecimal("0")
+      end
+
+      def storage_size
+        # Variable length, stored as string
+        nil
+      end
+    end
+  end
+end

data/lib/rubydb/types/float.rb

@@ -1,34 +1,34 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module Types
-    # 64-bit floating point (Double precision)
-    class Float < Type
-      SIZE = 8
-
-      def initialize
-        super(:float, size: SIZE)
-      end
-
-      def serialize(value)
-        validate(value)
-        [value.to_f].pack("E")  # Big-endian double
-      end
-
-      def deserialize(bytes)
-        return nil if bytes.nil? || bytes.empty?
-        bytes.unpack("E").first
-      end
-
-      def validate(value)
-        return true if value.nil?
-        raise ConstraintError, "Invalid float: #{value}" unless value.is_a?(::Numeric)
-        true
-      end
-
-      def default
-        0.0
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module Types
+    # 64-bit floating point (Double precision)
+    class Float < Type
+      SIZE = 8
+
+      def initialize
+        super(:float, size: SIZE)
+      end
+
+      def serialize(value)
+        validate(value)
+        [value.to_f].pack("E")  # Big-endian double
+      end
+
+      def deserialize(bytes)
+        return nil if bytes.nil? || bytes.empty?
+        bytes.unpack1("E")
+      end
+
+      def validate(value)
+        return true if value.nil?
+        raise ConstraintError, "Invalid float: #{value}" unless value.is_a?(::Numeric)
+        true
+      end
+
+      def default
+        0.0
+      end
+    end
+  end
+end

data/lib/rubydb/types/integer.rb

@@ -1,36 +1,36 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module Types
-    # 32-bit signed integer
-    class Integer < Type
-      RANGE = (-2_147_483_648..2_147_483_647).freeze
-      SIZE = 4
-
-      def initialize
-        super(:integer, size: SIZE)
-      end
-
-      def serialize(value)
-        validate(value)
-        [value.to_i].pack("l>")  # Big-endian 32-bit signed
-      end
-
-      def deserialize(bytes)
-        return nil if bytes.nil? || bytes.empty?
-        bytes.unpack("l>").first
-      end
-
-      def validate(value)
-        return true if value.nil?
-        raise ConstraintError, "Invalid integer: #{value}" unless value.is_a?(::Integer)
-        raise ConstraintError, "Integer out of range: #{value}" unless RANGE.include?(value)
-        true
-      end
-
-      def default
-        0
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module Types
+    # 32-bit signed integer
+    class Integer < Type
+      RANGE = (-2_147_483_648..2_147_483_647)
+      SIZE = 4
+
+      def initialize
+        super(:integer, size: SIZE)
+      end
+
+      def serialize(value)
+        validate(value)
+        [value.to_i].pack("l>")  # Big-endian 32-bit signed
+      end
+
+      def deserialize(bytes)
+        return nil if bytes.nil? || bytes.empty?
+        bytes.unpack1("l>")
+      end
+
+      def validate(value)
+        return true if value.nil?
+        raise ConstraintError, "Invalid integer: #{value}" unless value.is_a?(::Integer)
+        raise ConstraintError, "Integer out of range: #{value}" unless RANGE.include?(value)
+        true
+      end
+
+      def default
+        0
+      end
+    end
+  end
+end

data/lib/rubydb/types/json.rb

@@ -1,41 +1,41 @@
-# frozen_string_literal: true
-
-require "json"
-
-module RubyDB
-  module Types
-    # JSON type (stores JSON data)
-    class Json < Type
-      def initialize
-        super(:json)
-      end
-
-      def serialize(value)
-        validate(value)
-        return "null".encode("UTF-8") if value.nil?
-        JSON.generate(value)
-      end
-
-      def deserialize(bytes)
-        return nil if bytes.nil? || bytes.empty?
-        JSON.parse(bytes.force_encoding("UTF-8"))
-      rescue JSON::ParserError
-        nil
-      end
-
-      def validate(value)
-        return true if value.nil?
-        raise ConstraintError, "Invalid JSON: #{value}" unless value.is_a?(Hash) || value.is_a?(Array)
-        true
-      end
-
-      def default
-        {}
-      end
-
-      def storage_size
-        nil  # Variable length
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "json"
+
+module RubyDB
+  module Types
+    # JSON type (stores JSON data)
+    class Json < Type
+      def initialize
+        super(:json)
+      end
+
+      def serialize(value)
+        validate(value)
+        return "null".encode("UTF-8") if value.nil?
+        JSON.generate(value)
+      end
+
+      def deserialize(bytes)
+        return nil if bytes.nil? || bytes.empty?
+        JSON.parse(bytes.force_encoding("UTF-8"))
+      rescue JSON::ParserError
+        nil
+      end
+
+      def validate(value)
+        return true if value.nil?
+        raise ConstraintError, "Invalid JSON: #{value}" unless value.is_a?(Hash) || value.is_a?(Array)
+        true
+      end
+
+      def default
+        {}
+      end
+
+      def storage_size
+        nil  # Variable length
+      end
+    end
+  end
+end

data/lib/rubydb/types/null.rb

@@ -1,34 +1,34 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module Types
-    # NULL type (represents absence of value)
-    class Null < Type
-      SIZE = 0
-
-      def initialize
-        super(:null, size: SIZE)
-      end
-
-      def serialize(value)
-        ""
-      end
-
-      def deserialize(bytes)
-        nil
-      end
-
-      def validate(value)
-        true  # Always valid
-      end
-
-      def default
-        nil
-      end
-
-      def storage_size
-        0
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module Types
+    # NULL type (represents absence of value)
+    class Null < Type
+      SIZE = 0
+
+      def initialize
+        super(:null, size: SIZE)
+      end
+
+      def serialize(value)
+        ""
+      end
+
+      def deserialize(bytes)
+        nil
+      end
+
+      def validate(value)
+        true  # Always valid
+      end
+
+      def default
+        nil
+      end
+
+      def storage_size
+        0
+      end
+    end
+  end
+end