potassium 5.2.0 → 6.1.0

data/lib/potassium/recipes/github.rb

@@ -1,29 +1,107 @@
+require 'octokit'
+
 class Recipes::Github < Rails::AppBuilder
   def ask
-    repo_name = "platanus/#{get(:dasherized_app_name)}"
     github_repo_create = answer(:github) do
-      q = "Do you want to create the Github repository (https://github.com/#{repo_name}) " +
-        "for this project?"
-      Ask.confirm(q)
-    end
-    if github_repo_create
-      github_repo_private = answer(:"github-private") do
-        Ask.confirm("Should the repository be private?")
-      end
+      Ask.confirm('Do you want to create a Github repository?')
     end
-    set(:github_repo_name, repo_name)
     set(:github_repo, github_repo_create)
-    set(:github_repo_private, github_repo_private)
+    setup_repo if github_repo_create
+  end
+
+  def setup_repo
+    setup_repo_private
+    setup_repo_org
+    setup_repo_name
+    set(:github_access_token, get_access_token)
   end
 
   def create
-    github_repo_create(get(:github_repo_name), get(:github_repo_private)) if selected?(:github_repo)
+    return unless selected?(:github_repo)
+
+    create_github_repo
+    copy_file '../assets/.github/pull_request_template.md', '.github/pull_request_template.md'
   end
 
   private
 
-  def github_repo_create(repo_name, private_repo = false)
-    flag = private_repo ? "-p" : ""
-    run "hub create #{flag} #{repo_name}"
+  def setup_repo_private
+    repo_private = answer(:github_private) do
+      Ask.confirm('Should the repository be private?')
+    end
+    set(:github_repo_private, repo_private)
+  end
+
+  def setup_repo_org
+    has_organization = answer(:github_has_org) do
+      Ask.confirm('Is this repo for a Github organization?')
+    end
+    set(:github_has_org, has_organization)
+    if has_organization
+      repo_organization = answer(:github_org) do
+        Ask.input('What is the organization for this repository?', default: 'platanus')
+      end
+      set(:github_org, repo_organization)
+    end
+  end
+
+  def setup_repo_name
+    repo_name = answer(:github_name) do
+      Ask.input('What is the name for this repository?', default: get(:dasherized_app_name))
+    end
+    set(:github_repo_name, repo_name)
+  end
+
+  def create_github_repo
+    options = { private: get(:github_repo_private) }
+    options[:organization] = get(:github_org) if get(:github_has_org)
+    repo_name = get(:github_repo_name)
+
+    is_retry = false
+    begin
+      github_client(is_retry).create_repository(repo_name, options)
+    rescue Octokit::Unauthorized
+      is_retry = true
+      retry if retry_create_repo
+    end
+  end
+
+  def retry_create_repo
+    puts "Bad credentials, information on Personal Access Tokens here:"
+    puts "https://docs.github.com/en/github/authenticating-to-github/creating-a-personal-access-token"
+    puts "Make sure to give repo access to the personal access token"
+    Ask.confirm("Do you want to retry?")
+  end
+
+  def github_client(is_retry = false)
+    access_token = is_retry ? set_access_token : get(:github_access_token)
+    octokit_client.new(access_token: access_token)
+  end
+
+  def octokit_client
+    if answer(:test)
+      require_relative '../../../spec/support/fake_octokit'
+      FakeOctokit
+    else
+      Octokit::Client
+    end
+  end
+
+  def get_access_token
+    return File.open(config_filename, 'r').read if File.exists?(config_filename)
+
+    set_access_token
+  end
+
+  def set_access_token
+    access_token = answer(:github_access_token) do
+      Ask.input('Enter a GitHub personal access token', password: true)
+    end
+    File.open(config_filename, 'w') { |f| f.write(access_token) }
+    access_token
+  end
+
+  def config_filename
+    @config_filename ||= File.expand_path('~/.potassium')
   end
 end

data/lib/potassium/recipes/heroku.rb

@@ -41,6 +41,8 @@ class Recipes::Heroku < Rails::AppBuilder
 
     copy_file '../assets/Procfile', 'Procfile'
     copy_file '../assets/.buildpacks', '.buildpacks'
+    copy_file '../assets/bin/release', 'bin/release'
+    run 'chmod a+x bin/release'
 
     template "../assets/bin/setup_heroku.erb", "bin/setup_heroku", force: true
     run "chmod a+x bin/setup_heroku"
@@ -88,7 +90,6 @@ class Recipes::Heroku < Rails::AppBuilder
     run_toolbelt_command "labs:enable runtime-dyno-metadata", staged_app_name
     run_toolbelt_command "config:add HEROKU_APP_NAME=#{staged_app_name}", staged_app_name
     run_toolbelt_command "config:add #{rack_env}", staged_app_name
-    run_toolbelt_command "config:add DEPLOY_TASKS=db:migrate", staged_app_name
 
     set_rails_secrets(environment)
     set_app_multi_buildpack(environment)

data/lib/potassium/recipes/listen.rb

@@ -0,0 +1,7 @@
+class Recipes::Listen < Rails::AppBuilder
+  def create
+    gather_gems(:development) do
+      gather_gem('listen')
+    end
+  end
+end

