rubydb 0.1.4 → 0.1.5

data/lib/rubydb/types/smallint.rb

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

data/lib/rubydb/types/text.rb

@@ -1,37 +1,37 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module Types
-    # Variable-length text string (unlimited)
-    class Text < Type
-      def initialize
-        super(:text)
-      end
-
-      def serialize(value)
-        validate(value)
-        return "" if value.nil?
-        value.to_s.encode("UTF-8")
-      end
-
-      def deserialize(bytes)
-        return nil if bytes.nil? || bytes.empty?
-        bytes.force_encoding("UTF-8")
-      end
-
-      def validate(value)
-        return true if value.nil?
-        raise ConstraintError, "Invalid text: #{value}" unless value.respond_to?(:to_s)
-        true
-      end
-
-      def default
-        ""
-      end
-
-      def storage_size
-        nil  # Variable length
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module Types
+    # Variable-length text string (unlimited)
+    class Text < Type
+      def initialize
+        super(:text)
+      end
+
+      def serialize(value)
+        validate(value)
+        return "" if value.nil?
+        value.to_s.encode("UTF-8")
+      end
+
+      def deserialize(bytes)
+        return nil if bytes.nil? || bytes.empty?
+        bytes.force_encoding("UTF-8")
+      end
+
+      def validate(value)
+        return true if value.nil?
+        raise ConstraintError, "Invalid text: #{value}" unless value.respond_to?(:to_s)
+        true
+      end
+
+      def default
+        ""
+      end
+
+      def storage_size
+        nil  # Variable length
+      end
+    end
+  end
+end

data/lib/rubydb/types/time.rb

@@ -1,46 +1,46 @@
-# frozen_string_literal: true
-
-require "time"
-
-module RubyDB
-  module Types
-    # Time type (hour, minute, second)
-    class Time < Type
-      SIZE = 8  # Microseconds since midnight
-
-      def initialize
-        super(:time, size: SIZE)
-      end
-
-      def serialize(value)
-        validate(value)
-        return "\x00" * SIZE if value.nil?
-        seconds = value.hour * 3600 + value.min * 60 + value.sec
-        microseconds = value.usec
-        total = seconds * 1_000_000 + microseconds
-        [total].pack("q>")
-      end
-
-      def deserialize(bytes)
-        return nil if bytes.nil? || bytes.empty?
-        total = bytes.unpack("q>").first
-        seconds = total / 1_000_000
-        microseconds = total % 1_000_000
-        hour = seconds / 3600
-        minute = (seconds % 3600) / 60
-        sec = seconds % 60
-        ::Time.new(1970, 1, 1, hour, minute, sec, microseconds)
-      end
-
-      def validate(value)
-        return true if value.nil?
-        raise ConstraintError, "Invalid time: #{value}" unless value.is_a?(::Time) || value.is_a?(::DateTime)
-        true
-      end
-
-      def default
-        ::Time.now
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "time"
+
+module RubyDB
+  module Types
+    # Time type (hour, minute, second)
+    class Time < Type
+      SIZE = 8  # Microseconds since midnight
+
+      def initialize
+        super(:time, size: SIZE)
+      end
+
+      def serialize(value)
+        validate(value)
+        return "\x00" * SIZE if value.nil?
+        seconds = value.hour * 3600 + value.min * 60 + value.sec
+        microseconds = value.usec
+        total = seconds * 1_000_000 + microseconds
+        [total].pack("q>")
+      end
+
+      def deserialize(bytes)
+        return nil if bytes.nil? || bytes.empty?
+        total = bytes.unpack1("q>")
+        seconds = total / 1_000_000
+        microseconds = total % 1_000_000
+        hour = seconds / 3600
+        minute = (seconds % 3600) / 60
+        sec = seconds % 60
+        ::Time.new(1970, 1, 1, hour, minute, sec, microseconds)
+      end
+
+      def validate(value)
+        return true if value.nil?
+        raise ConstraintError, "Invalid time: #{value}" unless value.is_a?(::Time) || value.is_a?(::DateTime)
+        true
+      end
+
+      def default
+        ::Time.now
+      end
+    end
+  end
+end

data/lib/rubydb/types/timestamp.rb

