potassium 5.2.1 → 6.2.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/google_tag_manager.rb

@@ -0,0 +1,90 @@
+class Recipes::GoogleTagManager < Rails::AppBuilder
+  def ask
+    use_google_tag_manager = answer(:google_tag_manager) do
+      Ask.confirm 'Do you want to use Google Tag Manager?'
+    end
+
+    set(:google_tag_manager, use_google_tag_manager)
+  end
+
+  def create
+    install if selected?(:google_tag_manager)
+  end
+
+  def install
+    add_google_tag_manager
+  end
+
+  def add_google_tag_manager
+    copy_tag_manager_files
+    append_to_file '.env.development', "GTM_CONTAINER_ID=\n"
+    include_tag_manager
+    add_content_security_policy
+  end
+
+  def add_content_security_policy
+    inject_into_file(
+      'config/initializers/content_security_policy.rb',
+      content_security_policy_code
+    )
+  end
+
+  def copy_tag_manager_files
+    copy_file(
+      '../assets/app/views/shared/_gtm_head.html.erb',
+      'app/views/shared/_gtm_head.html.erb',
+      force: true
+    )
+
+    copy_file(
+      '../assets/app/views/shared/_gtm_body.html.erb',
+      'app/views/shared/_gtm_body.html.erb',
+      force: true
+    )
+  end
+
+  def include_tag_manager
+    inject_into_file(
+      'app/views/layouts/application.html.erb',
+      render_string('shared/gtm_head'),
+      before: '</head>'
+    )
+
+    inject_into_file(
+      'app/views/layouts/application.html.erb',
+      render_string('shared/gtm_body'),
+      after: '<body>'
+    )
+  end
+
+  private
+
+  def render_string(file_path)
+    "  <%if Rails.env.production? %>
+      <%= render \"#{file_path}\" %>
+    <% end %>\n  "
+  end
+
+  def content_security_policy_code
+    <<~HERE
+      Rails.application.config.content_security_policy do |policy|
+        if Rails.env.development?
+          policy.connect_src :self, :https, 'http://localhost:3035', 'ws://localhost:3035'
+          policy.script_src :self, :https, :unsafe_eval
+        else
+          policy.script_src :self, :https
+          # google tag manager requires to enable unsafe inline:
+          # https://developers.google.com/tag-manager/web/csp
+          policy.connect_src :self, :https, 'https://www.google-analytics.com'
+          policy.script_src :self,
+            :https,
+            :unsafe_inline,
+            'https://www.googletagmanager.com',
+            'https://www.google-analytics.com',
+            'https://ssl.google-analytics.com'
+          policy.img_src :self, :https, 'https://www.googletagmanager.com', 'https://www.google-analytics.com'
+        end
+      end
+    HERE
+  end
+end

data/lib/potassium/recipes/heroku.rb

@@ -1,13 +1,7 @@
 class Recipes::Heroku < Rails::AppBuilder
   NAME_PREFIX = 'pl'
-
-  attr_accessor :app_name_staging
-
-  def initialize(args)
-    super(args)
-    set(:heroku_app_name_staging, app_name_for('staging'))
-    set(:heroku_app_name_production, app_name_for('production'))
-  end
+  ENVIRONMENTS = ['staging', 'production']
+  HEROKU_NAMES_MAX_CHARS = 30
 
   def ask
     heroku = answer(:heroku) do
@@ -16,6 +10,8 @@ class Recipes::Heroku < Rails::AppBuilder
 
     if heroku
       set(:heroku, heroku)
+
+      ENVIRONMENTS.each { |environment| set_app_name_for(environment) }
     end
   end
 
@@ -41,35 +37,40 @@ 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"
 
-    if logged_in?
-      %w(staging production).each do |environment|
-        create_app_on_heroku(environment)
-      end
-      puts "Remember to connect the github repository to the new pipeline"
-      open_pipeline_command = "\e[33mheroku pipelines:open #{heroku_pipeline_name}\e[0m"
-      puts "run #{open_pipeline_command} to open the dashboard"
-    else
-      puts "You are not logged in into heroku"
-      login_command = "\e[33mheroku login\e[0m"
-      puts "Run #{login_command} and enter your credentials"
-      puts "You can install the heroku recipe again create the app in heroku"
-      install_command = "\e[33mpostassium install heroku --force\e[0m"
-      puts "Just run #{install_command}"
-    end
+    logged_in? ? create_apps : puts_not_logged_in_msg
 
     add_readme_header :deployment
   end
 
