rails_drivers 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 575d8e9162b65431801bf6d419fe5fca254d65fdd3a840877ea1a0c186bd90bd
+  data.tar.gz: 06e51508f802ee83223d9b9a0bea05f91f93d0813cf1aba6503f29d63cb9d631
+SHA512:
+  metadata.gz: 65a00d958eaf2d888c565149f840ac43f0048587b332c433c33734e38652bb31d5a90c6d3bb439eaca6c5e3c1b7b2fa7d9703f97a45dad40b059a3f3e05e298f
+  data.tar.gz: b5a03060c043e906ea25955a23513a6939a532fecb560c81cb3bc9075d708195d9bf60135e620a268ca025ec81a9ea90b17c0f0baf957761b091b330ef763a73

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2019 Nigel Baillie
+
+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.

data/README.md

@@ -0,0 +1,134 @@
+# RailsDrivers
+
+## What are these "drivers"?
+
+Each driver is like a mini Rails app that has full access to the main app. A driver has its own `app`, `config`, `spec`, and `db` folder.
+
+Technically speaking, drivers are just a fancy name for putting code into a different folder. The advantage of doing this is that it provides clear-cut separation of concerns. If we follow a couple of simple rules, we can actually test that separation:
+
+- Drivers should not touch other drivers
+- The main app should not touch drivers directly
+
+The "main app" refers to the files inside your `<project root>/app` directory.
+
+If your test suite is good, you can test that these rules are adhered to by selectively adding and removing drivers before running your tests.
+
+## Aren't these just engines?
+
+Very similar, yes. They use the same Rails facilities for adding new `app` paths, etc.
+
+But Drivers have less friction. They can be freely added and removed from your project without breaking anything. There's no need to mess around with gems, vendoring, or dummy apps.
+
+## Usage
+
+Every folder inside `drivers` has its own `app`, `config`, `db`, and `spec` folders. They are effectively a part of the overall Rails app.
+
+### Creating a new driver
+
+Just run `rails g driver my_new_driver_name`.
+
+### Creating migrations for a driver
+
+`bundle exec driver my_driver_name generate migration blah etc_etc:string`
+
+The `driver` utility technically works with other generators and rake tasks, but is only guaranteed to work with migrations.
+The reason is that some generators assume a particular path, rather than using the Rails path methods.
+
+### Testing for coupling
+
+Since drivers are merged into your main application just like engines, there's nothing stopping them from accessing other drivers, and there's nothing stopping your main application from accessing drivers. In order to ensure those things don't happen, we have a handful of rake tasks:
+
+1. `rake driver:isolate[<name of driver>] # leaves you with only one driver`
+2. `rake driver:clear                     # removes all drivers`
+3. `rake driver:restore                   # restores all drivers`
+
+Suppose you have a driver called `store` and a driver called `admin`. You don't want `store` and `admin` to talk to each other.
+
+```bash
+# Run specs with store driver only
+rake driver:isolate[store]
+rspec --pattern '{spec,drivers/*/spec}/**{,/*/**}/*_spec.rb'
+rake driver:restore
+
+# Run specs with admin driver only
+rake driver:isolate[admin]
+rspec --pattern '{spec,drivers/*/spec}/**{,/*/**}/*_spec.rb'
+rake driver:restore
+```
+
+This lets you to ensure that the store and admin function properly without each other. Note we're running all of the main app's specs twice. This is good because we also want to make sure the main app is not reaching into drivers.
+
+Of course there's nothing stopping you from using if-statements to detect whether a driver is present. It's up to you to determine what's a "safe" level of crossover. Generally, if you find yourself using a lot of those if-statements, you should consider rethinking which functionality belongs in a driver and which functionality belongs in your main app.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rails_drivers'
+```
+
+And then execute:
+```bash
+$ bundle install
+```
+
+Add this line to your routes.rb:
+
+```ruby
+require 'rails_drivers/routes'
+```
+
+### RSpec
+
+If you use RSpec, add these lines to your `spec/rails_helper.rb` or `spec/spec_helper.rb`:
+
+```ruby
+Dir[Rails.root.join("drivers/*/spec/support/*.rb")].each { |f| require f }
+
+RSpec.configure do |config|
+  Dir[Rails.root.join('drivers/*/spec')].each { |x| config.project_source_dirs << x }
+  Dir[Rails.root.join('drivers/*/lib')].each { |x| config.project_source_dirs << x }
+  Dir[Rails.root.join('drivers/*/app')].each { |x| config.project_source_dirs << x }
+end
+```
+
+### Webpacker
+
+If you use Webpacker, take a look at this snippet. You'll want to add the code between the comments:
+
+```javascript
+// config/webpack/environment.js
+const { environment } = require('@rails/webpacker')
+
+//// Begin driver code ////
+const { config } = require('@rails/webpacker')
+const { sync } = require('glob')
+const { basename, dirname, join, relative, resolve } = require('path')
+const extname = require('path-complete-extname')
+
+const getExtensionsGlob = () => {
+  const { extensions } = config
+  return extensions.length === 1 ? `**/*${extensions[0]}` : `**/*{${extensions.join(',')}}`
+}
+
+const addToEntryObject = (sourcePath) => {
+  const glob = getExtensionsGlob()
+  const rootPath = join(sourcePath, config.source_entry_path)
+  const paths = sync(join(rootPath, glob))
+  paths.forEach((path) => {
+    const namespace = relative(join(rootPath), dirname(path))
+    const name = join(namespace, basename(path, extname(path)))
+    environment.entry.set(name, resolve(path))
+  })
+}
+
+sync('drivers/*').forEach((driverPath) => {
+  addToEntryObject(join(driverPath, config.source_path));
+})
+//// End driver code ////
+
+module.exports = environment
+```
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+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    = 'RailsDrivers'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'bundler/gem_tasks'

data/bin/driver

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+APP_PATH = File.expand_path('config/application')
+require_relative "#{Dir.pwd}/config/boot"
+
+REPLACE_DEFAULT_PATH_WITH_DRIVER = ARGV.shift
+
+possible_drivers = Dir['drivers/*'].map { |d| d.split('/').last }
+unless possible_drivers.include?(REPLACE_DEFAULT_PATH_WITH_DRIVER)
+  puts "Unknown driver #{REPLACE_DEFAULT_PATH_WITH_DRIVER}. Must be one of [#{possible_drivers.join(', ')}]"
+  exit 1
+end
+
+require 'rails/commands'

data/lib/generators/driver/USAGE

@@ -0,0 +1,15 @@
+Description:
+    Generates the directory structure for a new driver.
+
+Example:
+    rails generate driver new_feature
+
+    This will create:
+        drivers/new_feature
+        drivers/new_feature/app
+        drivers/new_feature/app/controllers/new_feature
+        drivers/new_feature/app/models/new_feature
+        drivers/new_feature/app/views/new_feature
+        drivers/new_feature/config
+        drivers/new_feature/spec
+        drivers/new_feature/lib

data/lib/generators/driver/driver_generator.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class DriverGenerator < Rails::Generators::NamedBase
+  source_root File.expand_path('templates', __dir__)
+
+  def create_driver_dir_structure
+    create_file "drivers/#{file_name}/app/models/#{file_name}/.keep", ''
+    create_file "drivers/#{file_name}/app/controllers/#{file_name}/.keep", ''
+    create_file "drivers/#{file_name}/app/views/#{file_name}/.keep", ''
+    create_file "drivers/#{file_name}/spec/.keep", ''
+    create_file "drivers/#{file_name}/db/migrate/.keep", ''
+    create_file "drivers/#{file_name}/lib/.keep", ''
+
+    template 'routes.rb.erb',      "drivers/#{file_name}/config/routes.rb"
+    template 'initializer.rb.erb', "drivers/#{file_name}/config/initializers/#{file_name}_feature.rb"
+    template 'module.rb.erb',      "drivers/#{file_name}/app/models/#{file_name}.rb"
+  end
+end

data/lib/generators/driver/templates/initializer.rb.erb

@@ -0,0 +1,7 @@
+# The core app (or other drivers) can check the presence of the
+# <%= class_name %> driver with the following code snippit
+#
+#   do_something if RailsDrivers.loaded.include(:<%= file_name %>)
+#
+# use with caution!
+RailsDrivers.loaded << :<%= file_name %>

data/lib/generators/driver/templates/module.rb.erb

@@ -0,0 +1,5 @@
+module <%= class_name %>
+  def self.table_name_prefix
+    '<%= plural_name.singularize %>_'
+  end
+end

data/lib/generators/driver/templates/routes.rb.erb

@@ -0,0 +1,6 @@
+<%= Rails.application.class.name %>.routes.draw do
+  scope :<%= plural_name.singularize %> do
+    # TODO
+    # get '/my_path', to: '<%= file_name %>/my_controller'
+  end
+end

data/lib/rails_drivers.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'rails_drivers/version'
+require 'rails_drivers/setup'
+require 'rails_drivers/railtie'
+
+module RailsDrivers
+  def self.loaded
+    @loaded ||= []
+  end
+
+  def self.freeze!
+    @loaded = @loaded&.freeze
+  end
+end

data/lib/rails_drivers/railtie.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RailsDrivers
+  class Railtie < ::Rails::Railtie
+    include ::RailsDrivers::Setup
+
+    rake_tasks do
+      load File.expand_path("#{__dir__}/../tasks/rails_drivers_tasks.rake")
+    end
+
+    config.before_configuration { setup_paths }
+    config.after_initialize { RailsDrivers.freeze! }
+  end
+end

data/lib/rails_drivers/routes.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RailsDrivers
+  class Routes
+    def self.load_driver_routes
+      return if defined?(REPLACE_DEFAULT_PATH_WITH_DRIVER)
+
+      Dir[Rails.root.join('drivers/*')].each do |path|
+        load "#{path}/config/routes.rb" if File.exist?("#{path}/config/routes.rb")
+      end
+    end
+  end
+end
+
+# This is meant to be executed as soon as the file is required
+RailsDrivers::Routes.load_driver_routes

data/lib/rails_drivers/setup.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RailsDrivers
+  module Setup
+    DRIVER_PATHS = %w[
+      app
+      app/assets
+      app/models
+      app/views
+      app/controllers
+      app/mailers
+      config/initializers
+      db db/migrate
+      lib
+    ].freeze
+
+    #
+    # This allows Rails to find models, views, controllers, etc inside of drivers.
+    #
+    def setup_paths
+      # This REPLACE_DEFAULT_PATH_WITH_DRIVER constant gets defined by bin/driver when we want
+      # to run a command in the context of a driver instead of the main rails app.
+      if defined?(REPLACE_DEFAULT_PATH_WITH_DRIVER)
+        replace_rails_paths_with_driver(REPLACE_DEFAULT_PATH_WITH_DRIVER)
+      else
+        add_every_driver_to_rails_paths
+      end
+    end
+
+    private
+
+    def rails_config
+      Rails.application.config
+    end
+
+    def replace_rails_paths_with_driver(driver_name)
+      DRIVER_PATHS.each do |path|
+        rails_config.paths[path] = "drivers/#{driver_name}/#{path}"
+        rails_config.autoload_paths = ["#{rails_config.root}/drivers/#{driver_name}/lib"]
+      end
+    end
+
+    def add_every_driver_to_rails_paths
+      Dir['drivers/*'].each do |driver|
+        DRIVER_PATHS.each do |path|
+          rails_config.paths[path] << "#{driver}/#{path}"
+        end
+
+        # We want to autoload driver/*/lib folders
+        rails_config.autoload_paths += ["#{rails_config.root}/#{driver}/lib"]
+      end
+    end
+  end
+end

data/lib/rails_drivers/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RailsDrivers
+  VERSION = '0.2.0'
+end

data/lib/tasks/rails_drivers_tasks.rake

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+namespace :driver do
+  DriverError = Class.new(StandardError)
+
+  desc 'Removes every driver but the one specified. Can be undone with driver:restore.'
+  task :isolate, [:driver] do |_t, args|
+    include FileUtils
+
+    raise DriverError, 'No driver specified' if args.driver.blank?
+    raise DriverError, 'Driver not found' unless File.exist?("drivers/#{args.driver}")
+
+    mkdir_p 'tmp/drivers'
+    Dir['drivers/*'].each do |driver_path|
+      next if driver_path.include?("/#{args.driver}")
+
+      mv driver_path, "tmp/#{driver_path}"
+      puts "Moved #{driver_path} to tmp/drivers/"
+    end
+
+  rescue DriverError => e
+    puts e.message
+  end
+
+  desc 'Removes all drivers. Can be undone with driver:restore.'
+  task :clear do
+    include FileUtils
+
+    mkdir_p 'tmp/drivers'
+    Dir['drivers/*'].each do |driver_path|
+      mv driver_path, "tmp/#{driver_path}"
+      puts "Moved #{driver_path} to tmp/drivers/"
+    end
+  end
+
+  desc 'Undoes the effects of driver:isolate and driver:clear.'
+  task :restore do
+    include FileUtils
+
+    Dir['tmp/drivers/*'].each do |tmp_driver_path|
+      driver = tmp_driver_path.split('/').last
+      mv tmp_driver_path, "drivers/#{driver}"
+      puts "Moved #{tmp_driver_path} to drivers/"
+    end
+  end
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: rails_drivers
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Nigel Baillie
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-12-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webpacker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+description: Like Rails Engines, but without the friction. Your Rails app can't access
+  them, and they can't access each other.
+email:
+- nbaillie@degica.com
+executables:
+- driver
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- bin/driver
+- lib/generators/driver/USAGE
+- lib/generators/driver/driver_generator.rb
+- lib/generators/driver/templates/initializer.rb.erb
+- lib/generators/driver/templates/module.rb.erb
+- lib/generators/driver/templates/routes.rb.erb
+- lib/rails_drivers.rb
+- lib/rails_drivers/railtie.rb
+- lib/rails_drivers/routes.rb
+- lib/rails_drivers/setup.rb
+- lib/rails_drivers/version.rb
+- lib/tasks/rails_drivers_tasks.rake
+homepage: https://github.com/degica/rails_drivers
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.6
+signing_key: 
+specification_version: 4
+summary: De-coupled separation of concerns for Rails
+test_files: []