fastrb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 13e1e2010580def947129c3b9c5185d2a8ef6286fb1d507c80f330d8f8d796da
+  data.tar.gz: 9b9e53ad61201f2c3521f62bf551926c1dd2039d94153314d8e415bf9ee7d73e
+SHA512:
+  metadata.gz: 5f23bede7eb0a07968893f19eaf2d32326638d1bb6be94f87337f3090c63be615aa46de939a8fc4149b91f6c2fc467d9377038d825bf454755fb0eb379447f6c
+  data.tar.gz: 9a18768236867b0e470ed56adc2a09e9021656230648c9b01eaa52e9c1c58b1c77b5024de4229dcc2845536f04ef805aff8136e49e3cf4b652853afe48678f7f

data/bin/rubyapi

@@ -0,0 +1,2 @@
+require_relative "../lib/rubyapi/cli"
+RubyAPI::CLI.invoke(ARGV)

data/lib/rubyapi/cli.rb

@@ -0,0 +1,162 @@
+require "fileutils"
+require_relative "version"
+
+module RubyAPI
+  class CLI
+    def self.invoke(args)
+      command = args[0]
+      name = args[1]
+
+      case command
+      when "new"
+        new_project(name)
+      when "server"
+        start_server
+      when "version"
+        puts "rubyapi #{VERSION}"
+      else
+        puts "Usage: rubyapi <command> [options]"
+        puts ""
+        puts "Commands:"
+        puts "  new <name>    Create a new RubyAPI project"
+        puts "  server        Start the server (Falcon/Puma)"
+        puts "  version       Show version"
+        exit 1
+      end
+    end
+
+    def self.new_project(name)
+      puts "Creating new RubyAPI project: #{name}"
+
+      FileUtils.mkdir_p(name)
+      FileUtils.mkdir_p("#{name}/app")
+      FileUtils.mkdir_p("#{name}/config/environments")
+      FileUtils.mkdir_p("#{name}/public")
+      FileUtils.mkdir_p("#{name}/spec/unit")
+      FileUtils.mkdir_p("#{name}/spec/requests")
+
+      File.write("#{name}/Gemfile", gemfile_content(name))
+      File.write("#{name}/config.ru", config_ru_content)
+      File.write("#{name}/app/main.rb", main_rb_content)
+      File.write("#{name}/app/routes.rb", routes_rb_content)
+      File.write("#{name}/.rspec", ".rspec")
+      File.write("#{name}/spec/spec_helper.rb", spec_helper_content)
+      File.write("#{name}/spec/requests/hello_spec.rb", hello_spec_content)
+      File.write("#{name}/README.md", readme_content(name))
+
+      puts "Done! cd #{name} && bundle install && rubyapi server"
+    end
+
+    def self.start_server
+      require_relative "../../config.ru"
+    end
+
+    private
+
+    def self.gemfile_content(name)
+      <<~GEMFILE
+        source "https://rubygems.org"
+
+        gem "fastrb", "~> #{RubyAPI::VERSION}"
+        gem "rackup"
+        gem "puma"
+      GEMFILE
+    end
+
+    def self.config_ru_content
+      <<~RUBY
+        require_relative "app/main"
+        require_relative "app/routes"
+
+        run App.new
+      RUBY
+    end
+
+    def self.main_rb_content
+      <<~RUBY
+        require "rubyapi"
+
+        class App < RubyAPI::App
+          def initialize
+            super do
+              # Middleware
+              # use MyMiddleware
+
+              # Routes
+              include Routes
+            end
+          end
+        end
+      RUBY
+    end
+
+    def self.routes_rb_content
+      <<~RUBY
+        module Routes
+          def self.included(base)
+            base.get "/hello" do
+              { message: "Hello World" }
+            end
+          end
+        end
+      RUBY
+    end
+
+    def self.spec_helper_content
+      <<~RUBY
+        require "rubyapi"
+        require "rack/test"
+
+        RSpec.configure do |config|
+          config.expect_with :rspec do |expectations|
+            expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+          end
+
+          config.mock_with :rspec do |mocks|
+            mocks.verify_partial_doubles = true
+          end
+        end
+      RUBY
+    end
+
+    def self.hello_spec_content
+      <<~RUBY
+        require "spec_helper"
+
+        RSpec.describe "GET /hello" do
+          include Rack::Test::Methods
+
+          def app
+            App.new
+          end
+
+          it "returns hello world" do
+            get "/hello"
+            expect(last_response.status).to eq(200)
+            expect(JSON.parse(last_response.body)["message"]).to eq("Hello World")
+          end
+        end
+      RUBY
+    end
+
+    def self.readme_content(name)
+      <<~MARKDOWN
+        # #{name}
+
+        A RubyAPI application.
+
+        ## Setup
+
+            bundle install
+
+        ## Running
+
+            rubyapi server
+
+        ## Testing
+
+            bundle exec rspec
+      MARKDOWN
+    end
+  end
+end

