rhino_project_core 0.20.0.beta.18

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_command.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "dotenv"
+require "rails/command"
+
+module Rails
+  module Command
+    class RhinoCommand < Base # :nodoc:
+      include Thor::Actions
+
+      no_commands do
+        def help
+          say "rails rhino::dummy [module] command # Run rails command in dummy application, defaults to rhino"
+        end
+      end
+
+      def dummy(*args)
+        rhino_command("test/dummy", nil, *args)
+      end
+
+      def test(*args)
+        rhino_command(nil, "test", *args)
+      end
+
+      def rails(*args)
+        rhino_command(nil, nil, *args)
+      end
+
+      def coverage(*args)
+        ENV["COVERAGE"] = "1"
+        test(*args)
+      end
+
+      protected
+        def rhino_command(extra_path, base_command, *args) # rubocop:todo Metrics/MethodLength
+          # Default to just rhino/rhino if no obvious module
+          module_name = if Dir.exist?("rhino/rhino_#{args[0]}")
+            args.shift
+          else
+            nil
+          end
+          module_base = ["rhino", module_name].compact.join("_")
+          module_path = ["rhino/#{module_base}", extra_path].compact.join("/")
+          db_name = "#{module_base}_dummy"
+
+          # 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='#{__dir__}/../../../../Gemfile' bin/rails #{base_command} #{args.join(' ')}",
+              { abort_on_failure: true }
+            )
+          end
+        end
+    end
+  end
+end

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

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Generators
+    module Dev
+      # rubocop:disable Metrics/ClassLength
+      class SetupGenerator < ::Rails::Generators::Base
+        class_option :prompt, type: :boolean, default: true
+        class_option :server_port, type: :numeric
+        class_option :client_port, type: :numeric
+        class_option :db_host, type: :string
+        class_option :db_name, type: :string
+        class_option :db_port, type: :numeric
+        class_option :db_user, type: :string
+        class_option :db_password, type: :string
+        class_option :redis_port, type: :numeric
+        class_option :redis_database, type: :numeric
+
+        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 setup_env
+          say "Setting up local .env files"
+
+          collect_env_info
+
+          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"] || 3000
+          end
+
+          def client_port_default
+            @server_port.to_i + 1
+          end
+
+          def db_name_default
+            db_name =
+              options[:db_name] || ENV["DB_NAME"] ||
+              File.basename(project_dir).sub(/[-_]?mono/, "")
+
+            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"] || 5432
+          end
+
+          def db_user_default
+            options[:db_user] || ENV["DB_USERNAME"] || (dockerized ? "postgres" : "")
+          end
+
+          def db_password_default
+            options[:db_password] || ENV["DB_PASSWORD"] || (dockerized ? "password" : "")
+          end
+
+          def redis_host_default
+            options[:redis_host] || ENV["REDIS_HOST"] || "localhost"
+          end
+
+          def redis_port_default
+            options[:redis_port] || ENV["REDIS_PORT"] || 6379
+          end
+
+          def redis_database_default
+            options[:redis_database] || ENV["REDIS_DATABASE"] || 0
+          end
+
+          def dockerized_default
+            "yN"
+          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 server on docker?", dockerized_default))
+
+            return unless dockerized
+
+            @db_host = "db"
+            @redis_host = "redis"
+            @redis_port = 6379
+
+            puts <<~HERE
+              The following docker configuration has been automatically set for you:
+              Database host: #{db_host}
+              Redis host: #{redis_host}
+              Redis port: #{redis_port}
+            HERE
+          end
+
+          def collect_database_info # rubocop:todo Metrics/AbcSize
+            @db_name = ask_prompt("Database?", db_name_default)
+            @db_host = ask_prompt("Database host?", db_host_default) unless dockerized
+            @db_port = ask_prompt("Database port?", db_port_default)
+            @db_user = ask_prompt("Database User?", db_user_default) until !dockerized || db_user.present?
+            @db_password = ask_prompt("Database Password?", db_password_default) until !dockerized || db_password.present?
+          end
+
+          def collect_redis_info
+            unless dockerized
+              @redis_host = ask_prompt("Redis host?", redis_host_default)
+              @redis_port = ask_prompt("Redis port?", redis_port_default)
+            end
+
+            @redis_database = ask_prompt("Redis database?", redis_database_default)
+          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.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