data/lib/potassium/recipes/mailer.rb

@@ -24,8 +24,11 @@ class Recipes::Mailer < Rails::AppBuilder
     dependencies(email_service)
     config(email_service)
 
-    background_processor = load_recipe(:background_processor)
-    background_processor.add_sidekiq unless background_processor.installed?
+    background_processor_recipe = load_recipe(:background_processor)
+    background_processor_answer = get(:background_processor)
+
+    background_processor_recipe.add_sidekiq unless background_processor_recipe.installed? ||
+      background_processor_answer
   end
 
   def install
@@ -68,7 +71,7 @@ class Recipes::Mailer < Rails::AppBuilder
 
     mailer_config =
       <<~RUBY
-        require Rails.root.join("config/mailer")
+        require Rails.root.join("config", "mailer")
       RUBY
 
     prepend_file "config/environments/production.rb", mailer_config
@@ -81,11 +84,18 @@ class Recipes::Mailer < Rails::AppBuilder
     append_to_file '.env.development', "SENDGRID_API_KEY=\n"
     sendgrid_settings = <<~RUBY
       Rails.application.config.action_mailer.sendgrid_settings = {
-        api_key: ENV['SENDGRID_API']
+        api_key: ENV['SENDGRID_API_KEY']
       }
     RUBY
     inject_into_file 'config/mailer.rb', sendgrid_settings,
       after: "Rails.application.config.action_mailer.delivery_method = :sendgrid\n"
+    sendgrid_dev_settings = <<~RUBY
+      Rails.application.config.action_mailer.sendgrid_dev_settings = {
+        api_key: ENV['SENDGRID_API_KEY']
+      }
+    RUBY
+    application sendgrid_dev_settings, env: "development"
+    application "config.action_mailer.delivery_method = :sendgrid_dev", env: "development"
   end
 
   def aws_ses

data/lib/potassium/recipes/node.rb

@@ -0,0 +1,21 @@
+require 'net/http'
+require 'semantic'
+require 'json'
+
+class Recipes::Node < Rails::AppBuilder
+  def create
+    info "Using node version LTS #{version}"
+    create_file '.node-version', version, force: true
+    json_file = File.read(Pathname.new("package.json"))
+    js_package = JSON.parse(json_file)
+    js_package["engines"] = { "node" => "#{version}.x" }
+    json_string = JSON.pretty_generate(js_package)
+    create_file 'package.json', json_string, force: true
+  end
+
+  private
+
+  def version
+    Potassium::NODE_VERSION
+  end
+end

data/lib/potassium/recipes/puma.rb

@@ -5,8 +5,5 @@ class Recipes::Puma < Rails::AppBuilder
     end
 
     copy_file '../assets/config/puma.rb', 'config/puma.rb', force: true
-
-    # Configure rack-timout
-    application "Rack::Timeout.timeout = (ENV[\"RACK_TIMEOUT\"] || 10).to_i", env: "production"
   end
 end

data/lib/potassium/recipes/rack_cors.rb

@@ -4,23 +4,26 @@ class Recipes::RackCors < Rails::AppBuilder
   end
 
   def create
-    gather_gem('rack-cors', '~> 0.4.0')
+    gather_gem('rack-cors', '~> 1.1')
+    recipe = self
     after(:gem_install) do
-      rack_cors_config =
-        <<~RUBY
-          config.middleware.insert_before 0, Rack::Cors do
-            allow do
-              origins '*'
-              resource '*',
-                headers: :any,
-                expose: ['X-Page', 'X-PageTotal'],
-                methods: [:get, :post, :delete, :put, :options]
-            end
-          end
+      application recipe.rack_cors_config
+    end
+  end
 
-        RUBY
+  def rack_cors_config
+    <<~RUBY
+      config.middleware.insert_before 0, Rack::Cors do
+        allow do
+          origins '*'
+          resource '/public/*', headers: :any, methods: :get
+          resource '/api/*',
+            headers: :any,
+            expose: ['X-Page', 'X-PageTotal'],
+            methods: [:get, :post, :patch, :put, :delete, :options]
+        end
+      end
 
-      application rack_cors_config
-    end
+    RUBY
   end
 end

data/lib/potassium/recipes/rails.rb

@@ -1,9 +1,15 @@
 class Recipes::Rails < Rails::AppBuilder
   def create
     gather_gem("bootsnap", require: false)
+    gather_gems(:development) do
+      gather_gem("spring")
+    end
 
     environment 'config.force_ssl = true', env: 'production'
+    disable_automatic_nonce_generation
+  end
 
+  def disable_automatic_nonce_generation
     line = "Rails.application.config.content_security_policy_nonce_generator = \
 -> request { SecureRandom.base64(16) }"
     initializer = "config/initializers/content_security_policy.rb"

data/lib/potassium/recipes/schedule.rb

@@ -8,7 +8,7 @@ class Recipes::Schedule < Rails::AppBuilder
 
   def create
     if selected?(:schedule)
