tarsier 0.1.0

data/lib/tarsier/middleware/static.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Tarsier
+  module Middleware
+    # Static file serving middleware
+    # Serves files from a public directory with caching support
+    class Static < Base
+      MIME_TYPES = {
+        ".html" => "text/html",
+        ".htm" => "text/html",
+        ".css" => "text/css",
+        ".js" => "application/javascript",
+        ".json" => "application/json",
+        ".xml" => "application/xml",
+        ".txt" => "text/plain",
+        ".png" => "image/png",
+        ".jpg" => "image/jpeg",
+        ".jpeg" => "image/jpeg",
+        ".gif" => "image/gif",
+        ".svg" => "image/svg+xml",
+        ".ico" => "image/x-icon",
+        ".webp" => "image/webp",
+        ".woff" => "font/woff",
+        ".woff2" => "font/woff2",
+        ".ttf" => "font/ttf",
+        ".eot" => "application/vnd.ms-fontobject",
+        ".otf" => "font/otf",
+        ".pdf" => "application/pdf",
+        ".zip" => "application/zip",
+        ".mp3" => "audio/mpeg",
+        ".mp4" => "video/mp4",
+        ".webm" => "video/webm"
+      }.freeze
+
+      DEFAULT_OPTIONS = {
+        root: "public",
+        urls: ["/"],
+        index: "index.html",
+        cache_control: "public, max-age=31536000",
+        headers: {}
+      }.freeze
+
+      def initialize(app, **options)
+        super
+        @options = DEFAULT_OPTIONS.merge(options)
+        @root = File.expand_path(@options[:root])
+      end
+
+      def call(request, response)
+        return @app.call(request, response) unless servable?(request)
+
+        path = file_path(request.path)
+        return @app.call(request, response) unless path && File.file?(path)
+
+        serve_file(path, request, response)
+      end
+
+      private
+
+      def servable?(request)
+        return false unless request.get? || request.head?
+
+        @options[:urls].any? { |url| request.path.start_with?(url) }
+      end
+
+      def file_path(request_path)
+        # Prevent directory traversal
+        path = File.join(@root, request_path)
+        path = File.join(path, @options[:index]) if File.directory?(path)
+
+        # Ensure path is within root
+        return nil unless path.start_with?(@root)
+
+        path
+      end
+
+      def serve_file(path, request, response)
+        stat = File.stat(path)
+        etag = generate_etag(path, stat)
+        last_modified = stat.mtime.httpdate
+
+        # Check conditional request headers
+        if fresh?(request, etag, last_modified)
+          response.status = 304
+          response.body = ""
+          return response
+        end
+
+        response.status = 200
+        response.set_header("Content-Type", mime_type(path))
+        response.set_header("Content-Length", stat.size.to_s)
+        response.set_header("Last-Modified", last_modified)
+        response.set_header("ETag", etag)
+        response.set_header("Cache-Control", @options[:cache_control])
+
+        @options[:headers].each { |k, v| response.set_header(k, v) }
+
+        response.body = request.head? ? "" : File.read(path)
+        response
+      end
+
+      def fresh?(request, etag, last_modified)
+        if_none_match = request.header("If-None-Match")
+        if_modified_since = request.header("If-Modified-Since")
+
+        return true if if_none_match == etag
+        return true if if_modified_since == last_modified
+
+        false
+      end
+
+      def generate_etag(path, stat)
+        %("#{Digest::MD5.hexdigest("#{path}#{stat.mtime.to_i}#{stat.size}")}")
+      end
+
+      def mime_type(path)
+        ext = File.extname(path).downcase
+        MIME_TYPES[ext] || "application/octet-stream"
+      end
+    end
+  end
+end

data/lib/tarsier/model.rb

@@ -0,0 +1,590 @@
+# frozen_string_literal: true
+
+module Tarsier
+  # Lightweight Active Record pattern implementation
+  #
+  # Provides a clean, minimal ORM with support for SQLite, PostgreSQL,
+  # and MySQL. Designed for simplicity without sacrificing functionality.
+  #
+  # @example Define a model
+  #   class User < Tarsier::Model
+  #     table :users
+  #
+  #     attribute :name, :string
+  #     attribute :email, :string
+  #     attribute :age, :integer
+  #
+  #     validates :email, presence: true, format: /@/
+  #
+  #     has_many :posts
+  #   end
+  #
+  # @example Query records
+  #   User.all
+  #   User.find(1)
+  #   User.where(active: true).order(:name).limit(10)
+  #
+  # @since 0.1.0
+  class Model
+    class << self
+      # Set or get the table name
+      #
+      # @param name [String, Symbol, nil] table name
+      # @return [String]
+      #
+      # @example
+      #   table :users
+      def table(name = nil)
+        @table_name = name.to_s if name
+        @table_name ||= "#{self.name.split('::').last.downcase}s"
+      end
+
+      alias table_name table
+
+      # Set or get the primary key
+      #
+      # @param key [Symbol, nil] primary key column
+      # @return [Symbol]
+      def primary_key(key = nil)
+        @primary_key = key if key
+        @primary_key ||= :id
+      end
+
+      # Define an attribute
+      #
+      # @param name [Symbol] attribute name
+      # @param type [Symbol] attribute type (:string, :integer, :boolean, etc.)
+      # @param options [Hash] attribute options
+      #
+      # @example
+      #   attribute :name, :string
+      #   attribute :age, :integer, default: 0
+      #   attribute :active, :boolean, default: true
+      def attribute(name, type, **options)
+        attributes[name] = { type: type, **options }
+
+        define_method(name) { @attributes[name] }
+        define_method("#{name}=") do |value|
+          @attributes[name] = self.class.coerce(value, type)
+          @dirty << name unless @new_record
+        end
+      end
+
+      # @return [Hash] defined attributes
+      def attributes
+        @attributes ||= {}
+      end
+
+      # Define a validation
+      #
+      # @param attribute [Symbol] attribute to validate
+      # @param options [Hash] validation options
+      #
+      # @example
+      #   validates :email, presence: true, format: /@/
+      #   validates :age, numericality: true, greater_than: 0
+      def validates(attribute, **options)
+        validations[attribute] ||= []
+        validations[attribute] << options
+      end
+
+      # @return [Hash] defined validations
+      def validations
+        @validations ||= {}
+      end
+
+      # Define a has_many association
+      #
+      # @param name [Symbol] association name
+      # @param options [Hash] association options
+      #
+      # @example
+      #   has_many :posts
+      #   has_many :comments, class_name: 'Comment', foreign_key: :author_id
+      def has_many(name, class_name: nil, foreign_key: nil, **options)
+        associations[:has_many] ||= {}
+        associations[:has_many][name] = {
+          class_name: class_name || classify(name),
+          foreign_key: foreign_key || "#{table.chomp('s')}_id",
+          **options
+        }
+
+        define_method(name) do
+          @cache[name] ||= load_has_many(name)
+        end
+      end
+
+      # Define a belongs_to association
+      #
+      # @param name [Symbol] association name
+      # @param options [Hash] association options
+      #
+      # @example
+      #   belongs_to :user
+      #   belongs_to :author, class_name: 'User'
+      def belongs_to(name, class_name: nil, foreign_key: nil, **options)
+        associations[:belongs_to] ||= {}
+        associations[:belongs_to][name] = {
+          class_name: class_name || classify(name),
+          foreign_key: foreign_key || "#{name}_id",
+          **options
+        }
+
+        define_method(name) do
+          @cache[name] ||= load_belongs_to(name)
+        end
+      end
+
+      # Define a has_one association
+      #
+      # @param name [Symbol] association name
+      # @param options [Hash] association options
+      def has_one(name, class_name: nil, foreign_key: nil, **options)
+        associations[:has_one] ||= {}
+        associations[:has_one][name] = {
+          class_name: class_name || classify(name),
+          foreign_key: foreign_key || "#{table.chomp('s')}_id",
+          **options
+        }
+
+        define_method(name) do
+          @cache[name] ||= load_has_one(name)
+        end
+      end
+
+      # @return [Hash] defined associations
+      def associations
+        @associations ||= {}
+      end
+
+      # Find a record by ID
+      #
+      # @param id [Object] primary key value
+      # @return [Model, nil]
+      def find(id)
+        row = db.get("SELECT * FROM #{table} WHERE #{primary_key} = ?", id)
+        row ? from_row(row) : nil
+      end
+
+      # Find a record by ID or raise
+      #
+      # @param id [Object] primary key value
+      # @return [Model]
+      # @raise [RecordNotFoundError]
+      def find!(id)
+        find(id) || raise(RecordNotFoundError.new(self, id))
+      end
+
+      # Find by attributes
+      #
+      # @param attributes [Hash] attributes to match
+      # @return [Model, nil]
+      def find_by(**attributes)
+        where(attributes).first
+      end
+
+      # Get all records
+      #
+      # @return [Array<Model>]
+      def all
+        query.to_a
+      end
+
+      # Create a new query
+      #
+      # @return [Query]
+      def query
+        Query.new(self)
+      end
+
+      # Query methods delegation
+      %i[where where_not order limit offset select].each do |method|
+        define_method(method) { |*args, **kwargs| query.send(method, *args, **kwargs) }
+      end
+
+      # Create a new record
+      #
+      # @param attributes [Hash] record attributes
+      # @return [Model]
+      def create(attributes = {})
+        record = new(attributes)
+        record.save
+        record
+      end
+
+      # Create a new record or raise on failure
+      #
+      # @param attributes [Hash] record attributes
+      # @return [Model]
+      # @raise [ValidationError]
+      def create!(attributes = {})
+        record = new(attributes)
+        record.save!
+        record
+      end
+
+      # Count records
+      #
+      # @return [Integer]
+      def count
+        result = db.get("SELECT COUNT(*) as count FROM #{table}")
+        result[:count]
+      end
+
+      # Check if any records exist
+      #
+      # @return [Boolean]
+      def exists?(**conditions)
+        conditions.empty? ? count > 0 : where(conditions).exists?
+      end
+
+      # Coerce a value to the specified type
+      #
+      # @param value [Object] value to coerce
+      # @param type [Symbol] target type
+      # @return [Object]
+      def coerce(value, type)
+        return nil if value.nil?
+
+        case type
+        when :string then value.to_s
+        when :integer then value.to_i
+        when :float then value.to_f
+        when :boolean then coerce_boolean(value)
+        when :datetime then coerce_datetime(value)
+        when :date then coerce_date(value)
+        when :json then coerce_json(value)
+        else value
+        end
+      end
+
+      # Database connection
+      #
+      # @return [Database::Connection]
+      def db
+        Database.connection || raise(DatabaseError, "No database connection")
+      end
+
+      # Build model from database row
+      #
+      # @param row [Hash] database row
+      # @return [Model]
+      def from_row(row)
+        record = allocate
+        record.instance_variable_set(:@attributes, row)
+        record.instance_variable_set(:@new_record, false)
+        record.instance_variable_set(:@destroyed, false)
+        record.instance_variable_set(:@dirty, [])
+        record.instance_variable_set(:@cache, {})
+        record.instance_variable_set(:@errors, {})
+        record
+      end
+
+      private
+
+      def classify(name)
+        name.to_s.split("_").map(&:capitalize).join.chomp("s")
+      end
+
+      def coerce_boolean(value)
+        case value
+        when true, 1, "1", "true", "t" then true
+        when false, 0, "0", "false", "f" then false
+        else !!value
+        end
+      end
+
+      def coerce_datetime(value)
+        return value if value.is_a?(Time)
+
+        Time.parse(value.to_s)
+      rescue ArgumentError
+        nil
+      end
+
+      def coerce_date(value)
+        return value if value.is_a?(Date)
+
+        Date.parse(value.to_s)
+      rescue ArgumentError
+        nil
+      end
+
+      def coerce_json(value)
+        return value if value.is_a?(Hash) || value.is_a?(Array)
+
+        JSON.parse(value.to_s)
+      rescue JSON::ParserError
+        nil
+      end
+    end
+
+    # @return [Hash] validation errors
+    attr_reader :errors
+
+    # Create a new model instance
+    #
+    # @param attributes [Hash] initial attributes
+    def initialize(attributes = {})
+      @attributes = {}
+      @dirty = []
+      @cache = {}
+      @errors = {}
+      @new_record = true
+      @destroyed = false
+
+      # Set defaults
+      self.class.attributes.each do |name, config|
+        @attributes[name] = config[:default]
+      end
+
+      # Set provided attributes
+      attributes.each do |key, value|
+        send("#{key}=", value) if respond_to?("#{key}=")
+      end
+    end
+
+    # Get the primary key value
+    #
+    # @return [Object]
+    def id
+      @attributes[self.class.primary_key]
+    end
+
+    # Set the primary key value
+    #
+    # @param value [Object]
+    def id=(value)
+      @attributes[self.class.primary_key] = value
+    end
+
+    # @return [Boolean] true if this is a new record
+    def new_record?
+      @new_record
+    end
+
+    # @return [Boolean] true if record has been persisted
+    def persisted?
+      !@new_record && !@destroyed
+    end
+
+    # @return [Boolean] true if record has been destroyed
+    def destroyed?
+      @destroyed || false
+    end
+
+    # @return [Boolean] true if record has unsaved changes
+    def changed?
+      @dirty.any?
+    end
+
+    # Validate the record
+    #
+    # @return [Boolean]
+    def valid?
+      @errors.clear
+      run_validations
+      @errors.empty?
+    end
+
+    # Save the record
+    #
+    # @return [Boolean]
+    def save
+      return false unless valid?
+
+      if @new_record
+        insert_record
+      else
+        update_record
+      end
+
+      @dirty.clear
+      true
+    rescue StandardError => e
+      @errors[:base] = [e.message]
+      false
+    end
+
+    # Save the record or raise on failure
+    #
+    # @return [Boolean]
+    # @raise [ValidationError]
+    def save!
+      raise ValidationError, @errors unless save
+
+      true
+    end
+
+    # Update attributes
+    #
+    # @param attributes [Hash] attributes to update
+    # @return [Boolean]
+    def update(attributes)
+      attributes.each { |k, v| send("#{k}=", v) if respond_to?("#{k}=") }
+      save
+    end
+
+    # Update attributes or raise on failure
+    #
+    # @param attributes [Hash] attributes to update
+    # @return [Boolean]
+    # @raise [ValidationError]
+    def update!(attributes)
+      attributes.each { |k, v| send("#{k}=", v) if respond_to?("#{k}=") }
+      save!
+    end
+
+    # Destroy the record
+    #
+    # @return [Boolean]
+    def destroy
+      return false if @new_record
+
+      self.class.db.delete(self.class.table, self.class.primary_key => id)
+      @destroyed = true
+      true
+    rescue StandardError
+      false
+    end
+
+    # Reload the record from database
+    #
+    # @return [self]
+    def reload
+      fresh = self.class.find(id)
+      @attributes = fresh.to_h
+      @dirty.clear
+      @cache.clear
+      self
+    end
+
+    # Convert to hash
+    #
+    # @return [Hash]
+    def to_h
+      @attributes.dup
+    end
+
+    alias to_hash to_h
+
+    # Convert to JSON
+    #
+    # @return [String]
+    def to_json(*args)
+      to_h.to_json(*args)
+    end
+
+    # String representation
+    #
+    # @return [String]
+    def inspect
+      attrs = @attributes.map { |k, v| "#{k}: #{v.inspect}" }.join(", ")
+      "#<#{self.class.name} #{attrs}>"
+    end
+
+    private
+
+    def run_validations
+      self.class.validations.each do |attribute, rules|
+        value = @attributes[attribute]
+        rules.each { |rule| validate_rule(attribute, value, rule) }
+      end
+    end
+
+    def validate_rule(attribute, value, rule)
+      if rule[:presence] && (value.nil? || value == "")
+        add_error(attribute, "can't be blank")
+      end
+
+      if rule[:format] && value && !value.to_s.match?(rule[:format])
+        add_error(attribute, "has invalid format")
+      end
+
+      if rule[:length]
+        length = value.to_s.length
+        min = rule[:length][:minimum]
+        max = rule[:length][:maximum]
+        add_error(attribute, "is too short (minimum #{min})") if min && length < min
+        add_error(attribute, "is too long (maximum #{max})") if max && length > max
+      end
+
+      if rule[:inclusion] && !rule[:inclusion][:in].include?(value)
+        add_error(attribute, "is not included in the list")
+      end
+
+      if rule[:numericality] && value && !value.is_a?(Numeric)
+        add_error(attribute, "is not a number")
+      end
+
+      if rule[:greater_than] && value.is_a?(Numeric) && value <= rule[:greater_than]
+        add_error(attribute, "must be greater than #{rule[:greater_than]}")
+      end
+    end
+
+    def add_error(attribute, message)
+      @errors[attribute] ||= []
+      @errors[attribute] << message
+    end
+
+    def insert_record
+      attrs = @attributes.reject { |k, _| k == self.class.primary_key }
+      new_id = self.class.db.insert(self.class.table, attrs)
+      @attributes[self.class.primary_key] = new_id
+      @new_record = false
+    end
+
+    def update_record
+      attrs = @dirty.each_with_object({}) { |k, h| h[k] = @attributes[k] }
+      return if attrs.empty?
+
+      self.class.db.update(self.class.table, attrs, self.class.primary_key => id)
+    end
+
+    def load_has_many(name)
+      config = self.class.associations[:has_many][name]
+      klass = Object.const_get(config[:class_name])
+      klass.where(config[:foreign_key] => id).to_a
+    end
+
+    def load_belongs_to(name)
+      config = self.class.associations[:belongs_to][name]
+      klass = Object.const_get(config[:class_name])
+      fk_value = @attributes[config[:foreign_key].to_sym]
+      klass.find(fk_value)
+    end
+
+    def load_has_one(name)
+      config = self.class.associations[:has_one][name]
+      klass = Object.const_get(config[:class_name])
+      klass.find_by(config[:foreign_key] => id)
+    end
+  end
+
+  # Record not found error
+  class RecordNotFoundError < Error
+    # @return [Class] the model class
+    attr_reader :model
+
+    # @return [Object] the ID that was not found
+    attr_reader :id
+
+    def initialize(model, id)
+      @model = model
+      @id = id
+      super("#{model.name} with #{model.primary_key}=#{id} not found")
+    end
+  end
+
+  # Validation error
+  class ValidationError < Error
+    # @return [Hash] validation errors
+    attr_reader :errors
+
+    def initialize(errors)
+      @errors = errors
+      messages = errors.flat_map { |k, v| v.map { |m| "#{k} #{m}" } }
+      super("Validation failed: #{messages.join(', ')}")
+    end
+  end
+end