radical 1.0.0 → 1.2.0

data/lib/radical/flash.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Radical
+  class Flash
+    class SessionUnavailable < StandardError; end
+
+    SESSION_KEY = 'rack.session'
+    FLASH_KEY = '__FLASH__'
+
+    class FlashHash
+      def initialize(session)
+        raise SessionUnavailable, 'No session variable found. Requires Rack::Session' unless session
+
+        @session = session
+      end
+
+      def [](key)
+        hash[key] ||= session.delete(key)
+      end
+
+      def []=(key, value)
+        hash[key] = session[key] = value
+      end
+
+      def mark!
+        @flagged = session.keys
+      end
+
+      def clear!
+        @flagged.each { |k| session.delete(k) }
+        @flagged.clear
+      end
+
+      private
+
+      def hash
+        @hash ||= {}
+      end
+
+      def session
+        @session[FLASH_KEY] ||= {}
+      end
+    end
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      flash_hash ||= FlashHash.new(env[SESSION_KEY])
+
+      flash_hash.mark!
+
+      res = @app.call(env)
+
+      flash_hash.clear!
+
+      res
+    end
+  end
+end

data/lib/radical/form.rb

@@ -1,35 +1,66 @@
+# frozen_string_literal: true
+
 require 'rack/csrf'
 
 module Radical
   class Form
+    SELF_CLOSING_TAGS = %w[
+      area
+      base
+      br
+      col
+      embed
+      hr
+      img
+      input
+      keygen
+      link
+      meta
+      param
+      source
+      track
+      wbr
+    ].freeze
+
     def initialize(options, controller)
       @model = options[:model]
       @controller = controller
-      @route_name = @controller.class.route_name
-      @override_method = options[:method]&.upcase || (@model.saved? ? 'PATCH' : 'POST')
+      @override_method = options[:method]&.upcase || (@model&.saved? ? 'PATCH' : 'POST')
       @method = %w[GET POST].include?(@override_method) ? @override_method : 'POST'
+      @action = options[:action] || action_from(model: @model, controller: controller)
+    end
 
-      @action = if @model.saved?
-                  @controller.public_send(:"#{@route_name}_path", @model)
-                else
-                  @controller.public_send(:"#{@route_name}_path")
-                end
+    def text(name, attrs = {})
+      attrs.merge!(type: 'text', name: name, value: @model&.public_send(name))
+
+      tag 'input', attrs
     end
 
-    def text(name)
-      "<input type=text name=#{@route_name}[#{name}] value=\"#{@model.public_send(name)}\" />"
+    def number(name, attrs = {})
+      attrs.merge!(type: 'number', name: name, value: @model&.public_send(name))
+
+      tag 'input', attrs
     end
 
-    def button(name)
-      "<button type=submit>#{name}</button>"
+    def button(attrs = {}, &block)
+      tag 'button', attrs, &block
     end
 
-    def submit(value)
-      "<input type=submit value=#{value} />"
+    def submit(value_or_attrs = {})
+      attrs = {}
+
+      case value_or_attrs
+      when String
+        attrs[:value] = value_or_attrs
+      when Hash
+        attrs = value_or_attrs || {}
+      end
+
+      tag 'input', attrs.merge('type' => 'submit')
     end
 
     def open_tag
-      "<form action=#{@action} method=#{@method}>"
+      "<form #{html_attributes(action: @action, method: @method)}>"
     end
 
     def csrf_tag
@@ -37,11 +68,40 @@ module Radical
     end
 
     def rack_override_tag
-      "<input type=hidden name=_method value=#{@override_method} />" unless %w[GET POST].include?(@override_method)
+      attrs = { value: @override_method, type: 'hidden', name: '_method' }
+
+      tag('input', attrs) unless %w[GET POST].include?(@override_method)
     end
 
     def close_tag
       '</form>'
     end
+
+    private
+
+    def tag(name, attrs, &block)
+      attr_string = attrs.empty? ? '' : " #{html_attributes(attrs)}"
+      open_tag = "<#{name}"
+      self_closing = SELF_CLOSING_TAGS.include?(name)
+      end_tag = self_closing ? ' />' : "</#{name}>"
+
+      "#{open_tag}#{attr_string}#{self_closing ? '' : '>'}#{block&.call}#{end_tag}"
+    end
+
+    def html_attributes(options = {})
+      options.transform_keys(&:to_s).sort_by { |k, _| k }.map { |k, v| "#{k}=\"#{v}\"" }.join(' ')
+    end
+
+    def action_from(controller:, model:)
+      return if model.nil?
+
+      route_name = controller.class.route_name
+
+      if model.saved?
+        controller.send(:"#{route_name}_path", model)
+      else
+        controller.send(:"#{route_name}_path")
+      end
+    end
   end
 end

data/lib/radical/generator/app/.env

@@ -0,0 +1,5 @@
+<<-RB
+  RADICAL_ENV=development
+  SESSION_SECRET=#{SecureRandom.hex(32)}
+  DATABASE_URL=development.sqlite3
+RB

data/lib/radical/generator/app/Gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+gem 'radical', '~> 1.0'

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'radical'
+
+def require_all(*args)
+  args.each do |arg|
+    file = File.join(__dir__, arg)
+
+    if File.exist?("#{file}.rb")
+      require file
+    else
+      Dir[File.join(file, '*.rb')].sort.each do |f|
+        require f
+      end
+    end
+  end
+end
+
+require_all(
+  'models/model',
+  'models',
+  'controllers/controller',
+  'controllers',
+  'routes'
+)
+
+# the main entry point into the application
+class App < Radical::App
+  routes Routes
+
+  assets do |a|
+    a.css []
+    a.js []
+  end
+
+  compile_assets if Radical.env.production?
+end

data/lib/radical/generator/app/config.ru

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative 'app'
+
+run App

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/migration.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Radical
+  class Migration
+    class << self
+      def change(&block)
+        @change = block
+      end
+
+      def up(&block)
+        @up = block
+      end
+
+      def down(&block)
+        @down = block
+      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
+
+      def drop_table(name)
+        "drop table #{name}"
+      end
+
+      def migrate!(db:, version:)
+        db.execute(@change&.call || @up&.call)
+        db.execute 'insert into radical_migrations (version) values (?)', [version]
+      end
+
+      def rollback!(db:, version:)
+        @rollback = true
+
+        db.execute(@change&.call || @down&.call)
+        db.execute 'delete from radical_migrations where version = ?', [version]
+      end
+    end
+  end
+end

data/lib/radical/model.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'database'
 
 module Radical
@@ -7,17 +9,6 @@ module Radical
     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
@@ -58,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