-      gather_gem 'sidekiq-scheduler'
+      gather_gem 'sidekiq-scheduler', '>= 3.0.1'
       add_readme_section :internal_dependencies, :sidekiq_scheduler
     end
     template '../assets/sidekiq_scheduler.yml', 'config/sidekiq.yml', force: true

data/lib/potassium/recipes/style.rb

@@ -1,12 +1,30 @@
 class Recipes::Style < Rails::AppBuilder
   def create
-    append_to_file ".gitignore", ".rubocop.yml\n"
-    append_to_file ".gitignore", ".eslintrc.json\n"
-    append_to_file ".gitignore", ".sscs-lint.yml\n"
+    add_linters
+    add_config_files
     add_readme_header :style_guide
   end
 
   def install
     create
   end
+
+  private
+
+  def add_linters
+    gather_gems(:development, :test) do
+      gather_gem 'rubocop', '~> 0.82.0'
+      gather_gem 'rubocop-performance'
+      gather_gem 'rubocop-rails'
+      gather_gem 'rubocop-rspec'
+    end
+    run 'bin/yarn add --dev stylelint eslint eslint-plugin-import'
+    run 'bin/yarn add --dev eslint-plugin-vue' if selected?(:front_end, :vue)
+  end
+
+  def add_config_files
+    copy_file '../assets/.rubocop.yml', '.rubocop.yml'
+    copy_file '../assets/.eslintrc.json', '.eslintrc.json'
+    copy_file '../assets/.stylelintrc.json', '.stylelintrc.json'
+  end
 end

data/lib/potassium/recipes/vue_admin.rb

@@ -0,0 +1,124 @@
+class Recipes::VueAdmin < Rails::AppBuilder
+  def ask
+    if selected?(:admin_mode)
+      vue_admin = answer(:vue_admin) do
+        Ask.confirm "Do you want Vue support for ActiveAdmin?"
+      end
+      set(:vue_admin, vue_admin)
+      set(:front_end, :vue) if vue_admin
+    end
+  end
+
+  def create
+    recipe = self
+    if selected?(:vue_admin)
+      after(:admin_install) do
+        recipe.add_vue_admin
+      end
+    end
+  end
+
+  def install
+    active_admin = load_recipe(:admin)
+    if active_admin.installed?
+      add_vue_admin
+      info "VueAdmin installed"
+    else
+      info "VueAdmin can't be installed because Active Admin isn't installed."
+    end
+  end
+
+  def installed?
+    dir_exist?("app/assets/javascripts/admin")
+  end
+
+  def add_vue_admin
+    add_vue_component_library
+    add_component_integration
+    copy_file '../assets/active_admin/init_activeadmin_vue.rb',
+      'config/initializers/init_activeadmin_vue.rb'
+    copy_file '../assets/active_admin/admin_application.js',
+      'app/javascript/packs/admin_application.js',
+      force: true
+    empty_directory 'app/javascript/components'
+    copy_file '../assets/active_admin/admin-component.vue',
+      'app/javascript/components/admin-component.vue',
+      force: true
+  end
+
+  def add_component_integration
+    line = "class CustomFooter < ActiveAdmin::Component"
+    initializer = "config/initializers/active_admin.rb"
+    gsub_file initializer, /(#{Regexp.escape(line)})/mi do |_match|
+      <<~HERE
+        require "vue_component.rb"
+        AUTO_BUILD_ELEMENTS=[:admin_component, :template, :slot]
+        component_creator(AUTO_BUILD_ELEMENTS)
+
+        #{line}
+      HERE
+    end
+  end
+
+  def add_vue_component_library
+    lib_component_path = "lib/vue_component.rb"
+    class_definitions =
+      <<~HERE
+        #{vue_component}
+        #{component_builder}
+      HERE
+    File.open(lib_component_path, "w") { |file| file.write(class_definitions) }
+  end
+
+  def vue_component
+    <<~HERE
+      class VueComponent < Arbre::Component
+        builder_method :root
+        def tag_name
+          :root
+        end
+
+        def initialize(*)
+          super
+        end
+
+        def build(attributes = {})
+          super(process_attributes(attributes))
+        end
+
+        def process_attributes(attributes)
+          vue_attributes = {}
+          attributes.each do |key, value|
+            dasherized_key = key.to_s.dasherize
+            if value.is_a?(String)
+              vue_attributes[dasherized_key] = value
+            elsif !dasherized_key.index(':').nil? && dasherized_key.index(':').zero?
+              vue_attributes[dasherized_key] = value.to_json
+            else
+              vue_attributes[":" + dasherized_key] = value.to_json
+            end
+          end
+          vue_attributes
+        end
+      end
+    HERE
+  end
+
+  def component_builder
+    <<~HERE
+      def component_creator(auto_build_elements)
+        auto_build_elements.each do |element|
+          as_string=element.to_s
+          camelized_element = as_string.camelize
+          Object.const_set(camelized_element,Class.new(VueComponent))
+          Object.const_get(camelized_element).class_eval do
+            builder_method as_string.to_sym
+            def tag_name
+              self.class.to_s.underscore
+            end
+          end
+        end
+      end
+    HERE
+  end
+end