potassium 1.3.5 → 2.0.0

data/lib/potassium/recipes/angular_admin.rb

@@ -0,0 +1,56 @@
+class Recipes::AngularAdmin < Rails::AppBuilder
+  def ask
+    if selected?(:admin_mode)
+      angular_admin = answer(:"angular-admin") do
+        Ask.confirm "Do you want Angular support for ActiveAdmin?"
+      end
+      set(:angular_admin, angular_admin)
+    end
+  end
+
+  def create
+    recipe = self
+    if selected?(:angular_admin)
+      after(:admin_install) do
+        recipe.add_angular_admin
+      end
+    end
+  end
+
+  def install
+    active_admin = load_recipe(:admin)
+    if active_admin.installed?
+      add_angular_admin
+    else
+      info "ActiveAdmin can't be installed because Active Admin isn't installed."
+    end
+  end
+
+  def installed?
+    dir_exist?("app/assets/javascripts/admin")
+  end
+
+  def add_angular_admin
+    copy_file '../assets/active_admin/init_activeadmin_angular.rb',
+      'config/initializers/init_activeadmin_angular.rb'
+
+    create_file 'app/assets/javascripts/admin_app.js', "angular.module('ActiveAdmin', []);"
+
+    copy_file '../assets/active_admin/active_admin.js.coffee',
+      'app/assets/javascripts/active_admin.js.coffee',
+      force: true
+
+    empty_directory 'app/assets/javascripts/admin'
+    empty_directory 'app/assets/javascripts/admin/controllers'
+    empty_directory 'app/assets/javascripts/admin/services'
+    empty_directory 'app/assets/javascripts/admin/directives'
+
+    create_file 'app/assets/javascripts/admin/controllers/.keep'
+    create_file 'app/assets/javascripts/admin/services/.keep'
+    create_file 'app/assets/javascripts/admin/directives/.keep'
+
+    inside('.') do
+      run('bower install angular --save')
+    end
+  end
+end

data/lib/potassium/recipes/api.rb

@@ -0,0 +1,43 @@
+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)
+  end
+
+  def create
+    add_api if get(:api_support)
+  end
+
+  def install
+    add_api
+  end
+
+  def installed?
+    gem_exists?(/versionist/)
+  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'
+
+    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" }) do
+            end
+          end
+        HERE
+      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'
+    end
+  end
+end

data/lib/potassium/recipes/aws_sdk.rb

@@ -0,0 +1,5 @@
+class Recipes::AwsSdk < Rails::AppBuilder
+  def create
+    gather_gem('aws-sdk', '< 2')
+  end
+end

data/lib/potassium/recipes/bower.rb

@@ -0,0 +1,13 @@
+class Recipes::Bower < Rails::AppBuilder
+  def create
+    copy_file '../assets/.bowerrc', '.bowerrc'
+    template '../assets/bower.json', 'bower.json'
+    application "config.assets.paths << Rails.root.join('vendor', 'assets', 'bower_components')"
+
+    if get(:heroku)
+      bower_buildpack_url = 'https://github.com/platanus/heroku-buildpack-bower.git'
+      insert_point = 'https://github.com/platanus/heroku-buildpack-ruby-version.git'
+      inject_into_file '.buildpacks', "#{bower_buildpack_url}\n", before: insert_point
+    end
+  end
+end

data/lib/potassium/recipes/ci.rb

@@ -0,0 +1,42 @@
+class Recipes::Ci < Rails::AppBuilder
+  def create
+    if get(:heroku)
+      copy_file '../assets/Dockerfile.ci', 'Dockerfile.ci'
+      copy_file '../assets/circle.yml', 'circle.yml'
+
+      template '../assets/bin/cibuild.erb', 'bin/cibuild'
+      run "chmod a+x bin/cibuild"
+
+      copy_file '../assets/docker-compose.ci.yml', 'docker-compose.ci.yml'
+
+      compose = DockerHelpers.new('docker-compose.ci.yml')
+
+      if selected?(:database, :mysql)
+        service = <<-YAML
+          image: "mysql:5.6.23"
+          environment:
+            MYSQL_ALLOW_EMPTY_PASSWORD: 'true'
+        YAML
+        compose.add_service("mysql", service)
+        compose.add_link('test', 'mysql')
+        compose.add_env('test', 'MYSQL_HOST', 'mysql')
+        compose.add_env('test', 'MYSQL_PORT', '3306')
+
+      elsif selected?(:database, :postgresql)
+        service = <<-YAML
+          image: "postgres:9.4.5"
+          environment:
+            POSTGRES_USER: postgres
+            POSTGRES_PASSWORD: ''
+        YAML
+        compose.add_service("postgresql", service)
+        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')
+      end
+
+      add_readme_header :ci
+    end
+  end
+end

data/lib/potassium/recipes/cleanup.rb