data/lib/rubyapi/config.rb

@@ -0,0 +1,35 @@
+module RubyAPI
+  class Config
+    attr_accessor :environment, :settings
+
+    def initialize
+      @environment = ENV.fetch("RUBYAPI_ENV", "development")
+      @settings = default_settings
+    end
+
+    def load_environment_config(app_root = Dir.pwd)
+      config_file = File.join(app_root, "config", "environments", "#{@environment}.rb")
+      return unless File.exist?(config_file)
+      instance_eval(File.read(config_file))
+    end
+
+    def setting(key, value)
+      @settings[key] = value
+    end
+
+    def get(key)
+      @settings[key]
+    end
+
+    private
+
+    def default_settings
+      {
+        port: 3000,
+        host: "0.0.0.0",
+        log_level: "info",
+        secret_key: "change_me_in_production"
+      }
+    end
+  end
+end

data/lib/rubyapi/context.rb

@@ -0,0 +1,181 @@
+require "json"
+require "rack"
+
+module RubyAPI
+  class Context
+    attr_reader :request, :params, :body, :session, :files
+    attr_accessor :response_body, :response_status, :response_headers
+
+    def initialize(request, route)
+      @request = request
+      @route = route
+      @params = extract_path_params
+      @params.merge!(extract_query_params)
+      @body = extract_body
+      @files = extract_files
+      @session = {}
+      @response_headers = {}
+      @store = {}
+    end
+
+    def session=(val)
+      @session = val
+    end
+
+    def get(key)
+      @store[key]
+    end
+
+    def set(key, value)
+      @store[key] = value
+    end
+
+    def sse(&block)
+      io = @request.env["rack.hijack"]&.call
+      return [500, {}, ["rack.hijack not available"]] unless io
+
+      stream = SSEStream.new
+      sse_out = SSE.new(io)
+
+      @response_headers["content-type"] = "text/event-stream"
+      @response_headers["cache-control"] = "no-cache"
+      @response_headers["connection"] = "keep-alive"
+      @response_status = 200
+
+      block.call(sse_out)
+      sse_out.close
+      @response_body = ""
+    end
+
+    def stream(&block)
+      body = StreamingBody.new
+      @response_headers["content-type"] = "text/plain"
+      @response_headers["transfer-encoding"] = "chunked"
+      @response_status = 200
+      @response_body = body
+
+      Thread.new do
+        begin
+          block.call(body)
+        ensure
+          body.close
+        end
+      end
+    end
+
+    def apply_param_types!
+      type_map = @route[:params]
+      type_map.each do |name, type|
+        next unless @params.key?(name)
+        @params[name] = RubyAPI::ParamConverters.convert(@params[name], type)
+      end
+    rescue RubyAPI::ConversionError => e
+      @response_status = 422
+      @response_body = { error: e.message }
+    end
+
+    def validate_body!(schema_class)
+      raw = @body ? (@body.is_a?(BodyProxy) ? @body.to_h : @body) : {}
+      validated = schema_class.validate(raw)
+      stringified = validated.each_with_object({}) { |(k, v), h| h[k.to_s] = v }
+      @body = BodyProxy.new(stringified)
+    rescue Schema::ValidationError => e
+      @response_status = 422
+      @response_body = { errors: e.errors }
+    end
+
+    private
+
+    def extract_path_params
+      pattern = @route[:pattern]
+      names = @route[:param_names]
+      match = pattern.match(@request.path_info)
+      return {} unless match
+      names.each_with_index.each_with_object({}) do |(name, idx), hash|
+        hash[name] = match[idx + 1]
+      end
+    end
+
+    def extract_query_params
+      @request.params.each_with_object({}) do |(k, v), hash|
+        hash[k.to_sym] = v
+      end
+    end
+
+    def extract_body
+      return nil unless @request.post? || @request.put? || @request.patch?
+      return nil unless @request.content_type&.include?("application/json")
+
+      body_raw = @request.body.read
+      @request.body.rewind
+      return {} if body_raw.empty?
+
+      parsed = JSON.parse(body_raw)
+      BodyProxy.new(parsed)
+    rescue JSON::ParserError
+      BodyProxy.new({})
+    end
+
+    def extract_files
+      return {} unless @request.content_type&.include?("multipart/form-data")
+
+      files = {}
+      params = @request.env["rack.request.form_hash"]
+      return files unless params.is_a?(Hash)
+
+      params.each do |name, info|
+        next unless info.is_a?(Hash) && info[:tempfile]
+        files[name] = UploadedFile.new(
+          filename: info[:filename],
+          type: info[:type],
+          tempfile: info[:tempfile]
+        )
+      end
+      files
+    end
+  end
+
+  class BodyProxy
+    def initialize(data)
+      @data = data
+    end
+
+    def [](key)
+      @data[key.to_s]
+    end
+
+    def to_h
+      @data
+    end
+
+    def method_missing(name, *args)
+      if @data.key?(name.to_s)
+        @data[name.to_s]
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      @data.key?(name.to_s) || super
+    end
+  end
+
+  class UploadedFile
+    attr_reader :filename, :type, :tempfile
+
+    def initialize(filename:, type:, tempfile:)
+      @filename = filename
+      @type = type
+      @tempfile = tempfile
+    end
+
+    def read
+      @tempfile.read
+    end
+
+    def rewind
+      @tempfile.rewind
+    end
+  end
+end

