tarsier 0.1.0

data/exe/tarsier

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "tarsier"
+require "tarsier/cli/loader"
+
+Tarsier::CLI.start(ARGV)

data/lib/tarsier/application.rb

@@ -0,0 +1,336 @@
+# frozen_string_literal: true
+
+module Tarsier
+  # Main application class - the entry point for Tarsier apps
+  #
+  # Tarsier::Application is Rack-compatible and provides both a minimal
+  # Flask-style API and a more structured Rails-style API.
+  #
+  # @example Minimal (Flask-style)
+  #   app = Tarsier.app do
+  #     get('/') { { message: 'Hello!' } }
+  #     post('/users') { |req| User.create(req.params) }
+  #   end
+  #
+  # @example Structured (Rails-style)
+  #   Tarsier.application do
+  #     configure { self.secret_key = ENV['SECRET'] }
+  #     use Tarsier::Middleware::Logger
+  #     routes do
+  #       resources :users
+  #     end
+  #   end
+  #
+  # @since 0.1.0
+  class Application
+    # @return [Router] the application router
+    attr_reader :router
+
+    # @return [Middleware::Stack] the middleware stack
+    attr_reader :middleware_stack
+
+    # @return [Configuration] application configuration
+    attr_reader :config
+
+    # Create a new application
+    def initialize
+      @router = Router.new
+      @middleware_stack = Middleware::Stack.new
+      @config = Configuration.new
+      @booted = false
+    end
+
+    # Configure the application
+    #
+    # @yield [Configuration] configuration object
+    # @return [self]
+    #
+    # @example
+    #   configure do
+    #     self.secret_key = 'my-secret'
+    #     self.log_level = :debug
+    #   end
+    def configure(&block)
+      @config.instance_eval(&block) if block_given?
+      self
+    end
+
+    # Define routes using the router DSL
+    #
+    # @yield [Router] router instance
+    # @return [self]
+    #
+    # @example
+    #   routes do
+    #     root to: 'home#index'
+    #     resources :users
+    #   end
+    def routes(&block)
+      @router.draw(&block)
+      self
+    end
+
+    # Add middleware to the stack
+    #
+    # @param middleware [Class] middleware class
+    # @param args [Array] middleware arguments
+    # @param options [Hash] middleware options
+    # @return [self]
+    #
+    # @example
+    #   use Tarsier::Middleware::Logger
+    #   use Tarsier::Middleware::CORS, origins: ['*']
+    def use(middleware, *args, **options)
+      @middleware_stack.use(middleware, *args, **options)
+      self
+    end
+
+    # Define a GET route (Flask-style)
+    #
+    # @param path [String] route path
+    # @param to [String, Proc, nil] route handler
+    # @yield request handler block
+    # @return [self]
+    #
+    # @example
+    #   get('/') { { status: 'ok' } }
+    #   get('/users/:id') { |req| User.find(req.params[:id]) }
+    def get(path, to: nil, **options, &block)
+      add_inline_route(:get, path, to, **options, &block)
+    end
+
+    # Define a POST route (Flask-style)
+    #
+    # @param path [String] route path
+    # @param to [String, Proc, nil] route handler
+    # @yield request handler block
+    # @return [self]
+    def post(path, to: nil, **options, &block)
+      add_inline_route(:post, path, to, **options, &block)
+    end
+
+    # Define a PUT route (Flask-style)
+    #
+    # @param path [String] route path
+    # @param to [String, Proc, nil] route handler
+    # @yield request handler block
+    # @return [self]
+    def put(path, to: nil, **options, &block)
+      add_inline_route(:put, path, to, **options, &block)
+    end
+
+    # Define a PATCH route (Flask-style)
+    #
+    # @param path [String] route path
+    # @param to [String, Proc, nil] route handler
+    # @yield request handler block
+    # @return [self]
+    def patch(path, to: nil, **options, &block)
+      add_inline_route(:patch, path, to, **options, &block)
+    end
+
+    # Define a DELETE route (Flask-style)
+    #
+    # @param path [String] route path
+    # @param to [String, Proc, nil] route handler
+    # @yield request handler block
+    # @return [self]
+    def delete(path, to: nil, **options, &block)
+      add_inline_route(:delete, path, to, **options, &block)
+    end
+
+    # Boot the application (compile routes, etc.)
+    #
+    # @return [self]
+    def boot!
+      return self if @booted
+
+      @router.compile!
+      @booted = true
+      self
+    end
+
+    # Check if application is booted
+    #
+    # @return [Boolean]
+    def booted?
+      @booted
+    end
+
+    # Rack interface
+    #
+    # @param env [Hash] Rack environment
+    # @return [Array] Rack response tuple [status, headers, body]
+    def call(env)
+      boot! unless @booted
+
+      request = Request.new(env)
+      response = Response.new
+
+      begin
+        @middleware_stack.call(request, response, method(:dispatch))
+      rescue RouteNotFoundError => e
+        handle_not_found(request, response, e)
+      rescue StandardError => e
+        handle_error(request, response, e)
+      end
+
+      response.finish
+    end
+
+    # Direct dispatch (bypasses Rack for performance)
+    #
+    # @param request [Request] request object
+    # @param response [Response] response object
+    # @return [Response]
+    def dispatch(request, response)
+      match = @router.match(request.method, request.path)
+
+      unless match
+        raise RouteNotFoundError.new(request.method, request.path)
+      end
+
+      route, params = match
+      request = Request.new(request.env, params)
+
+      execute_route(route, request, response)
+    end
+
+    # Get a named route path
+    #
+    # @param name [Symbol] route name
+    # @param params [Hash] route parameters
+    # @return [String]
+    def path_for(name, params = {})
+      @router.path_for(name, params)
+    end
+
+    # Get all routes (for debugging/inspection)
+    #
+    # @return [Array<Route>]
+    def routes_list
+      @router.routes
+    end
+
+    private
+
+    def add_inline_route(method, path, to, **options, &block)
+      handler = block || to
+      @router.send(method, path, to: handler, **options)
+      self
+    end
+
+    def execute_route(route, request, response)
+      if route.proc_handler?
+        execute_proc_handler(route, request, response)
+      else
+        execute_controller_action(route, request, response)
+      end
+
+      response
+    end
+
+    def execute_proc_handler(route, request, response)
+      handler = route.handler
+      result = case handler.arity
+               when 0 then handler.call
+               when 1 then handler.call(request)
+               else handler.call(request, response)
+               end
+
+      # Auto-render hash as JSON
+      response.json(result) if result.is_a?(Hash) && !response.sent?
+    end
+
+    def execute_controller_action(route, request, response)
+      controller_class = resolve_controller_class(route.controller_class)
+      action = route.action_name
+
+      unless controller_class.method_defined?(action)
+        raise ActionNotFoundError.new(controller_class, action)
+      end
+
+      controller = controller_class.new(request, response, action)
+      controller.dispatch
+    end
+
+    def resolve_controller_class(class_name)
+      return class_name if class_name.is_a?(Class)
+
+      class_name.split("::").reduce(Object) do |mod, name|
+        mod.const_get(name)
+      end
+    end
+
+    def handle_not_found(request, response, error)
+      response.status = 404
+      response.content_type = "application/json"
+      response.body = JSON.generate({ error: "Not Found", path: error.path })
+    end
+
+    def handle_error(request, response, error)
+      response.status = 500
+      response.content_type = "application/json"
+
+      body = { error: error.class.name, message: error.message }
+      body[:backtrace] = error.backtrace&.first(10) if Tarsier.development?
+
+      response.body = JSON.generate(body)
+      log_error(error) if Tarsier.production?
+    end
+
+    def log_error(error)
+      warn "[Tarsier] #{error.class}: #{error.message}"
+      warn error.backtrace&.first(5)&.join("\n")
+    end
+  end
+
+  # Application configuration
+  #
+  # @since 0.1.0
+  class Configuration
+    # @return [String] secret key for sessions and CSRF
+    attr_accessor :secret_key
+
+    # @return [Symbol] session storage type
+    attr_accessor :session_store
+
+    # @return [Symbol] log level
+    attr_accessor :log_level
+
+    # @return [Boolean] serve static files
+    attr_accessor :static_files
+
+    # @return [Symbol] default response format
+    attr_accessor :default_format
+
+    # @return [Boolean] force SSL
+    attr_accessor :force_ssl
+
+    # @return [String] server host
+    attr_accessor :host
+
+    # @return [Integer] server port
+    attr_accessor :port
+
+    def initialize
+      @secret_key = ENV["TARSIER_SECRET_KEY"]
+      @session_store = :cookie
+      @log_level = :info
+      @static_files = true
+      @default_format = :json
+      @force_ssl = false
+      @host = "0.0.0.0"
+      @port = 7827
+    end
+
+    # Set configuration from hash
+    #
+    # @param options [Hash] configuration options
+    def set(options)
+      options.each do |key, value|
+        send("#{key}=", value) if respond_to?("#{key}=")
+      end
+    end
+  end
+end

