propel_api 0.2.1 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8fb51b38b12561c709712a339a39cf3639cd1e8a16149f72c00f1566ee37bdcf
-  data.tar.gz: a90352463962e6385b895cf339195b6860f0d5e98ccf1c4e6e3237957f6895cf
+  metadata.gz: 8891f7c2c3ace04fe703d6613d1a2595e19ed7ecaf89ecf960c3000bd1b00e0d
+  data.tar.gz: c51158c13407e9b91b01eb10d27b8bb89f5c80517855737a684e6f1fba88eac3
 SHA512:
-  metadata.gz: a2d01e1bcc8f7a749e8de4101d6f7be9dc5c4a7b2b0f2b7d5dc78e630dbba0102cedee82ff957cd210bde487a66c0b936a546b50c75f38e45db84dabcc74e6d0
-  data.tar.gz: 94dad0a33d4fd5af9327d42b21faa0a69bcdd7a018d914293db3643e68496b4b4f979d99cb14f8683b0df3040f6f15b55b6c4ff47c72015da9eaf6d336d5fb83
+  metadata.gz: c22770ffc6b60119d08f3f8d0e8d6d5f3520f9518b9cedf2c2ae0ad5dbe2e1cc5c98577cdf4639f228b66796a60dbbe901fbbaeb69ee5aaecdc96630a418a116
+  data.tar.gz: ea3cbbc43f1f827ceebb10d9e64cc56374ef8d0dbb24e015608bba00bfa1a9608d27edf343c7e2f9677ed049df906a5a1bf45af1161a85bb5d5a85646e67253c

data/CHANGELOG.md

@@ -10,9 +10,106 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Planned Features
 - GraphQL adapter support
 
