radical 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 537aa5f33439e08833e0aca3ff572a0e017c20cdbfaa3d267c303191cc692fd0
-  data.tar.gz: 95ee9c628803bf81f237d15aa6c3d92a1d0c55f4412809eb4e74a57dd510e15c
+  metadata.gz: 3d14c9a576701105d60a08c6339a19aeebc080b6a4fd6f7235d8c5dec82ea287
+  data.tar.gz: b03f1d945e0f441401d99375062423dff70fa9c50cc394e470444d253faa46c4
 SHA512:
-  metadata.gz: f30a37e86df78f5beb7a345b96031a1d83779a723629a7b1ca3c70223d7cea94acfc277bea77d32b8461382fbed2f146b3bf69a732a77224fd4d586f7877811d
-  data.tar.gz: a322aef87deae2b114842c4a88ac31fc02f35258701770d9a2017158616a6d07229a5960de8879efbd403b286d4c1a53ec64ba7f9b7e202570734f8b9de0c5b1
+  metadata.gz: cbdbdd7c8a1a56755ef772bbd7ce24a197111d97d44be0d1c1f6a56be24361d1f80469583f4969c0d8b8d9500ce92a66333e71539e8a79b845f249659b72a6ec
+  data.tar.gz: d3425aef0d2a3d87788b7169ba81b67b8c71faed045227aaff586a699ad46482d0770cfaacf0a738d787bb28b20be42c47b7d88ef79eda5632af5abe91da1e1b

data/.rubocop.yml

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

data/CHANGELOG.md

@@ -1,9 +1,50 @@
 # 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]
+# [Unreleased]
+
+# 1.2.0 (2021-12-17)
+
+- *Breaking* Support only one level of nested resources, make them shallow only
+- *Breaking* Move `db/migrations` to `migrations`
+- *Breaking* Change `<%== f.button 'Save' %>` to `<%== f.submit 'Save' %>`
+- *Breaking* Change the form helpers from `model[name]` to just `name`, it's cleaner.
+- Add `Radical.env.[development?|production?|test?]`
+- Add `_path` support for nested resource routes
+- Add a random secret to the session cookie on startup
+- Add asset concatention + compression (no minification yet)
+- Remove dependence on rack-flash3
+- Add security headers
+- Add session configuration with `session` method in `App`
+- Move all `_path` method definitions to `Radical::Controller`
+- Add `exe/rad`
+- Add `rad g mvc Todo(s) name:text done_at:integer` generators
+- Add attrs to form helpers
+- Add `rad g app` generator
+- Add migrate/rollback `rad` commands
+
+# 1.1.0 (2021-12-06)
+
+- *Breaking* `root`, `resource` and `resources` methods no longer take class constants
+- *Breaking* Move route class methods to `Routes` class instead of `App`
+- *Breaking* Create migration class, use migration classes in migrate!
+- *Breaking* Make routes take symbols or strings, not classes to better line up with models
+- *Breaking* Move connection string handling to database
+- Make everything use `frozen_string_literal`
+- Purposefully never add callbacks, `before_action` or autoloading
+
+# 1.0.2 (2021-12-02)
+
+- Set default views / migrations paths
+
+# 1.0.1 (2021-12-02)
+
+- Fix changelog link in gemspec
+
+# 1.0.0 (2021-12-01)
 
 - Very basic understanding of how much memory it takes for a basic ruby app
 - Start to integrate controllers and routing
@@ -25,3 +66,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 - Use Rack::Test
 - Rename routes to resources; add resource method
 - Add nested resources, multi-argument resources
+- Use rack sessions, rack-csrf and rack-flash3
+- Add naive migrations
+- Add naive models
+- Add naive form helper

data/Gemfile

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

data/README.md

@@ -27,8 +27,12 @@ class Home < Radical::Controller
   end
 end
 
+class Routes < Radical::Routes
+  root :Home
+end
+
 class App < Radical::App
-  root Home
+  routes Routes
 end
 
 run App