data/lib/tarsier/cli/commands/console.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Tarsier
+  class CLI
+    module Commands
+      class Console
+        HELP = <<~HELP
+          Usage: tarsier console [options]
+
+          Start an interactive console with your application loaded.
+
+          Options:
+            -e, --env ENV    Environment to load (default: development)
+
+          Examples:
+            tarsier console
+            tarsier console -e production
+        HELP
+
+        def self.show_help
+          puts HELP
+        end
+
+        def self.run(args)
+          options = parse_options(args)
+          ENV["TARSIER_ENV"] = options[:env]
+
+          puts "Tarsier Console (#{options[:env]})"
+          puts "Type 'exit' to quit"
+          puts
+
+          load_application
+          start_repl
+        end
+
+        def self.parse_options(args)
+          options = { env: "development" }
+
+          i = 0
+          while i < args.length
+            case args[i]
+            when "-e", "--env"
+              options[:env] = args[i + 1]
+              i += 2
+            else
+              i += 1
+            end
+          end
+
+          options
+        end
+
+        def self.load_application
+          if File.exist?("config/application.rb")
+            require "./config/application"
+          elsif File.exist?("app.rb")
+            require "./app"
+          end
+        rescue LoadError => e
+          puts "Warning: Could not load application: #{e.message}"
+        end
+
+        def self.start_repl
+          require "irb"
+          IRB.start
+        rescue LoadError
+          simple_repl
+        end
+
+        def self.simple_repl
+          loop do
+            print "tarsier> "
+            input = gets&.chomp
+            break if input.nil? || input == "exit"
+
+            begin
+              result = eval(input) # rubocop:disable Security/Eval
+              puts "=> #{result.inspect}"
+            rescue StandardError => e
+              puts "Error: #{e.message}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tarsier/cli/commands/generate.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Tarsier
+  class CLI
+    module Commands
+      class Generate
+        HELP = <<~HELP
+          Usage: tarsier generate <type> <name> [options]
+
+          Generate various components for your Tarsier application.
+
+          Types:
+            controller NAME [actions]  Generate a controller with optional actions
+            model NAME [attributes]    Generate a model with optional attributes
+            resource NAME [attrs]      Generate model, controller, and routes
+            middleware NAME            Generate a middleware class
+            migration NAME             Generate a database migration
+
+          Examples:
+            tarsier generate controller users index show create
+            tarsier generate model user name:string email:string
+            tarsier generate resource post title:string body:text
+            tarsier generate middleware authentication
+        HELP
+
+        def self.show_help
+          puts HELP
+        end
+
+        def self.run(args)
+          type = args.shift
+          name = args.shift
+
+          if type.nil?
+            puts "Error: Please specify what to generate"
+            show_help
+            exit 1
+          end
+
+          if name.nil?
+            puts "Error: Please provide a name"
+            exit 1
+          end
+
+          case type
+          when "controller", "c"
+            generate_controller(name, args)
+          when "model", "m"
+            generate_model(name, args)
+          when "resource", "r"
+            generate_resource(name, args)
+          when "middleware"
+            generate_middleware(name)
+          when "migration"
+            generate_migration(name, args)
+          else
+            puts "Unknown generator: #{type}"
+            show_help
+            exit 1
+          end
+        end
+
+        def self.generate_controller(name, actions)
+          Generators::Controller.new(name, actions).generate
+        end
+
+        def self.generate_model(name, attributes)
+          Generators::Model.new(name, attributes).generate
+        end
+
+        def self.generate_resource(name, attributes)
+          Generators::Resource.new(name, attributes).generate
+        end
+
+        def self.generate_middleware(name)
+          Generators::Middleware.new(name).generate
+        end
+
+        def self.generate_migration(name, columns)
+          Generators::Migration.new(name, columns).generate
+        end
+      end
+    end
+  end
+end

