radical 1.1.0 → 1.2.0

data/lib/radical/generator/app/controllers/controller.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class Controller < Radical::Controller
+end

data/lib/radical/generator/app/models/model.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class Model < Radical::Model
+end

data/lib/radical/generator/app/routes.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Routes < Radical::Routes
+  # root :Home
+end

data/lib/radical/generator/blank_migration.rb

@@ -0,0 +1,11 @@
+<<~RB
+  # frozen_string_literal: true
+
+  class #{@name.capitalize} < Radical::Migration
+    up do
+    end
+
+    down do
+    end
+  end
+RB

data/lib/radical/generator/controller.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+<<~RB
+  # frozen_string_literal: true
+
+  class #{plural_constant} < Controller
+    def index
+      @#{plural} = #{singular_constant}.all
+    end
+
+    def show; end
+
+    def new
+      @#{singular} = #{singular_constant}.new
+    end
+
+    def create
+      @#{singular} = #{singular_constant}.new(#{singular}_params)
+
+      if @#{singular}.save
+        flash[:success] = '#{singular_constant} created'
+        redirect #{plural}_path
+      else
+        render :new
+      end
+    end
+
+    def edit; end
+
+    def update
+      if #{singular}.update(#{singular}_params)
+        flash[:success] = '#{singular_constant} updated'
+        redirect #{plural}_path
+      else
+        render :edit
+      end
+    end
+
+    def destroy
+      if #{singular}.destroy
+        flash[:success] = '#{singular_constant} destroyed'
+      else
+        flash[:error] = 'Error destroying #{singular_constant}'
+      end
+
+      redirect #{plural}_path
+    end
+
+    private
+
+    def #{singular}_params
+      params['#{singular}'].slice(#{params})
+    end
+
+    def #{singular}
+      @#{singular} = #{singular_constant}.find(params['id'])
+    end
+  end
+RB

data/lib/radical/generator/migration.rb

@@ -0,0 +1,13 @@
+<<~RB
+  # frozen_string_literal: true
+
+  class CreateTable#{plural_constant} < Radical::Migration
+    change do
+      create_table :#{plural} do |t|
+        #{columns(leading: 8)}
+
+        t.timestamps
+      end
+    end
+  end
+RB

data/lib/radical/generator/model.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+<<~RB
+  # frozen_string_literal: true
+
+  class #{singular_constant} < Model
+    table '#{plural}'
+  end
+RB

data/lib/radical/generator/views/_form.rb

@@ -0,0 +1,6 @@
+<<~ERB
+  <%== form model: #{singular} do |f| %>
+    #{inputs(leading: 4)}
+    <%== f.submit 'Save' %>
+  <% end %>
+ERB

data/lib/radical/generator/views/edit.rb

@@ -0,0 +1,3 @@
+<<~ERB
+  <%== partial 'form' %>
+ERB

data/lib/radical/generator/views/index.rb

@@ -0,0 +1,24 @@
+<<~ERB
+  <a href="<%= new_#{plural}_path %>">New #{singular}</a>
+
+  <table>
+    <thead>
+      #{th(leading: 6)}
+      <th></th>
+    </thead>
+    <tbody>
+      <% @#{plural}.each do |#{singular}| %>
+        <tr>
+          #{td(leading: 10)}
+          <td>
+            <a href="<%= #{plural}_path(#{singular}) %>">show</a>
+            <a href="<%= edit_#{plural}_path(#{singular}) %>">edit</a>
+            <%== form model: #{singular}, method: :delete do |f| %>
+              <%== f.submit 'delete' %>
+            <% end %>
+          </td>
+        </tr>
+      <% end %>
+    </tbody>
+  </table>
+ERB

data/lib/radical/generator/views/new.rb

@@ -0,0 +1,4 @@
+<<~ERB
+  <%== partial 'form' %>
+ERB
+

data/lib/radical/generator/views/show.rb

@@ -0,0 +1,5 @@
+<<~ERB
+  <%= #{singular}.name %>
+
+  <a href="<%== #{plural}_path %>">Index</a>
+ERB

data/lib/radical/generator.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'securerandom'
+
+module Radical
+  class Generator
+    def initialize(name, props)
+      @name = name
+      @props = props
+    end
+
+    def mvc
+      migration
+      model
+      views
+      controller
+    end
+
+    def migration(model: true)
+      dir = File.join(Dir.pwd, 'migrations')
+      FileUtils.mkdir_p dir
+
+      template = instance_eval File.read(File.join(__dir__, 'generator', "#{model ? '' : 'blank_'}migration.rb"))
+      migration_name = model ? "#{Time.now.to_i}_create_table_#{plural}.rb" : "#{Time.now.to_i}_#{@name}.rb"
+      filename = File.join(dir, migration_name)
+
+      write(filename, template)
+    end
+
+    def model
+      template = instance_eval File.read File.join(__dir__, 'generator', 'model.rb')
+      dir = File.join(Dir.pwd, 'models')
+      FileUtils.mkdir_p dir
+      filename = File.join(dir, "#{singular}.rb")
+
+      write(filename, template)
+    end
+
+    def controller
+      template = instance_eval File.read File.join(__dir__, 'generator', 'controller.rb')
+      dir = File.join(Dir.pwd, 'controllers')
+      FileUtils.mkdir_p dir
+      filename = File.join(dir, "#{plural}.rb")
+
+      write(filename, template)
+    end
+
+    def views
+      dir = File.join(Dir.pwd, 'views', plural)
+      FileUtils.mkdir_p dir
+
+      Dir[File.join(__dir__, 'generator', 'views', '*.rb')].sort.each do |template|
+        contents = instance_eval File.read template
+        filename = File.join(dir, "#{File.basename(template, '.rb')}.erb")
+
+        write(filename, contents)
+      end
+    end
+
+    def app
+      @name = nil if @name == '.'
+      parts = [Dir.pwd, @name].compact
+      dir = File.join(*parts)
+      FileUtils.mkdir_p dir
+
+      %w[
+        assets/css
+        assets/js
+        controllers
+        migrations
+        models
+        views
+      ].each do |dir_|
+        puts "Creating directory #{dir_}"
+        FileUtils.mkdir_p File.join(dir, dir_)
+      end
+
+      Dir[File.join(__dir__, 'generator', 'app', '**', '*.*')].sort.each do |template|
+        contents = File.read(template)
+        filename = File.join(dir, File.path(template).gsub("#{__dir__}/generator/app/", ''))
+
+        write(filename, contents)
+      end
+
+      # Explicitly include .env
+      template = File.join(__dir__, 'generator', 'app', '.env')
+      contents = instance_eval File.read(template)
+      filename = File.join(dir, '.env')
+      write(filename, contents)
+    end
+
+    private
+
+    def write(filename, contents)
+      if File.exist?(filename)
+        puts "Skipped #{File.basename(filename)}"
+      else
+        File.write(filename, contents)
+        puts "Created #{filename}"
+      end
+    end
+
+    def singular_constant
+      @name.gsub(/\(.*\)/, '')
+    end
+
+    def plural_constant
+      @name.gsub(/[)(]/, '')
+    end
+
+    def singular
+      Strings.camel_case singular_constant
+    end
+
+    def plural
+      Strings.camel_case plural_constant
+    end
+
+    def columns(leading:)
+      @props
+        .map { |p| p.split(':') }
+        .map { |name, type| "t.#{type} #{name}" }
+        .join "#{' ' * leading}\n"
+    end
+
+    def th(leading:)
+      @props
+        .map { |p| p.split(':').first }
+        .map { |name| "<th>#{name}</th>" }
+        .join "#{' ' * leading}\n"
+    end
+
+    def td(leading:)
+      @props
+        .map { |p| p.split(':').first }
+        .map { |name| "<td><%= #{singular}.#{name} %></td>" }
+        .join "#{' ' * leading}\n"
+    end
+
+    def inputs(leading:)
+      @props
+        .map { |p| p.split(':').first }
+        .map { |name| "<%== f.text :#{name} %>" }
+        .join "#{' ' * leading}\n"
+    end
+
+    def params
+      @props
+        .map { |p| p.split(':').first }
+        .map { |name| "'#{name}'" }
+        .join ', '
+    end
+  end
+end

data/lib/radical/model.rb

@@ -49,7 +49,7 @@ module Radical
     def initialize(params = {})
       columns.each do |column|
         self.class.attr_accessor column.to_sym
-        instance_variable_set "@#{column}", params[column]
+        instance_variable_set "@#{column}", (params[column] || params[column.to_sym])
       end
     end
 

data/lib/radical/router.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # typed: true
+# frozen_string_literal: true
 
 require 'rack'
 require 'sorbet-runtime'
@@ -47,6 +47,8 @@ module Radical
     ].freeze
 
     RESOURCE_ACTIONS = [
+      [:new, 'GET', '/new'],
+      [:create, 'POST', ''],
       [:show, 'GET', ''],
       [:edit, 'GET', '/edit'],
       [:update, 'PUT', ''],
@@ -68,54 +70,31 @@ module Radical
 
     sig { params(klass: Class).void }
     def add_root(klass)
-      add_actions(klass, name: '')
+      add_routes(klass, name: '', actions: ACTIONS)
+      add_root_paths(klass)
     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_]+)')}$").freeze