data/exe/rad

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/radical/generator'
+require_relative '../lib/radical/database'
+require 'optparse'
+
+@options = {}
+
+OptionParser.new do |opts|
+  opts.on('-v', '--verbose', 'Show extra information') do
+    @options[:verbose] = true
+  end
+
+  opts.on('-h', '--help', 'Show help information') do
+    @options[:help] = true
+  end
+end.parse!
+
+generate = Radical::Generator.new(ARGV[2], ARGV.drop(3)) if %w[g generate].include?(ARGV.first)
+
+case ARGV[0..1]
+when %w[g mvc], %w[generate mvc]
+  generate.mvc
+when %w[g model], %w[generate model]
+  generate.migration
+  generate.model
+when %w[g controller], %w[generate controller]
+  generate.controller
+when %w[g views], %w[generate views]
+  generate.views
+when %w[g migration], %w[generate migration]
+  generate.migration(model: false)
+when %w[g app]
+  generate.app
+when %w[migrate]
+  Radical::Database.migrate!
+when %w[rollback]
+  Radical::Database.rollback!
+else
+  puts 'Command not supported'
+end

data/lib/radical/app.rb

@@ -1,9 +1,16 @@
+# frozen_string_literal: true
+
+require 'securerandom'
 require 'rack'
-require 'rack/flash'
 require 'rack/csrf'
 
-require_relative 'router'
+require_relative 'asset'
+require_relative 'assets'
+require_relative 'asset_compiler'
 require_relative 'env'
+require_relative 'flash'
+require_relative 'routes'
+require_relative 'security_headers'
 
 # The main entry point for a Radical application
 #
@@ -31,24 +38,39 @@ require_relative 'env'
 module Radical
   class App
     class << self
-      def root(klass)
-        router.add_root(klass)
+      def routes(route_class)
+        @routes = route_class
       end
 
-      def resource(klass)
-        router.add_actions(klass, actions: Router::RESOURCE_ACTIONS)
+      def assets(&block)
+        @assets = Assets.new
+
+        block.call(@assets)
       end
 
-      def resources(*classes, &block)
-        prefix = "#{router.route_prefix(@parents)}/" if instance_variable_defined?(:@parents)
+      def compile_assets
+        @assets.compile
+      end
 
-        router.add_routes(classes, prefix: prefix)
+      def serve_assets
+        @serve_assets = true
+      end
 
-        return unless block
+      def security_headers(headers = {})
+        @security_headers = headers
+      end
+
+      def session(options = {})
+        defaults = {
+          path: '/',
+          secret: session_secret,
+          http_only: true,
+          same_site: :lax,
+          secure: env.production?,
+          expire_after: 2_592_000 # 30 days
+        }
 
-        @parents ||= []
-        @parents << classes.last
-        block.call
+        @session = defaults.merge(options)
       end
 
       def env
@@ -56,8 +78,12 @@ module Radical
       end
 
       def app
-        router = self.router
+        router = @routes.router
         env = self.env
+        assets = @assets
+        serve_assets = @serve_assets
+        security_headers = @security_headers || {}
+        session = @session || self.session
 
         @app ||= Rack::Builder.app do
           use Rack::CommonLogger
@@ -65,23 +91,29 @@ module Radical
           use Rack::Runtime
           use Rack::MethodOverride
           use Rack::ContentLength
-          use Rack::Deflater
           use Rack::ETag
+          use Rack::Deflater
           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::Session::Cookie, session
           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