+  def create_apps
+    ENVIRONMENTS.each { |environment| create_app_on_heroku(environment) }
+    puts "Remember to connect the github repository to the new pipeline"
+    open_pipeline_command = "\e[33mheroku pipelines:open #{heroku_pipeline_name}\e[0m"
+    puts "run #{open_pipeline_command} to open the dashboard"
+  end
+
+  def puts_not_logged_in_msg
+    puts "You are not logged in into heroku"
+    login_command = "\e[33mheroku login\e[0m"
+    puts "Run #{login_command} and enter your credentials"
+    puts "You can install the heroku recipe again to create the app in heroku"
+    install_command = "\e[33mpostassium install heroku --force\e[0m"
+    puts "Just run #{install_command}"
+  end
+
   def heroku_pipeline_name
-    app_name.dasherize
+    @heroku_pipeline_name ||= valid_heroku_name(app_name.dasherize, 'pipeline', false)
   end
 
-  def app_name_for(environment)
-    "#{NAME_PREFIX}-#{app_name.dasherize}-#{environment}"
+  def set_app_name_for(environment)
+    default_name = "#{NAME_PREFIX}-#{app_name.dasherize}-#{environment}"
+    set("heroku_app_name_#{environment}".to_sym, valid_heroku_name(default_name, environment))
   end
 
   def logged_in?
@@ -82,13 +83,12 @@ class Recipes::Heroku < Rails::AppBuilder
 
   def create_app_on_heroku(environment)
     rack_env = "RACK_ENV=production"
-    staged_app_name = app_name_for(environment)
+    staged_app_name = get("heroku_app_name_#{environment}".to_sym)
 
     run_toolbelt_command "create #{staged_app_name} --remote #{environment}"
     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)
@@ -98,14 +98,14 @@ class Recipes::Heroku < Rails::AppBuilder
   def set_rails_secrets(environment)
     run_toolbelt_command(
       "config:add SECRET_KEY_BASE=#{generate_secret}",
-      app_name_for(environment)
+      get("heroku_app_name_#{environment}".to_sym)
     )
   end
 
   def set_app_multi_buildpack(environment)
     run_toolbelt_command(
       "buildpacks:set https://github.com/heroku/heroku-buildpack-multi.git",
-      app_name_for(environment)
+      get("heroku_app_name_#{environment}".to_sym)
     )
   end
 
@@ -132,4 +132,18 @@ class Recipes::Heroku < Rails::AppBuilder
       `heroku #{command} --app #{app_env_name}`
     end
   end
+
+  def valid_heroku_name(name, element, force_suffix = true)
+    suffix = "-#{element}"
+    while name.length > HEROKU_NAMES_MAX_CHARS
+      puts "Heroku names must be shorter than #{HEROKU_NAMES_MAX_CHARS} chars."
+      if force_suffix
+        puts "Potassium uses the heroku-stage gem, because of that '#{suffix}' will be "\
+             "added to your app name. The suffix, #{suffix}, counts towards the app name length."
+      end
+      name = Ask.input("Please enter a valid name for #{element}:")
+      name += suffix if force_suffix && !name.end_with?(suffix)
+    end
+    name
+  end
 end

data/lib/potassium/recipes/mailer.rb

@@ -24,8 +24,7 @@ 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?
+    ensure_sidekiq_install_and_add_mailers_queue
   end
 
   def install
@@ -33,6 +32,10 @@ class Recipes::Mailer < Rails::AppBuilder
     create
   end
 
+  def add_mailer_queue
+    insert_into_file "config/sidekiq.yml", "  - mailers", after: "- default\n"
+  end
+
   private
 
   def email_services(service_name)
@@ -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,15 +84,35 @@ 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
     gather_gems(:development) { gather_gem("letter_opener") }
     application "config.action_mailer.delivery_method = :letter_opener", env: "development"
   end
+
+  def ensure_sidekiq_install_and_add_mailers_queue
+    background_processor_recipe = load_recipe(:background_processor)
+    background_processor_answer = get(:background_processor)
+
+    if background_processor_recipe.installed?
+      add_mailer_queue
+    else
+      recipe = self
+      after(:install_sidekiq) { recipe.add_mailer_queue }
+      background_processor_recipe.add_sidekiq unless background_processor_answer
+    end
+  end
 end

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/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