hot-glue 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 46cd5cd43915874022d96f3342d3cd9b28f7c926c94ea04c29eb8df63152623f
+  data.tar.gz: 932672afaa6e13d9a0ebebf3014a3b67e9ec506b7531a23fa9cde4032652bbb8
+SHA512:
+  metadata.gz: 7dacdf0e6d3f91883084799025a5dd02a0d1016e55f455a9d9cbf177f1e723cadfc06bd2ddca7f1ad8ecf4e33dec8e3d851689578e123b78cf7a2d8bf2e4a349
+  data.tar.gz: ddc83432caf2a0ab52a952fbda552ab11ab8696efcdf967debd05988a699a8b62ceab227c0d4d00df68c204578adb5ab604683fafa4735b44140a616f375a46a

data/.github/FUNDING.yml

@@ -0,0 +1,2 @@
+github: [jasonfb]
+custom: ["https://jfb.teachable.com"]

data/.gitignore

@@ -0,0 +1,16 @@
+.bundle/
+log/*.log
+pkg/
+test/dummy/db/*.sqlite3
+test/dummy/db/*.sqlite3-journal
+test/dummy/db/*.sqlite3-*
+test/dummy/log/*.log
+test/dummy/storage/
+test/dummy/tmp/
+.byebug_history
+
+.idea/
+*.gem
+.DS_Store
+
+dump.rdb

data/Gemfile

@@ -0,0 +1,15 @@
+source 'https://rubygems.org'
+git_source(:github) { |repo| "https://github.com/#{repo}.git" }
+
+# Declare your gem's dependencies in common_core_js.gemspec.
+# Bundler will treat runtime dependencies like base dependencies, and
+# development dependencies will be added by default to the :development group.
+gemspec
+
+# Declare any dependencies that are still in development here instead of in
+# your gemspec. These might include edge Rails or gems from your path or
+# Git. Remember to move these dependencies to your gemspec before releasing
+# your gem to rubygems.org.
+
+# To use a debugger
+# gem 'byebug', group: [:development, :test]

data/Gemfile.lock

@@ -0,0 +1,196 @@
+PATH
+  remote: .
+  specs:
+    hot-glue (0.0.1)
+      ffaker (~> 2.16)
+      haml-rails (~> 2.0)
+      kaminari (~> 1.2)
+      rails (~> 6.0)
+      sass-rails
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actioncable (6.1.0)
+      actionpack (= 6.1.0)
+      activesupport (= 6.1.0)
+      nio4r (~> 2.0)
+      websocket-driver (>= 0.6.1)
+    actionmailbox (6.1.0)
+      actionpack (= 6.1.0)
+      activejob (= 6.1.0)
+      activerecord (= 6.1.0)
+      activestorage (= 6.1.0)
+      activesupport (= 6.1.0)
+      mail (>= 2.7.1)
+    actionmailer (6.1.0)
+      actionpack (= 6.1.0)
+      actionview (= 6.1.0)
+      activejob (= 6.1.0)
+      activesupport (= 6.1.0)
+      mail (~> 2.5, >= 2.5.4)
+      rails-dom-testing (~> 2.0)
+    actionpack (6.1.0)
+      actionview (= 6.1.0)
+      activesupport (= 6.1.0)
+      rack (~> 2.0, >= 2.0.9)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.2.0)
+    actiontext (6.1.0)
+      actionpack (= 6.1.0)
+      activerecord (= 6.1.0)
+      activestorage (= 6.1.0)
+      activesupport (= 6.1.0)
+      nokogiri (>= 1.8.5)
+    actionview (6.1.0)
+      activesupport (= 6.1.0)
+      builder (~> 3.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.1, >= 1.2.0)
+    activejob (6.1.0)
+      activesupport (= 6.1.0)
+      globalid (>= 0.3.6)
+    activemodel (6.1.0)
+      activesupport (= 6.1.0)
+    activerecord (6.1.0)
+      activemodel (= 6.1.0)
+      activesupport (= 6.1.0)
+    activestorage (6.1.0)
+      actionpack (= 6.1.0)
+      activejob (= 6.1.0)
+      activerecord (= 6.1.0)
+      activesupport (= 6.1.0)
+      marcel (~> 0.3.1)
+      mimemagic (~> 0.3.2)
+    activesupport (6.1.0)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    builder (3.2.4)
+    concurrent-ruby (1.1.8)
+    crass (1.0.6)
+    erubi (1.10.0)
+    erubis (2.7.0)
+    ffaker (2.17.0)
+    ffi (1.14.2)
+    globalid (0.4.2)
+      activesupport (>= 4.2.0)
+    haml (5.2.1)
+      temple (>= 0.8.0)
+      tilt
+    haml-rails (2.0.1)
+      actionpack (>= 5.1)
+      activesupport (>= 5.1)
+      haml (>= 4.0.6, < 6.0)
+      html2haml (>= 1.0.1)
+      railties (>= 5.1)
+    html2haml (2.2.0)
+      erubis (~> 2.7.0)
+      haml (>= 4.0, < 6)
+      nokogiri (>= 1.6.0)
+      ruby_parser (~> 3.5)
+    i18n (1.8.9)
+      concurrent-ruby (~> 1.0)
+    kaminari (1.2.1)
+      activesupport (>= 4.1.0)
+      kaminari-actionview (= 1.2.1)
+      kaminari-activerecord (= 1.2.1)
+      kaminari-core (= 1.2.1)
+    kaminari-actionview (1.2.1)
+      actionview
+      kaminari-core (= 1.2.1)
+    kaminari-activerecord (1.2.1)
+      activerecord
+      kaminari-core (= 1.2.1)
+    kaminari-core (1.2.1)
+    loofah (2.9.0)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.5.9)
+    mail (2.7.1)
+      mini_mime (>= 0.1.1)
+    marcel (0.3.3)
+      mimemagic (~> 0.3.2)
+    method_source (1.0.0)
+    mimemagic (0.3.5)
+    mini_mime (1.0.2)
+    minitest (5.14.3)
+    nio4r (2.5.4)
+    nokogiri (1.11.1-x86_64-darwin)
+      racc (~> 1.4)
+    racc (1.5.2)
+    rack (2.2.3)
+    rack-test (1.1.0)
+      rack (>= 1.0, < 3)
+    rails (6.1.0)
+      actioncable (= 6.1.0)
+      actionmailbox (= 6.1.0)
+      actionmailer (= 6.1.0)
+      actionpack (= 6.1.0)
+      actiontext (= 6.1.0)
+      actionview (= 6.1.0)
+      activejob (= 6.1.0)
+      activemodel (= 6.1.0)
+      activerecord (= 6.1.0)
+      activestorage (= 6.1.0)
+      activesupport (= 6.1.0)
+      bundler (>= 1.15.0)
+      railties (= 6.1.0)
+      sprockets-rails (>= 2.0.0)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.3.0)
+      loofah (~> 2.3)
+    railties (6.1.0)
+      actionpack (= 6.1.0)
+      activesupport (= 6.1.0)
+      method_source
+      rake (>= 0.8.7)
+      thor (~> 1.0)
+    rake (13.0.3)
+    rb-fsevent (0.10.4)
+    rb-inotify (0.10.1)
+      ffi (~> 1.0)
+    ruby_parser (3.15.0)
+      sexp_processor (~> 4.9)
+    sass (3.7.4)
+      sass-listen (~> 4.0.0)
+    sass-listen (4.0.0)
+      rb-fsevent (~> 0.9, >= 0.9.4)
+      rb-inotify (~> 0.9, >= 0.9.7)
+    sass-rails (5.1.0)
+      railties (>= 5.2.0)
+      sass (~> 3.1)
+      sprockets (>= 2.8, < 4.0)
+      sprockets-rails (>= 2.0, < 4.0)
+      tilt (>= 1.1, < 3)
+    sexp_processor (4.15.1)
+    sprockets (3.7.2)
+      concurrent-ruby (~> 1.0)
+      rack (> 1, < 3)
+    sprockets-rails (3.2.2)
+      actionpack (>= 4.0)
+      activesupport (>= 4.0)
+      sprockets (>= 3.0.0)
+    temple (0.8.2)
+    thor (1.1.0)
+    tilt (2.0.10)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    websocket-driver (0.7.3)
+      websocket-extensions (>= 0.1.0)
+    websocket-extensions (0.1.5)
+    zeitwerk (2.4.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  hot-glue!
+
+BUNDLED WITH
+   2.1.4

data/LICENCE

@@ -0,0 +1,13 @@
+Permission is hereby granted 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:
+
+Any users of this software agree to work to
+1) dismantle systemic racism;
+2) seek justice for black, brown, transgender people, women, and
+3) work towards LGBTQIAA+ representation and inclusion.
+
+Organizations using this software agree to center the narratives of black, brown, transgender, and non-advantaged people in the world.
+
+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.
+

data/README.md

@@ -0,0 +1,262 @@
+# Hot Glue
+
+Hot Glue is an evolution of the best of the admin-style scaffold builders 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) being the most popular of those). It harnesses the power of Rails 6, Turbo-Rails, and Hotwire to deliver a lightning fast experience.
+
+As well, its premise is a little different than the configuration-heavy admin interface toolkits. 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. 
+
+It gives users full control over objects they 'own' and by default it spits out functionality giving access to all fields. 
+
+Hot Glue generates functionality that's quick and dirty. It let's you be crafty. Like a real glue gun with hot glue, take care not to burn yourself while using it. 
+
+* Build plug-and-play scaffolding mixing HAML and turbo_stream responses
+* Automatically Reads Your Models (make them before building your scaffolding!)
+* CRUD, lists with pagination, (coming soon: sorting & searching)
+* Wonderful for prototyping.
+* Nest your routes model-by-model for built-in poor man's authentication.
+* Plays nicely with Devise, but you can implement your own current_user object instead.
+* Requires & uses Kaminari for pagination.
+* Create specs automatically along with the controllers (* rspec only for now).
+* Throw the scaffolding away when your app is ready to graduate to its next phase (or don't if you like it).
+
+## QUICK START (COMING SOON)
+
+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://blog.jasonfleetwoodboldt.com/hot-glue
+
+## HOW EASY?
+
+
+```
+rails generate hot_glue:scaffold Thing 
+```
+
+## TO INSTALL
+
+- Add 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 hot_glue to your Gemfile & bundle install, then install it with `rails hot_glue:install`
+
+- Install Bootstrap (optional)
+
+with Webpack: 
+  - change `stylesheet_link_tag` to `stylesheet_pack_tag` in your application layout
+  - `yarn add bootstrap`
+  - create a new file at `app/javascript/css/site.scss` with this contents
+    ```
+    @import "~bootstrap/scss/bootstrap.scss
+    ```
+    
+  - add to `app/javascript/packs/application.js` 
+    ```
+    import 'css/site'
+    ```
+    
+    
+
+- Install Devise or implement your own authentication
+
+
+
+## Options
+
+Note that the arguments are not preceded by dashes and are followed by equal sign and the input you are giving.
+
+Flags take two dashes (--) and do not take any value. Always pass options first, followed by the flags (or else your options won't work!)
+
+### First Argument
+
+TitleCase class name of the thing you want to build a scaffoling for.
+
+### `namespace=`
+
+pass `namespace=` as an option to denote a namespace to apply to the Rails path helpers
+
+
+`rails generate hot_glue:scaffold Thing namespace=dashboard`
+
+This produces several views at `app/views/dashboard/things/` and a controller at`app/controllers/dashboard/things_controller.rb`
+
+The controller looks like so:
+
+```
+class Dashboard::ThingsController < ApplicationController
+  before_action :authenticate_user!
+  before_action :load_thing, only: [:show, :edit, :update, :destroy]
+  def load_thing
+    @thing = current_user.things.find(params[:id])
+  end
+  ...
+end
+
+```
+
+
+### `nest=`
+
+pass `nest=` to denote a nested resources
+
+
+`rails generate hot_glue:scaffold Line nest=invoice`
+
+In this example, it is presumed that the current user has_many :invoices, and that invoices have many :lines
+
+
+For multi-level nesting use slashes to separate your levels of nesting. Remember, you should match what you have in your routes.rb file.
+
+```
+resources :invoices do
+    resources :lines do
+        resources :charge
+    end    
+end
+
+```
+In this example, it is presumed that the current user has_many :invoices, and that invoices have many :lines, and that lines have many :charges
+
+
+To generate scaffold:
+`rails generate hot_glue:scaffold Charge nest=invoice/line`
+
+The order of the nest should match the nested resources you have in your own app.  In particular, you auth root will be used as the starting point when loading the objects from the URL:
+
+In the example above, @invoice will be loaded from
+
+`@invoice = current_user.invoices.find(params[:invoice_id])`
+
+Then, @line will be loaded
+
+`@line = @invoice.lines.find(params[:line_id])`
+
+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 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).
+
+Your customers can delete their own objects by default (may be a good idea or a bad idea for you). If you don't want that, you should strip out the delete actions off the controllers.
+
+
+### `auth=`
+
+By default, it will be assumed you have a `current_user` for your user authentication. This will be treated as the "authentication root" for the "poor man's auth" explained above.
+
+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.
+
+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.
+
+If you use Devise, you probably already have a `current_user` method available in your controllers. If you don't use Devise, you can implement it in your ApplicationController.
+
+If you use a different object other than "User" for authentication, override using the `auth` option.
+
+`rails generate hot_glue:scaffold Thing auth=current_account`
+
+You will note that in this example it is presumed that the Account object will have an association for `things`
+
+It is also presumed that when viewing their own dashboard of things, the user will want to see ALL of their associated things.
+
+If you supply nesting (see below), your nest chain will automatically begin with your auth root object (see nesting)
+
+
+
+
+### `auth_identifier=`
+
+Your controller will call a method authenticate_ (AUTH IDENTIFIER) bang, like:
+
+`authenticate_user!`
+
+Before all of the controller actions. If you leave this blank, it will default to using the variable name supplied by auth with "current_" stripped away.
+(This is setup for devise.)
+
+Be sure to implement the following method in your ApplicationController or some other method. Here's a quick example using Devise. You will note in the code below, user_signed_in? is implemented when you add Devise methods to your User table.
+
+As well, the `after_sign_in_path_for(user)` here is a hook for Devise also that provides you with after login redirect to the page where the user first intended to go.
+
+```
+  def authenticate_user!
+    if ! user_signed_in?
+      session['user_return_to'] = request.path
+      redirect_to new_user_registration_path
+    end
+  end
+
+  def after_sign_in_path_for(user)
+    session['user_return_to'] || account_url(user)
+  end
+```
+
+
+The default (do not pass `auth_identifier=`) will match the `auth` (So if you use 'account' as the auth, `authenticate_account!` will get invoked from your generated controller; the default is always 'user', so you can leave both auth and auth_identifier off if you want 'user')
+
+
+`rails generate hot_glue:scaffold Thing auth=current_account auth_identifier=login`
+In this example, the controller produced with:
+```
+   before_action :authenticate_login!
+```
+However, the object graph anchors would continue to start from current_account. That is,
+```
+@thing = current_account.things.find(params[:id])
+```
+
+Use empty string to **turn this method off**:
+`rails generate hot_glue:scaffold Thing auth=current_account auth_identifier=''`
+
+In this case a controller would be generated that would have NO before_action to authenticate the account, but it would still treat the current_account as the auth root for the purpose of loading the objects.
+
+Please note that this example would product non-functional code, so you would need to manually fix your controllers to make sure `current_account` is available to the controller.
+
+
+### `plural=`
+
+You don't need this if the pluralized version is just + "s" of the singular version. Only use for non-standard plurlizations, and be sure to pass it as TitleCase (as if  you pluralized the model name)
+
+
+### `--god`
+
+Use this flag to create controllers with no root authentication. You can still use an auth_identifier, which can be useful for a meta-leval authentication to the controoler.
+
+For example, FOR ADMIN CONTROLLERS ONLY, supply a auth_identifier and use `--god` flag
+
+In God mode, the objects are loaded directly from the base class (these controllers have full access)
+```
+def load_thing
+    @thing = Thing.find(params[:id])
+end
+
+```
+
+
+
+### `--specs-only`
+
+Produces ONLY the controller spec file, nothing else.
+
+
+### `--no-specs`
+
+Produces all the files except the spec file.
+
+
+# VERSION HISTORY
+#### 2021-02-24 - v0.0.1 - first proof of concept release -- basic CRUD works 
+
+#### 2021-02-23 - v0.0.0 - Port of my prior work from github.com/jasonfb/common_core_js
+
+
+# ACKNOWLEDGEMENTS
+
+### "POOR MAN"
+
+I hope one day I will leave this Earth a poor man (like my code) owning only the most simple structure for the simple form of my existence. Thanks for having educated me in this wisdom goes to my former mentor [@trak3r](https://github.com/trak3r)! 
+
+

data/Rakefile

@@ -0,0 +1,32 @@
+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("test/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

@@ -0,0 +1,105 @@
+module HotGlue
+  module ControllerHelper
+
+    def timezonize(tz)
+      tz = tz.to_i
+      (tz >= 0 ? "+" : "-") + sprintf('%02d',tz.abs) + ":00"
+    end
+
+
+    def datetime_field_localized(form_object, field_name, value, label, timezone = nil )
+      res = form_object.label(label,
+                              field_name,
+                              class: 'small form-text text-muted')
+
+      res << form_object.text_field(field_name, class: 'form-control',
+                                    type: 'datetime-local',
+                                    value: date_to_current_timezone(value, timezone))
+
+      res << timezonize(timezone)
+      res
+    end
+
+
+    def date_field_localized(form_object, field_name, value, label, timezone = nil )
+
+      res = form_object.label(label,
+                              field_name,
+                              class: 'small form-text text-muted')
+
+      res << form_object.text_field(field_name, class: 'form-control',
+                                    type: 'date',
+                                    value: value )
+
+      res
+    end
+
+    def time_field_localized(form_object, field_name, value, label, timezone = nil )
+      res = form_object.label(label,
+                              field_name,
+                              class: 'small form-text text-muted')
+
+      res << form_object.text_field(field_name, class: 'form-control',
+                                    type: 'time',
+                                    value: date_to_current_timezone(value, timezone))
+
+      res << timezonize(tz)
+      res
+    end
+
+    def current_timezone
+      if defined?(current_user)
+        if current_user.try(:timezone)
+          Time.now.in_time_zone(current_user.timezone.to_i).strftime("%z").to_i/100
+        else
+          server_timezone
+        end
+      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
+    end
+
+    def server_timezone
+      Time.now.strftime("%z").to_i/100
+    end
+
+    def date_to_current_timezone(date, timezone = nil)
+      # if the timezone is nil, use the server date'
+      if timezone.nil?
+        timezone = Time.now.strftime("%z").to_i/100
+      end
+
+      return nil if date.nil?
+
+      begin
+        return date.in_time_zone(timezone).strftime("%Y-%m-%dT%H:%M")
+      rescue
+        return nil
+      end
+    end
+
+
+
+    def modify_date_inputs_on_params(modified_params, current_user_object = nil)
+      use_timezone = (current_user_object.try(:timezone)) || Time.now.strftime("%z")
+
+      modified_params = modified_params.tap do |params|
+        params.keys.each{|k|
+          if k.ends_with?("_at") || k.ends_with?("_date")
+
+            begin
+              params[k] = DateTime.strptime("#{params[k]} #{use_timezone}", '%Y-%m-%dT%H:%M %z')
+            rescue StandardError
+
+            end
+          end
+        }
+      end
+      modified_params
+    end
+  end
+end

data/app/helpers/hot_glue_helper.rb

@@ -0,0 +1,4 @@
+module HotGlueHelper
+
+
+end

data/bin/rails

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails gems
+# installed from the root of your application.
+
+ENGINE_ROOT = File.expand_path('..', __dir__)
+ENGINE_PATH = File.expand_path('../lib/common_core_js/engine', __dir__)
+APP_PATH = File.expand_path('../test/dummy/config/application', __dir__)
+
+# Set up gems listed in the Gemfile.
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])
+
+require 'rails/all'
+require 'rails/engine/commands'