+          use Flash
+          use SecurityHeaders, security_headers
+
+          if serve_assets || env.development?
+            use Rack::Static, urls: ['/assets', '/public'],
+                              header_rules: [
+                                [/\.(?:css\.gz)$/, { 'Content-Type' => 'text/css', 'Content-Encoding' => 'gzip' }],
+                                [/\.(?:js\.gz)$/, { 'Content-Type' => 'application/javascript', 'Content-Encoding' => 'gzip' }],
+                                [/\.(?:css\.br)$/, { 'Content-Type' => 'text/css', 'Content-Encoding' => 'br' }],
+                                [/\.(?:js\.br)$/, { 'Content-Type' => 'application/javascript', 'Content-Encoding' => 'br' }]
+                              ]
+          end
 
           run lambda { |rack_env|
             begin
-              router.route(Rack::Request.new(rack_env)).finish
+              router.route(Rack::Request.new(rack_env), options: { assets: assets }).finish
             rescue ModelNotFound
               raise unless env.production?
 
@@ -91,13 +123,15 @@ module Radical
         end
       end
 
-      def router
-        @router ||= Router.new
-      end
-
       def call(env)
         app.call(env)
       end
+
+      private
+
+      def session_secret
+        @session_secret ||= (ENV['SESSION_SECRET'] || SecureRandom.hex(32))
+      end
     end
   end
 end

data/lib/radical/asset.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Radical
+  class Asset
+    attr_reader :path
+
+    def initialize(filename, path:)
+      @filename = filename
+      @path = path
+    end
+
+    def full_path
+      File.join(path, @filename)
+    end
+
+    def content
+      File.read(full_path)
+    end
+
+    def ext
+      File.extname(@filename)
+    end
+  end
+end

data/lib/radical/asset_compiler.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'brotli'
+require 'digest'
+require 'zlib'
+
+module Radical
+  class AssetCompiler
+    def self.gzip(filename, content)
+      # nil, 31 == support for gunzip
+      File.write(filename, Zlib::Deflate.new(nil, 31).deflate(content, Zlib::FINISH))
+    end
+
+    def self.compile(assets, path:, compressor: :none)
+      s = assets.map(&:content).join("\n")
+      ext = assets.first.ext
+
+      # hash the contents of each concatenated asset
+      hash = Digest::SHA1.hexdigest s
+
+      # use hash to bust the cache
+      name = "#{hash}#{ext}"
+      filename = File.join(path, name)
+
+      case compressor
+      when :gzip
+        name = "#{name}.gz"
+        gzip("#{filename}.gz", s)
+      when :brotli
+        name = "#{name}.br"
+        File.write("#{filename}.br", Brotli.deflate(s, mode: :text, quality: 11))
+      else
+        File.write(filename, s)
+      end
+
+      # output asset path for browser
+      "/assets/#{name}"
+    end
+  end
+end

data/lib/radical/assets.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Radical
+  class Assets
+    attr_accessor :assets_path, :compiled, :assets
+
+    def initialize
+      @assets = {
+        css: [],
+        js: []
+      }
+      @compressor = :none
+      @assets_path = File.join(__dir__, 'assets')
+      @compiled = {}
+    end
+
+    def css(filenames)
+      @assets[:css] = filenames
+    end
+
+    def js(filenames)
+      @assets[:js] = filenames
+    end
+
+    def prepend_assets_path(path)
+      @assets_path = File.join(path, 'assets')
+    end
+
+    def brotli
+      @compressor = :brotli
+    end
+
+    def gzip
+      @compressor = :gzip
+    end
+
+    def compile
+      css = @assets[:css].map { |f| Asset.new(f, path: File.join(@assets_path, 'css')) }
+      js = @assets[:js].map { |f| Asset.new(f, path: File.join(@assets_path, 'js')) }
+
+      @compiled[:css] = AssetCompiler.compile(css, path: @assets_path, compressor: @compressor)
+      @compiled[:js] = AssetCompiler.compile(js, path: @assets_path, compressor: @compressor)
+    end
+  end
+end

data/lib/radical/controller.rb

@@ -1,4 +1,6 @@
 # typed: true
+# frozen_string_literal: true
+
 require 'rack/utils'
 require 'rack/request'
 require 'rack/response'
@@ -29,7 +31,7 @@ module Radical
 
       sig { returns(String) }
       def route_name
-        to_s.split('::').last.gsub(/Controller$/, '').gsub(/([A-Z])/, '_\1')[1..-1].downcase
+        Strings.snake_case to_s.split('::').last.gsub(/Controller$/, '')
       end
 
       sig { params(actions: Symbol).void }
@@ -70,9 +72,12 @@ module Radical
       end
     end
 
-    sig { params(request: Rack::Request).void }
-    def initialize(request)
+    attr_reader :options
+
+    sig { params(request: Rack::Request, options: T.nilable(Hash)).void }
+    def initialize(request, options: {})
       @request = request
+      @options = options
     end
 
     sig { params(status: T.any(Symbol, Integer)).returns(Rack::Response) }
@@ -90,14 +95,14 @@ module Radical
       @request.params
     end
 
-    sig { params(name: T.any(String, Symbol)).returns(String) }
-    def view(name)
-      View.render(self.class.route_name, name, self)
+    sig { params(name: T.any(String, Symbol), locals: T.nilable(Hash)).returns(String) }
+    def view(name, locals = {})
+      View.render(self.class.route_name, name, self, { locals: locals })
     end
 
-    sig { params(name: T.any(String, Symbol)).returns(String) }
-    def partial(name)
-      View.render(self.class.route_name, "_#{name}", self, layout: false)
+    sig { params(name: T.any(String, Symbol), locals: T.nilable(Hash)).returns(String) }
+    def partial(name, locals = {})
+      View.render(self.class.route_name, "_#{name}", self, { locals: locals, layout: false })
     end
 
     sig { params(options: Hash, block: T.proc.void).returns(String) }
@@ -128,17 +133,55 @@ module Radical
       @request.env['rack.session']
     end
 
+    def assets_path(type)
+      assets = options[:assets]
+
+      if Env.production?
+        compiled_assets_path(assets, type)
+      else
+        not_compiled_assets_path(assets, type)
+      end
+    end
+
+    def compiled_assets_path(assets, type)
+      if type == :css
+        link_tag(assets.compiled[:css])
+      else
+        script_tag(assets.compiled[:js])
+      end
+    end
+
+    def not_compiled_assets_path(assets, type)
+      if type == :css
+        assets.assets[:css].map do |asset|
+          link_tag("/assets/#{type}/#{asset}")
+        end.join("\n")
+      else
+        assets.assets[:js].map do |asset|
+          script_tag("/assets/#{type}/#{asset}")
+        end.join("\n")
+      end
+    end
+
     private
 
     def emit(tag)
-      @output = '' if @output.nil?
+      @output = String.new if @output.nil?
       @output << tag.to_s
     end
 
     def capture(block)
-      @output = eval('_buf', block.binding)
+      @output = eval '_buf', block.binding
       yield
       @output
     end
+
+    def script_tag(src)
+      "<script type=\"application/javascript\" src=\"#{src}\"></script>"
+    end
+
+    def link_tag(href)
+      "<link rel=\"stylesheet\" type=\"text/css\" href=\"#{href}\" />"
+    end
   end
 end

data/lib/radical/database.rb

@@ -1,40 +1,67 @@
+# frozen_string_literal: true
+
 require 'sqlite3'
 require_relative 'table'
+require_relative 'migration'
 
 module Radical
   class Database
     class << self
-      attr_accessor :connection, :migrations_path
+      attr_writer :connection_string
+      attr_accessor :migrations_path
+
+      def connection_string
+        @connection_string || ENV['DATABASE_URL']
+      end
+
+      def connection
+        conn = SQLite3::Database.new(connection_string)
+        conn.results_as_hash = true
+        conn.type_translation = true
+
+        @connection ||= conn
+      end
+
+      def prepend_migrations_path(path)
+        self.migrations_path = path
+      end
 
       def db
         connection
       end
 
-      def migrate!
-        @migrate = true
+      def migration(file)
+        context = Module.new
+        context.class_eval(File.read(file), file)
+        const = context.constants.find do |constant|
+          context.const_get(constant).ancestors.include?(Radical::Migration)
+        end
+
+        context.const_get(const)
+      end
 
+      def migrate!
         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)]
+        pending_migrations.each do |file|
+          puts "Executing migration #{file}"
+
+          v = version(file)
+
+          migration(file).migrate!(db: db, version: v)
         end
       end
 
       def rollback!
-        @rollback = true
-
         db.execute 'create table if not exists radical_migrations ( version integer primary key )'
 
-        migration = applied_migrations.last
+        file = applied_migrations.last
 
-        puts "Rolling back migration #{migration}"
+        puts "Rolling back migration #{file}"
 
-        sql = eval File.read(migration)
-        db.execute sql
-        db.execute 'delete from radical_migrations where version = ?', [version(migration)]
+        v = version(file)
+
+        migration(file).rollback!(db: db, version: v)
       end
 
       def applied_versions
@@ -53,40 +80,12 @@ module Radical
       end
 
       def migrations
-        Dir[File.join(migrations_path, 'db', 'migrations', '*.rb')].sort
+        Dir[File.join(migrations_path || '.', '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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # typed: true
 
 module Radical