radical 1.0.0

data/lib/radical/model.rb

@@ -0,0 +1,128 @@
+require_relative 'database'
+
+module Radical
+  class ModelNotFound < StandardError; end
+
+  class Model
+    class << self
+      attr_accessor :table_name
+
+      def database(name)
+        conn = SQLite3::Database.new name
+        conn.results_as_hash = true
+        conn.type_translation = true
+        Database.connection = conn
+      end
+
+      def prepend_migrations_path(path)
+        Database.migrations_path = path
+      end
+
+      def db
+        Database.connection
+      end
+
+      def table(name)
+        self.table_name = name
+      end
+
+      def columns
+        sql = "select name from pragma_table_info('#{table_name}');"
+
+        @columns ||= db.execute(sql).map { |r| r['name'] }
+      end
+
+      def save_columns
+        columns.reject { |c| %w[id created_at updated_at].include?(c) }
+      end
+
+      def find(id)
+        sql = "select * from #{table_name} where id = ? limit 1"
+
+        row = db.get_first_row sql, [id.to_i]
+
+        raise ModelNotFound, 'Record not found' unless row
+
+        new(row)
+      end
+
+      def all
+        sql = "select * from #{table_name} order by id"
+
+        rows = db.execute sql
+
+        rows.map { |r| new(r) }
+      end
+    end
+
+    def initialize(params = {})
+      columns.each do |column|
+        self.class.attr_accessor column.to_sym
+        instance_variable_set "@#{column}", params[column]
+      end
+    end
+
+    def columns
+      self.class.columns
+    end
+
+    def save_columns
+      self.class.save_columns
+    end
+
+    def db
+      self.class.db
+    end
+
+    def table_name
+      self.class.table_name
+    end
+
+    def delete
+      sql = "delete from #{table_name} where id = ? limit 1"
+
+      db.execute sql, id.to_i
+
+      self
+    end
+
+    def update(params)
+      save_columns.each { |c| instance_variable_set("@#{c}", params[c]) }
+
+      save
+    end
+
+    def save
+      values = save_columns.map { |c| instance_variable_get("@#{c}") }
+
+      if saved?
+        sql = <<-SQL
+          update #{table_name} set #{save_columns.map { |c| "#{c}=?" }.join(',')}, updated_at = ? where id = ?
+        SQL
+
+        db.transaction do |t|
+          t.execute sql, values + [Time.now.to_i, id]
+          self.class.find(id)
+        end
+      else
+        sql = <<-SQL
+          insert into #{table_name} (
+            #{save_columns.join(',')}
+          )
+          values (
+            #{save_columns.map { '?' }.join(',')}
+          )
+        SQL
+
+        db.transaction do |t|
+          t.execute sql, values
+          self.class.find t.last_insert_row_id
+        end
+      end
+    end
+
+    def saved?
+      !id.nil?
+    end
+  end
+end

data/lib/radical/router.rb