@@ -1,39 +1,39 @@
-# frozen_string_literal: true
-
-require "time"
-
-module RubyDB
-  module Types
-    # Timestamp (date + time with timezone)
-    class Timestamp < Type
-      SIZE = 8  # Seconds since epoch (Unix timestamp)
-
-      def initialize
-        super(:timestamp, size: SIZE)
-      end
-
-      def serialize(value)
-        value = ::Time.parse(value) if value.is_a?(String)
-        validate(value)
-        return "\x00" * SIZE if value.nil?
-        [value.to_i].pack("q>")
-      end
-
-      def deserialize(bytes)
-        return nil if bytes.nil? || bytes.empty?
-        seconds = bytes.unpack("q>").first
-        ::Time.at(seconds)
-      end
-
-      def validate(value)
-        return true if value.nil?
-        raise ConstraintError, "Invalid timestamp: #{value}" unless value.is_a?(::Time) || value.is_a?(::DateTime) || value.is_a?(::Date)
-        true
-      end
-
-      def default
-        ::Time.now
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "time"
+
+module RubyDB
+  module Types
+    # Timestamp (date + time with timezone)
+    class Timestamp < Type
+      SIZE = 8  # Seconds since epoch (Unix timestamp)
+
+      def initialize
+        super(:timestamp, size: SIZE)
+      end
+
+      def serialize(value)
+        value = ::Time.parse(value) if value.is_a?(String)
+        validate(value)
+        return "\x00" * SIZE if value.nil?
+        [value.to_i].pack("q>")
+      end
+
+      def deserialize(bytes)
+        return nil if bytes.nil? || bytes.empty?
+        seconds = bytes.unpack1("q>")
+        ::Time.at(seconds)
+      end
+
+      def validate(value)
+        return true if value.nil?
+        raise ConstraintError, "Invalid timestamp: #{value}" unless value.is_a?(::Time) || value.is_a?(::DateTime) || value.is_a?(::Date)
+        true
+      end
+
+      def default
+        ::Time.now
+      end
+    end
+  end
+end

data/lib/rubydb/types/type.rb

@@ -1,119 +1,119 @@
-# frozen_string_literal: true
-
-require_relative "../errors/constraint_error"
-require_relative "../errors/configuration_error"
-
-module RubyDB
-  module Types
-    # Base class for all data types
-    class Type
-      attr_reader :name, :size, :precision, :scale
-
-      def initialize(name, size: nil, precision: nil, scale: nil)
-        @name = name
-        @size = size
-        @precision = precision
-        @scale = scale
-      end
-
-      def serialize(value)
-        raise NotImplementedError, "#{self.class} must implement #serialize"
-      end
-
-      def deserialize(bytes)
-        raise NotImplementedError, "#{self.class} must implement #deserialize"
-      end
-
-      def validate(value)
-        raise NotImplementedError, "#{self.class} must implement #validate"
-      end
-
-      def compare(a, b)
-        return 0 if a == b
-        return -1 if a < b
-        1
-      end
-
-      def default
-        nil
-      end
-
-      def sql_type
-        @name.to_s.upcase
-      end
-
-      def storage_size
-        @size
-      end
-
-      def to_s
-        sql_type
-      end
-
-      def inspect
-        "#<#{self.class} name=#{@name} size=#{@size}>"
-      end
-    end
-
-    # Type registry for looking up types by name
-    class TypeRegistry
-      @types = {}
-
-      class << self
-        attr_reader :types
-
-        def register(name, type_class = nil)
-          klass = type_class || resolve(name)
-          return if klass.nil?
-
-          @types[name.to_sym] = klass
-        end
-
-        def lookup(name, **kwargs)
-          type_class = @types[name.to_sym] || resolve(name)
-          if type_class
-            return type_class.new(kwargs.fetch(:limit, 255)) if type_class == Varchar
-
-            return type_class.new(**kwargs)
-          end
-
-          raise ConfigurationError, "Unknown type: #{name}"
-        end
-
-        def reset
-          @types = {}
-        end
-
-        private
-
-        def resolve(name)
-          name = name.to_sym
-          const_name = case name
-                       when :bigint then "BigInt"
-                       when :smallint then "SmallInt"
-                       when :float then "Float"
-                       when :decimal then "Decimal"
-                       when :boolean then "Boolean"
-                       when :text then "Text"
-                       when :varchar then "Varchar"
-                       when :blob then "Blob"
-                       when :date then "Date"
-                       when :time then "Time"
-                       when :timestamp then "Timestamp"
-                       when :json then "Json"
-                       when :uuid then "UUID"
-                       when :null then "Null"
-                       when :integer then "Integer"
-                       else name.to_s.split("_").map { |part| part.capitalize }.join
-                       end
-
-          klass = RubyDB::Types.const_get(const_name)
-          @types[name] = klass
-          klass
-        rescue NameError
-          nil
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require_relative "../errors/constraint_error"
+require_relative "../errors/configuration_error"
+
+module RubyDB
+  module Types
+    # Base class for all data types
+    class Type
+      attr_reader :name, :size, :precision, :scale
+
+      def initialize(name, size: nil, precision: nil, scale: nil)
+        @name = name
+        @size = size
+        @precision = precision
+        @scale = scale
+      end
+
+      def serialize(value)
+        raise NotImplementedError, "#{self.class} must implement #serialize"
+      end
+
+      def deserialize(bytes)
+        raise NotImplementedError, "#{self.class} must implement #deserialize"
+      end
+
+      def validate(value)
+        raise NotImplementedError, "#{self.class} must implement #validate"
+      end
+
+      def compare(a, b)
+        return 0 if a == b
+        return -1 if a < b
+        1
+      end
+
+      def default
+        nil
+      end
+
+      def sql_type
+        @name.to_s.upcase
+      end
+
+      def storage_size
+        @size
+      end
+
+      def to_s
+        sql_type
+      end
+
+      def inspect
+        "#<#{self.class} name=#{@name} size=#{@size}>"
+      end
+    end
+
+    # Type registry for looking up types by name
+    class TypeRegistry
+      @types = {}
+
+      class << self
+        attr_reader :types
+
+        def register(name, type_class = nil)
+          klass = type_class || resolve(name)
+          return if klass.nil?
+
+          @types[name.to_sym] = klass
+        end
+
+        def lookup(name, **kwargs)
+          type_class = @types[name.to_sym] || resolve(name)
+          if type_class
+            return type_class.new(kwargs.fetch(:limit, 255)) if type_class == Varchar
+
+            return type_class.new(**kwargs)
+          end
+
+          raise ConfigurationError, "Unknown type: #{name}"
+        end
+
+        def reset
+          @types = {}
+        end
+
+        private
+
+        def resolve(name)
+          name = name.to_sym
+          const_name = case name
+          when :bigint then "BigInt"
+          when :smallint then "SmallInt"
+          when :float then "Float"
+          when :decimal then "Decimal"
+          when :boolean then "Boolean"
+          when :text then "Text"
+          when :varchar then "Varchar"
+          when :blob then "Blob"
+          when :date then "Date"
+          when :time then "Time"
+          when :timestamp then "Timestamp"
+          when :json then "Json"
+          when :uuid then "UUID"
+          when :null then "Null"
+          when :integer then "Integer"
+          else name.to_s.split("_").map { |part| part.capitalize }.join
+          end
+
+          klass = RubyDB::Types.const_get(const_name)
+          @types[name] = klass
+          klass
+        rescue NameError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/types/uuid.rb