data/lib/tarsier/cli/commands/help.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Tarsier
+  class CLI
+    module Commands
+      class Help
+        BANNER = <<~BANNER
+          Tarsier - A modern, high-performance Ruby web framework
+
+          Usage: tarsier <command> [options]
+
+          Commands:
+            new APP_NAME       Create a new Tarsier application
+            generate (g)       Generate controllers, models, etc.
+            server (s)         Start the development server
+            console (c)        Start an interactive console
+            routes (r)         Display all routes
+            version (v)        Show Tarsier version
+            help               Show this help message
+
+          Run 'tarsier <command> --help' for more information on a specific command.
+        BANNER
+
+        def self.run(args)
+          if args.first
+            show_command_help(args.first)
+          else
+            puts BANNER
+          end
+        end
+
+        def self.show_command_help(command)
+          case command
+          when "new", "n"
+            New.show_help
+          when "generate", "g"
+            Generate.show_help
+          when "server", "s"
+            Server.show_help
+          when "routes", "r"
+            Routes.show_help
+          else
+            puts "Unknown command: #{command}"
+            puts BANNER
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tarsier/cli/commands/new.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Tarsier
+  class CLI
+    module Commands
+      class New
+        HELP = <<~HELP
+          Usage: tarsier new APP_NAME [options]
+
+          Create a new Tarsier application with the given name.
+
+          Options:
+            --api          Create an API-only application (no views)
+            --minimal      Create a minimal application
+            --skip-git     Skip git initialization
+            --skip-bundle  Skip bundle install
+
+          Examples:
+            tarsier new my_app
+            tarsier new my_api --api
+            tarsier new my_app --minimal
+        HELP
+
+        def self.show_help
+          puts HELP
+        end
+
+        def self.run(args)
+          options = parse_options(args)
+          app_name = args.first
+
+          if app_name.nil? || app_name.empty?
+            puts "Error: Please provide an application name"
+            puts "Usage: tarsier new APP_NAME"
+            exit 1
+          end
+
+          Generator.new(app_name, options).generate
+        end
+
+        def self.parse_options(args)
+          options = { api: false, minimal: false, skip_git: false, skip_bundle: false }
+
+          args.delete_if do |arg|
+            case arg
+            when "--api" then options[:api] = true
+            when "--minimal" then options[:minimal] = true
+            when "--skip-git" then options[:skip_git] = true
+            when "--skip-bundle" then options[:skip_bundle] = true
+            else false
+            end
+          end
+
+          options
+        end
+      end
+    end
+  end
+end