@@ -0,0 +1,144 @@
+# typed: true
+require 'rack'
+require 'sorbet-runtime'
+
+# A very naive router for radical
+#
+# This class loops over routes for each http method (GET, POST, etc.)
+# and checks a simple regex built at startup
+#
+# '/users/:id' => "/users/:^#{path.gsub(/:(\w+)/, '(?<\1>[a-zA-Z0-9]+)')}$"
+#
+# Example:
+#
+# router = Router.new do
+#   get '/users/:id', to: 'users#show'
+# end
+#
+# router.route(
+#   {
+#     'PATH_INFO' => '/users/1',
+#     'REQUEST_METHOD' => 'GET'
+#   }
+# ) => 'users#show(1)'
+#
+# Dispatches to:
+#
+# class UsersController < Controller
+#   def show
+#     render plain: "users#show(#{params['id']})"
+#   end
+# end
+module Radical
+  class Router
+    extend T::Sig
+
+    ACTIONS = [
+      [:index, 'GET', ''],
+      [:new, 'GET', '/new'],
+      [:show, 'GET', '/:id'],
+      [:create, 'POST', ''],
+      [:edit, 'GET', '/:id/edit'],
+      [:update, 'PUT', '/:id'],
+      [:update, 'PATCH', '/:id'],
+      [:destroy, 'DELETE', '/:id']
+    ].freeze
+
+    RESOURCE_ACTIONS = [
+      [:show, 'GET', ''],
+      [:edit, 'GET', '/edit'],
+      [:update, 'PUT', ''],
+      [:update, 'PATCH', ''],
+      [:destroy, 'DELETE', '']
+    ].freeze
+
+    attr_accessor :routes
+
+    sig { void }
+    def initialize
+      @routes = Hash.new { |hash, key| hash[key] = [] }
+    end
+
+    sig { params(classes: T::Array[Class]).returns(String) }
+    def route_prefix(classes)
+      classes.map(&:route_name).map { |n| "#{n}/:#{n}_id" }.join('/')
+    end
+
+    sig { params(klass: Class).void }
+    def add_root(klass)
+      add_actions(klass, name: '')
+    end
+
+    sig { params(klass: Class, name: T.nilable(String), prefix: T.nilable(String), actions: Array).void }
+    def add_actions(klass, name: nil, prefix: nil, actions: ACTIONS)
+      name ||= klass.route_name
+
+      actions.each do |method, http_method, suffix|
+        next unless klass.method_defined?(method)
+
+        path = "/#{prefix}#{name}#{suffix}"
+        path = Regexp.new("^#{path.gsub(/:(\w+)/, '(?<\1>[a-zA-Z0-9_]+)')}$")
+
+        if %i[index create show update destroy].include?(method) && !klass.method_defined?(:"#{klass.route_name}_path")
+          klass.define_method :"#{klass.route_name}_path" do |obj = nil|
+            if obj.is_a?(Model)
+              "/#{klass.route_name}/#{obj.id}"
+            else
+              "/#{klass.route_name}"
+            end
+          end
+        end
+
+        if method == :new
+          klass.define_method :"new_#{klass.route_name}_path" do
+            "/#{klass.route_name}/new"
+          end
+        end
+
+        if method == :edit
+          klass.define_method :"edit_#{klass.route_name}_path" do |obj|
+            "/#{klass.route_name}/#{obj.id}/edit"
+          end
+        end
+
+        @routes[http_method] << [path, [klass, method]]
+      end
+    end
+
+    sig { params(classes: T::Array[Class], prefix: T.nilable(String), actions: Array).void }
+    def add_routes(classes, prefix: nil, actions: ACTIONS)
+      classes.each do |klass|
+        add_actions(klass, prefix: prefix, actions: actions)
+      end
+    end
+
+    sig { params(request: Rack::Request).returns(Rack::Response) }
+    def route(request)
+      params = T.let({}, T.nilable(Hash))
+
+      route = @routes[request.request_method].find do |r|
+        params = request.path_info.match(r.first)&.named_captures
+      end
+
+      return Rack::Response.new('404 Not Found', 404) unless route
+
+      klass, method = route.last
+
+      params.each do |k, v|
+        request.update_param(k, v)
+      end
+
+      instance = klass.new(request)
+
+      response = instance.public_send(method)
+
+      return response if response.is_a?(Rack::Response)
+
+      body = instance.view(method.to_s)
+
+      return Rack::Response.new(nil, 404) if body.nil?
+
+      Rack::Response.new(body, 200, { 'Content-Type' => 'text/html' })
+    end
+  end
+end

data/lib/radical/table.rb

@@ -0,0 +1,23 @@
+module Radical
+  class Table
+    attr_accessor :columns
+
+    def initialize(table)
+      @table = table
+      @columns = []
+    end
+
+    def string(name)
+      @columns << "#{name} text"
+    end
+
+    def integer(name)
+      @columns << "#{name} integer"
+    end
+
+    def timestamps
+      @columns << "created_at integer not null default(strftime('%s', 'now'))"
+      @columns << 'updated_at integer'
+    end
+  end
+end

data/lib/radical/view.rb

