rails-rapido 0.8.0 → 0.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6eaff7850cbfee3ff250c0346fc8803ed9b29b6abe046622c72883eac6b3777
-  data.tar.gz: 61dfea4640f66a7fb095e618890b9224fcf3a0f371a6dbdcef9201194b1966b2
+  metadata.gz: ba95de45e5c2da70d27301f8e1dfa05aa67826b67e5181b1b0a1abf99c8364c1
+  data.tar.gz: 135e89202da1052dc49da04497896d4254fb63e20f096b6473c6ef62b66b7367
 SHA512:
-  metadata.gz: dd665acfb46b79e7b80704cc64ba8d3fbe8780c51cb7196a3d39552f036e2df35138cb442126d1f0ca08b23038ef185b8b538a4c62de42c7403c74e3a03b6fe5
-  data.tar.gz: c31a11e293f0e2deca6de6c69d504c1ef836c9424bb8bd18a409c1275f5030c55a5541a7751908f358fda3ed27dd56680c6bbf6407840d3a68b9ab5a7fcad6a6
+  metadata.gz: 7538a106aab6e8abce41e80fbf69809834bf798350298a23a695a98d9be9939f8e5f8721b4748b05d298f8249ec5b8196872279818b047ae43ba8d2e0c66aee7
+  data.tar.gz: afa72fbef3ad4a135dbddcb91ca8e2c2f0ecf7e1909ee863f9dc50d9a15fb0acbbf5df5a56790749e4ee63622ece92c245ef79df2f271072cb745c7908572c96

data/.rubocop.yml

@@ -1,124 +1,431 @@
+# Continue here: https://raw.githubusercontent.com/rubocop-hq/rubocop/master/config/default.yml
+# TODO: Skipped rails or naming or style
+
 AllCops:
-  TargetRubyVersion: 2.3
-  # RuboCop has a bunch of cops enabled by default. This setting tells RuboCop
-  # to ignore them, so only the ones explicitly set in this file are enabled.
-  DisabledByDefault: true
   Exclude:
-    - '**/templates/**/*'
-    - '**/vendor/**/*'
-    - 'actionpack/lib/action_dispatch/journey/parser.rb'
+    - 'node_modules/**/*'
+    - 'vendor/**/*'
+    - '.git/**/*'
+    - 'db/**/*'
+    - 'lib/tasks/cucumber.rake'
+    - 'config/routes.rb'
+    - 'features/**/*'
+  EnabledByDefault: false
+  DisabledByDefault: true
+
+require: rubocop-performance
+
+Bundler/DuplicatedGem:
+  Enabled: true
+
+Bundler/InsecureProtocolSource:
+  Enabled: true
+
+Bundler/OrderedGems:
+  Enabled: true
+
+Gemspec/DuplicatedAssignment:
+  Enabled: true
+
+Gemspec/OrderedDependencies:
+  Enabled: true
 
-# Prefer &&/|| over and/or.
-Style/AndOr:
+Gemspec/RequiredRubyVersion:
   Enabled: true
 
-# Do not use braces for hash literals when they are the last argument of a
-# method call.
-Style/BracesAroundHashParameters:
+Layout/BlockEndNewline:
   Enabled: true
 
-# Align `when` with `case`.
-Style/CaseIndentation:
+Layout/ClassStructure:
   Enabled: true
 
-# Align comments with method definitions.
-Style/CommentIndentation:
+Layout/ClosingParenthesisIndentation:
   Enabled: true
 
-# No extra empty lines.
-Style/EmptyLines:
+Layout/ConditionPosition:
   Enabled: true
 
-# In a regular class definition, no empty lines around the body.
-Style/EmptyLinesAroundClassBody:
+Layout/DefEndAlignment:
   Enabled: true
 
-# In a regular method definition, no empty lines around the body.
-Style/EmptyLinesAroundMethodBody:
+Layout/ElseAlignment:
   Enabled: true
 
-# In a regular module definition, no empty lines around the body.
-Style/EmptyLinesAroundModuleBody:
+Layout/EmptyLineBetweenDefs:
   Enabled: true
 
-# Use Ruby >= 1.9 syntax for hashes. Prefer { a: :b } over { :a => :b }.
-Style/HashSyntax:
+Layout/EmptyLines:
   Enabled: true
 
