tarsier 0.1.0

data/lib/tarsier/cli/generators/middleware.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Tarsier
+  class CLI
+    module Generators
+      class Middleware < Base
+        def generate
+          create_file(middleware_path, middleware_content)
+          create_file(spec_path, spec_content)
+          puts "\nMiddleware generated successfully!"
+          puts "Add to your application:"
+          puts "  use #{camelize(name)}Middleware"
+        end
+
+        private
+
+        def middleware_path
+          "app/middleware/#{underscore(name)}_middleware.rb"
+        end
+
+        def spec_path
+          "spec/middleware/#{underscore(name)}_middleware_spec.rb"
+        end
+
+        def middleware_content
+          <<~RUBY
+            # frozen_string_literal: true
+
+            class #{camelize(name)}Middleware < Tarsier::Middleware::Base
+              def call(request, response)
+                # Before request processing
+                before(request, response)
+
+                # Call next middleware/app
+                @app.call(request, response)
+
+                # After request processing
+                after(request, response)
+
+                response
+              end
+
+              private
+
+              def before(request, response)
+                # Add your before logic here
+              end
+
+              def after(request, response)
+                # Add your after logic here
+              end
+            end
+          RUBY
+        end
+
+        def spec_content
+          <<~RUBY
+            # frozen_string_literal: true
+
+            require "spec_helper"
+
+            RSpec.describe #{camelize(name)}Middleware do
+              let(:app) { ->(req, res) { res } }
+              let(:middleware) { described_class.new(app) }
+
+              describe "#call" do
+                it "passes request to next middleware" do
+                  request = double("request")
+                  response = double("response")
+
+                  expect(app).to receive(:call).with(request, response)
+                  middleware.call(request, response)
+                end
+              end
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/tarsier/cli/generators/migration.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Tarsier
+  class CLI
+    module Generators
+      class Migration < Base
+        def initialize(name, columns = [])
+          super(name)
+          @columns = parse_columns(columns)
+          @timestamp = Time.now.strftime("%Y%m%d%H%M%S")
+        end
+
+        def generate
+          create_file(migration_path, migration_content)
+          puts "\nMigration generated successfully!"
+          puts "Run: tarsier db:migrate"
+        end
+
+        private
+
+        def parse_columns(cols)
+          cols.map do |col|
+            name, type = col.split(":")
+            type ||= "string"
+            { name: name, type: type }
+          end
+        end
+
+        def migration_path
+          "db/migrations/#{@timestamp}_#{underscore(name)}.rb"
+        end
+
+        def migration_content
+          if name.start_with?("create_")
+            create_table_migration
+          elsif name.start_with?("add_")
+            add_column_migration
+          else
+            generic_migration
+          end
+        end
+
+        def create_table_migration
+          table_name = name.sub(/^create_/, "")
+          <<~RUBY
+            # frozen_string_literal: true
+
+            class #{camelize(name)} < Tarsier::Migration
+              def up
+                create_table :#{table_name} do |t|
+            #{column_definitions}
+                  t.timestamps
+                end
+              end
+
+              def down
+                drop_table :#{table_name}
+              end
+            end
+          RUBY
+        end
+
+        def add_column_migration
+          match = name.match(/^add_(.+)_to_(.+)$/)
+          column_name = match ? match[1] : "column"
+          table_name = match ? match[2] : "table"
+
+          <<~RUBY
+            # frozen_string_literal: true
+
+            class #{camelize(name)} < Tarsier::Migration
+              def up
+                add_column :#{table_name}, :#{column_name}, :string
+              end
+
+              def down
+                remove_column :#{table_name}, :#{column_name}
+              end
+            end
+          RUBY
+        end
+
+        def generic_migration
+          <<~RUBY
+            # frozen_string_literal: true
+
+            class #{camelize(name)} < Tarsier::Migration
+              def up
+                # Add your migration code here
+              end
+
+              def down
+                # Add rollback code here
+              end
+            end
+          RUBY
+        end
+
+        def column_definitions
+          return "      # Add columns here" if @columns.empty?
+
+          @columns.map do |col|
+            "      t.#{col[:type]} :#{col[:name]}"
+          end.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/tarsier/cli/generators/model.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Tarsier
+  class CLI
+    module Generators
+      class Model < Base
+        TYPES = {
+          "string" => ":string",
+          "text" => ":text",
+          "integer" => ":integer",
+          "float" => ":float",
+          "boolean" => ":boolean",
+          "datetime" => ":datetime",
+          "date" => ":date",
+          "json" => ":json"
+        }.freeze
+
+        def initialize(name, attributes = [])
+          super(name)
+          @attributes = parse_attributes(attributes)
+        end
+
+        def generate
+          create_file(model_path, model_content)
+          create_file(spec_path, spec_content)
+          puts "\nModel generated successfully!"
+        end
+
+        private
+
+        def parse_attributes(attrs)
+          attrs.map do |attr|
+            name, type = attr.split(":")
+            type ||= "string"
+            { name: name, type: TYPES[type] || ":string" }
+          end
+        end
+
+        def model_path
+          "app/models/#{underscore(name)}.rb"
+        end
+
+        def spec_path
+          "spec/models/#{underscore(name)}_spec.rb"
+        end
+
+        def model_content
+          <<~RUBY
+            # frozen_string_literal: true
+
+            class #{camelize(name)} < Tarsier::Model
+              table_name "#{pluralize(underscore(name))}"
+
+            #{attribute_definitions}
+            #{validation_definitions}
+            end
+          RUBY
+        end
+
+        def attribute_definitions
+          return "  # Add attributes here" if @attributes.empty?
+
+          @attributes.map do |attr|
+            "  attribute :#{attr[:name]}, #{attr[:type]}"
+          end.join("\n")
+        end
+
+        def validation_definitions
+          return "" if @attributes.empty?
+
+          "\n" + @attributes.map do |attr|
+            "  # validates :#{attr[:name]}, presence: true"
+          end.join("\n")
+        end
+
+        def spec_content
+          <<~RUBY
+            # frozen_string_literal: true
+
+            require "spec_helper"
+
+            RSpec.describe #{camelize(name)} do
+              describe "validations" do
+            #{validation_specs}
+              end
+
+              describe "associations" do
+                pending "add association tests"
+              end
+            end
+          RUBY
+        end
+
+        def validation_specs
+          return '    pending "add validation tests"' if @attributes.empty?
+
+          @attributes.map do |attr|
+            <<~RUBY.chomp
+                it "has #{attr[:name]} attribute" do
+                  model = described_class.new(#{attr[:name]}: "test")
+                  expect(model.#{attr[:name]}).to eq("test")
+                end
+            RUBY
+          end.join("\n\n")
+        end
+      end
+    end
+  end
+end

data/lib/tarsier/cli/generators/resource.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Tarsier
+  class CLI
+    module Generators
+      class Resource < Base
+        ACTIONS = %w[index show new create edit update destroy].freeze
+
+        def initialize(name, attributes = [])
+          super(name)
+          @attributes = attributes
+        end
+
+        def generate
+          puts "Generating resource: #{name}"
+          puts
+
+          Model.new(name, @attributes).generate
+          Controller.new(name, ACTIONS).generate
+
+          puts "\nAdd to config/routes.rb:"
+          puts "  resources :#{pluralize(underscore(name))}"
+        end
+      end
+    end
+  end
+end

data/lib/tarsier/cli/loader.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# Load all CLI components
+require_relative "../cli"
+require_relative "commands/help"
+require_relative "commands/version"
+require_relative "commands/new"
+require_relative "commands/generate"
+require_relative "commands/server"
+require_relative "commands/console"
+require_relative "commands/routes"
+require_relative "generators/base"
+require_relative "generators/controller"
+require_relative "generators/model"
+require_relative "generators/resource"
+require_relative "generators/middleware"
+require_relative "generators/migration"
+require_relative "generators/app"

data/lib/tarsier/cli.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "optparse"
+require "fileutils"
+
+module Tarsier
+  # Command-line interface for Tarsier framework
+  class CLI
+    COMMANDS = %w[new generate server console routes version help].freeze
+    ALIASES = { "g" => "generate", "s" => "server", "c" => "console", "r" => "routes", "n" => "new", "v" => "version" }.freeze
+
+    class << self
+      def start(args = ARGV)
+        new(args).run
+      end
+    end
+
+    def initialize(args)
+      @args = args
+      @command = resolve_command(args.shift)
+    end
+
+    def run
+      case @command
+      when "new" then Commands::New.run(@args)
+      when "generate" then Commands::Generate.run(@args)
+      when "server" then Commands::Server.run(@args)
+      when "console" then Commands::Console.run(@args)
+      when "routes" then Commands::Routes.run(@args)
+      when "version" then Commands::Version.run(@args)
+      when "help", nil then Commands::Help.run(@args)
+      else
+        puts "Unknown command: #{@command}"
+        Commands::Help.run([])
+        exit 1
+      end
+    end
+
+    private
+
+    def resolve_command(cmd)
+      return nil if cmd.nil?
+      ALIASES[cmd] || cmd
+    end
+  end
+end

data/lib/tarsier/controller.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+module Tarsier
+  # Base controller class with filters, parameter validation, and rendering
+  class Controller
+    class << self
+      # Define parameter schema for actions
+      # @yield [ParamSchema] schema builder
+      def params(&block)
+        @param_schema ||= ParamSchema.new
+        @param_schema.instance_eval(&block) if block_given?
+        @param_schema
+      end
+
+      # Get parameter schema
+      # @return [ParamSchema, nil]
+      def param_schema
+        @param_schema
+      end
+
+      # Define a before filter
+      # @param method_name [Symbol] filter method name
+      # @param only [Array<Symbol>] actions to apply to
+      # @param except [Array<Symbol>] actions to exclude
+      def before_action(method_name, only: nil, except: nil)
+        filters[:before] << { method: method_name, only: only, except: except }
+      end
+
+      # Define an after filter
+      # @param method_name [Symbol] filter method name
+      # @param only [Array<Symbol>] actions to apply to
+      # @param except [Array<Symbol>] actions to exclude
+      def after_action(method_name, only: nil, except: nil)
+        filters[:after] << { method: method_name, only: only, except: except }
+      end
+
+      # Define an around filter
+      # @param method_name [Symbol] filter method name
+      # @param only [Array<Symbol>] actions to apply to
+      # @param except [Array<Symbol>] actions to exclude
+      def around_action(method_name, only: nil, except: nil)
+        filters[:around] << { method: method_name, only: only, except: except }
+      end
+
+      # Get all filters
+      # @return [Hash]
+      def filters
+        @filters ||= { before: [], after: [], around: [] }
+      end
+
+      # Rescue from specific exceptions
+      # @param exception_class [Class] exception class to rescue
+      # @param with [Symbol] handler method name
+      def rescue_from(exception_class, with:)
+        rescue_handlers[exception_class] = with
+      end
+
+      # Get rescue handlers
+      # @return [Hash]
+      def rescue_handlers
+        @rescue_handlers ||= {}
+      end
+
+      # Skip a before filter
+      # @param method_name [Symbol] filter method name
+      # @param only [Array<Symbol>] actions to skip for
+      # @param except [Array<Symbol>] actions to not skip for
+      def skip_before_action(method_name, only: nil, except: nil)
+        skipped_filters[:before] << { method: method_name, only: only, except: except }
+      end
+
+      # Get skipped filters
+      # @return [Hash]
+      def skipped_filters
+        @skipped_filters ||= { before: [], after: [], around: [] }
+      end
+    end
+
+    attr_reader :request, :response, :params, :action_name
+
+    # @param request [Request] the request object
+    # @param response [Response] the response object
+    # @param action [Symbol] the action to execute
+    def initialize(request, response, action)
+      @request = request
+      @response = response
+      @action_name = action.to_sym
+      @params = request.params
+      @halted = false
+    end
+
+    # Execute the controller action with filters
+    # @return [Response]
+    def dispatch
+      run_filters(:before)
+      return @response if halted?
+
+      run_around_filters do
+        validate_params! if self.class.param_schema
+        send(@action_name)
+      end
+
+      run_filters(:after) unless halted?
+      @response
+    rescue StandardError => e
+      handle_exception(e)
+    end
+
+    # Get validated parameters
+    # @return [Hash]
+    def validated_params
+      @validated_params ||= {}
+    end
+
+    # Render a response
+    # @param options [Hash] render options
+    def render(json: nil, html: nil, text: nil, status: 200, **options)
+      @response.status = status
+
+      if json
+        @response.json(json, status: status)
+      elsif html
+        @response.html(html, status: status)
+      elsif text
+        @response.text(text, status: status)
+      end
+    end
+
+    # Redirect to another URL
+    # @param url [String] redirect URL
+    # @param status [Integer] HTTP status code
+    def redirect_to(url, status: 302)
+      @response.redirect(url, status: status)
+      halt!
+    end
+
+    # Send a file
+    # @param path [String] file path
+    # @param options [Hash] options
+    def send_file(path, content_type: nil, filename: nil, disposition: "attachment")
+      raise Errno::ENOENT, path unless File.exist?(path)
+
+      content_type ||= guess_content_type(path)
+      filename ||= File.basename(path)
+
+      @response.set_header("Content-Type", content_type)
+      @response.set_header("Content-Disposition", "#{disposition}; filename=\"#{filename}\"")
+      @response.body = File.read(path)
+    end
+
+    # Stream response
+    # @yield [StreamWriter] stream writer
+    def stream(&block)
+      @response.stream(&block)
+    end
+
+    # Head-only response
+    # @param status [Integer] HTTP status code
+    # @param headers [Hash] additional headers
+    def head(status, **headers)
+      @response.status = status
+      headers.each { |k, v| @response.set_header(k.to_s, v) }
+      @response.body = ""
+    end
+
+    # Halt request processing
+    def halt!
+      @halted = true
+    end
+
+    # Check if processing is halted
+    # @return [Boolean]
+    def halted?
+      @halted
+    end
+
+    # Access session (if middleware is loaded)
+    # @return [Hash]
+    def session
+      @request.env["tarsier.session"] ||= {}
+    end
+
+    # Access flash messages
+    # @return [Hash]
+    def flash
+      session[:flash] ||= {}
+    end
+
+    protected
+
+    # Override in subclasses for custom authentication
+    def authenticate
+      # Default: no-op
+    end
+
+    # Override in subclasses for custom authorization
+    def authorize
+      # Default: no-op
+    end
+
+    private
+
+    def run_filters(type)
+      applicable_filters(type).each do |filter|
+        break if halted?
+        send(filter[:method])
+      end
+    end
+
+    def run_around_filters(&block)
+      around_filters = applicable_filters(:around)
+
+      if around_filters.empty?
+        yield
+      else
+        chain = around_filters.reverse.reduce(block) do |next_filter, filter|
+          -> { send(filter[:method]) { next_filter.call } }
+        end
+        chain.call
+      end
+    end
+
+    def applicable_filters(type)
+      all_filters = self.class.filters[type]
+      skipped = self.class.skipped_filters[type]
+
+      all_filters.select do |filter|
+        applies_to_action?(filter) && !skipped_for_action?(filter, skipped)
+      end
+    end
+
+    def applies_to_action?(filter)
+      return false if filter[:only] && !filter[:only].include?(@action_name)
+      return false if filter[:except] && filter[:except].include?(@action_name)
+      true
+    end
+
+    def skipped_for_action?(filter, skipped)
+      skipped.any? do |skip|
+        skip[:method] == filter[:method] && applies_to_action?(skip)
+      end
+    end
+
+    def validate_params!
+      @validated_params = self.class.param_schema.validate(@params)
+    end
+
+    def handle_exception(exception)
+      handler = find_rescue_handler(exception.class)
+
+      if handler
+        send(handler, exception)
+        @response
+      else
+        raise exception
+      end
+    end
+
+    def find_rescue_handler(exception_class)
+      self.class.rescue_handlers.each do |klass, handler|
+        return handler if exception_class <= klass
+      end
+      nil
+    end
+
+    def guess_content_type(path)
+      ext = File.extname(path).downcase
+      {
+        ".html" => "text/html",
+        ".css" => "text/css",
+        ".js" => "application/javascript",
+        ".json" => "application/json",
+        ".xml" => "application/xml",
+        ".png" => "image/png",
+        ".jpg" => "image/jpeg",
+        ".gif" => "image/gif",
+        ".svg" => "image/svg+xml",
+        ".pdf" => "application/pdf"
+      }[ext] || "application/octet-stream"
+    end
+  end
+end