typical_situation 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e4c1f0edb5145c0cbeab8bd20520a2be77459ff68280f2dfd99350e51c66c288
+  data.tar.gz: f72c7aba90b5984f87ddd5cba2982c512292e4ac1f44603a07eec230db4ccdee
+SHA512:
+  metadata.gz: cee57ac0c5eea896aea026f06a9889cb832ce98a303e95a6a18d9b91fe9fee9d54a5bcb19fbfa8f52279a73416aa818a2fbb88335113c29c04d2b299ebc51b8e
+  data.tar.gz: de2e3f522926679ae805b952c06ca33409d953d0d4ed3a1482081337bc1d6b87ab20bc7bbc89727037deb5fca5cef51732972c158b13c60d593d1a4a774e1835

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 YOURNAME
+
+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,405 @@
+# Typical Situation [![Spec CI](https://github.com/apsislabs/typical_situation/workflows/Spec%20CI/badge.svg)](https://github.com/apsislabs/typical_situation/actions)
+
+The missing Ruby on Rails ActionController REST API mixin.
+
+A Ruby mixin (module) providing the seven standard resource actions & responses for an ActiveRecord :model_type & :collection.
+
+## Installation
+
+Tested in:
+
+- Rails 7.0
+- Rails 7.1  
+- Rails 8.0
+
+Against Ruby versions:
+
+- 3.2
+- 3.3
+- 3.4
+
+Add to your **Gemfile**:
+
+    gem 'typical_situation'
+
+**Legacy Versions**: For Rails 4.x/5.x/6.x support, see older versions of this gem. Ruby 3.0+ is required.
+
+## Usage
+
+### Define your model and methods
+
+Basic usage is to declare the `typical_situation`, and then two required helper methods. Everything else is handled automatically.
+
+```rb
+class PostsController < ApplicationController
+  include TypicalSituation
+
+  # Symbolized, underscored version of the model to use as the resource.
+  typical_situation :post # => maps to the Post model
+
+  private
+
+  # The collection of model instances.
+  def collection
+    current_user.posts
+  end
+
+  # Find a model instance by ID.
+  def find_in_collection(id)
+    collection.find_by_id(id)
+  end
+end
+```
+
+There are two alternative helper methods:
+
+#### Typical REST
+
+The typical REST helper is an alias for `typical_situation`, and defines the 7 standard REST endpoints: `index`, `show`, `new`, `create`, `edit`, `update`, `destroy`.
+
+```rb
+class PostsController < ApplicationController
+  include TypicalSituation
+
+  typical_rest :post
+
+  ...
+end
+```
+
+#### Typical CRUD
+
+Sometimes you don't need all seven endpoints, and just need standard CRUD. The typical CRUD helper defines the 4 standard CRUD endpoints: `create`, `show`, `update`, `destroy`.
+
+```rb
+class PostsController < ApplicationController
+  include TypicalSituation
+
+  typical_crud :post
+
+  ...
+end
+```
+
+#### Customizing defined endpoints
+
+You can also define only the endpoints you want by passing an `only` flag to `typical_situation`:
+
+```rb
+class PostsController < ApplicationController
+  include TypicalSituation
+
+  typical_situation :post, only: [:index, :show]
+
+  ...
+end
+```
+
+### Customize by overriding highly composable methods
+
+`TypicalSituation` is composed of a library of common functionality, which can all be overridden in individual controllers. Express what is _different_ & _special_ about each controller, instead of repeating boilerplate.
+
+The library is split into modules:
+
+- [identity](https://github.com/mars/typical_situation/blob/master/lib/typical_situation/identity.rb) - **required definitions** of the model & how to find it
+- [actions](https://github.com/mars/typical_situation/blob/master/lib/typical_situation/actions.rb) - high-level controller actions
+- [operations](https://github.com/mars/typical_situation/blob/master/lib/typical_situation/operations.rb) - loading, changing, & persisting the model
+- [permissions](https://github.com/mars/typical_situation/blob/master/lib/typical_situation/permissions.rb) - handling authorization to records and actions
+- [responses](https://github.com/mars/typical_situation/blob/master/lib/typical_situation/responses.rb) - HTTP responses & redirects
+
+#### Common Customization Hooks
+
+**Scoped Collections** - Filter the collection based on user permissions or other criteria:
+
+```ruby
+def scoped_resource
+  if current_user.admin?
+    collection
+  else
+    collection.where(published: true)
+  end
+end
+```
+
+**Custom Lookup** - Use different attributes for finding resources:
+
+```ruby
+def find_resource(param)
+  collection.find_by!(slug: param)
+end
+```
+
+**Custom Redirects** - Control where users go after actions:
+
+```ruby
+def after_resource_created_path(resource)
+  { action: :index }
+end
+
+def after_resource_updated_path(resource)
+  edit_resource_path(resource)
+end
+
+def after_resource_destroyed_path(resource)
+  { action: :index }
+end
+```
+
+**Sorting** - Set default sorting for index pages:
+
+```ruby
+def default_sorting_attribute
+  :created_at
+end
+
+def default_sorting_direction
+  :desc
+end
+```
+
+**Pagination** - Bring your own pagination solution:
+
+```ruby
+# Kaminari
+def paginate_resources(resources)
+  resources.page(params[:page]).per(params[:per_page] || 25)
+end
+
+# will_paginate
+def paginate_resources(resources)
+  resources.paginate(page: params[:page], per_page: params[:per_page] || 25)
+end
+
+ # Custom pagination
+ def paginate_resources(resources)
+   resources.limit(20).offset((params[:page].to_i - 1) * 20)
+end
+```
+
+**Strong Parameters** - Control which parameters are allowed for create and update operations:
+
+```ruby
+class PostsController < ApplicationController
+  include TypicalSituation
+  typical_situation :post
+
+  private
+
+  # Only allow title and content for new posts
+  def permitted_create_params
+    [:title, :content]
+  end
+
+  # Allow title, content, and published for updates
+  def permitted_update_params
+    [:title, :content, :published]
+  end
+end
+```
+
+By default, `TypicalSituation` permits all parameters (`permit!`) when these methods return `nil` or an empty array. Override them to restrict parameters for security.
+
+#### Authorization
+
+Control access to resources by overriding the `authorized?` method:
+
+```rb
+class PostsController < ApplicationController
+  include TypicalSituation
+  typical_situation :post
+
+  private
+
+  def authorized?(action, resource = nil)
+    case action
+    when :destroy, :update, :edit
+      resource&.user == current_user || current_user&.admin?
+    when :show
+      resource&.published? || resource&.user == current_user
+    else
+      true
+    end
+  end
+end
+```
+
+You can also customize the response when authorization is denied:
+
+```rb
+def respond_as_forbidden
+  redirect_to login_path, alert: "Access denied"
+end
+```
+
+##### CanCanCan
+
+```rb
+def authorized?(action, resource = nil)
+  can?(action, resource || model_class)
+end
+```
+
+##### Pundit
+
+```rb
+def authorized?(action, resource = nil)
+  policy(resource || model_class).public_send("#{action}?")
+end
+```
+
+#### Serialization
+
+Under the hood `TypicalSituation` calls `to_json` on your `ActiveRecord` models. This isn't always the optimal way to serialize resources, though, and so `TypicalSituation` offers a simple means of overriding the base Serialization --- either on an individual controller, or for your entire application.
+
+##### Alba
+
+```rb
+class MockApplePieResource
+  include Alba::Resource
+
+  attributes :id, :ingredients
+  
+  association :grandma, resource: GrandmaResource
+end
+
+class MockApplePiesController < ApplicationController
+  include TypicalSituation
+  typical_situation :mock_apple_pie
+
+  private
+
+  def serializable_resource(resource)
+    MockApplePieResource.new(resource).serialize
+  end
+
+  def collection
+    current_user.mock_apple_pies
+  end
+
+  def find_in_collection(id)
+    collection.find_by_id(id)
+  end
+end
+```
+
+##### ActiveModelSerializers
+
+```rb
+class MockApplePieIndexSerializer < ActiveModel::Serializer
+  attributes :id, :ingredients
+end
+
+module TypicalSituation
+  module Operations
+    def serializable_resource(resource)
+      if action_name == "index"
+        ActiveModelSerializers::SerializableResource.new(
+          resource,
+          each_serializer: MockApplePieIndexSerializer
+        )
+      else
+        ActiveModelSerializers::SerializableResource.new(resource)
+      end
+    end
+  end
+end
+```
+
+###### Fast JSON API
+
+```rb
+class MockApplePieSerializer
+  include FastJsonapi::ObjectSerializer
+  attributes :ingredients
+  belongs_to :grandma
+end
+
+class MockApplePiesController < ApplicationController
+  include TypicalSituation
+
+  def serializable_resource(resource)
+    MockApplePieSerializer.new(resource).serializable_hash
+  end
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies.
+
+### Local Setup
+
+1. Clone the repository
+2. Install dependencies:
+   ```bash
+   bundle install
+   ```
+3. Install appraisal gemfiles for testing across Rails versions:
+   ```bash
+   bundle exec appraisal install
+   ```
+
+### Running Tests
+
+Tests are written using [RSpec](https://rspec.info/) and are setup to use [Appraisal](https://github.com/thoughtbot/appraisal) to run tests over multiple Rails versions.
+
+Run all tests across all supported Rails versions:
+```bash
+bundle exec appraisal rspec
+```
+
+Run tests for a specific Rails version:
+```bash
+bundle exec appraisal rails_7.0 rspec
+bundle exec appraisal rails_7.1 rspec
+bundle exec appraisal rails_8.0 rspec
+```
+
+Run specific test files:
+```bash
+bundle exec rspec spec/path/to/spec.rb
+bundle exec appraisal rails_7.0 rspec spec/path/to/spec.rb
+```
+
+### Linting and Formatting
+
+This project uses [Standard Ruby](https://github.com/testdouble/standard) for code formatting and linting.
+
+Check for style violations:
+```bash
+bundle exec standardrb
+```
+
+Automatically fix style violations:
+```bash
+bundle exec standardrb --fix
+```
+
+Run both linting and tests (the default rake task):
+```bash
+bundle exec rake
+```
+
+### Console
+
+Start an interactive console to experiment with the gem:
+```bash
+bundle exec irb -r typical_situation
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/apsislabs/typical_situation.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+
+---
+
+# Built by Apsis
+
+[![apsis](https://s3-us-west-2.amazonaws.com/apsiscdn/apsis.png)](https://www.apsis.io)
+
+`typical_situation` was built by Apsis Labs. We love sharing what we build! Check out our [other libraries on Github](https://github.com/apsislabs), and if you like our work you can [hire us](https://www.apsis.io) to build your vision.

data/Rakefile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+begin
+  require "standard/rake"
+rescue LoadError
+  # Standard not available
+end
+
+task default: [:standard, :spec]

data/lib/typical_situation/actions.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module TypicalSituation
+  # Standard REST/CRUD actions.
+  module Actions
+    def index
+      raise TypicalSituation::ActionForbidden unless authorized?(:index)
+
+      get_resources
+      respond_with_resources
+    end
+
+    def show
+      get_resource
+      raise TypicalSituation::ActionForbidden unless authorized?(:show, @resource)
+
+      respond_with_resource
+    end
+
+    def edit
+      get_resource
+      raise TypicalSituation::ActionForbidden unless authorized?(:edit, @resource)
+
+      respond_with_resource
+    end
+
+    def new
+      raise TypicalSituation::ActionForbidden unless authorized?(:new)
+
+      new_resource
+      respond_with_resource
+    end
+
+    def update
+      get_resource
+      raise TypicalSituation::ActionForbidden unless authorized?(:update, @resource)
+
+      update_resource(@resource, update_params)
+      respond_as_changed
+    end
+
+    def destroy
+      get_resource
+      raise TypicalSituation::ActionForbidden unless authorized?(:destroy, @resource)
+
+      destroy_resource(@resource)
+      respond_as_gone
+    end
+
+    def create
+      raise TypicalSituation::ActionForbidden unless authorized?(:create)
+
+      @resource = create_resource(create_params)
+      respond_as_created
+    end
+  end
+end

data/lib/typical_situation/identity.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module TypicalSituation
+  # These Identity methods must be defined for each implementation.
+  module Identity
+    # Symbolized, underscored version of the model (class) to use.
+    def model_type
+      raise(NotImplementedError, "#model_type must be defined in the TypicalSituation implementation.")
+    end
+
+    def model_params
+      params.require(model_type.to_sym)
+    end
+
+    def create_params
+      if permitted_create_params.nil? || permitted_create_params.empty?
+        return model_params.permit!
+      end
+
+      model_params.permit(permitted_create_params)
+    end
+
+    def update_params
+      if permitted_update_params.nil? || permitted_update_params.empty?
+        return model_params.permit!
+      end
+
+      model_params.permit(permitted_update_params)
+    end
+
+    def permitted_create_params
+      nil
+    end
+
+    def permitted_update_params
+      nil
+    end
+
+    # The collection of model instances.
+    def collection
+      raise(NotImplementedError, "#collection must be defined in the TypicalSituation implementation.")
+    end
+
+    # Find a model instance by ID.
+    def find_in_collection(_id)
+      raise(NotImplementedError, "#find_in_collection must be defined in the TypicalSituation implementation.")
+    end
+
+    def include_root?
+      true
+    end
+
+    def plural_model_type
+      model_type.to_s.pluralize.intern
+    end
+
+    def location_url
+      return if @resource.nil? || @resource.new_record?
+
+      @resource.respond_to?(:to_url) ?
+        @resource.to_url : polymorphic_url(@resource)
+    end
+  end
+end

data/lib/typical_situation/operations.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module TypicalSituation
+  # Model operations.
+  # Assume that we're working w/ an ActiveRecord association collection.
+  module Operations
+    def scoped_resource
+      collection
+    end
+
+    def find_resource(param)
+      find_in_collection(param)
+    end
+
+    def default_sorting_attribute
+      nil
+    end
+
+    def default_sorting_direction
+      :asc
+    end
+
+    def paginate_resources(resources)
+      resources
+    end
+
+    def pagination_params
+      params.permit(:page, :per_page)
+    end
+
+    def get_resource
+      if (@resource = find_resource(params[:id]))
+        set_single_instance
+        @resource
+      else
+        raise ActiveRecord::RecordNotFound, "Could not find #{model_class}( id:#{params[:id].inspect} )"
+      end
+    end
+
+    def has_errors?
+      !@resource.errors.empty?
+    end
+
+    def get_resources
+      @resources = paginate_resources(apply_sorting(scoped_resource))
+      set_collection_instance
+      @resources
+    end
+
+    def new_resource
+      @resource = collection.build
+    end
+
+    def update_resource(resource, attrs)
+      resource.update(attrs)
+    end
+
+    def assign_resource(resource, attrs)
+      resource.assign_attributes(attrs)
+    end
+
+    def destroy_resource(resource)
+      resource.destroy
+      collection.reload if resource.errors.empty?
+      resource
+    end
+
+    def create_resource(attrs)
+      @resource = collection.create(attrs)
+    end
+
+    def build_resource(attrs)
+      @resource = collection.build(attrs)
+    end
+
+    def model_class
+      @model_class ||= model_type.to_s.camelize.constantize
+    end
+
+    def serialize_resource(resource, options = {})
+      serializable_resource(resource).to_json(options.merge(root: include_root?))
+    end
+
+    def serialize_resources(resources)
+      if include_root?
+        return {plural_model_type => serializable_resource(resources)}
+      end
+
+      serializable_resource(resources).to_json(root: false)
+    end
+
+    def serializable_resource(resource)
+      resource
+    end
+
+    # Set the singular instance variable named after the model. Modules are delimited with "_".
+    # Example: a MockApplePie resource is set to ivar @mock_apple_pie.
+    def set_single_instance
+      instance_variable_set(:"@#{model_type.to_s.gsub("/", "__")}", @resource)
+    end
+
+    # Set the plural instance variable named after the model. Modules are delimited with "_".
+    # Example: a MockApplePie resource collection is set to ivar @mock_apple_pies.
+    def set_collection_instance
+      instance_variable_set(:"@#{model_type.to_s.gsub("/", "__").pluralize}", @resources)
+    end
+
+    private
+
+    def apply_sorting(resources)
+      return resources unless default_sorting_attribute
+      resources.order(default_sorting_attribute => default_sorting_direction)
+    end
+  end
+end

data/lib/typical_situation/permissions.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module TypicalSituation
+  module Permissions
+    def authorized?(_action, _resource = nil)
+      true
+    end
+  end
+end

data/lib/typical_situation/responses.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module TypicalSituation
+  # Rails MIME responses.
+  module Responses
+    # Return the collection as HTML or JSON
+    #
+    def respond_with_resources
+      respond_to do |format|
+        yield(format) if block_given?
+
+        format.html do
+          set_collection_instance
+          render
+        end
+        format.json do
+          render json: serialize_resources(@resources)
+        end
+      end
+    end
+
+    # Return the resource as HTML or JSON
+    #
+    # A provided block is passed the #respond_to format to further define responses.
+    #
+    def respond_with_resource
+      respond_to do |format|
+        yield(format) if block_given?
+
+        format.html do
+          set_single_instance
+          render
+        end
+        format.json do
+          render json: serialize_resource(@resource)
+        end
+      end
+    end
+
+    def respond_as_changed
+      if has_errors?
+        respond_as_error
+      else
+        respond_to do |format|
+          yield(format) if block_given?
+
+          format.html do
+            set_single_instance
+            changed_so_redirect || render
+          end
+          format.json do
+            render json: serialize_resource(@resource)
+          end
+        end
+      end
+    end
+
+    def respond_as_created
+      if has_errors?
+        respond_as_error
+      else
+        respond_to do |format|
+          yield(format) if block_given?
+
+          format.html do
+            set_single_instance
+            changed_so_redirect || render
+          end
+          format.json do
+            render json: serialize_resource(@resource),
+              location: location_url,
+              status: :created
+          end
+        end
+      end
+    end
+
+    def respond_as_error
+      respond_to do |format|
+        yield(format) if block_given?
+
+        format.html do
+          set_single_instance
+          render action: (@resource.new_record? ? :new : :edit),
+            status: :unprocessable_entity
+        end
+        format.json do
+          render json: serialize_resource(@resource, methods: [:errors]),
+            status: :unprocessable_entity
+        end
+      end
+    end
+
+    def respond_as_gone
+      if has_errors?
+        respond_as_error
+      else
+        respond_to do |format|
+          yield(format) if block_given?
+
+          format.html do
+            set_single_instance
+            gone_so_redirect || render
+          end
+          format.json do
+            head :no_content
+          end
+        end
+      end
+    end
+
+    def respond_as_not_found
+      respond_to do |format|
+        yield(format) if block_given?
+
+        format.html do
+          raise ActionController::RoutingError, "Not Found"
+        end
+        format.json do
+          head :not_found
+        end
+      end
+    end
+
+    def respond_as_forbidden
+      respond_to do |format|
+        format.html { render plain: "Forbidden", status: :forbidden }
+        format.json { head :forbidden }
+      end
+    end
+
+    def after_resource_created_path(resource)
+      {action: :show, id: resource.id}
+    end
+
+    def after_resource_updated_path(resource)
+      {action: :show, id: resource.id}
+    end
+
+    def after_resource_destroyed_path(_resource)
+      {action: :index}
+    end
+
+    # HTML response when @resource saved or updated.
+    def changed_so_redirect
+      redirect_to after_resource_updated_path(@resource)
+      true
+    end
+
+    # HTML response when @resource deleted.
+    def gone_so_redirect
+      redirect_to after_resource_destroyed_path(@resource)
+      true
+    end
+  end
+end

data/lib/typical_situation/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module TypicalSituation
+  VERSION = "1.0.0"
+end

data/lib/typical_situation.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "typical_situation/identity"
+require "typical_situation/permissions"
+require "typical_situation/actions"
+require "typical_situation/operations"
+require "typical_situation/responses"
+
+module TypicalSituation
+  class Error < StandardError; end
+  class ActionForbidden < Error; end
+
+  include Identity
+  include Permissions
+  include Operations
+  include Responses
+
+  def self.included(base)
+    add_rescues(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    # Syntactic sugar for defining model_type
+    #
+    # Example:
+    #   class PostsController < ApplicationController
+    #     include TypicalSituation
+    #     typical_situation :post
+    #   end
+    #
+    # This is equivalent to:
+    #   def model_type
+    #     :post
+    #   end
+    def typical_situation(model_type_symbol, only: nil)
+      define_method :model_type do
+        model_type_symbol
+      end
+
+      if only
+        only.each do |action|
+          if TypicalSituation::Actions.method_defined?(action)
+            define_method(action, TypicalSituation::Actions.instance_method(action))
+          end
+        end
+      else
+        include TypicalSituation::Actions
+      end
+    end
+
+    def typical_rest(model_type_symbol)
+      typical_situation(model_type_symbol, only: nil)
+    end
+
+    def typical_crud(model_type_symbol)
+      typical_situation(model_type_symbol, only: %i[create show update destroy])
+    end
+  end
+
+  def self.add_rescues(action_controller)
+    action_controller.class_eval do
+      rescue_from ActiveRecord::RecordNotFound, with: :respond_as_not_found
+      rescue_from TypicalSituation::ActionForbidden, with: :respond_as_forbidden
+    end
+  end
+end

metadata

@@ -0,0 +1,220 @@
+--- !ruby/object:Gem::Specification
+name: typical_situation
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Mars Hall
+- Wyatt Kirby
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: combustion
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: factory_bot_rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails-controller-testing
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A module providing the seven standard resource actions & responses for
+  an ActiveRecord :model_type & :collection.
+email:
+- m@marsorange.com
+- wyatt@apsis.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/typical_situation.rb
+- lib/typical_situation/actions.rb
+- lib/typical_situation/identity.rb
+- lib/typical_situation/operations.rb
+- lib/typical_situation/permissions.rb
+- lib/typical_situation/responses.rb
+- lib/typical_situation/version.rb
+homepage: https://github.com/apsislabs/typical_situation
+licenses: []
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: The missing Rails ActionController REST API mixin.
+test_files: []