rhino_project_core 0.20.0.alpha.0

data/app/resources/rhino/open_api_info.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Rhino
+  class OpenApiInfo
+    include Rhino::Resource
+
+    rhino_owner_global
+
+    rhino_routing only: [:index], path: 'info/openapi'
+    rhino_controller :simple
+    rhino_policy :resource_info
+
+    def self.describe
+      nil
+    end
+
+    def self.index
+      JSON.pretty_generate({
+        openapi: '3.0.3',
+        components: {
+          schemas: describe_schemas
+        },
+        paths: describe_paths,
+        info: describe_info
+      })
+    end
+
+    def self.describe_schemas
+      Rhino.resource_classes.index_with(&:describe).compact.transform_keys { |r| r.model_name.singular }
+    end
+
+    def self.describe_parameter(param)
+      {
+        name: param,
+        in: "path",
+        required: true
+      }
+    end
+
+    # https://gist.github.com/bantic/5688232#gistcomment-3274704
+    RESPONSE_CODES = [200, 400, 403, 422].freeze
+    SUCCESS_CODES = [200].freeze
+    def self.describe_path_content(klass, code)
+      {
+        "application/json":
+          ({ schema: { "$ref": "#/components/schemas/#{klass.model_name.singular}" } } if SUCCESS_CODES.include?(code)) || {}
+      }
+    end
+
+    def self.describe_path_responses(klass)
+      RESPONSE_CODES.index_with do |code|
+        {
+          description: Rack::Utils::HTTP_STATUS_CODES[code],
+          content: describe_path_content(klass, code)
+        }
+      end
+    end
+
+    def self.describe_path(path) # rubocop:todo Metrics/AbcSize
+      new_path = path.index_by { |p| p[:verb].downcase.to_sym }
+      new_path.transform_values! do |verb_values|
+        klass = verb_values[:rhino_resource].constantize
+
+        verb_info = {
+          operationId: "#{klass.model_name.singular}-#{verb_values[:action]}",
+          parameters: verb_values[:required_names].map { |param| describe_parameter(param) },
+          responses: describe_path_responses(klass),
+          tags: [klass.model_name.singular]
+        }
+
+        verb_info
+      end
+
+      new_path
+    end
+
+    PATH_IGNORES = ["Rhino::OpenApiInfo", "Rhino::InfoGraph"].freeze
+    def self.describe_paths # rubocop:todo Metrics/AbcSize
+      routes = Rails.application.routes.routes
+
+      # Extract the path information we need
+      paths = routes.map { |r| r.defaults.merge(verb: r.verb, path: r.path.spec.to_s, required_names: r.path.required_names) }
+      paths = paths.group_by { |r| r[:path] }
+
+      # Get rid of non-rhino paths
+      # Rhino paths have rhino_resource set as an attribute when the routes are created
+      paths.transform_values! { |v| v.select { |p| p[:rhino_resource].present? && PATH_IGNORES.exclude?(p[:rhino_resource]) } }
+
+      # Remove empty hashes
+      paths.compact_blank!
+
+      # For each path, list the verbs it supports
+      paths.transform_values! do |path|
+        describe_path(path)
+      end
+    end
+
+    def self.describe_info
+      {
+        title: "#{Rails.application.class.module_parent_name} API",
+        version: '0.0.0',
+        "x-rhino": {
+          modules: Rhino.registered_modules
+        }
+      }
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+Rails.application.routes.draw do
+  scope Rhino.namespace do
+    mount_devise_token_auth_for 'User', at: "auth"
+
+    Rhino.resource_classes.each do |m|
+      if m.route_singular?
+        resource m.route_key, path: m.route_path, controller: m.controller_name, only: m.routes, rhino_resource: m.name, format: false
+      else
+        resources m.route_key, path: m.route_path, controller: m.controller_name, only: m.routes, rhino_resource: m.name, format: false 
+      end
+    end
+  end
+
+  match "*#{Rhino.namespace}", to: 'rhino/base#not_found', via: :all, constraints: lambda { |request|
+    request.url[/\/rails\/active_storage\//].nil?
+  }
+end

data/db/migrate/20180101000000_devise_token_auth_create_users.rb

@@ -0,0 +1,54 @@
+class DeviseTokenAuthCreateUsers < ActiveRecord::Migration[5.1]
+  def change
+    create_table(:users) do |t|
+      ## Required
+      t.string :provider, :null => false, :default => "email"
+      t.string :uid, :null => false, :default => ""
+
+      ## Database authenticatable
+      t.string :encrypted_password, :null => false, :default => ""
+
+      ## Recoverable
+      t.string   :reset_password_token
+      t.datetime :reset_password_sent_at
+
+      ## Rememberable
+      t.datetime :remember_created_at
+
+      ## Trackable
+      t.integer  :sign_in_count, :default => 0, :null => false
+      t.datetime :current_sign_in_at
+      t.datetime :last_sign_in_at
+      t.string   :current_sign_in_ip
+      t.string   :last_sign_in_ip
+
+      ## Confirmable
+      t.string   :confirmation_token
+      t.datetime :confirmed_at
+      t.datetime :confirmation_sent_at
+      t.string   :unconfirmed_email # Only if using reconfirmable
+
+      ## Lockable
+      # t.integer  :failed_attempts, :default => 0, :null => false # Only if lock strategy is :failed_attempts
+      # t.string   :unlock_token # Only if unlock strategy is :email or :both
+      # t.datetime :locked_at
+
+      ## User Info
+      t.string :name
+      t.string :nickname
+      t.string :image
+      t.string :email
+
+      ## Tokens
+      t.json :tokens
+
+      t.timestamps
+    end
+
+    add_index :users, :email,                unique: true
+    add_index :users, [:uid, :provider],     unique: true
+    add_index :users, :reset_password_token, unique: true
+    add_index :users, :confirmation_token,   unique: true
+    # add_index :users, :unlock_token,       unique: true
+  end
+end

data/db/migrate/20180622142754_add_allow_change_password_to_users.rb

@@ -0,0 +1,5 @@
+class AddAllowChangePasswordToUsers < ActiveRecord::Migration[5.2]
+  def change
+    add_column :users, :allow_password_change, :boolean, default: false, null: false
+  end
+end

data/db/migrate/20191217010224_add_approved_to_users.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AddApprovedToUsers < ActiveRecord::Migration[5.2]
+  def change
+    add_column :users, :approved, :boolean, default: false
+  end
+end

data/db/migrate/20200503182019_change_tokens_to_json_b.rb

@@ -0,0 +1,9 @@
+class ChangeTokensToJsonB < ActiveRecord::Migration[5.2]
+  def up
+    change_column :users, :tokens, 'jsonb using tokens::jsonb'
+  end
+
+  def down
+    change_column :users, :tokens, 'json using tokens::json'
+  end
+end

data/lib/commands/rhino/module/coverage_command.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "dotenv"
+require "rails/command"
+
+module Rails
+  module Command
+    module Rhino
+      module Module
+        class CoverageCommand < Base # :nodoc:
+          include Thor::Actions
+
+          def perform(*args)
+            ENV["COVERAGE"] = "1"
+            test(*args)
+          end
+
+          protected
+            def rhino_command(extra_path, base_command, *args) # rubocop:todo Metrics/MethodLength
+              module_name = if Dir.exist?(args[0])
+                args.shift
+              else
+                abort "No module specified"
+              end
+              module_path = [module_name, extra_path].compact.join("/")
+              db_name = "#{module_name}_dummy"
+              gem_file_path = File.join(Dir.pwd, "Gemfile")
+
+              # Getting existing variables and re-use
+              ::Dotenv.load
+
+              inside(module_path) do
+                # Override DB_NAME so multiple can run in parallel
+                run(
+                  "DB_NAME=#{db_name} BUNDLE_GEMFILE='#{gem_file_path}' bin/rails #{base_command} #{args.join(' ')}",
+                  { abort_on_failure: true }
+                )
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/lib/commands/rhino/module/dummy_command.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "dotenv"
+require "rails/command"
+
+module Rails
+  module Command
+    module Rhino
+      module Module
+        class DummyCommand < Base # :nodoc:
+          include Thor::Actions
+
+          def perform(*args)
+            rhino_command("test/dummy", nil, *args)
+          end
+
+          protected
+            def rhino_command(extra_path, base_command, *args) # rubocop:todo Metrics/MethodLength
+              module_name = if Dir.exist?(args[0])
+                args.shift
+              else
+                abort "No module specified"
+              end
+              module_path = [module_name, extra_path].compact.join("/")
+              db_name = "#{module_name}_dummy"
+              gem_file_path = File.join(Dir.pwd, "Gemfile")
+
+              # Getting existing variables and re-use
+              ::Dotenv.load
+
+              inside(module_path) do
+                # Override DB_NAME so multiple can run in parallel
+                run(
+                  "DB_NAME=#{db_name} BUNDLE_GEMFILE='#{gem_file_path}' bin/rails #{base_command} #{args.join(' ')}",
+                  { abort_on_failure: true }
+                )
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/lib/commands/rhino/module/new_command.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "dotenv"
+require "rails/command"
+
+module Rails
+  module Command
+    module Rhino
+      module Module
+        class NewCommand < Base # :nodoc:
+          no_commands do
+            def help
+              run_module_generator %w[--help]
+            end
+          end
+
+          def self.banner(*) # :nodoc:
+            "#{executable} new [options]"
+          end
+
+          def perform(*args)
+            run_module_generator(args)
+          end
+
+          private
+            def run_module_generator(plugin_args)
+              require "generators/rhino/module/module_generator"
+              ::Rhino::Generators::ModuleGenerator.start plugin_args
+            end
+        end
+      end
+    end
+  end
+end

data/lib/commands/rhino/module/rails_command.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "dotenv"
+require "rails/command"
+
+module Rails
+  module Command
+    module Rhino
+      module Module
+        class RailsCommand < Base # :nodoc:
+          include Thor::Actions
+
+          def perform(*args)
+            rhino_command(nil, nil, *args)
+          end
+
+          protected
+            def rhino_command(extra_path, base_command, *args) # rubocop:todo Metrics/MethodLength
+              module_name = if Dir.exist?(args[0])
+                args.shift
+              else
+                abort "No module specified"
+              end
+              module_path = [module_name, extra_path].compact.join("/")
+              db_name = "#{module_name}_dummy"
+              gem_file_path = File.join(Dir.pwd, "Gemfile")
+
+              # Getting existing variables and re-use
+              ::Dotenv.load
+
+              inside(module_path) do
+                # Override DB_NAME so multiple can run in parallel
+                run(
+                  "DB_NAME=#{db_name} BUNDLE_GEMFILE='#{gem_file_path}' bin/rails #{base_command} #{args.join(' ')}",
+                  { abort_on_failure: true }
+                )
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/lib/commands/rhino/module/test_command.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "dotenv"
+require "rails/command"
+
+module Rails
+  module Command
+    module Rhino
+      module Module
+        class TestCommand < Base # :nodoc:
+          include Thor::Actions
+
+          def test(*args)
+            rhino_command(nil, "test", *args)
+          end
+
+          protected
+            def rhino_command(extra_path, base_command, *args) # rubocop:todo Metrics/MethodLength
+              module_name = if Dir.exist?(args[0])
+                args.shift
+              else
+                abort "No module specified"
+              end
+              module_path = [module_name, extra_path].compact.join("/")
+              db_name = "#{module_name}_dummy"
+              gem_file_path = File.join(Dir.pwd, "Gemfile")
+
+              # Getting existing variables and re-use
+              ::Dotenv.load
+
+              inside(module_path) do
+                # Override DB_NAME so multiple can run in parallel
+                run(
+                  "DB_NAME=#{db_name} BUNDLE_GEMFILE='#{gem_file_path}' bin/rails #{base_command} #{args.join(' ')}",
+                  { abort_on_failure: true }
+                )
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/lib/generators/rhino/dev/setup/setup_generator.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Generators
+    module Dev
+      # rubocop:disable Metrics/ClassLength
+      class SetupGenerator < ::Rails::Generators::Base
+        DEFAULT_SERVER_PORT = 3000
+        DEFAULT_CLIENT_PORT = DEFAULT_SERVER_PORT + 1
+
+        class_option :prompt, type: :boolean, default: true, desc: "Prompt user for configuration options"
+        class_option :defaults, type: :string, enum: %w[local docker], default: "local", desc: "Use configuration defaults of type DEFAULTS"
+        class_option :skip_existing, type: :boolean, default: false, desc: "Skip existing env files"
+        class_option :server_port, type: :numeric, default: DEFAULT_SERVER_PORT, group: :server, desc: "Server port"
+        class_option :client_port, type: :numeric, default: DEFAULT_CLIENT_PORT, group: :client, desc: "Client port"
+        class_option :db_host, type: :string, group: :database
+        class_option :db_name, type: :string, group: :database
+        class_option :db_port, type: :numeric, default: 5432, group: :database
+        class_option :db_user, type: :string, group: :database
+        class_option :db_password, type: :string, group: :database
+        class_option :redis_port, type: :numeric, default: 6379, group: :redis
+        class_option :redis_database, type: :numeric, default: 0, group: :redis
+
+        attr_reader :server_port,
+                    :client_port,
+                    :db_name,
+                    :db_host,
+                    :db_port,
+                    :db_user,
+                    :db_password,
+                    :redis_host,
+                    :redis_port,
+                    :redis_database,
+                    :dockerized
+
+        source_root File.expand_path("templates", __dir__)
+
+        def check_existing
+          return unless options[:skip_existing] && File.exist?(server_file(".env"))
+
+          say "Skipping existing .env files"
+          exit(0)
+        end
+
+        def setup_env
+          say "Setting up local .env files"
+
+          collect_env_info
+
+          template "env.root", project_file(".env")
+          template "env.server", server_file(".env")
+          template "env.client", client_file(".env")
+        end
+
+        def install_hooks
+          say "Installing git hooks"
+          # Hooks need to be executable
+          copy_file "prepare-commit-msg",
+                    project_file(".git/hooks/prepare-commit-msg"),
+                    mode: :preserve
+        end
+
+        private
+          def project_dir
+            # Up one level from the server directory
+            Rails.root.parent
+          end
+
+          def server_extension
+            Rails.root.basename.to_s.match(/[-_]?server/)[0]
+          end
+
+          def server_port_default
+            options[:server_port] || ENV["PORT"]
+          end
+
+          def client_port_default
+            @server_port.to_i + 1
+          end
+
+          def project_name
+            @project_name ||= File.basename(project_dir).sub(/[-_]?mono/, "")
+          end
+
+          def db_name_default
+            db_name = options[:db_name] || ENV["DB_NAME"] || project_name
+
+            return db_name if db_name.present?
+
+            File.basename(Rails.root.parent)
+          end
+
+          def db_host_default
+            options[:db_host] || ENV["DB_HOST"] || "localhost"
+          end
+
+          def db_port_default
+            options[:db_port] || ENV["DB_PORT"]
+          end
+
+          def db_user_default
+            options[:db_user] || ENV["DB_USERNAME"] || `whoami`
+          end
+
+          def db_password_default
+            options[:db_password] || ENV["DB_PASSWORD"] || ""
+          end
+
+          def redis_host_default
+            options[:redis_host] || ENV["REDIS_HOST"] || "localhost"
+          end
+
+          def redis_port_default
+            options[:redis_port] || ENV["REDIS_PORT"]
+          end
+
+          def redis_database_default
+            options[:redis_database] || ENV["REDIS_DATABASE"]
+          end
+
+          def dockerized_default
+            options[:defaults] == "docker" ? "Y" : "N"
+          end
+
+          def collect_env_info
+            collect_docker_info
+
+            @server_port = ask_prompt("Server Port?", server_port_default)
+            @client_port = ask_prompt("Client Port?", client_port_default)
+
+            collect_database_info
+            collect_redis_info
+          end
+
+          def collect_docker_info
+            @dockerized = %w[y Y].include?(ask_prompt("Run with docker?", dockerized_default))
+
+            return unless dockerized
+
+            @db_host = "db"
+            @db_user = "postgres"
+            @db_password = "password"
+            @db_port = 5432
+            @redis_host = "redis"
+            @redis_port = 6379
+            @redis_database = 0
+
+            puts <<~HERE
+              The following docker configuration has been automatically set for you:
+              Database host: #{db_host}
+              Database port: #{db_port}
+              Database user: #{db_user}
+              Database password: #{db_password}
+              Redis host: #{redis_host}
+              Redis port: #{redis_port}
+              Redis database: #{redis_database}
+            HERE
+          end
+
+          def collect_database_info
+            @db_name = ask_prompt("Database?", db_name_default)
+            @db_host ||= ask_prompt("Database host?", db_host_default)
+            @db_port ||= ask_prompt("Database port?", db_port_default)
+            @db_user ||= ask_prompt("Database User?", db_user_default)
+            @db_password ||= ask_prompt("Database Password?", db_password_default)
+
+            nil
+          end
+
+          def collect_redis_info
+            @redis_host ||= ask_prompt("Redis host?", redis_host_default)
+            @redis_port ||= ask_prompt("Redis port?", redis_port_default)
+            @redis_database ||= ask_prompt("Redis database?", redis_database_default)
+
+            nil
+          end
+
+          def project_file(file)
+            File.join(project_dir, file)
+          end
+
+          def client_file(file)
+            File.join(project_dir, "client", file)
+          end
+
+          def server_file(file)
+            File.join(project_dir, "server", file)
+          end
+
+          def ask_prompt(message, default)
+            return default unless options[:prompt]
+
+            ask(message, default:)
+          end
+      end
+      # rubocop:enable Metrics/ClassLength
+    end
+  end
+end

data/lib/generators/rhino/dev/setup/templates/env.client.tt

@@ -0,0 +1,4 @@
+PORT=<%= client_port %>
+
+VITE_API_ROOT_PATH=http://localhost:<%= server_port %>
+VITE_ROLLBAR_ACCESS_TOKEN=

data/lib/generators/rhino/dev/setup/templates/env.root.tt

@@ -0,0 +1 @@
+COMPOSE_PROJECT_NAME=<%= project_name %>

data/lib/generators/rhino/dev/setup/templates/env.server.tt

@@ -0,0 +1,35 @@
+PORT=<%= server_port %>
+
+ROOT_URL=http://localhost:<%= server_port %>
+FRONT_END_URL=http://localhost:<%= client_port %>
+
+DB_NAME=<%= db_name %>
+DB_HOST=<%= db_host %>
+DB_PORT=<%= db_port %>
+DB_USERNAME=<%= db_user %>
+DB_PASSWORD=<%= db_password %>
+REDIS_HOST=<%= redis_host %>
+REDIS_PORT=<%= redis_port %>
+REDIS_DATABASE=<%= redis_database %>
+
+SECRET_KEY_BASE=0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+
+# Production only:
+SENDGRID_API_KEY=<api-key>
+
+#AWS_ACCESS_KEY=
+#AWS_SECRET_KEY=
+#AWS_S3_BUCKET=
+#AWS_REGION=
+
+#AZURE_STORAGE_KEY=AAAAAAAAAAAAAA
+#AZURE_ACCOUNT_NAME="azure_acc_name"
+#AZURE_CONTAINER="container-test"
+
+#STRIPE_PUBLISHABLE_KEY=pk_...
+#STRIPE_SECRET_KEY=sk_...
+
+#AUTH_GOOGLE_OAUTH2_CLIENT_ID=
+#AUTH_GOOGLE_OAUTH2_SECRET_KEY=
+
+ROLLBAR_ACCESS_TOKEN=

data/lib/generators/rhino/dev/setup/templates/prepare-commit-msg

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+# This way you can customize which branches should be skipped when
+# prepending commit message.
+if [ -z "$BRANCHES_TO_SKIP" ]; then
+  BRANCHES_TO_SKIP=(main master develop test)
+fi
+
+BRANCH_NAME=$(git symbolic-ref --short HEAD)
+BRANCH_NAME="${BRANCH_NAME##*/}"
+
+BRANCH_EXCLUDED=$(printf "%s\n" "${BRANCHES_TO_SKIP[@]}" | grep -c "^$BRANCH_NAME$")
+BRANCH_IN_COMMIT=$(grep -c "\[$BRANCH_NAME\]" $1)
+
+if [ -n "$BRANCH_NAME" ] && ! [[ $BRANCH_EXCLUDED -eq 1 ]] && ! [[ $BRANCH_IN_COMMIT -ge 1 ]]; then
+  sed -i.bak -e "1s/^/[$BRANCH_NAME] /" $1
+fi