data/lib/rubyapi/di.rb

@@ -0,0 +1,51 @@
+module RubyAPI
+  class Container
+    def initialize
+      @registrations = {}
+      @instances = {}
+    end
+
+    def register(name, klass = nil, &block)
+      @registrations[name] = block || -> { klass.new }
+    end
+
+    def resolve(name)
+      return @instances[name] if @instances.key?(name)
+      registration = @registrations[name]
+      return nil unless registration
+      @instances[name] = registration.call
+    end
+
+    def registered?(name)
+      @registrations.key?(name)
+    end
+  end
+
+  class DependencyError < StandardError; end
+
+  module DI
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def inject(name)
+        @injected_deps ||= []
+        @injected_deps << name
+      end
+
+      def injected_deps
+        @injected_deps || []
+      end
+
+      def depends(check_class, failure_status: 401)
+        @dependency_checks ||= []
+        @dependency_checks << { check: check_class, status: failure_status }
+      end
+
+      def dependency_checks
+        @dependency_checks || []
+      end
+    end
+  end
+end

data/lib/rubyapi/error_handler.rb

@@ -0,0 +1,20 @@
+module RubyAPI
+  module ErrorHandler
+    def self.included(base)
+      base.instance_variable_set(:@error_handlers, {})
+    end
+
+    def self.extended(base)
+      base.instance_variable_set(:@error_handlers, {})
+    end
+
+    def rescue_from(exception_class, status: 500)
+      @error_handlers ||= {}
+      @error_handlers[exception_class] = status
+    end
+
+    def error_handlers
+      @error_handlers || {}
+    end
+  end
+end

data/lib/rubyapi/job.rb

