teamable 0.0.1.alpha

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 92e14701652541974d41ad1b2f37bb99ae1ba17e2932da58ff40a60164e40be7
+  data.tar.gz: cac90b085b07a4b5b616168a6d4a33a60cf904f357a563c96fe8fbd699dfda1f
+SHA512:
+  metadata.gz: a640b4d0df029a0cba8044a7ff47fea7bc56ab9538ae19ffd93a853b56a6b7bdd2001ccca4ca0c0028bd21199c71484ad3b7623b8105f1a3dcd92b2d85cee84e
+  data.tar.gz: 6ab50670c95b7451d6c35394302c812307f52f0678638eeced97527c6f8ae175c4e407a53fae297dee8135b7f0091c78cf5c3d55004811504b3f01399c8a3bf5

data/LICENSE.md

@@ -0,0 +1,19 @@
+Copyright (c) 2021 The Teamable developers.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,98 @@
+Teamable 
+========
+[![RuboCop Github Action](https://github.com/kiqr/teamable/actions/workflows/rubocop.yml/badge.svg)](https://github.com/kiqr/teamable/actions/workflows/rubocop.yml)
+[![RSpec](https://github.com/kiqr/teamable/actions/workflows/rspec.yml/badge.svg)](https://github.com/kiqr/teamable/actions/workflows/rspec.yml)
+[![codecov](https://codecov.io/gh/kiqr/teamable/branch/main/graph/badge.svg?token=UZMGXQKJRL)](https://codecov.io/gh/kiqr/teamable)
+[![MIT License](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE.md)
+
+Teamable enables role based multi-user accounts (teams/organizations). Teams are represented by the `Account` model. An account can have multiple users associated with it and a user can have multiple accounts. You can think of accounts as a common name for **teams** or **organizations**.
+
+Every user can have one personal account they're admin of, which allows our code to work the same way whether we're adding resources privately for a user or for a team/organization. When a user signs in for the first time, they will be redirected to `new_account_path` and prompted to create their first personal or team account.
+
+### Team resources
+
+**We recommend** you to scope all user resources under accounts instead of users. For example, in an application containing projects, the `Project` model could be declared like this:
+
+```ruby
+class Project < ApplicationRecord
+  # belongs_to :user <- don't do this.
+  belongs_to :account # personal or team account.
+end
+```
+
+or if you're combining teamable with [acts_as_tenant](https://github.com/ErwinM/acts_as_tenant):
+
+```ruby
+class Project < ApplicationRecord
+  acts_as_tenant(:account)
+end
+```
+
+### Switching between accounts
+
+When building your customized account switcher, redirect your user to `switch_account_path`. 
+
+```ruby
+current_user.accounts.each do |account|
+ button_to account.name, switch_account_path(account), method: :patch
+end
+```
+
+Installation
+------------
+
+Add the following line to Gemfile:
+
+```ruby
+gem "teamable", "~> 1.0"
+```
+
+and run `bundle install` from your terminal to install it.
+
+Getting started
+---------------
+
+**Teamable** expects a `User` model to be present and authenticatable before being installed. It also expects your application to respond properly to `current_user` and `user_signed_in?`. An authentication gem like [Authenticatable](https://github.com/kiqr/authenticatable) is recommended, but this gem should also work great with [Devise](https://github.com/heartcombo/devise), other gems or a custom solution. 
+
+#### Run the install generator
+
+Our next step is to run the install generator. To run the installer run the following command:
+
+```console
+$ rails g teamable:install
+```
+
+This will generate two models, `Member` & `Account` with configuration for teamable, migration files and `teamable` routes. It will also inject the `Teamable::Models::User` concern into your `User`-model. The output should be something similar to:
+
+```console
+foo@bar:~$ rails g teamable:install
+      insert  app/models/user.rb
+      create  app/models/account.rb
+      create  app/models/member.rb
+      create  db/migrate/20211010111722_teamable_create_accounts.rb
+      create  db/migrate/20211010111723_teamable_create_members.rb
+       route  teamable "organizations"
+```
+
+Contributing
+------------
+If you are interested in reporting/fixing issues and contributing directly to the code base, please see [CONTRIBUTING.md](CONTRIBUTING.md) for more information on what we're looking for and how to get started.
+
+Versioning
+----------
+This library aims to adhere to [Semantic Versioning 2.0.0](http://semver.org/). Violations
+of this scheme should be reported as bugs. Specifically, if a minor or patch
+version is released that breaks backward compatibility, that version should be
+immediately yanked and/or a new version should be immediately released that
+restores compatibility. Breaking changes to the public API will only be
+introduced with new major versions. As a result of this policy, you can (and
+should) specify a dependency on this gem using the [Pessimistic Version
+Constraint](http://guides.rubygems.org/patterns/#pessimistic-version-constraint) with two digits of precision. For example:
+
+```ruby
+gem "teamable", "~> 1.0"
+```
+
+License
+-------
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/app/controllers/teamable/accounts_controller.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Teamable
+  class AccountsController < TeamableController
+    skip_before_action :authenticate_account!, only: %i[new create switch]
+
+    # GET /account/new
+    def new
+      @account = current_user.accounts.new
+    end
+
+    # POST /account
+    def create
+      @account = current_user.accounts.build(account_params)
+      @account.members.build(user: current_user)
+
+      if @account.save
+        update_teamable_session_id!(@account.id)
+        redirect_to root_path, notice: "success"
+      else
+        render :new, status: :unprocessable_entity
+      end
+    end
+
+    def switch
+      account = current_user.accounts.find(params[:id])
+      update_teamable_session_id!(account.id)
+      redirect_to after_account_switched_path
+    end
+
+    private
+
+    # Only allow a list of trusted parameters through.
+    def account_params
+      params.require(:account).permit(:name, :billing_email)
+    end
+  end
+end

data/app/controllers/teamable/setup_controller.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Teamable
+  class SetupController < TeamableController
+    # GET /account/setup
+    def new
+      @account = current_user.accounts.new
+    end
+
+    # POST /account/setup
+    def create
+      @account = current_user.accounts.build(account_params)
+      @account.members.build(user: current_user)
+
+      if @account.save
+        update_teamable_session_id!(@account.id)
+        redirect_to root_path, notice: "success"
+      else
+        render :new, status: :unprocessable_entity
+      end
+    end
+
+    private
+
+    # Only allow a list of trusted parameters through.
+    def account_params
+      params.require(:account).permit(:name, :billing_email)
+    end
+  end
+end

data/app/controllers/teamable_controller.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class TeamableController < Teamable.config.parent_controller.constantize
+  before_action :authenticate_user!
+  before_action :authenticate_account!
+end

data/app/views/teamable/accounts/_form.html.erb

@@ -0,0 +1,7 @@
+<%= form_for @account, url: account_path, method: :post do |f| %>
+  <%= render 'teamable/shared/errors', resource: @account %>
+
+  <%= f.text_field :name, placeholder: "Account name" %><br>
+  <%= f.text_field :billing_email, placeholder: "Billing email" %><br>
+  <%= f.submit "Create account" %>
+<% end %>

data/app/views/teamable/accounts/new.html.erb

@@ -0,0 +1,6 @@
+<h2>New account</h2>
+<p>Create a new personal or team account</p>
+
+<%= render "teamable/shared/flash_messages" %>
+
+<%= render "form" %>

data/app/views/teamable/setup/_form.html.erb

@@ -0,0 +1,7 @@
+<%= form_for @account, url: setup_account_path, method: :post do |f| %>
+  <%= render 'teamable/shared/errors', resource: @account %>
+
+  <%= f.text_field :name, placeholder: "Account name" %><br>
+  <%= f.text_field :billing_email, placeholder: "Billing email" %><br>
+  <%= f.submit "Create account" %>
+<% end %>

data/app/views/teamable/setup/new.html.erb

@@ -0,0 +1,6 @@
+<h2>Setup your account</h2>
+<p>Finish the registration by setting up your account</p>
+
+<%= render "teamable/shared/flash_messages" %>
+
+<%= render "form" %>

data/app/views/teamable/shared/_errors.html.erb

@@ -0,0 +1,7 @@
+<% if resource.errors.any? %>
+  <ul>
+  <% resource.errors.full_messages.each do |message| %>
+    <li><%= message %></li>
+  <% end %>
+  </ul>
+<% end %>

data/app/views/teamable/shared/_flash_messages.html.erb

@@ -0,0 +1,3 @@
+<% flash.each do |key, value| %>
+  <%= content_tag :div, value, class: "flash #{key}" %>
+<% end %>

data/lib/generators/teamable/install_generator.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "rails/generators/base"
+require "rails/generators/active_model"
+require "rails/generators/active_record/migration"
+
+module Teamable
+  class InvalidUserModel < StandardError; end
+
+  class InstallGenerator < Rails::Generators::Base
+    include ActiveRecord::Generators::Migration
+    source_root File.expand_path("templates", __dir__)
+
+    def check_install_requirements
+      return if user_model_exists?
+
+      say "Teamable requires a User model to be present before you continue with the install", :red
+      say "Learn more at: https://github.com/kiqr/teamable#getting-started", :red
+      raise Teamable::InvalidUserModel, "Missing file: #{user_model_path}"
+    end
+
+    def inject_into_user_model
+      inject_into_class user_model_path, "User" do
+        "  include Teamable::Models::User\n"
+      end
+    end
+
+    def generate_models
+      template "models/account.tt", "app/models/account.rb"
+      template "models/member.tt", "app/models/member.rb"
+    end
+
+    def generate_migrations
+      migration_template "migrations/account.tt", "#{db_migrate_path}/teamable_create_accounts.rb"
+      migration_template "migrations/member.tt", "#{db_migrate_path}/teamable_create_members.rb"
+    end
+
+    def add_route
+      route 'teamable "account"'
+    end
+
+    private
+
+    def user_model_exists?
+      File.exist?(user_model_path)
+    end
+
+    def user_model_path
+      File.join(destination_root, "app/models/user.rb")
+    end
+  end
+end

data/lib/generators/teamable/templates/migrations/account.tt

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class TeamableCreateAccounts < ActiveRecord::Migration[5.2]
+  def change
+    create_table :accounts do |t|
+      t.string :name, null: false
+      t.string :billing_email, null: false
+      t.timestamps
+    end
+  end
+end

data/lib/generators/teamable/templates/migrations/member.tt

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class TeamableCreateMembers < ActiveRecord::Migration[5.2]
+  def change
+    create_table :members do |t|
+      t.references :user, foreign_key: { to_table: :users }
+      t.references :account, foreign_key: { to_table: :accounts }
+      t.string :invitee_email
+      t.string :role, nullable: false
+      t.timestamps
+    end
+  end
+end

data/lib/generators/teamable/templates/models/account.tt

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Account < ApplicationRecord
+  include Teamable::Models::Account
+end

data/lib/generators/teamable/templates/models/member.tt

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class Member < ApplicationRecord
+  include Teamable::Models::Member
+
+  AVAILABLE_ROLES = %w[member admin].freeze
+  FIRST_USER_ROLE = "admin" # Default role for the user who created the account.
+end

data/lib/teamable/controllers/current_account_helper.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Teamable
+  module Controllers
+    module CurrentAccountHelper
+      extend ActiveSupport::Concern
+
+      included do
+        before_action :load_current_account
+
+        if respond_to?(:helper_method)
+          helpers = %w[current_account account_selected?]
+          helper_method(*helpers)
+        end
+
+        rescue_from Teamable::MissingAccountError do
+          redirect_to setup_account_path
+        end
+      end
+
+      # Raise Teamable::MissingAccountError unless account_selected? is true.
+      def authenticate_account!
+        return unless user_signed_in?
+        return if teamable_controller?
+
+        raise Teamable::MissingAccountError unless account_selected?
+      end
+
+      # Access current team.
+      def current_account
+        @current_account ||= Teamable::Current.account
+      end
+
+      # Check if a team has been selected
+      def account_selected?
+        !!current_account
+      end
+
+      # Store an account id in a session variable.
+      # Warning: this does not validate that the current_user
+      # actually is a member of the specified account.
+      def update_teamable_session_id!(account_id)
+        session[:teamable_account_id] = account_id
+      end
+
+      private
+
+      # Load current account from Account model and store it
+      # in the Teamable::Current singleton.
+      def load_current_account
+        return unless user_signed_in?
+
+        Teamable::Current.account ||= account_from_session || fallback_account || nil
+      end
+
+      # Try to load current account using session[:teamable_account_id]
+      def account_from_session
+        return if session[:teamable_account_id].blank?
+
+        current_user.accounts.find_by(id: session[:teamable_account_id])
+      end
+
+      # Finds last joined account if the user have any associated accounts.
+      def fallback_account
+        memberships = current_user.members
+        return nil if memberships.length.zero?
+
+        memberships.last.account # Return last joined account.
+      end
+
+      # Check if the current controller is a TeamableController
+      def teamable_controller?
+        is_a?(::TeamableController)
+      end
+    end
+  end
+end

data/lib/teamable/controllers/url_helpers.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Teamable
+  module Controllers
+    module UrlHelpers
+      extend ActiveSupport::Concern
+
+      # Method references in Teamable::AccountsController#switch to redirect a user
+      # after they've switched to another account. You can override it in your
+      # ApplicationController to provide a custom url.
+      def after_account_switched_path
+        root_path
+      end
+    end
+  end
+end

data/lib/teamable/current.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Teamable
+  # Global class that holds the current user's selected team.
+  class Current < ActiveSupport::CurrentAttributes
+    attribute :account
+  end
+end

data/lib/teamable/engine.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Teamable
+  # Makes Teamable available to Rails as an Engine.
+  class Engine < ::Rails::Engine
+    initializer "teamable.setup" do
+      # Make teamable helpers available in controllers.
+      ActionController::Base.include Teamable::Controllers::CurrentAccountHelper
+      ActionController::Base.include Teamable::Controllers::UrlHelpers
+    end
+  end
+end

data/lib/teamable/errors/missing_account_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Teamable
+  class MissingAccountError < StandardError
+  end
+end

data/lib/teamable/models/account.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Teamable
+  module Models
+    module Account
+      extend ActiveSupport::Concern
+
+      included do
+        has_many :members
+        has_many :users, through: :members
+
+        validates :name, presence: true
+        validates :billing_email, presence: true, uniqueness: true
+        validates_format_of :billing_email, with: Teamable.config.email_regexp
+      end
+    end
+  end
+end

data/lib/teamable/models/member.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Teamable
+  module Models
+    module Member
+      extend ActiveSupport::Concern
+
+      included do
+        belongs_to :user
+        belongs_to :account
+
+        before_validation :set_owner_default_role, on: :create
+        validates :role, presence: true
+        validates_format_of :invitee_email, with: Teamable.config.email_regexp, allow_blank: true
+        validates_inclusion_of :role, in: proc { ::Member::AVAILABLE_ROLES }
+      end
+
+      # Temporary store an invitee's email for validation.
+      attr_accessor :invitee_email
+
+      def role_name
+        role.capitalize
+      end
+
+      def role?(input)
+        role.include? input.to_s
+      end
+
+      private
+
+      def set_owner_default_role
+        self.role = ::Member::FIRST_USER_ROLE if role.nil?
+      end
+    end
+  end
+end

data/lib/teamable/models/user.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Teamable
+  module Models
+    module User
+      extend ActiveSupport::Concern
+
+      included do
+        has_many :members
+        has_many :accounts, through: :members
+      end
+    end
+  end
+end

data/lib/teamable/routes.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ActionDispatch
+  module Routing
+    class Mapper
+      def teamable(team_label, options = {}, &block)
+        options[:path] ||= team_label.to_s
+
+        teamable_scope options do
+          teamable_accounts(options)
+          yield block if block_given?
+        end
+      end
+
+      protected
+
+      def teamable_scope(options, &block)
+        scope options[:path], module: "teamable", &block
+      end
+
+      def teamable_accounts(_options)
+        resource :account, only: %i[new create], path: "" do
+          get :setup, to: "setup#new"
+          post :setup, to: "setup#create"
+          patch ":id/switch", to: "accounts#switch", as: :switch
+        end
+      end
+    end
+  end
+end

data/lib/teamable/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Teamable
+  VERSION = "0.0.1.alpha"
+end

data/lib/teamable.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "teamable/current"
+require "teamable/routes"
+require "teamable/version"
+
+require "teamable/engine"
+
+require "dry-configurable"
+
+# Enable role based multi-user accounts (teams/organizations) in Rails.
+module Teamable
+  extend Dry::Configurable
+
+  module Controllers
+    autoload :CurrentAccountHelper, "teamable/controllers/current_account_helper"
+    autoload :UrlHelpers, "teamable/controllers/url_helpers"
+  end
+
+  module Models
+    autoload :Account, "teamable/models/account"
+    autoload :Member, "teamable/models/member"
+    autoload :User, "teamable/models/user"
+  end
+
+  autoload :MissingAccountError, "teamable/errors/missing_account_error"
+
+  # The controller class that all Teamable controllers will inherit from.
+  # Defaults to `ApplicationController`.
+  setting :parent_controller, "ApplicationController"
+
+  # Email regex used to validate email formats. It simply asserts that
+  # one (and only one) @ exists in the given string. This is mainly
+  # to give user feedback and not to assert the e-mail validity.
+  setting :email_regexp, /\A[^@\s]+@[^@\s]+\z/
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: teamable
+version: !ruby/object:Gem::Version
+  version: 0.0.1.alpha
+platform: ruby
+authors:
+- Rasmus Kjellberg
+- KIQR
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-10-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-configurable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+description:
+email: hello@kiqr.dev
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- README.md
+- app/controllers/teamable/accounts_controller.rb
+- app/controllers/teamable/setup_controller.rb
+- app/controllers/teamable_controller.rb
+- app/views/teamable/accounts/_form.html.erb
+- app/views/teamable/accounts/new.html.erb
+- app/views/teamable/setup/_form.html.erb
+- app/views/teamable/setup/new.html.erb
+- app/views/teamable/shared/_errors.html.erb
+- app/views/teamable/shared/_flash_messages.html.erb
+- lib/generators/teamable/install_generator.rb
+- lib/generators/teamable/templates/migrations/account.tt
+- lib/generators/teamable/templates/migrations/member.tt
+- lib/generators/teamable/templates/models/account.tt
+- lib/generators/teamable/templates/models/member.tt
+- lib/teamable.rb
+- lib/teamable/controllers/current_account_helper.rb
+- lib/teamable/controllers/url_helpers.rb
+- lib/teamable/current.rb
+- lib/teamable/engine.rb
+- lib/teamable/errors/missing_account_error.rb
+- lib/teamable/models/account.rb
+- lib/teamable/models/member.rb
+- lib/teamable/models/user.rb
+- lib/teamable/routes.rb
+- lib/teamable/version.rb
+homepage: https://github.com/kiqr/teamable
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/kiqr/teamable/issues
+  documentation_uri: https://github.com/kiqr/teamable/issues
+  source_code_uri: https://github.com/kiqr/teamable
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.2.26
+signing_key:
+specification_version: 4
+summary: Extension to enable teams for Authenticatable
+test_files: []