-# Method definitions after `private` or `protected` isolated calls need one
-# extra level of indentation.
-Style/IndentationConsistency:
+Layout/EmptyLinesAroundAccessModifier:
   Enabled: true
-  EnforcedStyle: rails
 
-# Two spaces, no tabs (for indentation).
-Style/IndentationWidth:
+Layout/EndAlignment:
   Enabled: true
 
-Style/SpaceAfterColon:
+Layout/EndOfLine:
   Enabled: true
 
-Style/SpaceAfterComma:
+Layout/EmptyLinesAroundArguments:
   Enabled: true
 
-Style/SpaceAroundEqualsInParameterDefault:
+Layout/IndentationWidth:
   Enabled: true
 
-Style/SpaceAroundKeyword:
+Layout/InitialIndentation:
   Enabled: true
 
-Style/SpaceAroundOperators:
+Layout/LeadingEmptyLines:
   Enabled: true
 
-Style/SpaceBeforeFirstArg:
-    Enabled: true
+Layout/SpaceAfterColon:
+  Enabled: true
+
+Layout/SpaceAfterComma:
+  Enabled: true
+
+Layout/SpaceAfterNot:
+  Enabled: true
+
+Layout/SpaceAfterSemicolon:
+  Enabled: true
+
+Layout/SpaceAroundEqualsInParameterDefault:
+  Enabled: true
+
+Layout/SpaceAroundKeyword:
+  Enabled: true
+
+Layout/SpaceBeforeComma:
+  Enabled: true
+
+Layout/SpaceInsideStringInterpolation:
+  Enabled: true
+
+Layout/IndentationStyle:
+  Enabled: true
+
+Layout/TrailingEmptyLines:
+  Enabled: true
+
+Layout/TrailingWhitespace:
+  Enabled: true
+
+Lint/AssignmentInCondition:
+  Enabled: true
+
+Lint/BooleanSymbol:
+  Enabled: true
+
+Lint/CircularArgumentReference:
+  Enabled: true
+
+Lint/Debugger:
+  Enabled: true
+
+Lint/DuplicateCaseCondition:
+  Enabled: true
+
+Lint/DuplicateMethods:
+  Enabled: true
+
+Lint/DuplicateHashKey:
+  Enabled: true
+
+Lint/EachWithObjectArgument:
+  Enabled: true
+
+Lint/ElseLayout:
+  Enabled: true
 
-# Defining a method with parameters needs parentheses.
-Style/MethodDefParentheses:
+Lint/EmptyEnsure:
   Enabled: true
 
-# Use `foo {}` not `foo{}`.
-Style/SpaceBeforeBlockBraces:
+Lint/EmptyExpression:
   Enabled: true
 
-# Use `foo { bar }` not `foo {bar}`.
-Style/SpaceInsideBlockBraces:
+Lint/EmptyInterpolation:
   Enabled: true
 
-# Use `{ a: 1 }` not `{a:1}`.
-Style/SpaceInsideHashLiteralBraces:
+Lint/EmptyWhen:
   Enabled: true
 
-Style/SpaceInsideParens:
+Lint/EnsureReturn:
   Enabled: true
 
-# Check quotes usage according to lint rule below.
-Style/StringLiterals:
+Lint/FloatOutOfRange:
   Enabled: true
-  EnforcedStyle: single_quotes
 
-# Detect hard tabs, no hard tabs.
-Style/Tab:
+Lint/FormatParameterMismatch:
   Enabled: true
 
-# Blank lines should not have any spaces.
-Style/TrailingBlankLines:
+Lint/SuppressedException:
   Enabled: true
 
-# No trailing whitespace.
-Style/TrailingWhitespace:
+Lint/ImplicitStringConcatenation:
   Enabled: true
 
-# Use quotes for string literals when they are enough.
-Style/UnneededPercentQ:
+Lint/IneffectiveAccessModifier:
   Enabled: true
 
