radical 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 537aa5f33439e08833e0aca3ff572a0e017c20cdbfaa3d267c303191cc692fd0
+  data.tar.gz: 95ee9c628803bf81f237d15aa6c3d92a1d0c55f4412809eb4e74a57dd510e15c
+SHA512:
+  metadata.gz: f30a37e86df78f5beb7a345b96031a1d83779a723629a7b1ca3c70223d7cea94acfc277bea77d32b8461382fbed2f146b3bf69a732a77224fd4d586f7877811d
+  data.tar.gz: a322aef87deae2b114842c4a88ac31fc02f35258701770d9a2017158616a6d07229a5960de8879efbd403b286d4c1a53ec64ba7f9b7e202570734f8b9de0c5b1

data/.rubocop.yml

@@ -0,0 +1,4 @@
+Style/FrozenStringLiteralComment:
+  Enabled: false
+Style/Documentation:
+  Enabled: false

data/.solargraph.yml

@@ -0,0 +1,10 @@
+---
+include:
+  - "**/*.rb"
+exclude:
+  - spec/**/*
+  - test/**/*
+  - vendor/**/*
+  - ".bundle/**/*"
+reporters:
+  - rubocop

data/CHANGELOG.md

@@ -0,0 +1,27 @@
+# Changelog
+All notable changes to this project will be documented in this file
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
+
+## [Unreleased]
+
+- Very basic understanding of how much memory it takes for a basic ruby app
+- Start to integrate controllers and routing
+- Add url params support to router
+- Simple (not efficient) loop through routes and compare regex routing
+- Bring in rack as a dependency in the gemspec
+- Actually make everything work with rack for real
+- Add an examples folder to test it out with real http requests!
+- Add very simple ERB views
+- Experiment with tilt
+- Better view stuff, no tilt yet
+- Use Rack::Request and Rack::Response
+- Automatically render view from controller if a Rack::Response isn't returned
+- Update tests
+- Experiment with a module based mvc thing, didn't pan out
+- Only allow resource routes, custom method names will not be found
+- Add a bunch of rack middleware
+- Move call to class
+- Use Rack::Test
+- Rename routes to resources; add resource method
+- Add nested resources, multi-argument resources

data/Dockerfile

@@ -0,0 +1,34 @@
+FROM docker.io/library/ruby:slim
+
+RUN apt-get update -qq
+RUN apt-get install -y build-essential libsqlite3-dev git-core
+
+RUN apt-get install -y --no-install-recommends libjemalloc2
+RUN rm -rf /var/lib/apt/lists/*
+
+ENV LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libjemalloc.so.2
+
+ARG USER=app
+ARG GROUP=app
+ARG UID=1101
+ARG GID=1101
+
+RUN groupadd --gid $GID $GROUP
+RUN useradd --uid $UID --gid $GID --groups $GROUP -ms /bin/bash $USER
+
+RUN mkdir -p /var/app
+RUN chown -R $USER:$GROUP /var/app
+
+USER $USER
+WORKDIR /var/app
+
+ENV BUNDLER_VERSION='2.2.27'
+RUN gem install bundler --no-document -v '2.2.27'
+
+COPY --chown=$USER Gemfile* /var/app/
+COPY --chown=$USER *.gemspec /var/app/
+RUN bundle install
+
+COPY --chown=$USER . /var/app
+
+CMD ["rake"]

data/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Sean Walker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,49 @@
+# radical
+
+A rails inspired ruby web framework
+
+# Learning
+
+Check out the `examples/` folder for some ideas on how to get started and when  you're ready, check the `docs/` folder for more details.
+
+# Quickstart
+
+Create a directory with a `config.ru` and a `Gemfile` file inside of it
+
+```sh
+mkdir your_project
+cd your_project
+touch config.ru Gemfile
+```
+
+Put this inside of the `config.ru`
+
+```rb
+require 'radical'
+
+class Home < Radical::Controller
+  def index
+    plain '/'
+  end
+end
+
+class App < Radical::App
+  root Home
+end
+
+run App
+```
+
+Install the gems and start the server
+
+```sh
+gem install radical puma
+puma
+```
+
+Test it out
+
+```sh
+curl localhost:9292
+# => /
+```

data/Rakefile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/**/test*.rb']
+end
+
+desc 'Run tests'
+task default: :test

data/lib/radical/app.rb

