potassium 5.2.2 → 6.3.0

data/lib/potassium/recipes/database.rb

@@ -46,5 +46,9 @@ class Recipes::Database < Rails::AppBuilder
     else
       gather_gem db[:gem_name]
     end
+
+    after(:gem_install) do
+      generate 'strong_migrations:install'
+    end
   end
 end

data/lib/potassium/recipes/database_container.rb

@@ -24,20 +24,21 @@ class Recipes::DatabaseContainer < Rails::AppBuilder
       environment:
         MYSQL_ALLOW_EMPTY_PASSWORD: 'true'
       volumes:
-       - mysql_data:/var/lib/mysql
+        - mysql_data:/var/lib/mysql
     YAML
 
   def create
-    copy_file '../assets/docker-compose.yml', 'docker-compose.yml'
+    db_type = get(:database)
+    return if [:None, :none].include? db_type.to_sym
 
+    copy_file '../assets/docker-compose.yml', 'docker-compose.yml'
     compose = DockerHelpers.new('docker-compose.yml')
 
-    db_type = get(:database)
     compose.add_service(db_type.to_s, self.class.const_get("#{db_type}_service".upcase))
     compose.add_volume("#{db_type}_data")
     template '../assets/Makefile.erb', 'Makefile'
 
-    run 'make services-up'
+    run "docker-compose up -d"
 
     set_env(db_type, CONTAINER_VARS[db_type][:port], CONTAINER_VARS[db_type][:user])
     set_dot_env(db_type, CONTAINER_VARS[db_type][:port], CONTAINER_VARS[db_type][:user])
@@ -53,11 +54,12 @@ class Recipes::DatabaseContainer < Rails::AppBuilder
     setup_text = # setup file is templated on project creation, manual install is needed
       <<~TEXT
         # Set up required services
-        make services-up
+        docker-compose up -d
 
       TEXT
 
     insert_into_file 'bin/setup', setup_text, before: "# Set up database"
+    create
     run 'bin/setup'
     info "A new container with a #{get(:database)} database has been created."
   end

data/lib/potassium/recipes/draper.rb

@@ -7,7 +7,6 @@ class Recipes::Draper < Rails::AppBuilder
   def create
     return unless selected?(:draper)
     add_draper
-    add_api_responder if selected?(:api_support)
   end
 
   def installed?
@@ -16,19 +15,11 @@ class Recipes::Draper < Rails::AppBuilder
 
   def install
     add_draper
-    api_recipe = load_recipe(:api)
-    add_api_responder if api_recipe.installed?
   end
 
   def add_draper
-    gather_gem 'draper', '3.0.1'
+    gather_gem 'draper', '~> 3.1'
     add_readme_section :internal_dependencies, :draper
     create_file 'app/decorators/.keep'
   end
-
-  def add_api_responder
-    after(:gem_install) do
-      copy_file '../assets/api/draper_responder.rb', 'app/responders/api_responder.rb', force: true
-    end
-  end
 end

data/lib/potassium/recipes/file_storage.rb

@@ -0,0 +1,66 @@
+class Recipes::FileStorage < Rails::AppBuilder
+  def ask
+    storages = {
+      active_storage: 'ActiveStorage',
+      shrine: 'Shrine',
+      none: 'None, thanks'
+    }
+
+    storage = answer(:storage) do
+      storages.keys[Ask.list('Which storage are you going to use?', storages.values)]
+    end
+
+    set(:storage, storage.to_sym)
+  end
+
+  def create
+    add_chosen_storage
+  end
+
+  def install
+    ask
+    add_chosen_storage
+  end
+
+  def installed?
+    file_exist?('config/storage.yml')
+  end
+
+  private
+
+  def add_active_storage
+    after(:gem_install) { run('bundle exec rails active_storage:install') }
+    copy_file('../assets/config/storage.yml', 'config/storage.yml', force: true)
+    active_storage_service_regexp = /config.active_storage.service = :local\n/
+    gsub_file 'config/environments/production.rb', active_storage_service_regexp do
+      'config.active_storage.service = :amazon'
+    end
+  end
+
+  def add_shrine
+    gather_gem('shrine', '~> 3.0')
+    gather_gem('marcel', '~> 1.0')
+    copy_file('../assets/config/shrine.rb', 'config/initializers/shrine.rb', force: true)
+    copy_file('../assets/app/uploaders/image_uploader.rb', 'app/uploaders/image_uploader.rb')
+    copy_file('../assets/app/uploaders/base_uploader.rb', 'app/uploaders/base_uploader.rb')
+    append_to_file('.gitignore', "/public/uploads\n")
+  end
+
+  def common_setup
+    gather_gem 'aws-sdk-s3', '~> 1.0'
+    add_readme_section :internal_dependencies, get(:storage)
+    append_to_file '.env.development', "S3_BUCKET=\n"
+  end
+
+  def add_chosen_storage
+    return if [:none, :None].include? get(:storage).to_sym
+
+    common_setup
+    case get(:storage)
+    when :active_storage
+      add_active_storage
+    when :shrine
+      add_shrine
+    end
+  end
+end