+## [0.3.1] - 2025-09-11
+
+### 🎉 New Features
+- **Full Stack and API-Only Rails App Support**: Enhanced architecture for different Rails application types
+  - New dedicated `api_base_controller.rb` template for API-only applications
+  - Improved controller template organization with better separation of concerns
+  - Enhanced CSRF error handling with dedicated `PropelApiCsrfError` class
+  - Better support for both full-stack Rails apps and API-only applications
+
+### 🔧 Enhanced Polymorphic Support
+- **Improved Polymorphic Generators**: Enhanced automatic fixture and test generation with --parents flag
+  - Better polymorphic association handling in controller and model generators
+  - Automatic fixture template adoption for polymorphic relationships
+  - Enhanced agency-organization relationship support in polymorphic contexts
+- **URL/Website/Domain Support**: Enhanced template handling for URL, website, and domain fields
+  - Improved model templates for URL validation and formatting
+  - Better seed data generation for URL-type fields
+  - Enhanced test coverage for URL/domain fields in fixtures and integration tests
+
+### 🛠️ Generator Improvements  
+- **Enhanced Core Named Base**: Improved polymorphic association detection and fixture generation
+  - Better template processing for polymorphic relationships
+  - Enhanced fixture name resolution and parent type selection
+  - Improved error handling for polymorphic parent specifications
+- **Template System Enhancements**: Upgraded all ERB templates for better polymorphic handling
+  - Consistent fixture template adoption across all generators
+  - Better integration with PropelAuthentication fixture patterns
+  - Enhanced test template generation with polymorphic parameter support
+- **Controller Architecture Improvements**: Enhanced controller template system
+  - Updated Graphiti and PropelFacets controller templates for better inheritance
+  - Improved controller base class organization and method visibility
+
+### 🐛 Bug Fixes
+- **Gem Installation**: Fixed issues with gems not being included when commented out in Gemfile
+- **Integration Test Templates**: Enhanced error handling and parameter validation in generated integration tests
+
+### ⚠️ Breaking Changes
+- **REQUIRED --parents for Polymorphic**: Polymorphic associations now require explicit `--parents Parent1,Parent2` declaration. Auto-discovery fallback has been removed. Generator will block with confirmation if --parents is missing.
+
+## [0.3.0] - 2025-01-15
+
+### 🎉 Major Features Added
+- **Full Polymorphic Association Support**: Complete implementation of polymorphic relationships in API resources
+  - New `--parents` command-line option for specifying valid parent models
+  - Automatic generation of correct fixtures, tests, and API parameters
+  - Support for quote-free polymorphic syntax: `field_name:polymorphic`
+  - Enhanced fixture generation using Rails' `fixture_name (ModelName)` syntax
+
+### ⚠️ Breaking Changes
+- **Generator Syntax Change**: Tenancy associations are not automatically created you must pass organization:references and/or agency:references and configure the tenancy in the PropelApi configurations, any automated workflows or CI/CD that generate resources assuming the organization and/or agency references will be auto-injected will break with generator calls. 
+- **Required --parents Option**: Polymorphic resources now require `--parents field_name:Parent1,Parent2` for proper test generation
+- **Fixture Format Change**: Polymorphic fixtures now use `field_name: fixture_name (ParentClass)` instead of hardcoded IDs
+- **Test Template Updates**: All test templates now include polymorphic-aware parameter generation
+
+### 🔧 Generator Improvements
+- **Enhanced Resource Generator**: 
+  - Added polymorphic syntax conversion (`field_name:polymorphic` → `field_name:references{polymorphic}`)
+  - Improved argument processing to handle polymorphic parent specifications
+  - Fixed migration generation to use processed attributes instead of raw ARGV
+- **Smart Fixture References**: 
+  - Automatic fixture name resolution (e.g., uses `marketing_agency` instead of `one` for Agency models)
+  - Dynamic parent type selection for varied test data
+  - Proper Rails fixture syntax for polymorphic associations
+
+### 🧪 Test Generation Enhancements
+- **Model Tests**: 
+  - Polymorphic association validation with proper parent type checking
+  - Automatic setup of polymorphic parent variables (`@field_name`)
+  - Correct assertions for polymorphic relationships
+- **Controller Tests**: 
+  - Automatic inclusion of both `field_name_id` and `field_name_type` in test parameters
+  - Proper polymorphic parent setup in test fixtures
+- **Integration Tests**: 
+  - Enhanced error handling tests with polymorphic parameter support
+  - Multi-tenancy isolation tests work correctly with polymorphic associations
+  - Comprehensive API workflow testing
+
+### 🏗️ Architecture Improvements
+- **Named Base Enhancements**: 
+  - New `polymorphic_associations` helper method
+  - Enhanced `polymorphic_parent_for_fixture` with fixture name resolution
+  - Improved parent type parsing and validation
+- **Template System**: 
+  - All ERB templates now polymorphic-aware
+  - Consistent handling of polymorphic vs. regular references
+  - Better error handling and edge case management
+
+### 🐛 Bug Fixes
+- **Migration Constraints**: Fixed polymorphic migrations to use `polymorphic: true` instead of incorrect `foreign_key: true`
+- **Fixture Loading**: Resolved issues with hardcoded IDs causing fixture loading failures
+- **Test Isolation**: Fixed multi-tenancy tests failing due to missing polymorphic associations
+- **API Parameter Generation**: Corrected missing `_type` parameters in generated API calls
+
 ## [0.2.1] - 2025-01-14
 
 ### Fixed
+- **Critical Pagy pagination bug**: Fixed `NoMethodError: undefined method 'items' for Pagy` 
+  - API controller templates now use correct `pagy.limit` instead of non-existent `pagy.items`
+  - Fixes pagination metadata generation in API responses
+  - Affects all generated API controllers with pagination
 - **Dependency update**: Improved compatibility with PropelFacets 0.2.1
   - API controllers now work correctly with fixed `for_organization` scope installation
   - Resolves `NoMethodError` when using generated controllers in fresh Rails installations

data/README.md

