potassium 5.2.0 → 6.1.0

data/lib/potassium/helpers/docker-helpers.rb

@@ -1,7 +1,7 @@
 class DockerHelpers
   def initialize(compose_path)
     @compose_path = compose_path
-    @compose = YAML.load(File.read(compose_path))
+    @compose = YAML.safe_load(File.read(compose_path))
   end
 
   def add_link(target_service, linked_service)
@@ -23,14 +23,23 @@ class DockerHelpers
   end
 
   def add_service(name, definition)
-    service = {}
-    service[name] = YAML.load(definition)
-    @compose['services'].merge!(service)
-    save
+    add_leaf('services', name, definition)
+  end
+
+  def add_volume(name, definition = '')
+    add_leaf('volumes', name, definition)
   end
 
   private
 
+  def add_leaf(root_name, leaf_name, definition)
+    leaf = {}
+    leaf[leaf_name] = YAML.safe_load(definition)
+    @compose[root_name] = {} unless @compose[root_name].is_a? Hash
+    @compose[root_name].merge!(leaf)
+    save
+  end
+
   def save
     File.open(@compose_path, 'w') { |f| f.write @compose.to_yaml }
   end

data/lib/potassium/helpers/gem-helpers.rb

@@ -69,7 +69,7 @@ module GemHelpers
   def add_original_rails_gems
     gemfile_entries.each do |entry|
       unless entry.commented_out
-        gather_gem(entry.name, entry.version)
+        gather_gem(entry.name, version: entry[:version])
       end
     end
   end

data/lib/potassium/helpers/template-helpers.rb

@@ -3,6 +3,10 @@ module TemplateHelpers
     @app_name || app_name_from_file
   end
 
+  def node_version
+    "#{Potassium::NODE_VERSION}.x"
+  end
+
   def load_recipe(recipe_name)
     @recipes ||= {}
     @recipes[recipe_name] ||= get_recipe_class(recipe_name.to_sym).new(self)

data/lib/potassium/newest_version_ensurer.rb

@@ -1,51 +1,34 @@
-require "term/ansicolor"
-require "gems"
-require "semantic"
-require "potassium/text_spinner"
+require 'gems'
+require 'semantic'
+require 'potassium/text_spinner'
+
+class VersionError < StandardError
+end
 
 module Potassium
   class NewestVersionEnsurer
-    include Term::ANSIColor
-
-    def initialize(current_version = Potassium::VERSION)
-      self.current_version = Semantic::Version.new(current_version)
+    def initialize
+      self.installed_version = Semantic::Version.new(Potassium::VERSION)
       self.text_spinner = Potassium::TextSpinner.new
     end
 
-    def ensure(&success_block)
-      spin_text("Checking your Potassium installation") { latest_version }
+    def ensure!
+      spin_text('Checking your Potassium installation') { published_version }
 
-      self.latest_version = Semantic::Version.new(
-        Gems.versions("potassium").first["number"]
-      )
-
-      if latest_version <= current_version
-        up_to_date
-        success_block.call
-      else
-        please_update
-      end
+      self.published_version = Semantic::Version.new(Gems.versions('potassium').first['number'])
+      raise VersionError.new(update_message) if published_version > installed_version
     end
 
     private
 
-    attr_accessor :latest_version, :current_version, :text_spinner
-
-    def up_to_date
-      puts green("\nYour Potassium installation is up to date.")
-    end
+    attr_accessor :published_version, :installed_version, :text_spinner
 
-    def please_update
-      puts red("\nYour Potassium installation is not up to date.")
-      puts red("Found: #{current_version}")
-      puts red("Expected: #{latest_version}\n")
-      print white("Please run: ")
-      print green("gem update potassium ")
-      print white("to upgrade your potassium installation.\n\n")
-      print white("If you really need to run this outdated version of potassium anyway, ")
-      print white("re-run this command with the ")
-      print black("--no-version-check")
-      puts white(" flag.")
+    def update_message
+      <<~HERE
+        Your potassium installation is not up to date.
+        The last available version is #{published_version} while the running version is #{installed_version}.
+        If you really need to run this outdated version of potassium, re-run this command with the `--no-version-check` flag.
+      HERE
     end
 
     def spin_text(message, &block)