@@ -0,0 +1,103 @@
+require 'rack'
+require 'rack/flash'
+require 'rack/csrf'
+
+require_relative 'router'
+require_relative 'env'
+
+# The main entry point for a Radical application
+#
+# Example:
+#
+# class App < Radical::App
+#   root Home
+# end
+#
+# App.call(
+#   {
+#     'PATH_INFO' => '/',
+#     'REQUEST_METHOD' => 'GET'
+#   }
+# )
+#
+# Dispatches to:
+#
+# class Controller < Radical::Controller
+#   # GET /
+#   def index
+#     head :ok
+#   end
+# end
+module Radical
+  class App
+    class << self
+      def root(klass)
+        router.add_root(klass)
+      end
+
+      def resource(klass)
+        router.add_actions(klass, actions: Router::RESOURCE_ACTIONS)
+      end
+
+      def resources(*classes, &block)
+        prefix = "#{router.route_prefix(@parents)}/" if instance_variable_defined?(:@parents)
+
+        router.add_routes(classes, prefix: prefix)
+
+        return unless block
+
+        @parents ||= []
+        @parents << classes.last
+        block.call
+      end
+
+      def env
+        Env
+      end
+
+      def app
+        router = self.router
+        env = self.env
+
+        @app ||= Rack::Builder.app do
+          use Rack::CommonLogger
+          use Rack::ShowExceptions if env.development?
+          use Rack::Runtime
+          use Rack::MethodOverride
+          use Rack::ContentLength
+          use Rack::Deflater
+          use Rack::ETag
+          use Rack::Head
+          use Rack::ConditionalGet
+          use Rack::ContentType
+          use Rack::Session::Cookie, path: '/',
+                                     secret: ENV['SESSION_SECRET'],
+                                     http_only: true,
+                                     same_site: :lax,
+                                     secure: env.production?,
+                                     expire_after: 2_592_000 # 30 days
+          use Rack::Csrf, raise: env.development?, skip: router.routes.values.flatten.select { |a| a.is_a?(Class) }.uniq.map(&:skip_csrf_actions).flatten(1)
+          use Rack::Flash, sweep: true
+
+          run lambda { |rack_env|
+            begin
+              router.route(Rack::Request.new(rack_env)).finish
+            rescue ModelNotFound
+              raise unless env.production?
+
+              Rack::Response.new('404 Not Found', 404).finish
+            end
+          }
+        end
+      end
+
+      def router
+        @router ||= Router.new
+      end
+
+      def call(env)
+        app.call(env)
+      end
+    end
+  end
+end

data/lib/radical/controller.rb

@@ -0,0 +1,144 @@
+# typed: true
+require 'rack/utils'
+require 'rack/request'
+require 'rack/response'
+require 'sorbet-runtime'
+require_relative 'view'
+require_relative 'env'
+require_relative 'form'
+
+module Radical
+  class Controller
+    extend T::Sig
+
+    attr_accessor :request
+
+    class << self
+      extend T::Sig
+
+      attr_accessor :skip_csrf_actions
+
+      sig { params(path: String).void }
+      def prepend_view_path(path)
+        View.path path
+      end
+
+      def layout(name)
+        View.layout name
+      end
+
+      sig { returns(String) }
+      def route_name
+        to_s.split('::').last.gsub(/Controller$/, '').gsub(/([A-Z])/, '_\1')[1..-1].downcase
+      end
+
+      sig { params(actions: Symbol).void }
+      def skip_csrf(*actions)
+        @skip_csrf_actions = [] if @skip_csrf_actions.nil?
+
+        actions.each do |action|
+          @skip_csrf_actions << "#{action_to_http_method(action)}:#{action_to_url(action)}"
+        end
+      end
+
+      sig { params(action: Symbol).returns(String) }
+      def action_to_url(action)
+        case action
+        when :index, :create
+          "/#{route_name}"
+        when :show, :update, :destroy
+          "/#{route_name}/:id"
+        when :new
+          "/#{route_name}/new"
+        when :edit
+          "/#{route_name}/:id/edit"
+        end
+      end
+
+      sig { params(action: Symbol).returns(String) }
+      def action_to_http_method(action)
+        case action
+        when :index, :show, :new, :edit
+          'GET'
+        when :create
+          'POST'
+        when :update
+          'PATCH'
+        when :destroy
+          'DELETE'
+        end
+      end
+    end
+
+    sig { params(request: Rack::Request).void }
+    def initialize(request)
+      @request = request
+    end
+
+    sig { params(status: T.any(Symbol, Integer)).returns(Rack::Response) }
+    def head(status)
+      Rack::Response.new(nil, Rack::Utils::SYMBOL_TO_STATUS_CODE[status])
+    end
+
+    sig { params(body: String).returns(Rack::Response) }
+    def plain(body)
+      Rack::Response.new(body, 200, { 'Content-Type' => 'text/plain' })
+    end
+
+    sig { returns(Hash) }
+    def params
+      @request.params
+    end
+
+    sig { params(name: T.any(String, Symbol)).returns(String) }
+    def view(name)
+      View.render(self.class.route_name, name, self)
+    end
+
+    sig { params(name: T.any(String, Symbol)).returns(String) }
+    def partial(name)
+      View.render(self.class.route_name, "_#{name}", self, layout: false)
+    end
+
+    sig { params(options: Hash, block: T.proc.void).returns(String) }
+    def form(options, &block)
+      f = Form.new(options, self)
+
+      capture(block) do
+        emit f.open_tag
+        emit f.csrf_tag
+        emit f.rack_override_tag
+        yield f
+        emit f.close_tag
+      end
+    end
+
+    sig { params(to: T.any(Symbol, String)).returns(Rack::Response) }
+    def redirect(to)
+      to = self.class.action_to_url(to) if to.is_a?(Symbol)
+
+      Rack::Response.new(nil, 302, { 'Location' => to })
+    end
+
+    def flash
+      @request.env['rack.session']['__FLASH__']
+    end
+
+    def session
+      @request.env['rack.session']
+    end
+
+    private
+
+    def emit(tag)
+      @output = '' if @output.nil?
+      @output << tag.to_s
+    end
+
+    def capture(block)
+      @output = eval('_buf', block.binding)
+      yield
+      @output
+    end
+  end
+end

