hot-glue 0.5.6 → 0.5.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61b8c21f0bf630a68d9861b8bb70141ce7fe0da0a0f1ae71c3bb4e69da6b081d
-  data.tar.gz: 865d633fe279b4db0b2927801c82ec6de1ab630b4ffb7d24ffc539dfbb56d44d
+  metadata.gz: 542376a38c918a449ff542925f226deccdc53df8c538d01044ac1c48ecd62943
+  data.tar.gz: 53f6afd924df425bb32ccd61b9d592a3d21e32ad8af4a71842d8c14539fe6fd0
 SHA512:
-  metadata.gz: 26901af291d1db0f028b14e320ed6c66908c90d94777c559bdba508c4e111b651357531f9fffc468cc419fbe16dda1d9bb6b86777c6e8f840631c4dfb7239e3d
-  data.tar.gz: 69775a6b4a31b142e1683c2017d2b85c1fda1f7350bb4b954948a0b06bfbb990578bed98c0eedce1534e10ad78aa44b87d27deecf027f017184aa731319c62cb
+  metadata.gz: 7a3d4402f80c44ec09955aa53a4f9fae2c02567957d0f3f5b174a829728af5e0e57ea6add91fe974c5752eef67826cea3c5d0e1bac42bab8a838a49979f27b8e
+  data.tar.gz: da590a33b01a00f798c6db36e2f68289284a2b886e2e92e34eb0dbfe538b515423c95d63732bdabe19c404323d78c88491238c9f591591abbc758bc4f068879d

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,12 +29,12 @@ 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
 
@@ -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=`
 
@@ -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)
 
@@ -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.
+
+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.
 
-(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.)
+### `--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,56 @@ 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.
 
-### `--display-list-after-update` 
+### `--factory-creation={ ... }`
 
-After an update-in-place normally only the edit view is swapped out for the show view of the record you just edited.
+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.
 
-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).
+For example, a user Factory might be called like so:
 
-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.
+`rails generate hot_glue:scaffold User --factory-creation={factory = UserFactory.new(params: user_params)} --gd`
 
-### `--with-turbo-streams`
+(Note we are relying on the `user_params` method provided by the controller.)
 
-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.
+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
 
-**_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.
+(The code example above is the option for #2 because it does not contain `@user =`)
 
-This happens using two interconnected mechanisms:
+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
+```
 
-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 +1023,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,11 +1036,68 @@ 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-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
 - Adds "Regenerate me" comment to top of all generated controllers
@@ -1133,9 +1318,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

@@ -62,6 +62,7 @@ module HotGlue
         if smart_layout
           # automatic control
           #
+          layout_object[:columns][:button_columns] = 2
 
           if columns.size > available_columns
             if available_columns == 0
@@ -79,14 +80,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 +134,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,13 @@
 class LayoutStrategy::Bootstrap < LayoutStrategy::Base
   def button_classes
-    " " + column_classes_for_line_fields
+    " " + "col-sm-#{builder.layout_object[:columns][:button_columns]}"
   end
 
+  def column_classes_for_button_column
+    "col-md-#{builder.layout_object[:columns][:button_columns]}"
+  end
+
+
   def column_classes_for_form_fields
     "col-md-#{builder.layout_object[:columns][:size_each]}"
   end