hot-glue 0.5.6 → 0.5.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61b8c21f0bf630a68d9861b8bb70141ce7fe0da0a0f1ae71c3bb4e69da6b081d
-  data.tar.gz: 865d633fe279b4db0b2927801c82ec6de1ab630b4ffb7d24ffc539dfbb56d44d
+  metadata.gz: 14d86dc6800770982fbc2775311698b33f0e21180a3f3e8e6b0d8078dc304629
+  data.tar.gz: 8682fffd425887c274e016b382c374f95fde00fc7607ada565d590139adabc9d
 SHA512:
-  metadata.gz: 26901af291d1db0f028b14e320ed6c66908c90d94777c559bdba508c4e111b651357531f9fffc468cc419fbe16dda1d9bb6b86777c6e8f840631c4dfb7239e3d
-  data.tar.gz: 69775a6b4a31b142e1683c2017d2b85c1fda1f7350bb4b954948a0b06bfbb990578bed98c0eedce1534e10ad78aa44b87d27deecf027f017184aa731319c62cb
+  metadata.gz: f142e3f8e048193ae628d446826dc9628ac37db747f25dbee38259f9ec7aee41b6ee91ded483065a28e80d777468b949e72b7021146a6812ee6e8ae58b0034bf
+  data.tar.gz: cfe2f196c675d6d89105e153b79f8712cb5a9543a64900eac06976705e7bb39dff688db6b0db93e9bc2871be852101790856b5ad526088ff344fed0c9b8c854c

data/.github/FUNDING.yml

@@ -1 +1 @@
-custom: ["https://heliosdev.shop/p/hot-glue/","https://jfbcodes.com/p/hot-glue-in-depth-tutorial?utm_source=github.com&utm_campaign=github_hot_glue_repo_funding_link"]
+custom: ["https://twitter.com/HotGlueForRails",  "https://school.jasonfleetwoodboldt.com/8188?utm_source=github.com&utm_campaign=github_hot_glue_repo_funding_link"]

data/LICENSE

@@ -1,10 +1,17 @@
-© 2022 Jason Fleetwood-Boldt. All Rights Reserved
-This software is 'fauxpen source,' which means you can think of it like 'free' as in speech but not 'free' as in beer....
 
-It is definitely 'free' as in Britney.
+
+Copyright © 2022 Jason Fleetwood-Boldt. All Rights Reserved
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
 
 TO PURCHASE A COMMERCIAL USAGE LICENSE PLEASE VISIT
 https://heliosdev.shop/hot-glue-license
 
-OR PURCHASE THE TUTORIAL (all purchases come with lifetime license)
-https://jfbcodes.com/p/hot-glue-in-depth-tutorial
+OR PURCHASE THE TUTORIALS AT
+https://school.jasonfleetwoodboldt.com/8188/?utm_source=github.com

data/README.md

@@ -11,16 +11,16 @@ Alternatively, you can use this tool to create a Turbo-backed *section* of your
 
 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 scaffolding after adding fields.
 
-By default, it generates code that gives users full control over objects they 'own' and by default it spits out functionality giving access to all fields.
+By default, it generates code that gives users full control over objects they 'own' and by default it spits out functionality giving access to all fields. (Handily, Hot Glue leaves the command you used in a comment at the top of your generated controller so you can regenerate it again in the future.)
 
 Hot Glue generates functionality that is quick and dirty. It lets you be crafty. As with a real glue gun, use it with caution.
 
 * Build plug-and-play scaffolding mixing generated ERB with the power of Hotwire and Turbo-Rails
 * Everything edits-in-place (unless you use `--big-edit`)
-* Automatically reads your models (make them AND migrate your database before building your scaffolding!)
+* Automatically reads your models (make them, add relationships, **and** migrate your database before building your scaffolding!)
 * Excellent for CREATE-READ-UPDATE-DELETE (CRUD), lists with pagination
 * Great for prototyping, but you should learn Rails fundamentals first.