-# Align `end` with the matching keyword or starting expression except for
-# assignments, where it should be aligned with the LHS.
-Lint/EndAlignment:
+Lint/InheritException:
+  Enabled: true
+
+Lint/InterpolationCheck:
+  Enabled: true
+
+Lint/LiteralAsCondition:
+  Enabled: true
+
+Lint/LiteralInInterpolation:
+  Enabled: true
+
+Lint/Loop:
+  Enabled: true
+
+Lint/MissingCopEnableDirective:
+  Enabled: true
+
+Lint/MultipleComparison:
+  Enabled: true
+
+Lint/NestedMethodDefinition:
+  Enabled: true
+
+Lint/NextWithoutAccumulator:
+  Enabled: true
+
+Lint/NonLocalExitFromIterator:
+  Enabled: true
+
+# This caused too much confusion.
+Lint/NumberConversion:
+  Enabled: false
+
+Lint/ParenthesesAsGroupedExpression:
+  Enabled: true
+
+Lint/PercentStringArray:
+  Enabled: true
+
+Lint/PercentSymbolArray:
+  Enabled: true
+
+Lint/RandOne:
+  Enabled: true
+
+Lint/RedundantWithIndex:
+  Enabled: true
+
+Lint/RedundantWithObject:
+  Enabled: true
+
+Lint/RegexpAsCondition:
   Enabled: true
-  EnforcedStyleAlignWith: variable
 
-# Use my_method(my_arg) not my_method( my_arg ) or my_method my_arg.
 Lint/RequireParentheses:
   Enabled: true
+
+Lint/RescueException:
+  Enabled: true
+
+Lint/RescueType:
+  Enabled: true
+
+Lint/ReturnInVoidContext:
+  Enabled: true
+
+Lint/SafeNavigationChain:
+  Enabled: true
+
+Lint/SafeNavigationConsistency:
+  Enabled: true
+
+Lint/ShadowedArgument:
+  Enabled: true
+
+Lint/ShadowedException:
+  Enabled: true
+
+Lint/ShadowingOuterLocalVariable:
+  Enabled: true
+
+Lint/RedundantStringCoercion:
+  Enabled: true
+
+Lint/Syntax:
+  Enabled: true
+
+Lint/UnderscorePrefixedVariableName:
+  Enabled: true
+
+Lint/UnifiedInteger:
+  Enabled: true
+
+Lint/RedundantRequireStatement:
+  Enabled: true
+
+Lint/RedundantSplatExpansion:
+  Enabled: true
+
+Lint/UnreachableCode:
+  Enabled: true
+
+Lint/UnusedBlockArgument:
+  Enabled: true
+
+Lint/UnusedMethodArgument:
+  Enabled: true
+
+Lint/UselessAccessModifier:
+  Enabled: true
+
+Lint/UselessAssignment:
+  Enabled: true
+
+Lint/BinaryOperatorWithIdenticalOperands:
+  Enabled: true
+
+Lint/UselessElseWithoutRescue:
+  Enabled: true
+
+Lint/UselessSetterCall:
+  Enabled: true
+
+Lint/Void:
+  Enabled: true
+  
+Metrics/AbcSize:
+  Enabled: true
+  Max: 150
+
+Metrics/BlockLength:
+  Enabled: true
+  Max: 100
+
+Metrics/BlockNesting:
+  Enabled: true
+  Max: 3
+
+Metrics/ClassLength:
+  Description: 'Avoid long classes'
+  Enabled: true
+  Max: 250
+
+Metrics/CyclomaticComplexity:
+  Enabled: true
+  Max: 12
+
+Layout/LineLength:
+  Enabled: true
+  Max: 200
+
+Metrics/MethodLength:
+  Description: 'Avoid long methods.'
+  Enabled: true
+  Max: 30
+
+Metrics/ModuleLength:
+  Description: 'Avoid long modules.'
+  Enabled: true
+  Max: 250
+
+Metrics/ParameterLists:
+  Description: 'Avoid long parameter lists.'
+  Enabled: true
+  Max: 100
+
+Metrics/PerceivedComplexity:
+  Enabled: true
+  Max: 15
+
+Performance/Caller:
+  Enabled: true
+
+Performance/Casecmp:
+  Enabled: true
+
+# TODO: Re-enable
+Performance/ChainArrayAllocation:
+  Enabled: false
+
+Performance/CompareWithBlock:
+  Enabled: true
+
+Performance/Count:
+  Enabled: true
+
+Performance/Detect:
+  Enabled: true
+
+Performance/DoubleStartEndWith:
+  Enabled: true
+
+Performance/EndWith:
+  Enabled: true
+
+Performance/FixedSize:
+  Enabled: true
+
+Performance/FlatMap:
+  Enabled: true
+
+Performance/InefficientHashSearch:
+  Enabled: true
+
+Performance/RangeInclude:
+  Enabled: true
+
+Performance/RedundantBlockCall:
+  Enabled: true
+
+Performance/RedundantMatch:
+  Enabled: true
+
+Performance/RedundantMerge:
+  Enabled: true
+
+Style/RedundantSortBy:
+  Enabled: true
+
+Performance/RegexpMatch:
+  Enabled: true
+
+Performance/ReverseEach:
+  Enabled: true
+
+Style/Sample:
+  Enabled: true
+
+Performance/Size:
+  Enabled: true
+
+Performance/StartWith:
+  Enabled: true
+
+Performance/StringReplacement:
+  Enabled: true
+
+Performance/TimesMap:
+  Enabled: true
+
+Performance/UnfreezeString:
+  Enabled: true
+
+Style/RedundantSort:
+  Enabled: true
+
+Security/Eval:
+  Enabled: true
+
+Security/JSONLoad:
+  Enabled: true
+
+Security/MarshalLoad:
+  Enabled: true
+
+Security/Open:
+  Enabled: true
+
+Security/YAMLLoad:
+  Enabled: true