data/lib/potassium/node_version_ensurer.rb

@@ -0,0 +1,30 @@
+module Potassium
+  class NodeVersionEnsurer
+    def ensure!
+      raise VersionError.new(install_message) if installed_node_version.nil?
+      raise VersionError.new(update_message) if Potassium::NODE_VERSION != installed_node_version
+    end
+
+    private
+
+    def installed_node_version
+      node_version = `node -v 2>&1`
+      return node_version.delete('^[0-9\.]').split('.').first if $?.success?
+    end
+
+    def install_message
+      <<~HERE
+        Node doesn't appear to be installed.
+        Please make sure you have node #{Potassium::NODE_VERSION} installed.
+      HERE
+    end
+
+    def update_message
+      <<~HERE
+        An unsupported version of node was found.
+        Please make sure you have node #{Potassium::NODE_VERSION} installed. Newer versions may work but potassium only supports that one.
+        If you really need to run potassium with a different version of node, re-run this command with the `--no-node-version-check` flag.
+      HERE
+    end
+  end
+end

data/lib/potassium/recipes/admin.rb

@@ -32,10 +32,10 @@ class Recipes::Admin < Rails::AppBuilder
   private
 
   def add_active_admin
-    gather_gem 'activeadmin', '~> 1.3.0'
+    gather_gem 'activeadmin', '~> 2.6'
     gather_gem 'activeadmin_addons'
-    gather_gem 'active_skin'
-
+    gather_gem 'active_skin', github: 'SoftwareBrothers/active_skin'
+    add_readme_section :internal_dependencies, :active_admin
     after(:gem_install, wrap_in_action: :admin_install) do
       generate "active_admin:install"
       line = "ActiveAdmin.setup do |config|"

data/lib/potassium/recipes/annotate.rb

@@ -1,7 +1,7 @@
 class Recipes::Annotate < Rails::AppBuilder
   def create
     gather_gems(:development) do
-      gather_gem('annotate')
+      gather_gem('annotate', '~> 3.0')
     end
 
     template '../assets/lib/tasks/auto_annotate_models.rake',

data/lib/potassium/recipes/api.rb

@@ -1,43 +1,115 @@
 class Recipes::Api < Rails::AppBuilder
   def ask
-    api_support = answer(:api) { Ask.confirm("Do you want to enable API support?") }
-    set(:api_support, api_support)
+    api_interfaces = {
+      rest: "REST (with Power API)",
+      graphql: "GraphQL (beta)",
+      none: "None, thanks"
+    }
+    api_interface = answer(:api) do
+      api_interfaces.keys[Ask.list("Which API interface are you using?", api_interfaces.values)]
+    end
+    set :api, api_interface.to_sym
   end
 
   def create
-    add_api if get(:api_support)
+    if get(:api) == :graphql
+      add_graphql
+    elsif get(:api) == :rest
+      add_power_api
+    end
   end
 
   def install
-    add_api
+    ask
+    create
   end
 
   def installed?
-    gem_exists?(/versionist/)
+    gem_exists?(/power_api/) || gem_exists?(/graphql/)
   end
 
   private
 
-  def add_api
-    gather_gem 'versionist'
-    gather_gem 'responders'
-    gather_gem 'active_model_serializers', '~> 0.9.3'
-    gather_gem 'simple_token_authentication', '~> 1.0'
+  def add_power_api
+    gather_gem 'power_api'
+
+    gather_gems(:development, :test) do
+      gather_gem 'rswag-specs'
+    end
+
+    add_readme_section :internal_dependencies, :power_api
+
+    after(:gem_install) do
+      generate "power_api:install"
+    end
+  end
+
+  def add_graphql
+    gather_gem 'graphql'
+    if get(:authentication)
+      gather_gem 'jwt'
+    end
+    gather_gems(:development, :test) do
+      gather_gem 'graphql_playground-rails'
+    end
 
     after(:gem_install) do