-* 'Packaged' with Devise, Kaminari, Rspec, FontAwesome
+* 'Packaged' with Devise, Kaminari, Rspec, FontAwesome (optional)
 * 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.
@@ -29,19 +29,19 @@ How is it different than Rails scaffolding?
 
 Although inspired by the Rails scaffold generators (built-in to Rails), Hot Glue does something similiar but has made opinionated decisions that deviate from the normal Rails scaffold: 
 
-1. The Hot Glue scaffolds are complete packages and pre-optimized for 'edit-in-place.' (the Rails scaffolds still generates views that make you flip between pages to do create/update operations)
+1. The Hot Glue scaffolds are complete packages and pre-optimized for 'edit-in-place.' (the Rails scaffolding still generates views that make you flip between pages to do create/update operations)
 2. Hot Glue does not create your models along with your scaffolding. Instead, create them first using `rails generate model X`
-3. Hot Glue *reads* the fields on your database *and* the relationships defined on your models. Unlike the Rails scaffolding you must add relationships and migration your DB before building your scaffolding.
+3. Hot Glue *reads* the fields on your database *and* the relationships defined on your models. Unlike the Rails scaffolding you must add relationships and migrate your DB before building your scaffolding.
 4. Hot Glue has many more features for building layouts quickly, like choosing which fields to include or exclude and how to lay them out on the page, for stitching together related objects (nesting and child portals), and more. 
 
-Other than the opinionated differences and additional features, Hot Glue produces code that is fundamentally very similiar and works consistent with the Rails 7 ways of working. 
+Other than the opinionated differences and additional features, Hot Glue produces code that is fundamentally very similiar and works consistent with the Rails 7 Hotwire & Turbo paradigms.
 
 # Get Hot Glue
 
