potassium 6.0.0 → 6.1.0

data/lib/potassium/assets/config/puma.rb

@@ -24,7 +24,7 @@ rack_env = ENV.fetch("RACK_ENV", "development")
 environment rack_env
 
 # Set 1 day timeout for workers while developing
-worker_timeout 1.day.seconds.to_i if rack_env == "development"
+worker_timeout 24 * 60 * 60 if rack_env == "development"
 
 on_worker_boot do
   # Worker specific setup for Rails 4.1+

data/lib/potassium/assets/config/shrine.rb

@@ -24,7 +24,10 @@ elsif Rails.env.production?
 else
   require 'shrine/storage/memory'
 
-  Shrine.storages[:store] = Shrine::Storage::Memory.new
+  Shrine.storages = {
+    cache: Shrine::Storage::Memory.new,
+    store: Shrine::Storage::Memory.new
+  }
 end
 
 Shrine.plugin :activerecord

data/lib/potassium/assets/redis.yml

@@ -1,6 +1,5 @@
 development: &default
-  host: <%= ENV["BOXEN_REDIS_HOST"] || ENV["REDIS_HOST"] || "127.0.0.1" %>
-  port: <%= ENV["BOXEN_REDIS_PORT"] || ENV["REDIS_PORT"] || 6379 %>
+  url: <%= ENV.fetch("REDIS_URL") %>
 
 test:
   <<: *default

data/lib/potassium/assets/testing/rails_helper.rb

@@ -26,6 +26,8 @@ Dir[Rails.root.join('spec', 'support', '**', '*.rb')].each { |f| require f }
 # If you are not using ActiveRecord, you can remove this line.
 ActiveRecord::Migration.maintain_test_schema!
 
+PowerTypes::Observable.observable_disabled = true
+
 RSpec.configure do |config|
   # If you're not using ActiveRecord, or you'd prefer not to run each of your
   # examples within a transaction, remove the following line or assign false

data/lib/potassium/cli/commands/create.rb

@@ -3,37 +3,29 @@ require 'potassium/cli_options'
 module Potassium::CLI
   extend Potassium::CliOptions
 
-  desc "Create a new Potassium Rails project."
+  desc 'Create a new Potassium Rails project.'
   arg 'app_path'
   command :create do |c|
-    c.default_desc "Create a new project."
-    c.switch "version-check",
-      default_value: true,
-      desc: "Performs a version check before running.",
-      negatable: true
-
+    c.default_desc 'Create a new project.'
     create_options.each { |opts| c.send(opts.delete(:type), opts.delete(:name), opts) }
 
     c.action do |_global_options, options, _args|
-      require "potassium/newest_version_ensurer"
-
-      begin_creation = -> do
-        require "potassium/generators/application"
-        require "potassium/template_finder"
+      require 'potassium/newest_version_ensurer'
+      require 'potassium/node_version_ensurer'
+      require 'potassium/generators/application'
+      require 'potassium/template_finder'
 
+      begin
+        Potassium::NewestVersionEnsurer.new.ensure! if options['version-check']
+        Potassium::NodeVersionEnsurer.new.ensure! if options['node-version-check']
         template_finder = Potassium::TemplateFinder.new
         template = template_finder.default_template
         template.cli_options = options
         template.source_paths << Rails::Generators::AppGenerator.source_root
         ARGV.push('--skip-webpack-install', '--skip-bundle')
         template.start
-      end
-
-      if options["version-check"]
-        ensurer = Potassium::NewestVersionEnsurer.new
-        ensurer.ensure(&begin_creation)
-      else
-        begin_creation.call
+      rescue VersionError => e
+        print "\nError: #{e.message}" # rubocop:disable Rails/Output
       end
     end
   end

data/lib/potassium/cli_options.rb

@@ -1,5 +1,21 @@
 module Potassium::CliOptions # rubocop:disable Metrics/ModuleLength
   CREATE_OPTIONS = [
+    {
+      type: :switch,
+      name: 'version-check',
+      desc: 'Performs a version check before running.',
+      negatable: true,
+      default_value: true,
+      default_test_value: true
+    },
+    {
+      type: :switch,
+      name: 'node-version-check',
+      desc: 'Performs a node version check before running.',
+      negatable: true,
+      default_value: true,
+      default_test_value: true
+    },
     {
       type: :flag,
       name: [:db, :database],
@@ -59,12 +75,11 @@ module Potassium::CliOptions # rubocop:disable Metrics/ModuleLength
       default_test_value: false
     },
     {
-      type: :switch,
+      type: :flag,
       name: "api",
-      desc: "Whether to apply the API mode or not",
-      negatable: true,
+      desc: "Which API interface to use",
       default_value: "none",
-      default_test_value: false
+      default_test_value: "None"
     },
     {
       type: :flag,
@@ -105,12 +120,41 @@ module Potassium::CliOptions # rubocop:disable Metrics/ModuleLength
     },
     {
       type: :switch,
-      name: "github-private",
-      desc: "Whether to the github repository is private",
+      name: "github_private",
+      desc: "Whether the github repository is private or not",
       negatable: true,
-      default_value: false,
+      default_value: "none",
+      default_test_value: false
+    },
+    {
+      type: :switch,
+      name: "github_has_org",
+      desc: "Whether the github repository should belong to an organization",
+      negatable: true,
+      default_value: "none",
       default_test_value: false
     },
+    {
+      type: :flag,
+      name: "github_org",
+      desc: "The github organization where the repository will be created",
+      default_value: "none",
+      default_test_value: "none"
+    },
+    {
+      type: :flag,
+      name: "github_name",
+      desc: "The github repository name",
+      default_value: "none",
+      default_test_value: "none"
+    },
+    {
+      type: :flag,
+      name: "github_access_token",
+      desc: "Github personal access token used to auth to Github API",
+      default_value: "none",
+      default_test_value: "none"
+    },
     {
       type: :switch,
       name: "schedule",
@@ -132,6 +176,14 @@ module Potassium::CliOptions # rubocop:disable Metrics/ModuleLength
       name: :front_end,
       desc: "Decides which front-end framework to use. Available: Vue, Angular 2, None",
       default_test_value: "None"
+    },
+    {
+      type: :switch,
+      name: "test",
+      desc: "Whether or not it is a test project creation",
+      negatable: true,
+      default_value: false,
+      default_test_value: true
     }
   ]
 

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/api.rb

@@ -1,51 +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
-      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
-      end
+      generate "power_api:install"
+    end
+  end
 
-      api_error_concern_path = 'app/controllers/concerns/api_error_concern.rb'
+  def add_graphql
+    gather_gem 'graphql'
+    if get(:authentication)
+      gather_gem 'jwt'
+    end
+    gather_gems(:development, :test) do
+      gather_gem 'graphql_playground-rails'
+    end
 
-      copy_file '../assets/api/base_controller.rb', 'app/controllers/api/v1/base_controller.rb'
-      copy_file '../assets/api/api_error_concern.rb', api_error_concern_path
-      copy_file '../assets/api/responder.rb', 'app/responders/api_responder.rb'
+    after(:gem_install) do
+      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 selected?(:report_error)
-        previous_line = 'logger.error exception.backtrace.join("\n")'
-        new_line = "\n      Raven.capture_exception(exception)"
-        insert_into_file api_error_concern_path, new_line, after: previous_line
+      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
+
+      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")