@@ -0,0 +1,10 @@
+class Recipes::Cleanup < Rails::AppBuilder
+  def create
+    erase_comments "config/application.rb"
+    erase_comments "config/environments/production.rb"
+    erase_comments "config/environments/staging.rb"
+    erase_comments "config/environments/test.rb"
+    erase_comments "config/environments/development.rb"
+    cut_comments "config/initializers/backtrace_silencers.rb", limit: 100
+  end
+end

data/lib/potassium/recipes/database.rb

@@ -0,0 +1,42 @@
+class Recipes::Database < Rails::AppBuilder
+  def ask
+    databases = {
+      mysql: "MySQL",
+      postgresql: "PostgreSQL",
+      none: "None, thanks"
+    }
+
+    database = answer(:db) do
+      databases.keys[Ask.list("Which database are you using?", databases.values)]
+    end
+
+    set :database, database.to_sym
+  end
+
+  def create
+    databases = {
+      mysql: { name: 'mysql', gem_name: 'mysql2', version: '~> 0.3.18', relational: true },
+      postgresql: { name: 'postgresql', gem_name: 'pg', relational: true }
+    }
+
+    if db = databases[get(:database)]
+      if db[:relational]
+        activate_for_active_record(db)
+      end
+    end
+  end
+
+  private
+
+  def activate_for_active_record(db)
+    remove_file 'config/database.yml'
+    template "../assets/config/database_#{db[:name]}.yml.erb", 'config/database.yml'
+
+    discard_gem 'sqlite3'
+    if db[:version]
+      gather_gem db[:gem_name], db[:version]
+    else
+      gather_gem db[:gem_name]
+    end
+  end
+end

data/lib/potassium/recipes/delayed_job.rb

@@ -0,0 +1,41 @@
+class Recipes::DelayedJob < Rails::AppBuilder
+  def ask
+    use_delayed_job = answer(:"delayed-job") { Ask.confirm("Do you want to use delayed jobs?") }
+    set(:delayed_job, use_delayed_job)
+  end
+
+  def create
+    add_delayed_job if selected?(:delayed_job)
+  end
+
+  def install
+    heroku = load_recipe(:heroku)
+    set(:heroku, heroku.installed?)
+    add_delayed_job
+  end
+
+  def installed?
+    gem_exists?(/delayed_job_active_record/)
+  end
+
+  private
+
+  def add_delayed_job
+    gather_gem "delayed_job_active_record"
+
+    delayed_job_config = "config.active_job.queue_adapter = :delayed_job"
+    application(delayed_job_config)
+
+    after(:gem_install) do
+      generate "delayed_job:active_record"
+      run "bundle binstubs delayed_job"
+      add_readme_section :internal_dependencies, :delayed_job
+
+      if selected?(:heroku)
+        gsub_file "Procfile", /^.*$/m do |match|
+          "#{match}worker: bundle exec rake jobs:work"
+        end
+      end
+    end
+  end
+end

data/lib/potassium/recipes/devise.rb