@@ -49,13 +49,16 @@ After installation, you can remove the gem from your Gemfile. All functionality
 
 ```bash
 # Basic resource with PropelFacets
-rails generate propel_api User name:string email:string role:string
+rails generate propel_api:resource User name:string email:string role:string
 
 # Resource with associations
-rails generate propel_api Article title:string content:text user:references category:references
+rails generate propel_api:resource Article title:string content:text user:references category:references
 
-# Polymorphic associations
-rails generate propel_api Comment content:text commentable:references
+# 🎉 NEW: Polymorphic associations (v0.3.0) - REQUIRES --parents flag
+rails generate propel_api:resource Comment content:text commentable:references{polymorphic} --parents Post,Video,Product
+
+# Polymorphic with tenancy
+rails generate propel_api:resource Review rating:integer comment:text review_parent:polymorphic --parents Product,Agency
 
 # With Graphiti adapter
 rails generate propel_api Product name:string price:decimal --adapter=graphiti
@@ -70,6 +73,238 @@ This generates:
 - **Fixtures** with realistic test data
 - **Seeds** with Faker-generated sample data
 
+## 🎉 Polymorphic Association Support (v0.3.0)
+
+PropelApi now provides comprehensive support for polymorphic associations with automatic test generation and intelligent fixture management.
+
+### Quick Start with Polymorphic Resources
+
+```bash
+# Generate a Comment that can belong to Posts, Videos, or Products
+rails generate propel_api:resource Comment body:text commentable:references{polymorphic} --parents Post,Video,Product
+
+# Generate a Review with full tenancy support
+rails generate propel_api:resource Review rating:integer comment:text review_parent:references{polymorphic} --parents Product,Agency
+```
+
+### Key Features
+
+#### ✨ Simple, Intuitive Syntax
+- Additional support `field_name:polymorphic` instead of Rails' verbose `field_name:references{polymorphic}`
+- No need for complex quote escaping or nested syntax
+
+#### 🎯 Required Parent Specification
+- `--parents Parent1,Parent2,Parent3` defines valid parent models (REQUIRED for polymorphic associations)
+- Automatically generates varied test data using different parent types
+- Generator will block with confirmation if --parents is not provided
+
+#### 🧪 Complete Test Coverage
+- **Model Tests**: Proper polymorphic association validation and parent type checking
+- **Controller Tests**: Automatic inclusion of both `_id` and `_type` parameters
+- **Integration Tests**: Full API workflow testing with polymorphic data
+- **Fixtures**: Uses Rails' clean `fixture_name (ModelName)` syntax
+
+#### 🔧 Generated Code Quality
+```ruby
+# Generated Model
+class Comment < ApplicationRecord
+  belongs_to :commentable, polymorphic: true
+  # ... other associations and validations
+end
+
+# Generated Migration  
+def change
+  create_table :comments do |t|
+    t.text :body
+    t.references :commentable, polymorphic: true, null: false
+    # ... other fields
+  end
+end
+
+# Generated Fixtures (clean Rails syntax)
+one:
+  commentable: one (Post)
+  body: "Great post!"
+
+two:
+  commentable: featured_video (Video)
+  body: "Amazing video content!"
+```
+
+#### 🚀 API-Ready Controllers
+Controllers automatically include proper parameter handling:
+```ruby
+class Api::V1::CommentsController < Api::V1::ApiController
+  permitted_params :body, :commentable_id, :commentable_type
+end
+```
+
+### Breaking Changes from v0.2.x
+
+⚠️ **Migration Required**: The polymorphic syntax and test generation has been completely rewritten for better reliability and Rails compatibility.
+
+- **Old**: `rails generate propel_api:resource Comment body:text commentable:references{polymorphic}`
+- **New**: `rails generate propel_api:resource Comment body:text commentable:polymorphic --parents commentable:Post,Video`
+
+The new approach provides:
+- More reliable test generation
+- Better fixture management
+- Cleaner, more maintainable code
+- Full Rails compatibility
+
+## 🚀 API Explorer for Development
+
+PropelApi includes a comprehensive test application with multiple API resources perfect for development and testing. The dummy app provides a fully functional API with authentication, multi-tenancy, and polymorphic associations.
+
+### Quick Start with the Test API
+
+```bash
+# Navigate to the test application
+cd test/dummy
+
+# Set up the database
+rails db:setup
+
+# Start the development server
+rails server
+
+# Your API is now running at http://localhost:3000
+```
+
+### Available API Endpoints
+
+The dummy app provides these fully functional endpoints:
+
+#### Authentication
+- `POST /api/v1/signup` - User registration
+- `POST /api/v1/login` - User authentication  
+- `GET /api/v1/me` - Current user info
+- `DELETE /api/v1/logout` - Logout
+- `POST /api/v1/reset` - Password reset request
+- `PATCH /api/v1/reset` - Password reset update
+
+#### Core Resources
+- `GET|POST /api/v1/users` - User management
+- `GET|POST /api/v1/organizations` - Organization management
+- `GET|POST|PATCH|DELETE /api/v1/products` - Product CRUD
+- `GET|POST|PATCH|DELETE /api/v1/comments` - Comment CRUD
+- `GET|POST|PATCH|DELETE /api/v1/attachments` - File attachments
+- `GET|POST|PATCH|DELETE /api/v1/reviews` - Reviews (polymorphic!)
+
+### Setting Up API Explorer Tools
+
+#### Option 1: Postman Collection
+
+Create a Postman collection with these base settings:
+
+```json
+{
+  "info": {
+    "name": "PropelApi Development",
+    "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
+  },
+  "variable": [
+    {
+      "key": "base_url",
+      "value": "http://localhost:3000/api/v1",
+      "type": "string"
+    },
+    {
+      "key": "auth_token",
+      "value": "",
+      "type": "string"
+    }
+  ]
+}
+```
+
+#### Option 2: Insomnia Workspace
+
+1. Create a new workspace in Insomnia
+2. Set base URL: `http://localhost:3000/api/v1`
+3. Create environment variables:
+   - `base_url`: `http://localhost:3000/api/v1`
+   - `auth_token`: (will be populated after login)
+
+#### Option 3: cURL Scripts
+
+```bash
+# Login and get token
+TOKEN=$(curl -s -X POST http://localhost:3000/api/v1/login \
+  -H "Content-Type: application/json" \
+  -d '{"data": {"email_address": "test@example.com", "password": "password123"}}' \
+  | jq -r '.token')
+
+# Use token for authenticated requests
+curl -H "Authorization: Bearer $TOKEN" \
+     -H "Content-Type: application/json" \
+     http://localhost:3000/api/v1/me
+```
+
+### API Response Format
+
+All PropelApi endpoints follow consistent JSON:API-inspired formatting:
+
+```json
+{
+  "data": {
+    "id": 1,
+    "name": "Example Product",
+    "price": 99.99,
+    "organization": {
+      "id": 1,
+      "name": "Test Organization"
+    }
+  },
+  "meta": {
+    "total": 1,
+    "page": 1,
+    "limit": 25
+  }
+}
+```
+
+### Testing Polymorphic Associations
+
+The Reviews resource demonstrates polymorphic associations:
+
+```bash
+# Create a review for a product
+curl -X POST http://localhost:3000/api/v1/reviews \
+  -H "Authorization: Bearer $TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "data": {
+      "rating": 5,
+      "comment": "Great product!",
+      "reviewable_id": 1,
+      "reviewable_type": "Product"
+    }
+  }'
+
+# Create a review for an agency
+curl -X POST http://localhost:3000/api/v1/reviews \
+  -H "Authorization: Bearer $TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "data": {
+      "rating": 4,
+      "comment": "Good service!",
+      "reviewable_id": 1,
+      "reviewable_type": "Agency"
+    }
+  }'
+```
+
+### Development Tips
+
+1. **Seed Data**: Run `rails db:seed` to populate with realistic test data
+2. **Test User**: Default login is `test@example.com` / `password123`
+3. **Admin User**: Admin login is `admin@example.com` / `password123`
+4. **Multi-tenancy**: All resources are scoped to organizations automatically
+5. **Error Handling**: All endpoints return consistent error formats
+6. **Validation**: Try invalid data to see validation error responses
+
 ### Generate Controllers for Existing Models
 
 ```bash

data/lib/generators/propel_api/controller/controller_generator.rb

@@ -48,6 +48,11 @@ module PropelApi
                  type: :boolean,
                  default: false,
                  desc: "Include usage comments in generated controller"
+                 
+    class_option :parents,
+                 type: :hash,
+                 default: {},
+                 desc: "Specify parent types for polymorphic associations (e.g., --parents commentable:Post,Photo,Video)"
 
     def validate_model_exists
       # Ensure attributes are parsed before validation
@@ -64,6 +69,9 @@ module PropelApi
       if !options[:all_attributes] && (@attributes.nil? || @attributes.empty?) && model_file_exists
         show_auto_introspection_warning
       end      
+      # Process polymorphic parent information if provided
+      process_polymorphic_parents if options[:parents].present?
+      
       # Validate attributes if not using introspection
       validate_attributes_exist unless should_auto_introspect?
     end
@@ -110,6 +118,24 @@ module PropelApi
 
     private
 
+    def process_polymorphic_parents
+      # Convert _type attributes to polymorphic associations for template processing
+      options[:parents].each do |field_name, parent_list|
+        # Check if we have the corresponding _id and _type attributes
+        type_attr = @attributes.find { |attr| attr.name == "#{field_name}_type" }
+        id_attr = @attributes.find { |attr| attr.name == "#{field_name}_id" }
+        
+        if type_attr && id_attr
+          # Add a mock polymorphic attribute to @attributes for template processing
+          @attributes << OpenStruct.new(
+            name: field_name,
+            type: :references,
+            polymorphic?: true
+          )
+        end
+      end
+    end
+
     def route_name
       file_name.pluralize
     end

data/lib/generators/propel_api/core/named_base.rb

@@ -93,7 +93,7 @@ module PropelApi
           attributes << attr_data
         end
       end
-      
+
       # Look for basic validations that might indicate attributes
       # Exclude association names (they're already handled above as foreign keys)
       # NOTE: Only add validated attributes if they weren't already detected by schema introspection
@@ -514,5 +514,101 @@ module PropelApi
       
       content
     end
+
+    # Helper methods for templates to detect tenancy attributes
+    # These are shared between ResourceGenerator and ControllerGenerator
+    def has_organization_reference?
+      return false unless defined?(@attributes) && @attributes
+      @attributes.any? { |attr| attr.name == 'organization' && attr.type == :references }
+    end
+
+    def has_agency_reference?
+      return false unless defined?(@attributes) && @attributes
+      @attributes.any? { |attr| attr.name == 'agency' && attr.type == :references }
+    end
+
+    def has_user_reference?
+      return false unless defined?(@attributes) && @attributes
+      @attributes.any? { |attr| (attr.name == 'user' && attr.type == :references) || attr.name == 'user_id' }
+    end
+
+    # Polymorphic associations helper methods
+    def polymorphic_parent_types
+      @polymorphic_parent_types ||= parse_polymorphic_parent_types
+    end
+
+    def polymorphic_associations
+      return [] unless defined?(@attributes) && @attributes
+      
+      @polymorphic_associations ||= begin
+        polymorphic_attrs = @attributes.select { |attr| attr.type == :references && attr.respond_to?(:polymorphic?) && attr.polymorphic? }
+        
+        polymorphic_attrs.map do |attr|
+          parent_types = polymorphic_parent_types[attr.name.to_s] || discover_available_models.first(1)
+          
+          # Create one association entry per polymorphic field with all parent types
+          {
+            field_name: attr.name,
+            id_field: "#{attr.name}_id",
+            type_field: "#{attr.name}_type",
+            parent_types: parent_types,
+            # For fixture generation, we'll use the first parent type for fixture "one", second for "two", etc.
+            primary_parent_type: parent_types.first,
+            primary_parent_table: parent_types.first.underscore.pluralize
+          }
+        end
+      end
+    end
+
+    # Helper method for fixture generation to get the appropriate parent type for each fixture
+    def polymorphic_parent_for_fixture(field_name, fixture_index)
+      poly_assoc = polymorphic_associations.find { |assoc| assoc[:field_name].to_s == field_name.to_s }
+      return nil unless poly_assoc
+      
+      parent_types = poly_assoc[:parent_types]
+      parent_type = parent_types[fixture_index % parent_types.length] || parent_types.first
+      
+      # Determine the fixture name based on parent type and fixture index
+      fixture_name = case parent_type.underscore
+      when 'agency'
+        ['marketing_agency', 'tech_agency', 'sales_agency'][fixture_index] || 'marketing_agency'
+      else
+        ['one', 'two', 'three'][fixture_index] || 'one'
+      end
+      
+      {
+        id_field: poly_assoc[:id_field],
+        type_field: poly_assoc[:type_field],
+        parent_type: parent_type,
+        parent_table: parent_type.underscore.pluralize,
+        fixture_name: fixture_name
+      }
+    end
+
+    private
+
+    def parse_polymorphic_parent_types
+      return {} unless defined?(options) && options[:parents]
+      
+      parsed_types = {}
+      options[:parents].each do |field_name, parent_list|
+        parsed_types[field_name] = parent_list.split(',').map(&:strip).map(&:camelize)
+      end
+      parsed_types
+    end
+
+    def discover_available_models
+      # Auto-discover available models from app/models directory
+      models_dir = File.join(destination_root, 'app/models')
+      return ['Post'] unless File.directory?(models_dir) # Fallback
+      
+      model_files = Dir[File.join(models_dir, '*.rb')]
+      model_files.map do |file|
+        File.basename(file, '.rb').camelize
+      end.reject do |model|
+        # Skip common non-domain models
+        %w[ApplicationRecord Concerns].include?(model)
+      end.sort
+    end
   end
 end 

data/lib/generators/propel_api/core/relationship_inferrer.rb

@@ -106,20 +106,13 @@ class RelationshipInferrer
   end
   
   def polymorphic_belongs_to(attribute)
-    # Extract the base name for polymorphic association
-    if attribute.name.to_s.end_with?('_parent')
-      # resource_parent -> resource
-      base_name = attribute.name.to_s.gsub(/_parent$/, '')
-    elsif attribute.name.to_s.end_with?('able')
-      # commentable -> commentable
-      base_name = attribute.name.to_s
-    else
-      base_name = attribute.name.to_s
-    end
+    # Keep the full attribute name for polymorphic associations
+    # Don't strip the '_parent' suffix - it's needed to match the schema columns
+    association_name = attribute.name.to_s
     
     # Polymorphic associations default to required (Rails convention)
     # Add 'optional: true' manually if optional behavior is needed
-    "belongs_to :#{base_name}, polymorphic: true"
+    "belongs_to :#{association_name}, polymorphic: true"
   end
   
 

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

@@ -31,6 +31,12 @@ module PropelApi
       else
         say "Installing API controller with #{@adapter} adapter", :green
         say "Using namespace: #{namespace_display} version: #{version_display}", :blue
+        
+        # Create Api::BaseController first
+        create_api_base_controller
+        
+        # Optionally enhance CSRF error messages (non-breaking)
+        add_csrf_error_handling
       end
       
       case @adapter
@@ -107,6 +113,37 @@ module PropelApi
 
     private
 
+    def create_api_base_controller
+      template "controllers/api_base_controller.rb", "app/controllers/api/base_controller.rb"
+      say "Created Api::BaseController for CSRF-free API endpoints", :green
+    end
+
+    def add_csrf_error_handling
+      # Copy the error handler
+      template "errors/propel_api_csrf_error.rb", "app/errors/propel_api_csrf_error.rb"
+      
+      # Inject rescue_from into ApplicationController
+      inject_into_class "app/controllers/application_controller.rb", ApplicationController, <<-RUBY
+  # Enhanced CSRF error handling for JSON requests - added by PropelAPI
+  rescue_from ActionController::InvalidAuthenticityToken, with: :handle_propel_csrf_error
+  
+  private
+  
+  def handle_propel_csrf_error
+    if request.format.json? || request.content_type&.include?('application/json')
+      PropelApiCsrfError.handle_csrf_error_for_json(self)
+    else
+      raise ActionController::InvalidAuthenticityToken
+    end
+  end
+      RUBY
+      
+      say "Enhanced ApplicationController with helpful API guidance", :green
+    rescue => e
+      say "Could not inject CSRF error handling into ApplicationController: #{e.message}", :yellow
+      say "You can manually add the rescue_from handler if desired", :blue
+    end
+
     def copy_propel_facets_controller
       template "controllers/api_controller_propel_facets.rb", api_controller_path
       copy_example_controller
@@ -140,8 +177,8 @@ module PropelApi
 
     def add_propel_facets_gems
       add_gem_if_missing 'faker', '~> 3.5', 'Realistic seed data generation'
-      add_gem_if_missing 'pagy', '~> 9.0', 'Pagination for Propel Facets API'
-      add_gem_if_missing 'has_scope', '~> 0.8.0', 'Scope filtering for Propel Facets API'
+      add_gem_if_missing 'pagy', '~> 9.4', 'Pagination for Propel Facets API'
+      add_gem_if_missing 'has_scope', '~> 0.8.2', 'Scope filtering for Propel Facets API'
       add_gem_if_missing 'ransack', '~> 4.0', 'Advanced search for Propel Facets API'
       
       say "Don't forget to run: bundle install", :yellow