@@ -0,0 +1,93 @@
+module RubyAPI
+  class Job
+    class << self
+      def inherited(subclass)
+        subclass.instance_variable_set(:@queue, Queue.new)
+        subclass.instance_variable_set(:@worker_thread, nil)
+        subclass.instance_variable_set(:@job_results, [])
+        subclass.instance_variable_set(:@job_errors, [])
+        JobRegistry.register(subclass)
+      end
+
+      def enqueue(*args)
+        job = { class: self, args: args, enqueued_at: Time.now }
+        @queue << job
+        start_worker unless @worker_thread&.alive?
+        job
+      end
+
+      def results
+        @job_results.dup
+      end
+
+      def errors
+        @job_errors.dup
+      end
+
+      def clear_results
+        @job_results.clear
+        @job_errors.clear
+      end
+
+      def queue
+        @queue
+      end
+
+      def perform(*args)
+        raise "#{self} must implement `perform`"
+      end
+
+      def worker_running?
+        @worker_thread&.alive? || false
+      end
+
+      private
+
+      def start_worker
+        @worker_thread = Thread.new do
+          loop do
+            break if @queue.empty? && !@worker_thread&.alive?
+            begin
+              job = @queue.pop(true)
+            rescue ThreadError
+              sleep 0.01
+              retry
+            end
+
+            begin
+              result = job[:class].perform(*job[:args])
+              @job_results << {
+                class: job[:class].name,
+                args: job[:args],
+                result: result,
+                completed_at: Time.now
+              }
+            rescue => e
+              @job_errors << {
+                class: job[:class].name,
+                args: job[:args],
+                error: e.class.name,
+                message: e.message,
+                failed_at: Time.now
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+
+  class JobRegistry
+    def self.jobs
+      @jobs ||= []
+    end
+
+    def self.register(klass)
+      jobs << klass unless jobs.include?(klass)
+    end
+
+    def self.find(name)
+      jobs.find { |j| j.name == name || j.name&.end_with?("::#{name}") }
+    end
+  end
+end

data/lib/rubyapi/middleware/logging.rb

@@ -0,0 +1,67 @@
+require "json"
+require "time"
+
+module RubyAPI
+  module Middleware
+    class StructuredLogger
+      def initialize(app, output: $stdout)
+        @app = app
+        @output = output
+      end
+
+      def call(env)
+        start_time = Time.now
+        status, headers, body = @app.call(env)
+        duration_ms = ((Time.now - start_time) * 1000).round(2)
+
+        log_entry = {
+          method: env["REQUEST_METHOD"],
+          path: env["PATH_INFO"],
+          status: status,
+          duration_ms: duration_ms,
+          timestamp: Time.now.iso8601
+        }
+
+        @output.puts(JSON.generate(log_entry))
+        [status, headers, body]
+      end
+    end
+
+    class Metrics
+      attr_reader :counts, :latencies
+
+      def initialize(app)
+        @app = app
+        @counts = Hash.new(0)
+        @latencies = Hash.new(0.0)
+        @mutex = Mutex.new
+      end
+
+      def call(env)
+        start_time = Time.now
+        status, headers, body = @app.call(env)
+        duration = Time.now - start_time
+
+        key = "#{env["REQUEST_METHOD"]} #{env["PATH_INFO"]}"
+        @mutex.synchronize do
+          @counts[key] += 1
+          @latencies[key] += duration
+        end
+
+        [status, headers, body]
+      end
+
+      def summary
+        @mutex.synchronize do
+          @counts.each_with_object({}) do |(key, count), hash|
+            total = @latencies[key]
+            hash[key] = {
+              count: count,
+              avg_latency_ms: (total / count * 1000).round(2)
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubyapi/openapi.rb

@@ -0,0 +1,50 @@
+require "json"
+
+module RubyAPI
+  class OpenAPI
+    def initialize(app)
+      @app = app
+    end
+
+    def generate
+      {
+        openapi: "3.0.0",
+        info: {
+          title: "RubyAPI App",
+          version: "0.1.0"
+        },
+        paths: generate_paths
+      }
+    end
+
+    def to_json
+      JSON.pretty_generate(generate)
+    end
+
+    private
+
+    def generate_paths
+      paths = {}
+      @app.router.routes.each do |route|
+        path = route[:path]
+        method = route[:method].downcase
+        paths[path] ||= {}
+        paths[path][method] = {
+          summary: "#{method.upcase} #{path}",
+          parameters: route[:param_names].map do |name|
+            {
+              name: name,
+              in: "path",
+              required: true,
+              schema: { type: "string" }
+            }
+          end,
+          responses: {
+            "200" => { description: "Success" }
+          }
+        }
+      end
+      paths
+    end
+  end
+end