@@ -0,0 +1,64 @@
+class Recipes::Devise < Rails::AppBuilder
+  def ask
+    use_devise = answer(:devise) do
+      Ask.confirm "Do you want to use Devise for authentication? (required for ActiveAdmin)"
+    end
+
+    if use_devise
+      set(:authentication, use_devise)
+      ask_for_devise_model
+    end
+  end
+
+  def create
+    add_devise if selected?(:authentication)
+  end
+
+  def install
+    ask_for_devise_model
+    add_devise
+  end
+
+  def installed?
+    gem_exists?(/devise/)
+  end
+
+  private
+
+  def ask_for_devise_model
+    create_user_model = answer(:"devise-user-model") do
+      Ask.confirm "Do you want to create a user model for Devise?"
+    end
+
+    set(:authentication_model, :user) if create_user_model
+  end
+
+  def add_devise
+    gather_gem 'devise'
+    gather_gem 'devise-i18n'
+
+    after(:gem_install) do
+      generate "devise:install"
+
+      if auth_model = get(:authentication_model)
+        generate "devise #{auth_model}"
+      end
+
+      gsub_file "config/initializers/devise.rb", /(\# config.secret_key.+)/i do |_match|
+        "config.secret_key = ENV['DEVISE_SECRET_KEY']"
+      end
+
+      gsub_file "config/initializers/devise.rb", /(config.mailer_sender.+)/i do |_match|
+        "config.mailer_sender = ENV['DEFAULT_EMAIL_ADDRESS']"
+      end
+
+      gsub_file "config/initializers/devise.rb", /(\# config.pepper.+)/i do |_match|
+        "# config.pepper = 'onhcylrat7x8bjyr5o15sxaix3vbu0sl'"
+      end
+
+      append_to_file '.env.example', 'DEVISE_SECRET_KEY='
+      append_to_file '.env', 'DEVISE_SECRET_KEY='
+      add_readme_section :internal_dependencies, :devise
+    end
+  end
+end

data/lib/potassium/recipes/editorconfig.rb

@@ -0,0 +1,5 @@
+class Recipes::Editorconfig < Rails::AppBuilder
+  def create
+    copy_file '../assets/.editorconfig', '.editorconfig'
+  end
+end

data/lib/potassium/recipes/env.rb

@@ -0,0 +1,10 @@
+class Recipes::Env < Rails::AppBuilder
+  def create
+    gather_gems(:development, :test) do
+      gather_gem('dotenv-rails')
+    end
+
+    template '../assets/.env.example.erb', '.env.example'
+    run "cp .env.example .env"
+  end
+end

data/lib/potassium/recipes/git.rb

@@ -0,0 +1,13 @@
+class Recipes::Git < Rails::AppBuilder
+  def create
+    git :init
+    after(:database_creation) do
+      append_to_file '.gitignore', ".env\n"
+      append_to_file '.gitignore', ".powder\n"
+      append_to_file '.gitignore', "vendor/assets/bower_components\n"
+
+      git add: "."
+      git commit: %{ -m 'Initial commit' }
+    end
+  end
+end

data/lib/potassium/recipes/github.rb

@@ -0,0 +1,27 @@
+class Recipes::Github < Rails::AppBuilder
+  def ask
+    repo_name = "platanus/#{get(:dasherized_app_name)}"
+    github_repo_create = answer(:github) do
+      Ask.confirm("Do you want to use create the github repository? (#{repo_name})")
+    end
+    if github_repo_create
+      github_repo_private = answer(:"github-private") do
+        Ask.confirm("Should the repository be private?")
+      end
+    end
+    set(:github_repo_name, repo_name)
+    set(:github_repo_create, github_repo_create)
+    set(:github_repo_private, github_repo_private)
+  end
+
+  def create
+    github_repo_create(get(:github_repo_name), get(:github_repo_private))
+  end
+
+  private
+
+  def github_repo_create(repo_name, private_repo = false)
+    flag = private_repo ? "-p" : ""
+    run "hub create #{flag} #{repo_name}"
+  end
+end

data/lib/potassium/recipes/heroku.rb

@@ -0,0 +1,138 @@
+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
+
+  def ask
+    heroku = answer(:heroku) do
+      Ask.confirm("Are you going to deploy to heroku? (#{who_am_i})")
+    end
+
+    if heroku
+      set(:heroku, heroku)
+    end
+  end
+
+  def create
+    add_heroku if get(:heroku)
+  end
+
+  def install
+    add_heroku
+  end
+
+  def installed?
+    gem_exists?(/rails_stdout_logging/)
+  end
+
+  private
+
+  def add_heroku
+    gather_gems(:production, :staging) do
+      gather_gem('rails_stdout_logging')
+    end
+
+    copy_file '../assets/Procfile', 'Procfile'
+    copy_file '../assets/.buildpacks', '.buildpacks'
+
+    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
+
+    add_readme_header :deployment
+  end
+
+  def heroku_pipeline_name
+    app_name.dasherize
+  end
+
+  def app_name_for(environment)
+    "#{NAME_PREFIX}-#{app_name.dasherize}-#{environment}"
+  end
+
+  def logged_in?
+    !who_am_i.include? "not logged in"
+  end
+
+  def who_am_i
+    `heroku auth:whoami`.strip
+  end
+
+  def create_app_on_heroku(environment)
+    rack_env = "RACK_ENV=#{environment} RAILS_ENV=#{environment}"
+    staged_app_name = app_name_for(environment)
+
+    run_toolbelt_command "create #{staged_app_name} --remote #{environment}"
+    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)
+    add_app_to_pipeline(staged_app_name, environment)
+  end
+
+  def set_rails_secrets(environment)
+    run_toolbelt_command(
+      "config:add SECRET_KEY_BASE=#{generate_secret}",
+      app_name_for(environment)
+    )
+  end
+
+  def set_app_multi_buildpack(environment)
+    run_toolbelt_command(
+      "buildpacks:set https://github.com/ddollar/heroku-buildpack-multi.git",
+      app_name_for(environment)
+    )
+  end
+
+  def add_app_to_pipeline(app_env_name, environment)
+    pipelines_plugin = `heroku plugins | grep pipelines`
+    if pipelines_plugin.empty?
+      puts "You need heroku pipelines plugin. Run: heroku plugins:install heroku-pipelines"
+      exit 1
+    end
+
+    pipeline = `heroku pipelines:info \
+      #{heroku_pipeline_name} 2>/dev/null | grep #{heroku_pipeline_name}`
+    pipeline_command = pipeline.empty? ? "create" : "add"
+
+    run_toolbelt_command(
+      "pipelines:#{pipeline_command} #{heroku_pipeline_name} \
+        --stage #{environment}",
+      app_env_name
+    )
+  end
+
+  def generate_secret
+    SecureRandom.hex(64)
+  end
+
+  def run_toolbelt_command(command, app_env_name = nil)
+    if app_env_name.nil?
+      `heroku #{command}`
+    else
+      `heroku #{command} --app #{app_env_name}`
+    end
+  end
+end