-      line = "Rails.application.routes.draw do\n"
-      insert_into_file "config/routes.rb", after: line do
-        <<-HERE.gsub(/^ {8}/, '')
-          scope path: '/api' do
-            api_version(module: "Api::V1", path: { value: "v1" }, defaults: { format: 'json' }) do
-            end
-          end
-        HERE
+      generate "graphql:install --skip_graphiql"
+      playground_route = <<~HEREDOC
+      \n
+        if Rails.env.development?
+          mount GraphqlPlayground::Rails::Engine, at: "/graphiql", graphql_path: "/graphql"
+        end
+      HEREDOC
+      inject_into_file(
+        'config/routes.rb',
+        playground_route,
+        after: 'post "/graphql", to: "graphql#execute"'
+      )
+      copy_file(
+        "../assets/config/graphql_playground.rb",
+        "config/initializers/graphql_playground.rb"
+      )
+      remove_dir 'app/graphql/types'
+      directory '../assets/app/graphql/types', 'app/graphql/types'
+      gsub_file 'app/graphql/mutations/base_mutation.rb', 'Types::Base', 'Types::Base::Base'
+      directory '../assets/app/graphql/queries', 'app/graphql/queries'
+      gsub_file 'app/graphql/mutations/base_mutation.rb', 'RelayClassic', ''
+      gsub_file(
+        'app/graphql/mutations/base_mutation.rb',
+        "    input_object_class Types::Base::BaseInputObject\n", ''
+      )
+
+      if get(:authentication)
+        copy_file(
+          '../assets/app/graphql/graphql_controller.rb',
+          'app/controllers/graphql_controller.rb',
+          force: true
+        )
+        gsub_file(
+          'app/controllers/graphql_controller.rb',
+          'GqlSampleSchema',
+          "#{get(:titleized_app_name).delete(' ')}Schema"
+        )
+        copy_file(
+          '../assets/app/graphql/mutations/login_mutation.rb',
+          'app/graphql/mutations/login_mutation.rb'
+        )
+        inject_into_file(
+          'app/graphql/types/mutation_type.rb',
+          "\n    field :login, mutation: Mutations::LoginMutation",
+          after: 'class MutationType < Types::Base::BaseObject'
+        )
+        append_to_file(".env.development", "HMAC_SECRET=\n")
       end
 
-      copy_file '../assets/api/base_controller.rb', 'app/controllers/api/v1/base_controller.rb'
-      copy_file '../assets/api/api_error_concern.rb', 'app/controllers/concerns/api_error_concern.rb'
-      copy_file '../assets/api/responder.rb', 'app/responders/api_responder.rb'
+      inject_into_file(
+        'app/controllers/graphql_controller.rb',
+        "\n\n  skip_before_action :verify_authenticity_token",
+        after: '# protect_from_forgery with: :null_session'
+      )
+
+      add_readme_section :internal_dependencies, :graphql
     end
   end
 end

data/lib/potassium/recipes/background_processor.rb

@@ -12,7 +12,11 @@ class Recipes::BackgroundProcessor < Rails::AppBuilder
   end
 
   def create
-    add_sidekiq if get(:background_processor)
+    if get(:background_processor)
+      add_sidekiq
+      add_docker_compose_redis_config
+      set_redis_dot_env
+    end
   end
 
   def install
@@ -26,6 +30,35 @@ class Recipes::BackgroundProcessor < Rails::AppBuilder
     gem_exists?(/sidekiq/)
   end
 
+  private
+
+  def add_docker_compose_redis_config
+    compose = DockerHelpers.new('docker-compose.yml')
+
+    service_definition =
+      <<~YAML
+        image: redis
+        ports:
+          - 6379
+        volumes:
+          - redis_data:/data
+      YAML
+
+    compose.add_service('redis', service_definition)
+    compose.add_volume('redis_data')
+  end
+
+  def set_redis_dot_env
+    append_to_file(
+      '.env.development',
+      <<~TEXT
+        REDIS_HOST=127.0.0.1
+        REDIS_PORT=$(make services-port SERVICE=redis PORT=6379)
+        REDIS_URL=redis://${REDIS_HOST}:${REDIS_PORT}/1
+      TEXT
+    )
+  end
+
   def add_sidekiq
     gather_gem("sidekiq")
     add_adapters("sidekiq")