@@ -0,0 +1,58 @@
+require 'erubi'
+require 'tilt'
+
+module Radical
+  class CaptureEngine < ::Erubi::Engine
+    private
+
+    BLOCK_EXPR = /\s*((\s+|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/.freeze
+
+    def add_expression(indicator, code)
+      if BLOCK_EXPR.match?(code) && %w[== =].include?(indicator)
+        src << ' ' << code
+      else
+        super
+      end
+    end
+  end
+
+  class View
+    class << self
+      attr_accessor :_views_path, :_layout
+
+      def view_path(dir, name)
+        filename = File.join(@_views_path, 'views', dir, "#{name}.erb")
+
+        raise "Could not find view file: #{filename}. You need to create it." unless File.exist?(filename)
+
+        filename
+      end
+
+      def template(dir, name)
+        Tilt.new(view_path(dir, name), engine_class: CaptureEngine, escape_html: true)
+      end
+
+      def path(path = nil, test = Env.test?)
+        @_views_path = path || ((test ? 'test' : '') + __dir__)
+      end
+
+      def layout(name)
+        @_layout = name
+      end
+
+      def render(dir, name, scope, options = {})
+        t = template(dir, name)
+
+        if @_layout && options[:layout] != false
+          layout = template('', @_layout)
+
+          layout.render(scope, {}) do
+            t.render scope
+          end
+        else
+          t.render scope
+        end
+      end
+    end
+  end
+end

data/lib/radical.rb

@@ -0,0 +1,4 @@
+require_relative 'radical/app'
+require_relative 'radical/controller'
+require_relative 'radical/view'
+require_relative 'radical/model'

data/radical.gemspec

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+Gem::Specification.new do |spec|
+  spec.platform      = Gem::Platform::RUBY
+  spec.name          = 'radical'
+  spec.version       = '1.0.0'
+  spec.author        = 'Sean Walker'
+  spec.email         = 'sean@swlkr.com'
+
+  spec.summary       = 'Rails inspired web framework'
+  spec.description   = 'This gem helps you write rails-like web applications'
+  spec.homepage      = 'https://github.com/swlkr/radical'
+  spec.license       = 'MIT'
+
+  if spec.respond_to?(:metadata)
+    spec.metadata['homepage_uri'] = spec.homepage
+    spec.metadata['source_code_uri'] = 'https://github.com/swlkr/radical'
+    spec.metadata['changelog_uri'] = 'https://github.com/swlkr/radical/CHANGELOG.md'
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against ' \
+      'public gem pushes.'
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(docs|examples|test|Dockerfile|\.rubocop.yml|\.solargraph.yml|\.github)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'minitest', '~> 5.14'
+  spec.add_development_dependency 'puma', '~> 5.5'
+  spec.add_development_dependency 'rack-test', '~> 1.1'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'sorbet', '~> 0.5'
+
+  spec.add_dependency 'erubi', '~> 1.10'
+  spec.add_dependency 'rack', '~> 2.2'
+  spec.add_dependency 'rack_csrf', '~> 2.6'
+  spec.add_dependency 'rack-flash3', '~> 1.0'
+  spec.add_dependency 'sorbet-runtime', '~> 0.5'
+  spec.add_dependency 'sqlite3', '~> 1.4'
+  spec.add_dependency 'tilt', '~> 2.0'
+end

data/sorbet/config

@@ -0,0 +1,3 @@
+--dir
+.
+--ignore=/vendor/bundle

data/sorbet/rbi/sorbet-typed/lib/minitest/all/minitest.rbi

@@ -0,0 +1,108 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi sorbet-typed
+#
+# If you would like to make changes to this file, great! Please upstream any changes you make here:
+#
+#   https://github.com/sorbet/sorbet-typed/edit/master/lib/minitest/all/minitest.rbi
+#
+# typed: strong
+
+module Minitest
+  class Runnable
+  end
+
+  class Test < Runnable
+    include Minitest::Assertions
+  end
+
+  sig { void }
+  def self.autorun; end
+
+  sig { params(args: T::Array[String]).returns(T::Boolean) }
+  def self.run(args = []); end
+end
+
+module Minitest::Assertions
+  extend T::Sig
+
+  sig { params(test: T.untyped, msg: T.nilable(String)).returns(TrueClass) }
+  def assert(test, msg = nil); end
+
+  sig do
+    params(
+      exp: BasicObject,
+      msg: T.nilable(String)
+    ).returns(TrueClass)
+  end
+  def assert_empty(exp, msg = nil); end
+
+  sig do
+    params(
+      exp: BasicObject,
+      act: BasicObject,
+      msg: T.nilable(String)
+    ).returns(TrueClass)
+  end
+  def assert_equal(exp, act, msg = nil); end
+
+  sig do
+    params(
+      collection: T::Enumerable[T.untyped],
+      obj: BasicObject,
+      msg: T.nilable(String)
+    ).returns(TrueClass)
+  end
+  def assert_includes(collection, obj, msg = nil); end
+
+  sig do
+    params(
+      obj: BasicObject,
+      msg: T.nilable(String)
+    ).returns(TrueClass)
+  end
+  def assert_nil(obj, msg = nil); end
+
+  sig do
+    params(
+      exp: T.untyped
+    ).returns(StandardError)
+  end
+  def assert_raises(*exp, &block); end
+
+  sig { params(test: T.untyped, msg: T.nilable(String)).returns(TrueClass) }
+  def refute(test, msg = nil); end
+
+  sig do
+    params(
+      exp: BasicObject,
+      msg: T.nilable(String)
+    ).returns(TrueClass)
+  end
+  def refute_empty(exp, msg = nil); end
+
+  sig do
+    params(
+      exp: BasicObject,
+      act: BasicObject,
+      msg: T.nilable(String)
+    ).returns(TrueClass)
+  end
+  def refute_equal(exp, act, msg = nil); end
+
+  sig do
+    params(
+      collection: T::Enumerable[T.untyped],
+      obj: BasicObject,
+      msg: T.nilable(String)
+    ).returns(TrueClass)
+  end
+  def refute_includes(collection, obj, msg = nil); end
+
+  sig do
+    params(
+      obj: BasicObject,
+      msg: T.nilable(String)
+    ).returns(TrueClass)
+  end
+  def refute_nil(obj, msg = nil); end
+end