hot-glue 0.2.3 → 0.2.9E

data/README.md

@@ -1,7 +1,17 @@
 
+[![Build Status](https://app.travis-ci.com/jasonfb/hot-glue.svg?branch=main)](https://travis-ci.com/jasonfb/hot-glue)
+
+
 Hot Glue is a Rails scaffold builder for the Turbo era. It is an evolution of the admin-interface style scaffolding systems of the 2010s ([activeadmin](https://github.com/activeadmin/activeadmin), [rails_admin](https://github.com/sferik/rails_admin), and [active_scaffold](https://github.com/activescaffold/active_scaffold)). 
 
-Using Turbo-Rails and Hotwire you get a lightning-fast out-of-the-box CRUD building experience. Every page displays only a list view: new and edit operations happen as 'edit-in-place', so the user never leaves the page. 
+
+Using Turbo-Rails and Hotwire (default in Rails 7) you get a lightning-fast out-of-the-box CRUD building experience. 
+
+Every page displays only a list view: new and edit operations happen as 'edit-in-place', so the user never leaves the page. 
+
+Because all page navigation is Turbo's responsibilty, everything plugs & plays nicely into a Turbo-backed Rails app. 
+
+Alternatively, you can use this tool to create a Turbo-backed *section* of your Rails app-- like an admin interface -- while still treating the rest of the Rails app as an API or building out other features by hand. 
 
 It will read your relationships and field types to generate your code for you, leaving you with a 'sourdough starter' to work from. If you modify the generated code, you're on your own if you want to preserve your changes and also re-generate scaffold after adding fields. 
 
@@ -9,25 +19,19 @@ By default, it generates code that gives users full control over objects they 'o
 
 Hot Glue generates functionality that's quick and dirty. It let's you be crafty. As with a real hot glue gun, use with caution. 
 
-* Build plug-and-play scaffolding for any CRUD on any object
-* mixes HAML and turbo_stream responses
-* Everything edits-in-place (unless you use --big-edit, then it won't)  
-* Automatically reads your ActiveRecord models and relationships (make them before building your scaffolding!)
-* Create-read-update-delete (CRUD) with pagination (one day: sorting & searching)
-* Excellent tool for prototyping and hackathons, but a knowledge of Rails is needed. 
-* Nest your routes model-by-model for built-in poor man's authentication. (Customers have_many :invoices; Invoices have_many :line_items; etc)
-* Plays nicely with Devise, but you can implement your own current_user object instead.
-* Kaminari for pagination.
-* Create specs automatically along with the controllers.
-* Throw the scaffolding away when your app is ready to graduate to its next phase (or don't if you like it).
+* Build plug-and-play scaffolding mixing generated ERB or HAML with the power of Hotwire and Turbo-Rails
+* Everything edits-in-place (unless you use --big-edit, then it won't)
+* Automatically Reads Your Models (make them before building your scaffolding!)
+* Excellent for CREATE-READ-UPDATE-DELETE (CRUD), lists with pagination (coming soon: searching & sorting)
+* Great for prototyping, but you should learn Rails fundamentals first.
+* 'Packaged' with Devise, Kaminari, Rspec, FontAwesome
+* Create system specs  automatically along with the generated code.
+* Nest your routes model-by-model for built-in poor man's authentication.
+* Throw the scaffolding away when your app is ready to graduate to its next phase.
 
 ## QUICK START
 
-It's really easy to get started by following along with this blog post that creates three simple tables (User, Event, and Format).
-
-Feel free to build your own tables when you get to the sections for building the 'Event' scaffold:
-
-https://jasonfleetwoodboldt.com/hot-glue
+If you like tutorials, try https://jasonfleetwoodboldt.com/hot-glue
 
 ## HOW EASY?
 
@@ -44,88 +48,141 @@ Instantly get a simple CRUD interface
 
 ![hot-glue-4](https://user-images.githubusercontent.com/59002/116405517-c2b2e300-a7fd-11eb-8423-d43e3afc9fa6.gif)
 
-## TO INSTALL (RAILS 7)
+# Getting Started
 
-- Install Turbo `rails turbo:install` (?)
+## 1. ADD HOTWIRE
+(RAILS 6 ONLY— SKIP THIS STEP FOR RAILS 7)
+```
+yarn add @hotwired/turbo-rails
+```
+or `npm install @hotwired/turbo-rails`
 
-- Add `gem 'hot-glue'` to your Gemfile & `bundle install`
-  `rails generate hot_glue:install --markup=erb`
 
-- Add to your `application.html.erb`
+## 2. SWITCH FROM TurblLinks to Turbo-Rails 
+(RAILS 6 ONLY— SKIP THIS STEP FOR RAILS 7)
+(THIS WAS AUTOMATICALLY DONE BY THE HOT GLUE INSTALLATION -- CONFIRM CHANGES ONLY)
+- Add `gem 'turbo-rails'` to your Gemfile & `bundle install`
+- Then install it with `rails turbo:install`
+- The Turbo install has switched your action cable settings from 'async' to Redis, so be sure to start a redis server
+- in `app/javascript/packs/application.js` remove this line
 ```
-  <%= render partial: 'layouts/flash_notices' %>
+import Turbolinks from "turbolinks"
+```
+and replace it with
+```
+import { Turbo } from "@hotwired/turbo-rails"
 ```
 
 
-## TO INSTALL (RAILS 6)
+Also replace
+``` 
+Turbolinks.start()
+```
+with:
+```
+Turbo.start()
+```
 
-- Add `gem 'turbo-rails'` to your Gemfile & `bundle install`
-  
-- Then install it with `rails turbo:install`
 
-- The Turbo install has switched your action cable settings from 'async' to Redis, so be sure to start a redis server
-  
-- Add `gem 'hot-glue'` to your Gemfile & `bundle install`
-  
-- in `javascript/packs/application.js` remove this line:
-`import Turbolinks from "turbolinks"`
+## 3. ADD HOT-GLUE GEM
+- Add `gem 'hot-glue', '~> 0.2.6'` to your Gemfile & `bundle install`
+
+(TODO: figure out why bundler seems to install the yanked version 0.0.0 if you don't specify the hot glue version)
+
+## 4. ADD RSPEC, FACTORY-BOT, AND FFAKER
 
-- in the same file (`javascript/packs/application.js`) add this line:
-`import { Turbo } from "@hotwired/turbo-rails"`
+add these 3 gems to your gemfile **inside a group for both :development and :test*. Do not add these gems to only the :test group or else your will have problems with the generators.
+```
+gem 'rspec-rails'
+gem 'factory_bot_rails'
+gem 'ffaker'
+```
 
-- Run the hot-glue install generator 
+- run `rails generate rspec:install`
 
-FOR ERB:
+## 5(A). RUN HOT-GLUE INSTALL
+### FOR ERB:
 `rails generate hot_glue:install --markup=erb`
 
-FOR HAML:
+### FOR HAML:
 `rails generate hot_glue:install --markup=haml`
 
-- Add to your `application.html.erb`
+
+
+
+
+## 5(B). Modify `application.html.erb` 
+(THIS WAS AUTOMATICALLY DONE BY THE HOT GLUE INSTALLATION -- CONFIRM CHANGES ONLY)
+Note: if you have some kind of non-standard application layout, like one at a different file
+or if you have modified your opening <body> tag, this may not have been automatically applied by the installer.
+
+- This was added to your `application.html.erb`
 ```
   <%= render partial: 'layouts/flash_notices' %>
 ```
 
+## 5(C). Modify `rails_helper.rb` 
+(THIS WAS AUTOMATICALLY DONE BY THE HOT GLUE INSTALLATION)
+Note: if you have some kind of non-standard rails_helper.rb, like one that does not use the standard ` do |config|` syntax after your `RSpec.configure` 
+this may not have been automatically applied by the installer.
 
-## Rspec setup
-  - add `gem 'rspec-rails'` to your gemfile inside :development and :test
-  - add `gem 'factory_bot_rails'` to your gemfile inside :development and :test
-  - run `rails generate rspec:install`
-  - configure Rspec to work with Factory Bot inside of `rails_helper.rb`
-    ```
-    RSpec.configure do |config|
-        // ... more rspec configuration (not shown)
-        config.include FactoryBot::Syntax::Methods
-    end
-    ```  
-  more info:
-  https://github.com/thoughtbot/factory_bot/blob/master/GETTING_STARTED.md#rspec
+- configure Rspec to work with Factory Bot inside of `rails_helper.rb`
+  ```
+  RSpec.configure do |config|
+      // ... more rspec configuration (not shown)
+      config.include FactoryBot::Syntax::Methods
+  end
+  ```  
 
-  - for a quick Capybara login, create a support helper in `spec/support/` and log-in as your user
-    ```
-    def login_as(account)
-      visit '/accounts/sign_in'
-      within("#new_account") do
-      fill_in 'Email', with: account.email
-      fill_in 'Password', with: 'password'
-      end
-      click_button 'Log in'
-    end
-    ```
 
-## Install Bootstrap using Sprockets (IMPORTANT: YOU DO NOT NEED JQUERY*)
-    - Bootstrap with Sprockets for Rails 5 or 7 default — Rails 6 custom
-      - use twbs/bootstrap-rubygem gem
-      - see README for bootstrap-rubygem to install
-    - Bootstrap with Webpack for FOR RAILS 7 :
-          
-- add to Gemfile
-- gem 'bootstrap', '~> 5.1.0'
+## 5(D) CAPYBARA: SWITCH FROM RACK-TEST TO HEADLESS CHROME
+(THIS WAS AUTOMATICALLY DONE BY THE HOT GLUE INSTALLATION)
+
+- By default Capybara is installed with :rack_test as its driver.
+- This does not support Javascript, and the code from Hot Glue IS NOT fallback compatible-- it will not work on non-Javascript browsers.
+- From the [Capybara docs](https://github.com/teamcapybara/capybara#drivers):
+```
+By default, Capybara uses the :rack_test driver, which is fast but limited: it does not support JavaScript
+```
+
+- To fix this, you must switch to a Javascript-supporting Capybara driver. You can choose one of:
+
+`Capybara.default_driver = :selenium`
+`Capybara.default_driver = :selenium_chrome`
+`Capybara.default_driver = :selenium_chrome_headless`
+
+By default, the installer should have added this option to your `rails_helper.rb` file:
+
+```
+Capybara.default_driver = :selenium_chrome_headless 
+```
+
+Alternatively, can define your own driver like so:
 
+  ```
+  Capybara.register_driver :my_headless_chrome_desktop do |app|
+    options = Selenium::WebDriver::Chrome::Options.new
+    options.add_argument('--headless')
+    options.add_argument('--disable-gpu')
+    options.add_argument('--window-size=1280,1200')
+    
+    driver = Capybara::Selenium::Driver.new(app,
+                                            browser: :chrome,
+                                            options: options)
+    
+    driver
+  end
+  Capybara.default_driver = :my_headless_chrome_desktop
+    
+  ```
 
+
+### 6(A) Bootstrap with Webpack:    
+DO EIETHER 6(A) OR 6(B)
+- add to Gemfile
+- `gem 'bootstrap', '~> 5.1.3'`
 - completely delete the file `app/assets/application.css`
 - create new file where it was `app/assets/application.scss` with this contents (do not keep the contents of the old application.css file):
-
 ``` 
 // Custom bootstrap variables must be set or imported *before* bootstrap.
 @import "bootstrap";
@@ -133,7 +190,7 @@ FOR HAML:
 
 * You do not need jQuery for HotGlue to work *
 
-### Bootstrap with Webpack RAILS 6 ONLY:
+### Hook your Bootstrap into your global application scss
 - change `stylesheet_link_tag` to `stylesheet_pack_tag` in your application layout
   - run `yarn add bootstrap`
   - create a new file at `app/javascript/require_bootstrap.scss` with this content
@@ -145,17 +202,95 @@ FOR HAML:
     ```
     import 'require_bootstrap'
     ```
-  
 
 
+## 6(B) Install Bootstrap using Sprockets
+(IMPORTANT: YOU DO NOT NEED JQUERY)
+DO EIETHER 6(A) OR 6(B)
+
+Bootstrap with Sprockets for Rails 5 or 7 default — Rails 6 custom
+- add `gem 'bootstrap-rubygem'` to your gemfile
+- replace `application.css` with a new file (delete old contents) `application.scss`
+```
+@import "bootstrap";
+```
+- see README at github.com/twbs/bootstrap-rubygem to install
+
+
+
+
+## 7. install font-awesome
+
+I recommend https://github.com/tomkra/font_awesome5_rails
+or https://github.com/FortAwesome/font-awesome-sass
 
-## Install Devise or implement your own authentication
-  (or only use --gd mode, see below)
 
-## install font-awesome. I recommend https://github.com/tomkra/font_awesome5_rails or https://github.com/FortAwesome/font-awesome-sass
 
+## 8. For Enum support, I recommend activerecord-pg_enum
 
-### First Argument
+Instructions for Rails are here:
+https://jasonfleetwoodboldt.com/courses/stepping-up-rails/enumerated-types-in-rails-and-postgres/
+
+
+
+## 9. Devise
+(or only use --gd mode, see below)
+
+  Add to your Gemfile `gem 'devise'`
+
+
+
+```
+rails generate devise:install
+```
+
+IMPORTANT: Follow the instructions the Devise installer gives you, *Except Step 3*, you can skip this step:
+```
+ 3. Ensure you have flash messages in app/views/layouts/application.html.erb.
+     For example:
+
+       <p class="notice"><%= notice %></p>
+       <p class="alert"><%= alert %></p>
+
+```
+
+
+You can also skip Devise installer Step 4, which is optional: 
+``` 
+  4. You can copy Devise views (for customization) to your app by running:
+
+       rails g devise:views
+       
+     * Not required *
+```
+
+
+## 9(B) Devise & Capybara - Add User Authentication if you are using Access Control
+(THIS WAS AUTOMATICALLY DONE BY THE HOT GLUE INSTALLATION)
+
+- for a quick Capybara login, create a support helper in `spec/support/` and log-in as your user
+- in the default code, the devise login would be for an object called account and lives at the route `/accounts/sign_in`
+- modify the generated code (it was installed by the installed) for your devise login
+   ```
+   def login_as(account)
+     visit '/accounts/sign_in'
+     within("#new_account") do
+     fill_in 'Email', with: account.email
+     fill_in 'Password', with: 'password'
+     end
+     click_button 'Log in'
+   end
+   ```
+
+
+## RAILS 7: Devise is not yet supported on Rails 7 unless you use the master branch of devise
+
+
+
+# HOT GLUE DOCS
+
+
+## First Argument
 (no double slash)
 
 TitleCase class name of the thing you want to build a scaffoling for.
@@ -229,7 +364,7 @@ Then, finally the @charge will be loaded
 
 `@charge = @line.charges.find(params[:id])`
 
-It's called "poor man's auth" because if a user attempts to hack the URL by passing ids for objects they don't own--- which Rails makes relatively easy with its default URL pattern-- they will hit ActiveRecord not found errors (the objects they don't own won't be found in the associated relationship).
+It's called "poor man's access control" because if a user attempts to hack the URL by passing ids for objects they don't own--- which Rails makes relatively easy with its default URL pattern-- they will hit ActiveRecord not found errors (the objects they don't own won't be found in the associated relationship).
 
 It works, but it isn't granular. As well, it isn't appropriate for a large app with any level of intricacy to access control (that is, having roles).
 
@@ -242,7 +377,7 @@ By default, it will be assumed you have a `current_user` for your user authentic
 
 The poor man's auth presumes that object graphs have only one natural way to traverse them (that is, one primary way to traverse them), and that all relationships infer that a set of things or their descendants are granted access to me for reading, writing, updating, and deleting.
 
-Of course this is a sloppy way to do authentication, and can easily leave open endpoints your real users shouldn't have access to.
+Of course this is a sloppy way to do access control, and can easily leave open endpoints your real users shouldn't have access to.
 
 When you display anything built with the scaffolding, we assume the `current_user` will have `has_many` association that matches the pluralized name of the scaffold. In the case of nesting, we will automatically find the nested objects first, then continue down the nest chain to find the target object. In this way, we know that all object are 'anchored' to the logged-in user.
 
@@ -344,9 +479,18 @@ IMPORTANT: By default, all fields that begin with an underscore (`_`) are automa
 
 I would recommend this for fields you want globally non-editable by users in your app. For example, a counter cache or other field set only by a backend mechanism.
 
-### `stimulus_syntax` (default is false for Rails <=6; true for Rails 7)
+### `--stimulus_syntax=true` or `--stimulus_syntax=false`
+(for Rails <=6, default is false. For Rails 7, default is true.)
+
+Stimulus is only used for the delete button's confirmation dialog. 
+
+If you don't have stimulus syntax enabled, your delete buttons have this. This will confirm the delete with a simple alert if you have UJS enabled. 
 
-Your delete buttons will look like so:
+```
+{confirm: 'Are you sure?'}
+```
+
+If you do have Stimulus syntax enabled, your delete buttons will look like so:
 ```
     <%= button_to "Delete <i class='fa fa-1x fa-remove'></i>".html_safe, 
         thing_path(branch), method: :delete, 
@@ -356,8 +500,6 @@ Your delete buttons will look like so:
             'action': 'confirmation#confirm'
         },  
         disable_with: "Loading...", class: "delete-branch-button btn btn-primary " %>
-
-
 ```
 
 Your install script will output an additional stimulus controller:
@@ -416,13 +558,79 @@ Omits delete action.
 
 ### `--big-edit`
 
-If you do not want inline editing of your list items but instead to fall back to old fashioned new page behavior for your edit views, use `--big-edit`.
+If you do not want inline editing of your list items but instead to fall back to full page style behavior for your edit views, use `--big-edit`. Turbo still handles the page interactions, but the user is taken to a full-screen edit page instead of an edit-in-place interaction.
+
+### `--display-list-after-update` (default: false)
+
+After an update-in-place normally only the edit view is swapped out for the show view of the record you just edited.
+
+Sometimes you might want to redisplay the entire list after you make an update (for example, if your action removes that record from the result set).
+
+To do this, use flag `--display_list_after_update`. The update will behave like delete and re-fetch all the records in the result and tell Turbo to swap out the entire list. 
+
+
+
+### `--downnest`
+(2021-11-23 - WIP)
+
+Automatically create subviews down your object tree. This should be the name of a has_many relationship based from the current object. 
+You will need to build scaffolding with the same name for the related object as well. 
+On the list view, the object you are currently building will be built with a sub-view list of the objects related from the given line. 
+
+### `--nestable` (default: false)
+(2021-11-23 - WIP)
+When creating a controller that you will use a another controllers downnest (that is, you will display related records-- like a portal-- from the parent within each row of the parent's list view), set nestable to true.
+
+If the cooresponding Rails route contains nesting and this controller is downnested by someone else, you'll want to set nestable to true.
+
+If the cooresponding Rails route is not nested and the controller sits a the root of the namespace, set nestable to false.
+
+
+## Automatic Base Controller
 
+HotGlue will copy a file named base_controller.rb to the same folder where it tries to create any controller, unless such a file exists there already.
 
+Obviously, the created controller will always have this base controller as its subclass. In this way, you are encouraged to implement functionality common to the *namespace* (shared between the controllers in the namespace), using this technique.
+
+## Field Types Supported
+
+- Integers that don't end with `_id`, they will be displayed as text fields.
+- Integers that do end with `_id` will be treated automatically as associations. You should have a Rails association defined. (Hot Glue will warn you if it can't find one.)
+- String*
+- Text*
+- Float*
+- Datetime
+- Date
+- Time
+- Boolean 
+- Enum - will display as a value list populated from the enum list defined on your model. see https://jasonfleetwoodboldt.com/courses/stepping-up-rails/enumerated-types-in-rails-and-postgres/
+
+* shows in a size-aware container, i.e. in a bigger box if the field allows for more content
 
 
 
 # VERSION HISTORY
+
+#### 2021-11-27 - v0.2.9E   — EXPERIMENTAL 
+                     - Downnesting
+                     - Adds spec coverage support for enums
+                     - Several more fixes; this is preparation for forthcoming release.
+                     - Some parts still experimental. Use with caution. 
+
+#### 2021-10-11 - v0.2.6 - many additional automatic fixes for default Rails installation 6 or 7 for the generate hot_glue:install command
+
+
+#### 2021-10-10 - v0.2.5 - this version is all about developer happyness:
+                            - significant fixes for the behavioral (system) specs. they now create new & update interactions
+                            for (almost) all field types
+                            - the install generator now checks your layouts/application.html.erb for `render partial: 'layouts/flash_messages' ` and adds it if it isn't there already
+                            - the install generator also checks your spec/rails_helper for `config.include FactoryBot::Syntax::Methods` and adds it at the top of the Rspec configure block if it isn't there
+
+#### 2021-10-07 - v0.2.4 - removes erroneous icons display in delete buttos (these don't work inside of button_to); 
+                            - adds support for ENUM types direclty on your field types
+                            - you  must use activerecord-pgenum
+                            - see my blog post at https://jasonfleetwoodboldt.com/courses/stepping-up-rails/enumerated-types-in-rails-and-postgres/
+
 #### 2021-09-30 - v0.2.3 - fixes ERB output for show-only fields; fixes flash_notices for erb or haml; adds @stimulus_syntax flag for delete confirmations with stimulus
 
 #### 2021-09-27  - v0.2.2 - Fixes some issues with related fields; unlocks Rails 7 in Gemspec file
@@ -457,6 +665,20 @@ If you do not want inline editing of your list items but instead to fall back to
 
 #### 2021-02-23 - v0.0.0 - Port of my prior work from github.com/jasonfb/common_core_js
 
+# PROBLEMS
+
+Here are some defeciencies to note
+
+- [ ] the ERB output has a necessary gsub that makes it so that every file always kicks the "Overwrite?" even when it has not changed. Unfortunately because of the meta programming involved in the ERB, I do not see a way around this although I would like to eventually fix it or match the AR generator internals to fix this problem. 
+
+- [ ] the system_spec that is generated (system/*_spec.rb) works most of the time but obviously you must run it to confirm it passes correclty. still working out bugs in this area for special cases.
+
+
+
+- [ ] Note that the specs use FFaker data and random numbers, so if you have model-level validations and out-of-bounds choices are made, your specs might fail *intermittently*.
+---> I know I hate intermittent failing specs, and if I had any in my app I would surely refactor them out. I'm not sure how I feel about *randomized* data-- or this much randomized data-- in specs. It's kind of fun but it also is tempting fate somewhat, and hopefully encouraging/forcing you to refactor them to be meaningful to your models and model-level validations. 
+
+- [ ] The specs themselves and some generated code is particularly ugly-- especially, formated inconsistently. Sorry about this, will clean this up soon. It is there to encourage you to read the generated code and lint or rubocop it before you check it in. I know the indentation is off and very ugly. 
 
 
 # HOW THIS GEM IS TESTED

data/Rakefile

@@ -1,32 +1,42 @@
+
 begin
   require 'bundler/setup'
 rescue LoadError
   puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
 end
 
-require 'rdoc/task'
-
-RDoc::Task.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'HotGlue'
-  rdoc.options << '--line-numbers'
-  rdoc.rdoc_files.include('README.md')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
-APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
-load 'rails/tasks/engine.rake'
-
-load 'rails/tasks/statistics.rake'
-
-require 'bundler/gem_tasks'
-
-require 'rake/testtask'
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = false
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+  task :default => :spec
+rescue LoadError
+  puts 'FAILED: unable to load rspec/core/rake_task in Rakefile'
 end
 
-task default: :test
+#
+# require 'rdoc/task'
+#
+# RDoc::Task.new(:rdoc) do |rdoc|
+#   rdoc.rdoc_dir = 'rdoc'
+#   rdoc.title    = 'HotGlue'
+#   rdoc.options << '--line-numbers'
+#   rdoc.rdoc_files.include('README.md')
+#   rdoc.rdoc_files.include('lib/**/*.rb')
+# end
+#
+# APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
+# load 'rails/tasks/engine.rake'
+#
+# load 'rails/tasks/statistics.rake'
+#
+# require 'bundler/gem_tasks'
+
+# require 'rake/testtask'
+#
+# Rake::TestTask.new(:test) do |t|
+#   t.libs << 'test'
+#   t.pattern = 'test/**/*_test.rb'
+#   t.verbose = false
+# end
+#
+# task default: :test

data/app/helpers/hot_glue/controller_helper.rb

@@ -54,10 +54,12 @@ module HotGlue
         else
           server_timezone
         end
-      elsif defined?(controller) == "method"
-        # controller.try(:current_timezone)
-      elsif self.class.ancestors.include?(ApplicationController)
-        self.try(:current_timezone)
+      elsif true
+        server_timezone
+      # elsif defined?(controller) == "method"
+      #   # controller.try(:current_timezone)
+      # elsif self.class.ancestors.include?(ApplicationController)
+      #   self.try(:current_timezone)
       else
         raise "no method current_user is available; please implement/override the method current_timezone IN YOUR CONTROLLER"
       end

data/app/helpers/hot_glue_helper.rb

@@ -1,4 +1,8 @@
 module HotGlueHelper
 
+  def enum_to_collection_select(hash)
+    hash.collect{|k,v| OpenStruct.new({key: k, value: v})}
+
+  end
 
 end

data/app/views/layouts/_flash_notices.erb

@@ -0,0 +1,12 @@
+<%= turbo_frame_tag "flash_notices" do %>
+  <% unless notice.nil? %>
+    <div class="alert alert-notice alert-dismissible">
+      <%= notice %>
+    </div>
+  <% end %>
+  <% unless alert.nil? %>
+    <div class="alert alert-danger alert-dismissible">
+      <%= alert %>
+    </div>
+  <% end %>
+<% end %>