@@ -44,7 +77,10 @@ class Recipes::BackgroundProcessor < Rails::AppBuilder
   end
 
   def edit_procfile(cmd)
-    gsub_file("Procfile", /^.*$/m) { |match| "#{match}worker: #{cmd}" } if selected?(:heroku)
+    heroku = load_recipe(:heroku)
+    if selected?(:heroku) || heroku.installed?
+      gsub_file('Procfile', /^.*$/m) { |match| "#{match}worker: #{cmd}" }
+    end
   end
 
   def add_adapters(name)

data/lib/potassium/recipes/ci.rb

@@ -1,7 +1,7 @@
 class Recipes::Ci < Rails::AppBuilder
   def create
     copy_file '../assets/Dockerfile.ci', 'Dockerfile.ci'
-    copy_file '../assets/.circleci/config.yml', '.circleci/config.yml'
+    template '../assets/.circleci/config.yml.erb', '.circleci/config.yml'
 
     template '../assets/bin/cibuild.erb', 'bin/cibuild'
     run "chmod a+x bin/cibuild"
@@ -17,7 +17,7 @@ class Recipes::Ci < Rails::AppBuilder
     if selected?(:database, :mysql)
       srv =
         <<~YAML
-          image: "mysql:5.6.23"
+          image: mysql:#{Potassium::MYSQL_VERSION}
           environment:
             MYSQL_ALLOW_EMPTY_PASSWORD: 'true'
         YAML
@@ -29,18 +29,20 @@ class Recipes::Ci < Rails::AppBuilder
     elsif selected?(:database, :postgresql)
       srv =
         <<~YAML
-          image: "postgres:9.4.5"
+          image: "postgres:#{Potassium::POSTGRES_VERSION}"
           environment:
             POSTGRES_USER: postgres
             POSTGRES_PASSWORD: ''
         YAML
       compose.add_service("postgresql", srv)
       compose.add_link('test', 'postgresql')
-      compose.add_env('test', 'POSTGRESQL_USER', 'postgres')
-      compose.add_env('test', 'POSTGRESQL_HOST', 'postgresql')
-      compose.add_env('test', 'POSTGRESQL_PORT', '5432')
+      compose.add_env('test', 'DB_USER', 'postgres')
+      compose.add_env('test', 'DB_HOST', 'postgresql')
+      compose.add_env('test', 'DB_PORT', '5432')
     end
 
+    compose.add_volume('test_data')
+
     add_readme_header :ci
 
     application 'config.assets.js_compressor = :uglifier', env: 'test'

data/lib/potassium/recipes/data_migrate.rb

@@ -0,0 +1,44 @@
+class Recipes::DataMigrate < Rails::AppBuilder
+  def create
+    gather_gem('data_migrate')
+    annotate_task = 'lib/tasks/auto_annotate_models.rake'
+    insert_into_file annotate_task, annotate_config, after: "Annotate.load_tasks\n"
+  end
+
+  def install
+    create
+  end
+
+  def installed?
+    gem_exists?(/data_migrate/)
+  end
+
+  private
+
+  def annotate_config
+    <<-RUBY
+
+  data_migrate_tasks = %w(
+    db:migrate:with_data
+    db:migrate:up:with_data
+    db:migrate:down:with_data
+    db:migrate:redo:with_data
+    db:rollback:with_data
+  )
+
+  data_migrate_tasks.each do |task|
+    Rake::Task[task].enhance do
+      Rake::Task[Rake.application.top_level_tasks.last].enhance do
+        annotation_options_task = if Rake::Task.task_defined?('app:set_annotation_options')
+                                    'app:set_annotation_options'
+                                  else
+                                    'set_annotation_options'
+                                  end
+        Rake::Task[annotation_options_task].invoke
+        Annotate::Migration.update_annotations
+      end
+    end
+  end
+    RUBY
+  end
+end