@@ -1,47 +1,47 @@
-# frozen_string_literal: true
-
-require "securerandom"
-
-module RubyDB
-  module Types
-    # UUID type (Universally Unique Identifier)
-    class UUID < Type
-      SIZE = 16
-      UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
-
-      def initialize
-        super(:uuid, size: SIZE)
-      end
-
-      def serialize(value)
-        validate(value)
-        return "\x00" * SIZE if value.nil?
-        # Remove hyphens and convert hex to bytes
-        hex = value.to_s.gsub("-", "")
-        [hex].pack("H*")
-      end
-
-      def deserialize(bytes)
-        return nil if bytes.nil? || bytes.empty?
-        hex = bytes.unpack("H*").first
-        # Add hyphens back
-        "#{hex[0...8]}-#{hex[8...12]}-#{hex[12...16]}-#{hex[16...20]}-#{hex[20...32]}"
-      end
-
-      def validate(value)
-        return true if value.nil?
-        str = value.to_s
-        raise ConstraintError, "Invalid UUID: #{value}" unless str.match?(UUID_REGEX)
-        true
-      end
-
-      def default
-        SecureRandom.uuid
-      end
-
-      def generate
-        SecureRandom.uuid
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "securerandom"
+
+module RubyDB
+  module Types
+    # UUID type (Universally Unique Identifier)
+    class UUID < Type
+      SIZE = 16
+      UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+
+      def initialize
+        super(:uuid, size: SIZE)
+      end
+
+      def serialize(value)
+        validate(value)
+        return "\x00" * SIZE if value.nil?
+        # Remove hyphens and convert hex to bytes
+        hex = value.to_s.gsub("-", "")
+        [hex].pack("H*")
+      end
+
+      def deserialize(bytes)
+        return nil if bytes.nil? || bytes.empty?
+        hex = bytes.unpack1("H*")
+        # Add hyphens back
+        "#{hex[0...8]}-#{hex[8...12]}-#{hex[12...16]}-#{hex[16...20]}-#{hex[20...32]}"
+      end
+
+      def validate(value)
+        return true if value.nil?
+        str = value.to_s
+        raise ConstraintError, "Invalid UUID: #{value}" unless str.match?(UUID_REGEX)
+        true
+      end
+
+      def default
+        SecureRandom.uuid
+      end
+
+      def generate
+        SecureRandom.uuid
+      end
+    end
+  end
+end