data/.ruby-version

@@ -1 +1 @@
-2.6.5
+2.7.2

data/README.md

@@ -4,9 +4,53 @@
 
 Rapido is a simple, highly opinionated library that can be included into your Rails controllers to enforce standardized behavior and security.
 
+## Example
+
+Below is a typical example of a class using Rapido. More examples are available in the [dummy application](https://github.com/starfighterheavy/rapido/tree/master/test/dummy).
+
+```ruby
+# Create, Index: https://www.example.com/api/documents/
+# Show, update, delete: https://www.example.com/api/documents/123
+
+class DocumentsController < ApplicationController
+  include Rapido::ApiController
+  
+  attr_permitted :file, file_name, :category
+  
+  belongs_to :user, getter: :current_user
+  
+  present_with DocumentPresenter
+  
+  present_collection_with DocumentCollectionPresenter, :query # Query could be a string supplied as a URL parameter to search documents by name.
+end
+```
+
+Another example where records are automatically retrieved from route parameters.
+
+```ruby
+# Create, Index: https://www.example.com/api/documents/123/pages
+# Show, update, delete: https://www.example.com/api/documents/123/pages/345
+
+class PagesController < ApplicationController
+  include Rapido::ApiController
+  
+  attr_permitted :contents, :page_number
+  
+  belongs_to :document, owner: :current_user
+  
+  present_with PagePresenter
+  
+  present_collection_with PageCollectionPresenter
+end
+```
+
 ## API
 
-#### `belongs_to`
+### `attr_permitted`
+
+Accepts a list of symbols. These symbols specify the attributes that are supplied to StrongParameters as permitted parameters in `create` and `update` actions.
+
+### `belongs_to`
 
 Specifies the owner of the resource. For example, if many `Post` belonged to `User`, then in the `PostsController`, the following would be included: `belongs_to :user` and `Post` would be retrieved like so:
 
@@ -48,41 +92,56 @@ Default `[singular owner name]_id`. Specifies the param used as the owner's fore
 
 `User.find(params[:author_id]).posts.find(params[:id])`.
 
-#### `lookup_param`
+### `lookup_param`
 
 Specifies the param used to retrieve the resource. For example, if `Post` belongs to `User`, then in the `PostsController` if `lookup_param :token` is supplied, then the post would be retrieved like so: 
 
 `User.find_by(params[:id]).posts.find_by(token: params[:token])`.
 
-#### `presented_by`
+### `present_with`
 
 Specifies the class that will present the resource. This class must accept the resource as the only parameter at initialization, and respond to the `as_json` for output when used with the `Rapido::ApiController`.
 
 For example, if `params` contained a `:filter` parameter which should be used by the presenter , then the following would work:
 
-`presented_by WidgetsPresenter, :filter`
+`present_with WidgetsPresenter, :filter`
 
 The `initialize` method of the presenter should be structured as such:
 
 `def initialize(widgets, filter = nil)`
 
-#### `collection_presented_by`
+### `present_collection_with`
 
 Specifies the class that will present a collection of resources, as in the index method. Similar to `presented_by`, the class must accept the resource collection as the only argument at initialization, and respond to `as_json` for output when used with the `Rapido::ApiController`. The `collection_presented_by` can also accept a list of arguments, as symbols, that should be pulled from the `params` hash and passed to presenter class at initialization as optional argments.
 
-Collection presenters can also be provided args, similar to `presented_by`
+Collection presenters can also be provided args, similar to `present_with`
 
-#### `attr_permitted`
+### `permit_no_params!`
 
-Accepts a list of symbols. These symbols specify the attributes that are supplied to StrongParameters as permitted parameters in `create` and `update` actions.
+This will disallow any parameters in `create` and `update` actions.
 
-#### `permit_no_params!`
+## Filters
 
-This will disallow any parameters in `create` and `update` actions.
+The following filters are available to override, similar to the standard Rails action filters.
+
+#### Create
+
+* before_build
+* before_create
+* after_create_success
+* after_create_failure
+
+#### Destroy
+
+* before_destroy
+* after_destroy_success
 
-## Notes
+#### Update
 
-Authentication & AppController functionality will be deprecated in v0.6 and removed in v1.0. With the 1.0 release, Rapido will remove all functionality that is not strictly oriented to streamlining API Controller development and security.
+* before_assign_attributes
+* before_updat
+* after_update_success
+* after_update_failure
 
 ## Development
 

data/lib/rapido/api_controller.rb

@@ -1,6 +1,7 @@
 require 'active_support'
 require 'active_support/core_ext'
 require 'active_support/rescuable'
+require 'rapido/controller'
 require 'rapido/errors'
 
 module Rapido
@@ -10,6 +11,8 @@ module Rapido
     include Rapido::Errors
 
     included do
+      include Rapido::Controller
+
       rescue_from RecordNotFound do |e|
         render json: { errors: [ e.to_s ] }, status: 404
       end
@@ -18,21 +21,44 @@ module Rapido
     end
 
     def index
-      render json: present_resource_collection(resource_collection)
+      return if performed?
+      render json: resource_collection_presenter
     end
 
     def show
-      render json: present_resource(resource)
+      return if performed?
+      if request.format.to_sym == :json
+        if(params["filename"])
+          send_data resource_presenter.as_json.to_json, filename: params["filename"]
+        else
+          render json: resource_presenter
+        end
+      elsif request.format.to_sym == :xml
+        if(params["filename"])
+          send_data resource_presenter.to_xml, filename: params["filename"]
+        else
+          render xml: resource_presenter
+        end
+      elsif request.format.to_sym == :csv
+        if(params["filename"])
+          send_data resource_presenter.to_csv, filename: params["filename"]
+        else
+          render plain: resource_presenter.send("to_csv")
+        end
+      else
+        render json: resource_presenter
+      end
     end
 
     def create
+      return if performed?
       before_build
       new_resource = build_resource(resource_params)
       before_create(new_resource)
       if new_resource.save
         after_create_success(new_resource)
         return if performed?
-        render json: present_resource(new_resource), status: :created
+        render json: resource_presenter(new_resource), status: :created
       else
         after_create_failure(new_resource)
         return if performed?
@@ -41,7 +67,8 @@ module Rapido
     end
 
     def destroy
-      resource_before_destruction = present_resource(resource)
+      return if performed?
+      resource_before_destruction = resource_presenter
       before_destroy
       resource.destroy
       after_destroy_success
@@ -50,13 +77,14 @@ module Rapido
     end
 
     def update
+      return if performed?
       before_assign_attributes
       resource.assign_attributes(resource_params)
       before_update
       if resource.save
         after_update_success
         return if performed?
-        render json: present_resource(resource)
+        render json: resource_presenter
       else
         after_update_failure
         return if performed?
@@ -66,52 +94,63 @@ module Rapido
 
     private
 
-      def after_create_failure(new_resource)
-      end
+    def after_create_failure(new_resource)
+    end
 
-      def after_create_success(new_resource)
-      end
+    def after_create_success(new_resource)
+    end
 
-      def after_destroy_success
-      end
+    def after_destroy_success
+    end
 
-      def after_update_failure
-      end
+    def after_update_failure
+    end
 
-      def after_update_success
-      end
+    def after_update_success
+    end
 
-      def before_assign_attributes
-      end
+    def before_assign_attributes
+    end
 
-      def before_build
-      end
+    def before_build
+    end
 
-      def before_create(new_resource)
-      end
+    def before_create(new_resource)
+    end
 
-      def before_destroy
-      end
+    def before_destroy
+    end
 
-      def before_update
-      end
+    def before_update
+    end
 
-      def permit_only_allowed_actions
-        return unless allowed_actions
-        head :unauthorized unless allowed_actions.include?(params[:action].to_sym)
-      end
+    def permit_only_allowed_actions
+      return unless allowed_actions
+      head :unauthorized unless allowed_actions.include?(params[:action].to_sym)
+    end
 
-      def present_resource(resource)
+    def resource_presenter(new_resource = nil)
+      @resource_presenter ||= begin
         args = presenter_args.nil? ? nil : presenter_args.map { |arg| params[arg] }
-        return presenter.new(*[resource, *args]).as_json if presenter
-        resource.to_h
+        if presenter
+          presenter.new(new_resource || resource, *args)
+        else
+          (new_resource || resource).to_h
+        end
       end
+    end
 
-      def present_resource_collection(resource_collection)
+    def resource_collection_presenter
+      @resource_collection_presenter ||= begin
         args = collection_presenter_args.nil? ? nil : collection_presenter_args.map { |arg| params[arg] }
-        return collection_presenter.new(*[resource_collection, *args]).as_json if collection_presenter
-        return resource_collection.map { |r| presenter.new(r).as_json } if presenter
-        resource_collection.map(&:to_h)
+        if collection_presenter
+          collection_presenter.new(resource_collection, *args)
+        elsif presenter
+          resource_collection.map { |r| presenter.new(r) }
+        else
+          resource_collection.map(&:to_h)
+        end
       end
+    end
   end
 end

data/lib/rapido/controller.rb

@@ -97,136 +97,136 @@ module Rapido
 
     private
 
-      def allowed_actions
-        setting(:allowed_actions)
-      end
+    def allowed_actions
+      setting(:allowed_actions)
+    end
 
-      def build_resource(params = {})
-        return owner.send('build_' + resource_class_name, params) if setting(:has_one)
-        return owner.send(resource_class_name.pluralize).build(params) if owner && owner.respond_to?(resource_class_name.pluralize)
-        begin
-          send(:build)
-        rescue NoMethodError
-          raise 'Rapido::Controller must belong to something that responds to build or define a build method'
-        end
+    def build_resource(params = {})
+      return owner.send('build_' + resource_class_name, params) if setting(:has_one)
+      return owner.send(resource_class_name.pluralize).build(params) if owner && owner.respond_to?(resource_class_name.pluralize)
+      begin
+        send(:build)
+      rescue NoMethodError => _e
+        raise 'Rapido::Controller must belong to something that responds to build or define a build method'
       end
+    end
 
-      def collection_presenter
-        setting(:collection_presenter)
-      end
+    def collection_presenter
+      setting(:collection_presenter)
+    end
 
-      def collection_presenter_args
-        setting(:collection_presenter_args)
-      end
+    def collection_presenter_args
+      setting(:collection_presenter_args)
+    end
 
-      def owner_class
-        return nil unless setting(:owner_class)
-        @owner_class ||= begin
-          name = setting(:owner_class)
-          name.to_s.camelize.constantize
-        rescue NameError
-          raise BadOwnerClassName, name
-        end
+    def owner_class
+      return nil unless setting(:owner_class)
+      @owner_class ||= begin
+        name = setting(:owner_class)
+        name.to_s.camelize.constantize
+      rescue NameError
+        raise BadOwnerClassName, name
       end
+    end
 
-      def owner_class_name
-        @owner_class_name ||= owner_class.to_s.underscore
-      end
+    def owner_class_name
+      @owner_class_name ||= owner_class.to_s.underscore
+    end
 
-      def owner_lookup_param
-        @owner_lookup_param ||=
-          setting(:owner_lookup_param).to_s
-      end
+    def owner_lookup_param
+      @owner_lookup_param ||=
+        setting(:owner_lookup_param).to_s
+    end
 
-      def owner_lookup_field
-        @owner_lookup_field ||=
-          (setting(:owner_lookup_field) || owner_lookup_param).to_s
-      end
+    def owner_lookup_field
+      @owner_lookup_field ||=
+        (setting(:owner_lookup_field) || owner_lookup_param).to_s
+    end
 
-      def owner
-        @owner ||= begin
-          if setting(:owner_getter)
-            send(setting(:owner_getter))
-          elsif setting(:owner_class)
-            if setting(:owners_owner)
-              base = send(setting(:owners_owner)).send(owner_class_name.pluralize)
-            else
-              base = owner_class
-            end
-            base.find_by!(owner_lookup_field => params[owner_lookup_param])
+    def owner
+      @owner ||= begin
+        if setting(:owner_getter)
+          send(setting(:owner_getter))
+        elsif setting(:owner_class)
+          if setting(:owners_owner)
+            base = send(setting(:owners_owner)).send(owner_class_name.pluralize)
           else
-            nil
+            base = owner_class
           end
-        rescue ActiveRecord::RecordNotFound
-          raise RecordNotFound
+          base.find_by!(owner_lookup_field => params[owner_lookup_param])
+        else
+          nil
         end
+      rescue ActiveRecord::RecordNotFound
+        raise RecordNotFound
       end
+    end
 
-      def presenter
-        setting(:presenter)
-      end
+    def presenter
+      setting(:presenter)
+    end
 
-      def presenter_args
-        setting(:presenter_args)
-      end
+    def presenter_args
+      setting(:presenter_args)
+    end
 
-      def resource
-        @resource ||= begin
-          if setting(:has_one)
-            owner.send(resource_class_name)
-          elsif owner && owner.respond_to?(resource_class_name.pluralize)
-            owner
-              .send(resource_class_name.pluralize)
-              .find_by!(resource_lookup_param => params[resource_lookup_param])
-          else
-            begin NoMethodError
-                  send(:find)
-            rescue
-              raise 'Rapido::Controller must belong to something that has many or has one of resource, or define a find method'
-            end
+    def resource
+      @resource ||= begin
+        if setting(:has_one)
+          owner.send(resource_class_name)
+        elsif owner && owner.respond_to?(resource_class_name.pluralize)
+          owner
+            .send(resource_class_name.pluralize)
+            .find_by!(resource_lookup_param => params[resource_lookup_param])
+        else
+          begin
+            send(:find)
+          rescue  NoMethodError => _e
+            raise 'Rapido::Controller must belong to something that has many or has one of resource, or define a find method'
           end
-       rescue ActiveRecord::RecordNotFound
-         raise RecordNotFound
         end
+     rescue ActiveRecord::RecordNotFound
+       raise RecordNotFound
       end
+    end
 
-      def resource_class
-        @resource_class ||= resource_class_name.to_s.camelize.constantize
-      end
+    def resource_class
+      @resource_class ||= resource_class_name.to_s.camelize.constantize
+    end
 
-      def resource_class_name
-        self.class.resource_class_name
-      end
+    def resource_class_name
+      self.class.resource_class_name
+    end
 
       # Todo: FIXME
-      def resource_collection
-        @resource_collection ||= begin
-          if setting(:has_one)
-            owner.send(resource_class_name)
-          else
-            owner.send(resource_class_name.pluralize)
-          end
+    def resource_collection
+      @resource_collection ||= begin
+        if setting(:has_one)
+          owner.send(resource_class_name)
+        else
+          owner.send(resource_class_name.pluralize)
         end
       end
+    end
 
-      def resource_lookup_param
-        @resource_lookup_param ||=
-          setting(:resource_lookup_param) || :id
-      end
+    def resource_lookup_param
+      @resource_lookup_param ||=
+        setting(:resource_lookup_param) || :id
+    end
 
-      def resource_permitted_params
-        @resource_permitted_params ||=
-          setting(:resource_permitted_params)
-      end
+    def resource_permitted_params
+      @resource_permitted_params ||=
+        setting(:resource_permitted_params)
+    end
 
-      def resource_params
-        return {} if setting(:permit_no_params)
-        base = params.require(resource_class_name)
-        base.permit(resource_permitted_params)
-      end
+    def resource_params
+      return {} if setting(:permit_no_params)
+      base = params.require(resource_class_name)
+      base.permit(resource_permitted_params)
+    end
 
-      def setting(var)
-        self.class.instance_variable_get("@#{var}")
-      end
+    def setting(var)
+      self.class.instance_variable_get("@#{var}")
+    end
   end
 end

data/lib/rapido/version.rb

@@ -1,3 +1,3 @@
 module Rapido
-  VERSION = '0.8.0'
+  VERSION = '0.9.4'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-rapido
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.4
 platform: ruby
 authors:
 - Jonathan Kirst
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-20 00:00:00.000000000 Z
+date: 2021-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -83,7 +83,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Rails API Dryer-o