-
-        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
+    sig { params(klass: Class).void }
+    def add_resource(klass)
+      add_routes(klass, actions: RESOURCE_ACTIONS)
+      add_resource_paths(klass)
     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)
+    sig { params(klass: Class, parents: T.nilable(T::Array[Class])).void }
+    def add_resources(klass, parents: nil)
+      if parents
+        parents.each do |scope|
+          add_routes(klass, actions: ACTIONS, scope: scope)
+          add_resources_paths(klass, scope: scope)
+        end
+      else
+        add_routes(klass, actions: ACTIONS)
+        add_resources_paths(klass)
       end
     end
 
-    sig { params(request: Rack::Request).returns(Rack::Response) }
-    def route(request)
+    sig { params(request: Rack::Request, options: T.nilable(Hash)).returns(Rack::Response) }
+    def route(request, options: {})
       params = T.let({}, T.nilable(Hash))
 
       route = @routes[request.request_method].find do |r|
@@ -130,7 +109,7 @@ module Radical
         request.update_param(k, v)
       end
 
-      instance = klass.new(request)
+      instance = klass.new(request, options: options)
 
       response = instance.public_send(method)
 
@@ -142,5 +121,125 @@ module Radical
 
       Rack::Response.new(body, 200, { 'Content-Type' => 'text/html' })
     end