-## [GET THE COURSE TODAY](https://jfbcodes.com/courses/hot-glue-in-depth-tutorial/?utm_source=github.com&utm_campaign=github_hot_glue_readme_page) **only $60 USD!**
+## [GET THE COURSE TODAY](https://school.jasonfleetwoodboldt.com/8188/?utm_source=github.com&utm_campaign=github_hot_glue_readme_page) **only $60 USD!**
 
 
-[![Hot Glue Course](https://user-images.githubusercontent.com/59002/189544503-6edbcd40-1728-4b13-ac9a-c7772ccb8284.jpg)](https://jfbcodes.com/courses/hot-glue-in-depth-tutorial/?utm_source=github.com&utm_campaign=github_hot_glue_readme_page)
+[![Hot Glue Course](https://user-images.githubusercontent.com/59002/189544503-6edbcd40-1728-4b13-ac9a-c7772ccb8284.jpg)](https://school.jasonfleetwoodboldt.com/8188?utm_source=github.com&utm_campaign=github_hot_glue_readme_page)
 
 ---
 ---
@@ -366,13 +366,15 @@ Alternatively, you can define your own driver like so:
 
 TitleCase class name of the thing you want to build a scaffoling for.
 
+```
 rails generate hot_glue:scaffold Thing
+```
 
-(note: Your Thing object must belong_to an authenticated User or alternatively you must create a Gd controller, see below.)
+(note: Your `Thing` object must `belong_to` an authenticated `User` or alternatively you must create a Gd controller, see below.)
 
 ## Options With Arguments
 
-All options two dashes (--) and these take an `=` and a value
+All options begin with two dashes (`--`) and a followed by an `=` and a value
 
 ### `--namespace=`
 
@@ -578,7 +580,7 @@ The short form looks like this. It presumes there is a 'pets' association from `
 
 (The long form equivalent of this would be `--hawk=pet_id{current_user.pets}`)
 
-This is covered in [Example #3 in the Hot Glue Tutorial](https://jfb.teachable.com/courses/hot-glue-in-depth-tutorial/lectures/38584014)
+This is covered in [Example #3 in the Hot Glue Tutorial](https://school.jasonfleetwoodboldt.com/8188)
 
 To hawk to a scope that is not the currently authenticated user, use the long form with `{...}` 
 to specify the scope. Be sure to note to add the association name itself, like `users`: 
@@ -588,7 +590,7 @@ to specify the scope. Be sure to note to add the association name itself, like `
 This would hawk the Appointment's `user_id` key to any users who are within the scope of the 
 current_user's has_many association (so, for any other "my" family, would be `current_user.family.users`). 
 
-This is covered in [Example #4 in the Hot Glue Tutorial](https://jfb.teachable.com/courses/hot-glue-in-depth-tutorial/lectures/38787505)
+This is covered in [Example #4 in the Hot Glue Tutorial](https://school.jasonfleetwoodboldt.com/8188)
 
 
 ### `--plural=`
@@ -608,10 +610,6 @@ ActiveSupport::Inflector.inflections do |inflect|
 end
 ```
 
-### `--form-labels-position` (default: `after`; options are **before**, **after**, and **omit**)
-By default form labels appear after the form inputs. To make them appear before or omit them, use this flag.
-
-See also `--form-placeholder-labels` to use placeolder labels. 
 
 
 
@@ -715,11 +713,31 @@ This is what would happen if 9 fields, specified in the order A,B,C,D,E,F,G,H,I,
 ### `--show-only=`
 (separate field names by COMMA)
 
-Any fields only the 'show-only' list will appear as non-editable on the generate form. (visible only)
+Any fields only the 'show-only' list will appear as non-editable on the generated form for both new & edit actions. (visible only)
 
 IMPORTANT: By default, all fields that begin with an underscore (`_`) are automatically show-only.
 
-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.
+This is 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.
+
+
+### `--update-show-only`
+(separate field names by COMMA)
+
+Fields on the `update show only`  (and not on the `show only` list) will appear as non-editible only for the **edit** action, but will still allow entry for the **create** action.
+
+Note that Hot Glue still generates a singular partial (`_form`) for both actions, but your form will now contain statements like:
+
+```
+ <% if action_name == 'edit' %>
+    <%= xyz.name %><
+ <% else %>
+    <%= f.text_field :name %>
+ <% end %>
+```
+
+This works for both regular fields, association fields, and alt lookup fields.
+
+
 
 ### `--ujs_syntax=true` (Default is set automatically based on whether you have turbo-rails installed)
 
@@ -756,7 +774,7 @@ The bang (`!`) methods can respond in one of four ways:
 
 This means you can be a somewhat lazy about your bang methods, but keep in mind the truth operator compares boolean true NOT any object is truth. So your return object must either be actually true (boolean), or an object that is string or string-like (responds to .to_s). Want to just say it didn’t work? Return false. Want to just say it was OK? Return true. Want to say it was successful but provide a more detailed response? Return a string.
 
-Finally, you can raise an ActiveRecord error which will also get passed to the user, but in the flash alert area
+Finally, you can raise an ActiveRecord error which will also get passed to the user in the flash alert area.
 
 For more information see Example 5 in the Tutorial
 
@@ -812,15 +830,106 @@ Omits pagination. (All list views have pagination by default.)
 Omits list action. Only makes sense to use this if want to create a view where you only want the create button or to navigate to the update screen alternative ways. (The new/create still appears, as well the edit, update & destroy actions are still created even though there is no natural way to navigate to them.)
 
 
-### `--no-list-label`
 
-Omits list LABEL itself above the list. (Do not confuse with the list heading which contains the field labels.)
+### `--no-create`
+
+Omits new & create actions.
+
+### `--no-delete`
+
+Omits delete button & destroy action.
+
+### `--big-edit`
+
+If you do not want inline editing of your list items but instead want 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`
+
+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.
+
+### `--with-turbo-streams`
+
+If and only if you specify `--with-turbo-streams`, your views will contain `turbo_stream_from` directives. Whereas your views will always contain `turbo_frame_tags` (wether or not this flag is specified) and will use the Turbo stream replacement mechanism for non-idempotent actions (create & update). This flag just brings the magic of live-reload to the scaffold interfaces themselves.
+
+**_To test_**: Open the same interface in two separate browser windows. Make an edit in one window and watch your edit appear in the other window instantly.
+
+This happens using two interconnected mechanisms:
+
+1) by default, all Hot Glue scaffold is wrapped in `turbo_frame_tag`s. The id of these tags is your namespace + the Rails dom_id(...). That means all Hot Glue scaffold is namespaced to the namespaces you use and won't collide with other turbo_frame_tag you might be using elsewhere
+
+2) by appending **model callbacks**, we can automatically broadcast updates to the users who are using the Hot Glue scaffold. The model callbacks (after_update_commit and after_destroy_commit) get appended automatically to the top of your model file. Each model callback targets the scaffold being built (so just this scaffold), using its namespace, and renders the line partial (or destroys the content in the case of delete) from the scaffolding.
+
+please note that *creating* and *deleting* do not yet have a full & complete implementation: Your pages won't re-render the pages being viewed cross-peer (that is, between two users using the app at the same time) if the insertion or deletion causes the pagination to be off for another user.
+
+
+### `--alt-foreign-key-lookup` (Foreign Key Lookups)
+
+`--alt-foreign-key-lookup=user_id{email}`
+
+Let's assume a `Company` `has_many :company_users` and also a `Company` `has_many :users, through: :company_users`
+
+Normally, you would be constructing a CompanyUsers downnest portal on the Company page. (Showing you only CompanyUsers associated with that company.)
+
+A drop down of _all users in the_ database will be display on the screen where you create a new CompanyUser (join) record.
+
+Let's say instead you don't want to expose the full list of all users to this controller, but instead make your user enter the full email address of the user to identify them.
+
+Instead of a drop-down, the interface will present an input box for the user to supply an *search by* email.
+
+** Note: Current implementation does not work in conjunction with hawked associations to protect against users from accessing associated records not within scope.**
+TODO: make it work with hawked associations to protect against users from accessing associated records not within scope
+
+
+## "Thing" Label
+
+Note that on a per model basis, you can also globally omit the label or set a unique label value using
+`@@table_label_singular` and `@@table_label_plural` on your model objects.
 
-(Note that on a per model basis, you can also globally omit the label or set a unique label value using
-`@@table_label_singular` and `@@table_label_plural` on your model objects.)
+You have three options to specify labels explicitly with a string, and 1 option to specify a global name for which the words "Delete ___" and "New ___" will be added.
+
+If no `--label` is specified, it will be inferred to be the Capitalized version of the name of the thing you are building, with spaces for two or more words.
+
+### `--label`
+
+The general name of the thing, will be applied as "New ___" for the new button & form. Will be *pluralized* for list label heading, so if the word has a non-standard pluralization, be sure to specify it in `config/inflictions.rb`
+
+If you specify anything explicitly, it will be used.
+If not, a specification that exists as `@@tabel_label_singular` from the Model will be used.
+If this does not exist, the Titleized (capitalized) version of the model name. 
+
+### `--list-label-heading`
+The plural of the list of things at the top of the list.
+If not, a specification that exists as `@@tabel_label_plural` from the Model will be used.
+If this does not exist, the UPCASE (all-uppercase) version of the model name.
+
+### `--new-button-label`
+The button on the list that the user clicks onto to create a new record.
+(Follows same rules described in the `--label` option but with the word "New" prepended.)
+
+### `--new-form-heading`
+The text at the top of the new form that appears when the new input entry is displayed.
+(Follows same rules described in the `--label` option but with the word "New" prepended.)
+
+### `--no-list-label`
+Omits list LABEL itself above the list. (Do not confuse with the list heading which contains the field labels.)
 
 Note that list labels may  be automatically omitted on downnested scaffolds.
 
+
+
+
+## Field Labels
+
+### `--form-labels-position` (default: `after`; options are **before**, **after**, and **omit**)
+By default form labels appear after the form inputs. To make them appear before or omit them, use this flag.
+
+See also `--form-placeholder-labels` to use placeolder labels.
+
+
 ### `--form-placeholder-labels` (default: false)
 
 When set to true, fields, numbers, and text areas will have placeholder labels.
@@ -841,39 +950,85 @@ Use `before` to make the labels come before or `after` to make them come after.
 
 Omits the heading of column names that appears above the 1st row of data.
 
-### `--no-create`
 
-Omits new & create actions.
 
-### `--no-delete`
 
-Omits delete button & destroy action.
 
-### `--big-edit`
+## Special Features
 
-If you do not want inline editing of your list items but instead want 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.
+### `--alt-lookup-foreign-keys`
 
-### `--display-list-after-update` 
+Allows you to specify that a foreign key should act as a search field, allowing the user to input a unique value (like an email) to search for a related record.
 
-After an update-in-place normally only the edit view is swapped out for the show view of the record you just edited.
+Example:
+```
+--alt-foreign-key-lookup='agent_id{email+}'
+```
 
-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).
+First, assume the current able has a `belongs_to` association for `agent_id` to a foreign model, `Agent`
 
-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.
+Here, we would build a scaffold that would treat the foreign key `agent_id` as an alt lookup, allowing the user to search for foreign records by email (the agent's email).
 
-### `--with-turbo-streams`
+The `+` symbol indicates to automatically make a new `agent` record (without it, the agent_id will be set to nil if there is no associated agent record found -- this may cause the update to fail, unless `optional: true` is on the belongs_to association.)
 
-If and only if you specify `--with-turbo-streams`, your views will contain `turbo_stream_from` directives. Whereas your views will always contain `turbo_frame_tags` (wether or not this flag is specified) and will use the Turbo stream replacement mechanism for non-idempotent actions (create & update). This flag just brings the magic of live-reload to the scaffold interfaces themselves.
 
-**_To test_**: Open the same interface in two separate browser windows. Make an edit in one window and watch your edit appear in the other window instantly.
+### `--factory-creation={ ... }`
 
-This happens using two interconnected mechanisms:
+The code you specify inside of `{` and `}` will be used to generate a new object. The factory should instantiate with any arguments (I suggest Ruby keyword arguments) and must provide a method that is the name of the thing.
+
+For example, a user Factory might be called like so:
+
+`rails generate hot_glue:scaffold User --factory-creation={factory = UserFactory.new(params: user_params)} --gd`
+
+(Note we are relying on the `user_params` method provided by the controller.)
+
+You must do one of two things:
+1) In the code you specify, set an instance variable `@user` to be the newly created thing. (Your code should contain something like `@thing = ` to trigger this option.)
+2) Make a local variable called `factory` **and** have a method of the name of the object (`user`) on a local variable called `factory` that your code created
+
+(The code example above is the option for #2 because it does not contain `@user =`)
+
+If using number #2, Hot Glue will append this to the code specified:
+```
+@user = factory.user
+```
+
+
+Here's a sample UserFactory that will create a new user only if one with a matching email address doesn't exist. (Otherwise, it will update the existing record.)
+Your initialize method can take any params you need it to, and using this pattern your business logic is applied consistently throughout your app. (You must, of course, use your Factory everywhere else in your app too.)
+
+```
+class UserFactory
+    attr_reader :user
+    attr_accessor :email
+
+    def initialize(params: {})
+        user = User.find_or_create_by(email: params[:email])
+    
+        user.update(params)
+        if user.new_record?
+            # do special new user logic here, like sending an email
+        end
+    end
+end
+```
+
+
+If you are using factory creation along with with alt lookups, be sure your factory code creates a local variable that follows this name
+
+**<downcase association name>**_factory.<downcase association name>
+
+Thus, your factory object must have a method of the same name as the factory being created which returns the thing that got created.
+(It can do the creation either on instantiation or when calling that method)
+
+For example, assuming the example from above, we are going to do the lookup ourselves inside of our own `AgentFactory` object.)
+
+```
+agent_factory = AgentFactory.new(find_or_create_by_email: agent_company_params[:__lookup_email])
+```
 
-1) by default, all Hot Glue scaffold is wrapped in `turbo_frame_tag`s. The id of these tags is your namespace + the Rails dom_id(...). That means all Hot Glue scaffold is namespaced to the namespaces you use and won't collide with other turbo_frame_tag you might be using elsewhere
 
-2) by appending **model callbacks**, we can automatically broadcast updates to the users who are using the Hot Glue scaffold. The model callbacks (after_update_commit and after_destroy_commit) get appended automatically to the top of your model file. Each model callback targets the scaffold being built (so just this scaffold), using its namespace, and renders the line partial (or destroys the content in the case of delete) from the scaffolding.
 