data/lib/potassium/recipes/front_end.rb

@@ -17,22 +17,22 @@ class Recipes::FrontEnd < Rails::AppBuilder
   def create
     return if [:none, :None].include? get(:front_end).to_sym
 
-    gather_gem 'webpacker', github: 'rails/webpacker'
-
+    recipe = self
     after(:gem_install) do
       value = get(:front_end)
       run "rails webpacker:install"
       run "rails webpacker:install:#{value}" if value
 
       if value == :vue
-        application_js_file = "app/javascript/packs/application.js"
-        FileUtils.move "app/javascript/packs/hello_vue.js", application_js_file
-        gsub_file application_js_file, %r{\/\/.*\n}, ""
-
-        js_pack_tag = "\n    <%= javascript_pack_tag 'application' %>\n"
-        layout_file = "app/views/layouts/application.html.erb"
-        insert_into_file layout_file, js_pack_tag, after: "<%= csrf_meta_tags %>"
+        recipe.setup_vue_with_compiler_build
+        recipe.setup_jest
+        if get(:api) == :graphql
+          recipe.setup_apollo
+        end
       end
+      recipe.add_responsive_meta_tag
+      recipe.setup_tailwind
+      add_readme_header :webpack
     end
   end
 
@@ -48,6 +48,66 @@ class Recipes::FrontEnd < Rails::AppBuilder
     package_content.include?("\"@angular/core\"") || package_content.include?("\"vue\"")
   end
 
+  def setup_vue_with_compiler_build
+    application_js = 'app/javascript/packs/application.js'
+    remove_file "app/javascript/packs/hello_vue.js"
+    create_file application_js, application_js_content, force: true
+
+    layout_file = "app/views/layouts/application.html.erb"
+    insert_into_file(
+      layout_file,
+      "<div id=\"vue-app\">\n      <app></app>\n      ",
+      before: "<%= yield %>"
+    )
+    insert_into_file layout_file, "\n    </div>", after: "<%= yield %>"
+  end
+
+  def add_responsive_meta_tag
+    tag = "\n    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n"
+    layout_file = "app/views/layouts/application.html.erb"
+    insert_into_file layout_file, tag, after: "<%= csrf_meta_tags %>"
+  end
+
+  def setup_tailwind
+    run "bin/yarn add tailwindcss@#{Potassium::TAILWINDCSS}"
+    specify_autoprefixer_postcss_compatibility_versions
+    setup_client_css
+    remove_server_css_requires
+    setup_tailwind_requirements
+  end
+
+  def setup_jest
+    run 'bin/yarn add jest vue-jest babel-jest @vue/test-utils jest-serializer-vue babel-core@^7.0.0-bridge.0 --dev'
+    json_file = File.read(Pathname.new("package.json"))
+    js_package = JSON.parse(json_file)
+    js_package = js_package.merge(jest_config)
+    json_string = JSON.pretty_generate(js_package)
+    create_file 'package.json', json_string, force: true
+
+    copy_file '../assets/app/javascript/app.spec.js', 'app/javascript/app.spec.js'
+  end
+
+  def setup_apollo
+    run 'bin/yarn add vue-apollo graphql apollo-client apollo-link apollo-link-http apollo-cache-inmemory graphql-tag'
+
+    inject_into_file(
+      'app/javascript/packs/application.js',
+      apollo_imports,
+      after: "import App from '../app.vue';"
+    )
+
+    inject_into_file(
+      'app/javascript/packs/application.js',
+      apollo_loading,
+      after: "import VueApollo from 'vue-apollo';"
+    )
+    inject_into_file(
+      'app/javascript/packs/application.js',
+      "\n    apolloProvider,",
+      after: "components: { App },"
+    )
+  end
+
   private
 
   def frameworks(framework)
@@ -58,4 +118,160 @@ class Recipes::FrontEnd < Rails::AppBuilder
     }
     frameworks[framework]
   end