+
+    private
+
+    sig { params(klass: Class, actions: Array, name: T.nilable(String), scope: T.nilable(Class)).void }
+    def add_routes(klass, actions:, name: nil, scope: nil)
+      name ||= klass.route_name
+
+      actions.each do |method, http_method, suffix|
+        next unless klass.method_defined?(method)
+
+        path = if scope
+                 if %i[index new create].include?(method)
+                   "/#{scope.route_name}/:#{scope.route_name}_id/#{name}#{suffix}"
+                 else
+                   "/#{name}#{suffix}"
+                 end
+               else
+                 "/#{name}#{suffix}"
+               end
+
+        path = Regexp.new("^#{path.gsub(/:(\w+)/, '(?<\1>[a-zA-Z0-9_]+)')}$").freeze
+
+        @routes[http_method] << [path, [klass, method]]
+      end
+    end
+
+    sig { params(klass: Class).void }
+    def add_root_paths(klass)
+      route_name = klass.route_name
+
+      if %i[index create show update destroy].any? { |method| klass.method_defined?(method) }
+        Controller.define_method :"#{route_name}_path" do |obj = nil|
+          if obj
+            "/#{obj.id}"
+          else
+            '/'
+          end
+        end
+      end
+
+      if klass.method_defined?(:new)
+        Controller.define_method :"new_#{route_name}_path" do
+          '/new'
+        end
+      end
+
+      return unless klass.method_defined?(:edit)
+
+      Controller.define_method :"edit_#{route_name}_path" do |obj|
+        "/#{obj.id}/edit"
+      end
+    end
+
+    sig { params(klass: Class).void }
+    def add_resource_paths(klass)
+      name = klass.route_name
+
+      if %i[create show update destroy].any? { |method| klass.method_defined?(method) }
+        Controller.define_method :"#{name}_path" do
+          "/#{name}"
+        end
+      end
+
+      if klass.method_defined?(:new)
+        Controller.define_method :"new_#{name}_path" do
+          "/#{name}/new"
+        end
+      end
+
+      return unless klass.method_defined?(:edit)
+
+      Controller.define_method :"edit_#{name}_path" do
+        "/#{name}/edit"
+      end
+    end
+
+    sig { params(klass: Class, scope: T.nilable(Class)).void }
+    def add_resources_paths(klass, scope: nil)
+      path_name = klass.route_name
+      scope_path_name = [scope&.route_name, klass.route_name].compact.join('_')
+      name = klass.route_name
+
+      if %i[index create show update destroy].any? { |method| klass.method_defined?(method) }
+        if scope
+          Controller.define_method :"#{scope_path_name}_path" do |parent|
+            "/#{scope.route_name}/#{parent.id}/#{name}"
+          end
+
+          Controller.define_method :"#{path_name}_path" do |obj|
+            "/#{name}/#{obj.id}"
+          end
+        else
+          Controller.define_method :"#{path_name}_path" do |obj = nil|
+            if obj
+              "/#{name}/#{obj.id}"
+            else
+              "/#{name}"
+            end
+          end
+        end
+      end
+
+      if klass.method_defined?(:new)
+        if scope
+          Controller.define_method :"new_#{scope_path_name}_path" do |parent|
+            "/#{scope.route_name}/#{parent.id}/#{name}/new"
+          end
+        else
+          Controller.define_method :"new_#{path_name}_path" do
+            "/#{name}/new"
+          end
+        end
+      end
+
+      return unless klass.method_defined?(:edit)
+
+      Controller.define_method :"edit_#{path_name}_path" do |obj|
+        "/#{name}/#{obj.id}/edit"
+      end
+    end
   end
 end