data/lib/generators/rhino/install/install_generator.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      source_root File.expand_path('templates', __dir__)
+
+      def install_user
+        say 'Installing user to app/models'
+        template 'user.rb', 'app/models/user.rb'
+      end
+
+      def install_account
+        say 'Installing account to app/models'
+        template 'account.rb', 'app/models/account.rb'
+      end
+
+      def install_initializer
+        say 'Installing initializer'
+        template 'rhino.rb', 'config/initializers/rhino.rb'
+      end
+    end
+  end
+end

data/lib/generators/rhino/install/templates/account.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class Account < Rhino::Account
+end

data/lib/generators/rhino/install/templates/rhino.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+Rhino.setup do |config|
+  # ==> Owner configuration
+  # The auth owner class
+  # config.auth_owner = 'User'
+
+  # The base owner class
+  # config.base_owner = 'Organization'
+
+  # ==> Resource Configuration
+
+  # Include Rhino::Resource::ActiveRecordExtension by default
+  # config.auto_include_active_record = true
+
+  # The root path for the api ie '/api'
+  # config.namespace = :api
+
+  # Authentication
+  # config.allow_signup = true
+
+  # The list of resources exposed in the API
+  config.resources += ['User', 'Account']
+end

data/lib/generators/rhino/install/templates/user.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class User < Rhino::User
+end

data/lib/generators/rhino/module/module_generator.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Generators
+    class ModuleGenerator < ::Rails::Generators::Base
+      attr_reader :module_name, :module_path
+
+      class_option :full, type: :boolean, default: false,
+                          desc: 'Full plugin generation'
+
+      class_option :skip_plugin, type: :boolean, default: false,
+                                 desc: 'Skip plugin generation'
+
+      source_root File.expand_path('templates', __dir__)
+
+      def create_module
+        @module_name = ask('Module name?')
+        @module_name = "rhino_#{module_name}" unless module_name.starts_with?('rhino_')
+        @module_path = "rhino/#{module_name}"
+
+        return if options[:skip_plugin]
+
+        say "Creating #{module_name}"
+
+        plugin_command = "plugin new #{module_path} --skip-git"
+        plugin_command = "#{plugin_command} --full" if options[:full]
+        rails_command(plugin_command)
+      end
+
+      def remove_license
+        remove_file "#{module_path}/MIT-LICENSE"
+      end
+
+      def engine_registration
+        engine_file = "#{module_path}/lib/#{module_name}/engine.rb"
+
+        remove_file engine_file
+        template 'engine.rb', engine_file
+      end
+
+      def create_install_generator
+        generator_path = "#{module_path}/lib/generators/#{module_name}/install"
+        tasks_path = "#{module_path}/lib/tasks"
+
+        empty_directory "#{generator_path}/templates"
+        create_file("#{generator_path}/templates/.keep")
+
+        template 'install_generator.rb', "#{generator_path}/install_generator.rb"
+        template 'module_tasks.rake', "#{tasks_path}/#{module_name}.rake"
+
+        remove_file "#{tasks_path}/#{module_name}_tasks.rake"
+      end
+
+      def fix_gemspec
+        gemspec_file = "#{module_path}/#{module_name}.gemspec"
+
+        gsub_file gemspec_file, /spec.homepage.*/, 'spec.homepage    = ""'
+        gsub_file gemspec_file, /spec.summary.*/, 'spec.summary     = ""'
+        gsub_file gemspec_file, /spec.description.*/, 'spec.description = ""'
+        gsub_file gemspec_file, /spec.license.*/, 'spec.license      = ""'
+        gsub_file gemspec_file, 'spec.files = Dir["{app,config,db,lib}/**/*", "MIT-LICENSE", "Rakefile", "README.md"]', 'spec.files = Dir["{app,config,db,lib}/**/*", "Rakefile", "README.md"]' # rubocop:disable Layout/LineLength
+      end
+
+      # Gross hack for now
+      DUMMY_SETUP_FILES = [
+        'config/database.yml',
+        'config/initializers/devise_token_auth.rb',
+        'config/initializers/devise.rb',
+        'app/models/user.rb',
+        'db/migrate/20210111014230_devise_token_auth_create_users.rhino_engine.rb'
+      ].freeze
+
+      def dummy_setup
+        return unless options[:full]
+
+        rhino_dummy = Rails.root.join('rhino/rhino/test/dummy')
+        module_dummy = Rails.root.join("#{module_path}/test/dummy")
+
+        remove_file "#{module_dummy}/config/database.yml"
+
+        DUMMY_SETUP_FILES.each do |file|
+          copy_file "#{rhino_dummy}/#{file}", "#{module_dummy}/#{file}"
+        end
+      end
+
+      def rubocop
+        inside(module_path) do
+          run 'bundle exec rubocop -a', capture: true
+        end
+      end
+    end
+  end
+end