data/lib/radical/database.rb

@@ -0,0 +1,92 @@
+require 'sqlite3'
+require_relative 'table'
+
+module Radical
+  class Database
+    class << self
+      attr_accessor :connection, :migrations_path
+
+      def db
+        connection
+      end
+
+      def migrate!
+        @migrate = true
+
+        db.execute 'create table if not exists radical_migrations ( version integer primary key )'
+
+        pending_migrations.each do |migration|
+          puts "Executing migration #{migration}"
+          sql = eval File.read(migration)
+          db.execute sql
+          db.execute 'insert into radical_migrations (version) values (?)', [version(migration)]
+        end
+      end
+
+      def rollback!
+        @rollback = true
+
+        db.execute 'create table if not exists radical_migrations ( version integer primary key )'
+
+        migration = applied_migrations.last
+
+        puts "Rolling back migration #{migration}"
+
+        sql = eval File.read(migration)
+        db.execute sql
+        db.execute 'delete from radical_migrations where version = ?', [version(migration)]
+      end
+
+      def applied_versions
+        sql = 'select * from radical_migrations order by version'
+        rows = db.execute sql
+
+        rows.map { |r| r['version'] }
+      end
+
+      def applied_migrations
+        migrations.select { |f| applied_versions.include?(version(f)) }
+      end
+
+      def pending_migrations
+        migrations.reject { |f| applied_versions.include?(version(f)) }
+      end
+
+      def migrations
+        Dir[File.join(migrations_path, 'db', 'migrations', '*.rb')].sort
+      end
+
+      def version(filename)
+        filename.split(File::SEPARATOR).last.split('_').first.to_i
+      end
+
+      def migration(&block)
+        block.call
+      end
+
+      def change(&block)
+        @change = true
+
+        block.call
+      end
+
+      def up(&block)
+        block.call
+      end
+
+      def down(&block)
+        block.call
+      end
+
+      def create_table(name, &block)
+        return "drop table #{name}" if @change && @rollback
+
+        table = Table.new(name)
+
+        block.call(table)
+
+        "create table #{name} ( id integer primary key, #{table.columns.join(',')} )"
+      end
+    end
+  end
+end

data/lib/radical/env.rb

@@ -0,0 +1,23 @@
+# typed: true
+
+module Radical
+  class Env
+    class << self
+      def radical_env
+        ENV['RADICAL_ENV'] || ''
+      end
+
+      def development?
+        radical_env.downcase == 'development'
+      end
+
+      def test?
+        radical_env.downcase == 'test'
+      end
+
+      def production?
+        radical_env.downcase == 'production'
+      end
+    end
+  end
+end

data/lib/radical/form.rb

@@ -0,0 +1,47 @@
+require 'rack/csrf'
+
+module Radical
+  class Form
+    def initialize(options, controller)
+      @model = options[:model]
+      @controller = controller
+      @route_name = @controller.class.route_name
+      @override_method = options[:method]&.upcase || (@model.saved? ? 'PATCH' : 'POST')
+      @method = %w[GET POST].include?(@override_method) ? @override_method : 'POST'
+
+      @action = if @model.saved?
+                  @controller.public_send(:"#{@route_name}_path", @model)
+                else
+                  @controller.public_send(:"#{@route_name}_path")
+                end
+    end
+
+    def text(name)
+      "<input type=text name=#{@route_name}[#{name}] value=\"#{@model.public_send(name)}\" />"
+    end
+
+    def button(name)
+      "<button type=submit>#{name}</button>"
+    end
+
+    def submit(value)
+      "<input type=submit value=#{value} />"
+    end
+
+    def open_tag
+      "<form action=#{@action} method=#{@method}>"
+    end
+
+    def csrf_tag
+      Rack::Csrf.tag(@controller.request.env)
+    end
+
+    def rack_override_tag
+      "<input type=hidden name=_method value=#{@override_method} />" unless %w[GET POST].include?(@override_method)
+    end
+
+    def close_tag
+      '</form>'
+    end
+  end
+end