-please note that *creating* and *deleting* do not yet have a full & complete implementation: Your pages won't re-render the pages being viewed cross-peer (that is, between two users using the app at the same time) if the insertion or deletion causes the pagination to be off for another user.
 
 
 ## Automatic Base Controller
@@ -897,8 +1052,10 @@ Child portals have the headings omitted automatically (there is a heading identi
 ## Field Types Supported
 
 - Integers that don't end with `_id`: displayed as input fields with type="number"
-- Foreign keys: 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.)
+- Foreign key integers: 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.)
   - Note:  if your foreign key has a nonusual class name, it should be using the `class_name:` in the model definition
+- UUIDs (as primary key): Works seamlessly for the `id` field to make your primary key a UUID (Be sure to specify UUID in your model's migration). 
+- UUIDs (as foreign key): All UUIDs that are not named `id` are assumed to be foreign keys and will be treated as associations.
 - String: displayed as small input box 
 - Text: displayed as large textarea
 - Float: displayed as input box
@@ -908,10 +1065,108 @@ Child portals have the headings omitted automatically (there is a heading identi
 - Boolean: displayed radio buttons yes/ no
 - Enum - displayed as a drop-down list (defined the enum values on your model). 
   - For Rails 6 see https://jasonfleetwoodboldt.com/courses/stepping-up-rails/enumerated-types-in-rails-and-postgres/
-  - AFAIK, you must specify the enum definition both in your model and also in your database migration for both Rails 6 + Rails 7
+  - You must specify the enum definition both in your model and also in your database migration for both Rails 6 + Rails 7
+
+# Note about enums
+
+The Rails 7 enum implementation for Postgres is very slick but has a counter-intuitive facet.
+Define your Enums in Postgres as strings:
+(database migration)
+```
+    create_enum :status, ["pending", "active", "archived"]
+
+    create_table :users, force: true do |t|
+      t.enum :status, enum_type: "status", default: "pending", null: false
+      t.timestamps
+    end
+```
+
+Then define your `enum` ActiveRecord declaration with duplicate keys & strings:
+(model definition)
+```
+enum status: {
+    pending: "pending",
+    active: "active",
+    archived: "archived",
+    disabled: "disabled",
+    waiting: "waiting"
+  }
+```
+
+To set the labels, use another class-level method that is a hash of keys-to-labels using a method named the same name as the enum method but with `_labels`
+
+If no `_labels` method exists, Hot Glue will fallback to using the Postgres-defined names.
+```
+def self.status_labels
+    {
+      pending: 'Is Pending',
+      active: 'Is active',
+      archived: 'Is Archived',
+      disabled: 'Is Disabled',
+      waiting: 'Is Waiting'
+    }
+```
+
+Now, your labels will show up as defined in the `_labels` ("Is Pending", etc) instead of the database-values.
 
 
 # VERSION HISTORY
+#### 2023-03-01 - v0.5.8 
+
+• Fixes spec assertions for enums to work with the enum `_label` field (when provided).
+
+• Fixes `--form-label-position` (before/after) so that a carriage return is placed between the label & field correctly for either choice
+
+• All spec files are now created in `spec/features/` folder (previously was `spec/system/` with `type: :feature`; they no longer have `type: :feature` as this is not necessary when they are in the `spec/features` folder)
+
+• Corrects the hawk scope to only add the plural related entity when NOT using the shorthand `{ ... }`
+
+• BEM (block element modifier)-style has been added list headings, show cells, edit cells. These class names will get added to the `<div>` tags for both the heading and cells. 
+
+The format is as follows:
+
+For headings
+    `heading--{singular}--{field name}-{field name}-{field name}`
+
+For cells:
+    `cell--{singular}--{field name}-{field name}-{field name}`
+   use this to globally style different fields by object & field name
+
+Note that if you have multiple fields inside one cell (for example, with specified grouping or smart layout), your fields names get concatinated using single-hyphens:
+For example, consider a customer scaffold with a first name & last name appearing in one cell. The cell itself will have a class of:
+`cell--customer--first_name-last_name`
+
+If your cell contains only one field, for example, a phone number, it would look like this:
+`cell--customer--phone_number`
+
+Tip: Use the _ends with_ and _starts with_ selectors, which can be used like this:.
+
+```
+div[class$="--phone_number"] {
+    text-decoration: underline; 
+}
+```
+
+
+```
+
+```
+
+
+#### 2023-02-13 - v0.5.7 - factory-creation, alt lookups, update show only, fixes to Enums, support for Ruby 3.2
+• See `--factory-creation` section.
+
+• `--alt-lookup-foreign-keys`
+Allows you to specify that a foreign key should act as a search field, allowing the user to input a unique value (like an email) to search for a related record.
+
+• `--update-show-only`
+Allows you to specify a list fields that should be show-only (non-editable) on the **edit** page but remain inputable on the **create** page. 
+Note that a singular partial `_form` is still used for new & edit, but now contains `if` statements that check the action and display the show-only version only on the edit action. 
+
+• Syntax fix to support Ruby 3.2.0 (the installer was broken if you used Ruby 3.2)
+
+• Tweaks to how Enums are display (see "Note about Enums")
+
 
 #### 2023-01-02 - v0.5.6
 - Changes the long-form of the hawk specifier to require you to use the has_many of the relationship you are hawking (previously, it was assumed). See Hawk for details
@@ -962,8 +1217,8 @@ License check has been removed (Hot Glue is now free to use for hobbyists and in
 #### 2022-03-23 - v0.5.2 - Hawked Foreign Keys
 
  - You can now protect your foreign keys from malicious input and also restrict the scope of drop downs to show only records with the specified access control restriction.
- - [Example #3](https://jfb.teachable.com/courses/hot-glue-in-depth-tutorial/lectures/38584014) in the Hot Glue Tutorial shows you how to use the hawk to limit the scope to the logged in user.
- - [Example #4](https://jfb.teachable.com/courses/hot-glue-in-depth-tutorial/lectures/38787505) in the Hot Glue Tutorial shows how to hawk to a non-usual scope, the inverse of the current user's belongs_to (that is, hawk the scope to X where current_user `belongs_to :x`)
+ - [Example #3](https://school.jasonfleetwoodboldt.com/8188) in the Hot Glue Tutorial shows you how to use the hawk to limit the scope to the logged in user.
+ - [Example #4](https://school.jasonfleetwoodboldt.com/8188) in the Hot Glue Tutorial shows how to hawk to a non-usual scope, the inverse of the current user's belongs_to (that is, hawk the scope to X where current_user `belongs_to :x`)
  
 
 #### 2022-03-12  - v0.5.1 - Inline List Labels
@@ -1133,9 +1388,9 @@ This runs both the **generated specs** and also the **internal specs**. Examine
 
 To run only the internal specs, use 
 
-`COVERGE=on rspec spec`
+`rspec spec`
 
-Internal Test coverage as of 2022-03-23 (v0.5.2)
+Internal Test coverage as of 2023-02-10 (v0.5.7)
 
-![HG 84 89 coverage report](https://user-images.githubusercontent.com/59002/159719583-a956cfb3-1797-4186-b32c-237ed19e8e2b.png)
+<img width="1202" alt="Screen Shot 2023-02-10 at 4 43 59 PM" src="https://user-images.githubusercontent.com/59002/218204736-5740505b-1ec8-456f-b0fb-9c359f6f7037.png">
 

data/lib/generators/hot_glue/install_generator.rb

@@ -119,7 +119,7 @@ module HotGlue
 
 
       begin
-        if !File.exists?("#{'spec/dummy/' if Rails.env.test?}config/hot_glue.yml")
+        if !File.exist?("#{'spec/dummy/' if Rails.env.test?}config/hot_glue.yml")
           yaml = {layout: layout,
                   markup: @markup}.to_yaml
           File.write("#{'spec/dummy/' if Rails.env.test?}config/hot_glue.yml", yaml)
@@ -131,7 +131,7 @@ module HotGlue
 
 
       begin
-        if !File.exists?("#{'spec/dummy/' if Rails.env.test?}spec/support/capybara_login.rb")
+        if !File.exist?("#{'spec/dummy/' if Rails.env.test?}spec/support/capybara_login.rb")
           copy_file "capybara_login.rb", "#{'spec/dummy/' if Rails.env.test?}spec/support/capybara_login.rb"
         end
       rescue StandardError => e

data/lib/generators/hot_glue/layout/builder.rb

@@ -79,14 +79,18 @@ module HotGlue
             layout_object[:columns][:container] = (0..available_columns-1).collect { |x|
               [ columns[x]]
             }
+            layout_object[:columns][:container] = (0..available_columns-1).collect { |x|  [columns[x]] }
             layout_object[:columns][:container].reject!{|x| x == [nil]}
+            layout_object[:columns][:size_each] = 2
           end
         elsif ! specified_grouping_mode
           # not smart and no specified grouping
-          #
+          layout_object[:columns][:button_columns] = 2
+
           layout_object[:columns][:container] = columns.collect{|col| [col]}
 
         else # specified grouping mode -- the builder is given control
+          layout_object[:columns][:button_columns] = 2
 
           (0..available_columns-1).each do |int|
             layout_object[:columns][:container][int] = []
@@ -129,7 +133,7 @@ module HotGlue
         #   # give some space back to the downnest
         # end
 
-        puts "*** constructed layout columns #{layout_object.inspect}"
+        puts "*** constructed smart layout columns #{layout_object.inspect}"
         layout_object
       end
 

data/lib/generators/hot_glue/layout_strategy/base.rb

@@ -5,6 +5,7 @@ module LayoutStrategy
       @builder = scaffold_builder
     end
 
+    def column_classes_for_button_column; ""; end
     def button_classes; ""; end
     def button_column_style; "" ; end
     def button_style ; ""; end

data/lib/generators/hot_glue/layout_strategy/bootstrap.rb

@@ -1,8 +1,22 @@
 class LayoutStrategy::Bootstrap < LayoutStrategy::Base
-  def button_classes
-    " " + column_classes_for_line_fields
+  def button_classes # column classes
+    " " + "col-sm-#{builder.layout_object[:columns][:button_columns]}"
   end
 
+  def button_applied_classes
+    "btn btn-sm"
+  end
+
+  def magic_button_classes
+    "btn-secondary"
+  end
+
+
+  def column_classes_for_button_column
+    "col-md-#{builder.layout_object[:buttons][:size]}"
+  end
+
+
   def column_classes_for_form_fields
     "col-md-#{builder.layout_object[:columns][:size_each]}"
   end
@@ -12,7 +26,7 @@ class LayoutStrategy::Bootstrap < LayoutStrategy::Base
   end
 
   def container_name
-    "container-fluid"
+    "container"
   end
 
   def column_classes_for_line_fields