+
+  def apollo_imports
+    <<~JS
+      \n
+      import { ApolloClient } from 'apollo-client';
+      import { createHttpLink } from 'apollo-link-http';
+      import { InMemoryCache } from 'apollo-cache-inmemory';
+      import VueApollo from 'vue-apollo';
+    JS
+  end
+
+  def apollo_loading
+    <<~JS
+      \n
+      const httpLink = createHttpLink({
+        uri: `${window.location.origin}/graphql`,
+      })
+      const cache = new InMemoryCache()
+      const apolloClient = new ApolloClient({
+        link: httpLink,
+        cache,
+      })
+
+      Vue.use(VueApollo)
+      const apolloProvider = new VueApollo({
+        defaultClient: apolloClient,
+      })
+    JS
+  end
+
+  def specify_autoprefixer_postcss_compatibility_versions
+    run 'bin/yarn -D add postcss@^7 autoprefixer@^9'
+  end
+
+  def setup_client_css
+    application_css = 'app/javascript/css/application.css'
+    create_file application_css, "", force: true
+
+    stylesheet_pack_tag = "\n    <%= stylesheet_pack_tag 'application' %>\n  "
+    layout_file = "app/views/layouts/application.html.erb"
+    insert_into_file layout_file, stylesheet_pack_tag, before: "</head>"
+
+    application_js = 'app/javascript/packs/application.js'
+    if get(:front_end) != :vue
+      create_file application_js, "import '../css/application.css';\n", force: true
+    else
+      insert_into_file(
+        application_js,
+        "\nimport '../css/application.css';",
+        after: "import App from '../app.vue';"
+      )
+    end
+  end
+
+  def setup_tailwind_requirements
+    application_css = 'app/javascript/css/application.css'
+    insert_into_file application_css, tailwind_client_css
+
+    tailwind_config = 'tailwind.config.js'
+    create_file tailwind_config, tailwind_config_content, force: true
+
+    postcss_file = 'postcss.config.js'
+    insert_into_file postcss_file, postcss_require_tailwind, after: "plugins: [\n"
+  end
+
+  def remove_server_css_requires
+    assets_css_file = 'app/assets/stylesheets/application.css'
+    gsub_file(assets_css_file, " *= require_tree .\n *= require_self\n", "")
+  end
+
+  def application_js_content
+    <<~JS
+      import Vue from 'vue/dist/vue.esm';
+      import App from '../app.vue';
+
+      document.addEventListener('DOMContentLoaded', () => {
+        const app = new Vue({
+          el: '#vue-app',
+          components: { App },
+        });
+
+        return app;
+      });
+    JS
+  end
+
+  def tailwind_client_css
+    <<~CSS
+      @import 'tailwindcss/base';
+      @import 'tailwindcss/components';
+      @import 'tailwindcss/utilities';
+    CSS
+  end
+
+  def tailwind_config_content
+    <<~JS
+      /* eslint-disable no-undef */
+      module.exports = {
+        theme: {
+          extend: {},
+        },
+        variants: {},
+        plugins: [],
+        purge: {
+          enabled: process.env.NODE_ENV === 'production',
+          content: [
+            './app/**/*.html',
+            './app/**/*.vue',
+            './app/**/*.js',
+            './app/**/*.erb',
+          ],
+        }
+      };
+    JS
+  end
+
+  def postcss_require_tailwind
+    <<-JS.gsub(/^ {4}/, '  ')
+      require('tailwindcss'),
+      require('autoprefixer'),
+    JS
+  end
+
+  def jest_config
+    {
+      "scripts": {
+        "test": "jest",
+        "test:watch": "jest --watch"
+      },
+      "jest": {
+        "roots": [
+          "app/javascript"
+        ],
+        "moduleDirectories": [
+          "node_modules",
+          "app/javascript"
+        ],
+        "moduleNameMapper": {
+          "^@/(.*)$": "app/javascript/$1"
+        },
+        "moduleFileExtensions": [
+          "js",
+          "json",
+          "vue"
+        ],
+        "transform": {
+          "^.+\\.js$": "<rootDir>/node_modules/babel-jest",
+          ".*\\.(vue)$": "<rootDir>/node_modules/vue-jest"
+        },
+        "snapshotSerializers": [
+          "<rootDir>/node_modules/jest-serializer-vue"
+        ],
+        "testEnvironment": "jsdom"
+      }
+    }
+  end
 end

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