data/lib/generators/rhino/module/templates/engine.rb.tt

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "rhino/engine"
+
+module <%= module_name.camelize %>
+  class Engine < ::Rails::Engine
+    config.autoload_paths << File.expand_path("../../lib", __dir__)
+
+    initializer "<%= module_name %>.register_module" do
+      config.after_initialize do
+        if true
+          Rhino.registered_modules[:<%= module_name %>] = {
+            version: <%= module_name.camelize %>::VERSION
+          }
+        end
+      end
+    end
+  end
+end

data/lib/generators/rhino/module/templates/install_generator.rb.tt

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module <%= module_name.camelize %>
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      def install
+      end
+    end
+  end
+end

data/lib/generators/rhino/module/templates/module_tasks.rake.tt

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+namespace :<%= module_name %> do
+  # Prevent migration installation task from showing up twice.
+  if Rake::Task.task_defined?("<%= module_name %>_engine:install:migrations")
+    Rake::Task["<%= module_name %>_engine:install:migrations"].clear_comments
+  end
+
+  desc "Install <%= module_name %>"
+  task install: :environment do
+    if Rake::Task.task_defined?("<%= module_name %>_engine:install:migrations")
+      Rake::Task["<%= module_name %>_engine:install:migrations"].invoke
+    end
+
+    Rails::Command.invoke :generate, ["<%= module_name %>:install"]
+  end
+end

data/lib/generators/rhino/policy/policy_generator.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Rhino
+  class PolicyGenerator < ::Rails::Generators::NamedBase
+    source_root File.expand_path("templates", __dir__)
+
+    class_option :parent, type: :string, default: "Rhino::ViewerPolicy", desc: "The parent class for the policy"
+
+    check_class_collision suffix: "Policy"
+
+    hook_for :test_framework, as: :rhino_policy
+
+    def create_policy_file
+      template "policy.rb", File.join("app/policies", class_path, "#{file_name}_policy.rb")
+    end
+
+    private
+      def parent_class_name
+        # FIXME: Does this really need to be top level namespaced?
+        return options[:parent] if options[:parent].starts_with?("::")
+
+        "::#{options[:parent]}"
+      end
+
+      def parent_scope_class_name
+        "#{parent_class_name}::Scope"
+      end
+
+      def file_name
+        @file_name ||= super.sub(/_policy\z/i, "")
+      end
+  end
+end

data/lib/generators/rhino/policy/templates/policy.rb.tt

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+<% module_namespacing do -%>
+class <%= class_name %>Policy < <%= parent_class_name %>
+  # NOTE: Be explicit about which action you allow!
+  # def index?
+  #   authorize_action(false)
+  # end
+
+  # def show?
+  #   authorize_action(false)
+  # end
+
+  # def create?
+  #   authorize_action(false)
+  # end
+
+  # def update?
+  #   authorize_action(false)
+  # end
+
+  # def destroy?
+  #   authorize_action(false)
+  # end
+
+  # def permitted_attributes_for_create
+  #   super
+  #   super - [:name] # Remove the name attribute from the permitted attributes for create
+  # end
+
+  # def permitted_attributes_for_show
+  #   super
+  # end
+
+  # def permitted_attributes_for_update
+  #   super
+  # end
+
+  class Scope < <%= parent_scope_class_name %>
+    # NOTE: Be explicit about which records you allow access to!
+    # def resolve
+    #   scope.all
+    # end
+  end
+end
+<% end -%>