data/lib/radical/routes.rb

@@ -13,6 +13,10 @@ module Radical
         @router ||= Router.new
       end
 
+      def parents
+        @parents ||= []
+      end
+
       sig { params(name: T.any(String, Symbol)).void }
       def root(name)
         klass = Object.const_get(name)
@@ -25,7 +29,7 @@ module Radical
         classes = names.map { |c| Object.const_get(c) }
 
         classes.each do |klass|
-          router.add_actions(klass, actions: Router::RESOURCE_ACTIONS)
+          router.add_resource(klass)
         end
       end
 
@@ -33,14 +37,21 @@ module Radical
       def resources(*names, &block)
         classes = names.map { |c| Object.const_get(c) }
 
-        prefix = "#{router.route_prefix(@parents)}/" if instance_variable_defined?(:@parents)
-
-        router.add_routes(classes, prefix: prefix)
+        classes.each do |klass|
+          if parents.any?
+            router.add_resources(klass, parents: @parents)
+
+            # only one level of nesting
+            @parents = []
+          else
+            router.add_resources(klass)
+          end
+        end
 
         return unless block
 
-        @parents ||= []
-        @parents << classes.last
+        @parents = classes
+
         block.call
       end
     end

data/lib/radical/security_headers.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Radical
+  class SecurityHeaders
+    DEFAULT_HEADERS = {
+      'X-Content-Type-Options' => 'nosniff',
+      'X-Frame-Options' => 'deny',
+      'X-XSS-Protection' => '1; mode=block',
+      'X-Permitted-Cross-Domain-Policies' => 'none',
+      'Strict-Transport-Security' => 'max-age=31536000;, max-age=31536000; includeSubdomains',
+      'Content-Security-Policy' => "default-src 'none'; style-src 'self'; script-src 'self'; connect-src 'self'; img-src 'self'; font-src 'self'; form-action 'self'; base-uri 'none'; frame-ancestors 'none'; block-all-mixed-content;"
+    }.freeze
+
+    def initialize(app, headers)
+      @app = app
+      @headers = DEFAULT_HEADERS.merge(headers)
+    end
+
+    def call(env)
+      @app.call(env).tap do |_, headers|
+        @headers.each do |k, v|
+          headers[k] ||= v
+        end
+      end
+    end
+  end
+end

data/lib/radical/strings.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Radical
+  class Strings
+    SNAKE_CASE_REGEX = /\B([A-Z])/.freeze
+
+    class << self
+      def snake_case(str)
+        str.gsub(SNAKE_CASE_REGEX, '_\1').downcase
+      end
+
+      def camel_case(str)
+        str.split('_').map(&:capitalize).join
+      end
+    end
+  end
+end