introspective_grape 0.4.3 → 0.5.4

data/lib/introspective_grape/api.rb

@@ -1,5 +1,6 @@
 require 'action_controller'
 require 'kaminari'
+#require 'byebug'
 require 'grape-kaminari'
 require 'introspective_grape/validators'
 
@@ -7,13 +8,16 @@ class IntrospectiveGrapeError < StandardError
 end
 
 module IntrospectiveGrape
+  # rubocop:disable Metrics/ClassLength
   class API < Grape::API::Instance
+    # rubocop:enable Metrics/ClassLength
     extend IntrospectiveGrape::Helpers
     extend IntrospectiveGrape::CreateHelpers
     extend IntrospectiveGrape::Filters
     extend IntrospectiveGrape::Traversal
     extend IntrospectiveGrape::Doc
     extend IntrospectiveGrape::SnakeParams
+    include Grape::Kaminari
 
     # Allow files to be uploaded through ActionController:
     ActionController::Parameters::PERMITTED_SCALAR_TYPES.push Rack::Multipart::UploadedFile, ActionController::Parameters
@@ -36,7 +40,7 @@ module IntrospectiveGrape
     # types for the attributes specified in a hash:
     #
     #  def self.grape_param_types
-    #   { "<attribute name>" => Virtus::Attribute::Boolean,
+    #   { "<attribute name>" => Grape::API::Boolean,
     #     "<attribute name>" => Integer,
     #     "<attribute name>" => String }
     #  end
@@ -48,30 +52,30 @@ module IntrospectiveGrape
     #
 
     class << self
-      PLURAL_REFLECTIONS = [ ActiveRecord::Reflection::HasManyReflection, ActiveRecord::Reflection::HasManyReflection].freeze
+      PLURAL_REFLECTIONS = [ActiveRecord::Reflection::HasManyReflection, ActiveRecord::Reflection::HasManyReflection].freeze
       # mapping of activerecord/postgres 'type's to ruby data classes, where they differ
-      Pg2Ruby = { datetime: DateTime }.freeze
+      PG2RUBY = { datetime: DateTime }.freeze
 
       def inherited(child)
         super(child)
         child.before do
           # Ensure that a user is logged in.
-          self.send(IntrospectiveGrape::API.authentication_method(self))
+          send(IntrospectiveGrape::API.authentication_method(self))
         end
 
         child.snake_params_before_validation if IntrospectiveGrape.config.camelize_parameters
       end
 
       # We will probably need before and after hooks eventually, but haven't yet...
-      #api_actions.each do |a|
-      #  define_method "before_#{a}_hook" do |model,params| ; end
-      #  define_method "after_#{a}_hook" do |model,params| ; end
-      #end
+      # api_actions.each do |a|
+      #   define_method "before_#{a}_hook" do |model, params| ; end
+      #   define_method "after_#{a}_hook" do |model, params| ; end
+      # end
 
+      # rubocop:disable Metrics/AbcSize
       def restful(model, strong_params=[], routes=[])
-        if model.respond_to?(:attribute_param_types)
-          raise IntrospectiveGrapeError.new("#{model.name}'s attribute_param_types class method needs to be changed to grape_param_types")
-        end
+        raise IntrospectiveGrapeError.new("#{model.name}'s attribute_param_types class method needs to be changed to grape_param_types") if model.respond_to?(:attribute_param_types)
+
         # Recursively define endpoints for the model and any nested models.
         #
         # model: the model class for the API
@@ -84,9 +88,9 @@ module IntrospectiveGrape
         begin ActiveRecord::Migration.check_pending! rescue return end
 
         # normalize the whitelist to symbols
-        strong_params.map!{|f| f.kind_of?(String) ? f.to_sym : f }
+        strong_params.map! {|f| f.is_a?(String) ? f.to_sym : f }
         # default to a flat representation of the model's attributes if left unspecified
-        strong_params = strong_params.blank? ? model.attribute_names.map(&:to_sym)-[:id, :updated_at, :created_at] : strong_params
+        strong_params = strong_params.blank? ? model.attribute_names.map(&:to_sym) - %i(id updated_at created_at) : strong_params
 
         # The strong params will be the same for all routes, differing from the Grape params
         # when routes are nested
@@ -109,14 +113,14 @@ module IntrospectiveGrape
         # recursively define endpoints
         model = routes.last.model || return
 
-        api_params.select{|a| a.kind_of?(Hash) }.each do |nested|
+        api_params.select {|a| a.is_a?(Hash) }.each do |nested|
           # Recursively add RESTful nested routes for every nested model:
-          nested.each do |r,fields|
+          nested.each do |r, fields|
             # Look at model.reflections to find the association's class name:
-            reflection_name = r.to_s.sub(/_attributes$/,'')
+            reflection_name = r.to_s.sub(/_attributes$/, '')
             begin
               relation = model.reflections[reflection_name].class_name.constantize
-            rescue
+            rescue StandardError
               Rails.logger.fatal "Can't find associated model for #{r} on #{model}"
             end
 
@@ -126,69 +130,18 @@ module IntrospectiveGrape
         end
       end
 
-      def convert_nested_params_hash(dsl, routes)
-        root  = routes.first
-        klass = root.klass
-        dsl.after_validation do
-          # After Grape validates its parameters:
-          # 1) Find the root model instance for the API if its passed (implicitly either
-          #    an update/destroy on the root node or it's a nested route
-          # 2) For nested endpoints convert the params hash into Rails-compliant nested
-          #    attributes, to be passed to the root instance for update. This keeps
-          #    behavior consistent between bulk and single record updates.
-
-          if params[root.key]
-            @model = root.model.includes( klass.default_includes(root.model) ).find(params[root.key])
-          end
-
-          if routes.size > 1
-            nested_attributes = klass.build_nested_attributes(routes[1..-1], params.except(root.key,:api_key) )
-            @params.merge!( nested_attributes ) if nested_attributes.kind_of?(Hash)
-          end
-        end
-      end
-
-      def define_restful_api(dsl, routes, model, api_params)
-        # declare index, show, update, create, and destroy methods:
-        API_ACTIONS.each do |action|
-          send("define_#{action}", dsl, routes, model, api_params) unless exclude_actions(model).include?(action)
-        end
-      end
-
-      def define_endpoints(routes,api_params)
-        # De-reference these as local variables from their class scope, or when we make
-        # calls to the API they will be whatever they were last set to by the recursive
-        # calls to "nest_routes".
-        routes     = routes.clone
-        api_params = api_params.clone
-
-        model     = routes.last.model || return
-
-        # We define the param keys for ID fields in camelcase for swagger's URL substitution,
-        # they'll come back in snake case in the params hash, the API as a whole is agnostic:
-        namespace = routes[0..-2].map{|p| "#{p.name.pluralize}/:#{p.swaggerKey}/" }.join + routes.last.name.pluralize
-
-        resource namespace do
-          convert_nested_params_hash(self, routes)
-          define_restful_api(self, routes, model, api_params)
-        end
-      end
-
       def define_index(dsl, routes, model, api_params)
-        include Grape::Kaminari
         root  = routes.first
         klass = routes.first.klass
         name  = routes.last.name.pluralize
         simple_filters(klass, model, api_params)
 
         dsl.desc "list #{name}" do
-          detail klass.index_documentation || "returns list of all #{name}"
+          detail klass.index_documentation(name)
         end
         dsl.params do
           klass.declare_filter_params(self, klass, model, api_params)
-        end
-        if klass.pagination
-          paginate per_page: klass.pagination[:per_page]||25, max_per_page: klass.pagination[:max_per_page], offset: klass.pagination[:offset]||0
+          use :pagination, per_page: klass.pagination[:per_page]||25, max_per_page: klass.pagination[:max_per_page], offset: klass.pagination[:offset]||0 if klass.pagination
         end
         dsl.get '/' do
           # Invoke the policy for the action, defined in the policy classes for the model:
@@ -196,10 +149,8 @@ module IntrospectiveGrape
 
           # Nested route indexes need to be scoped by the API's top level policy class:
           records = policy_scope( root.model.includes(klass.default_includes(root.model)) )
-
           records = klass.apply_filter_params(klass, model, api_params, params, records)
-
-          records = records.map{|r| klass.find_leaves( routes, r, params ) }.flatten.compact.uniq
+          records = records.map {|r| klass.find_leaves( routes, r, params ) }.flatten.compact.uniq
 
           # paginate the records using Kaminari
           records = paginate(Kaminari.paginate_array(records)) if klass.pagination
@@ -208,12 +159,12 @@ module IntrospectiveGrape
       end
 
       def define_show(dsl, routes, model, _api_params)
-        name = routes.last.name.singularize
+        name  = routes.last.name.singularize
         klass = routes.first.klass
         dsl.desc "retrieve a #{name}" do
-          detail klass.show_documentation || "returns details on a #{name}"
+          detail klass.show_documentation(name)
         end
-        dsl.get ":#{routes.last.swaggerKey}" do
+        dsl.get ":#{routes.last.swagger_key}" do
           authorize @model, :show?
           present klass.find_leaf(routes, @model, params), with: "#{klass}::#{model}Entity".constantize
         end
@@ -223,7 +174,7 @@ module IntrospectiveGrape
         name  = routes.last.name.singularize
         klass = routes.first.klass
         dsl.desc "create a #{name}" do
-          detail klass.create_documentation || "creates a new #{name} record"
+          detail klass.create_documentation(name)
         end
         dsl.params do
           klass.generate_params(self, :create, model, api_params, true)
@@ -236,18 +187,18 @@ module IntrospectiveGrape
 
       def define_update(dsl, routes, model, api_params)
         klass = routes.first.klass
-        name = routes.last.name.singularize
+        name  = routes.last.name.singularize
         dsl.desc "update a #{name}" do
-          detail klass.update_documentation || "updates the details of a #{name}"
+          detail klass.update_documentation(name)
         end
         dsl.params do
           klass.generate_params(self, :update, model, api_params, true)
         end
-        dsl.put ":#{routes.last.swaggerKey}" do
+        dsl.put ":#{routes.last.swagger_key}" do
           authorize @model, :update?
 
           @model.update_attributes!( safe_params(params).permit(klass.whitelist) )
-         
+
           if IntrospectiveGrape.config.skip_object_reload
             present klass.find_leaf(routes, @model, params), with: "#{klass}::#{model}Entity".constantize
           else
@@ -257,18 +208,66 @@ module IntrospectiveGrape
         end
       end
 
+      # rubocop:enable Metrics/AbcSize
       def define_destroy(dsl, routes, _model, _api_params)
         klass = routes.first.klass
         name = routes.last.name.singularize
         dsl.desc "destroy a #{name}" do
-          detail klass.destroy_documentation || "destroys the details of a #{name}"
+          detail klass.destroy_documentation(name)
         end
-        dsl.delete ":#{routes.last.swaggerKey}" do
+        dsl.delete ":#{routes.last.swagger_key}" do
           authorize @model, :destroy?
           present status: (klass.find_leaf(routes, @model, params).destroy ? true : false)
         end
       end
 
+      def convert_nested_params_hash(dsl, routes)
+        root  = routes.first
+        klass = self
+        dsl.after_validation do
+          next unless params[root.key] # there was no one, nothing to see
+
+          # After Grape validates its parameters:
+          # 1) Find the root model instance for the API if its passed (implicitly either
+          #    an update/destroy on the root node or it's a nested route
+          # 2) For nested endpoints convert the params hash into Rails-compliant nested
+          #    attributes, to be passed to the root instance for update. This keeps
+          #    behavior consistent between bulk and single record updates.
+          @model = root.model.includes( root.klass.default_includes(root.model) ).find(params[root.key])
+          @params.merge!( klass.merge_nested_params(routes, params) )
+        end
+      end
+
+      def merge_nested_params(routes, params)
+        attr = params.reject {|k| [routes.first.key, :api_key].include?(k) }
+        build_nested_attributes(routes[1..-1], attr)
+      end
+
+      def define_restful_api(dsl, routes, model, api_params)
+        # declare index, show, update, create, and destroy methods:
+        API_ACTIONS.each do |action|
+          send("define_#{action}", dsl, routes, model, api_params) unless exclude_actions(model).include?(action)
+        end
+      end
+
+      def define_endpoints(routes, api_params)
+        # De-reference these as local variables from their class scope, or when we make
+        # calls to the API they will be whatever they were last set to by the recursive
+        # calls to "nest_routes".
+        routes     = routes.clone
+        api_params = api_params.clone
+        model      = routes.last.model || return
+
+        # We define the param keys for ID fields in camelcase for swagger's URL substitution,
+        # they'll come back in snake case in the params hash, the API as a whole is agnostic:
+        namespace = routes[0..-2].map {|p| "#{p.name.pluralize}/:#{p.swagger_key}/" }.join + routes.last.name.pluralize
+
+        klass      = self # the 'resource' block changes the context to the Grape::API::Instance...
+        resource namespace do
+          klass.convert_nested_params_hash(self, routes)
+          klass.define_restful_api(self, routes, model, api_params)
+        end
+      end
 
       def build_routes(routes, model, reflection_name=nil)
         routes = routes.clone
@@ -278,21 +277,26 @@ module IntrospectiveGrape
         #
         # Constructs an array representation of the route's models and their associations,
         # a /root/:rootId/branch/:branchId/leaf/:leafId path would have flat array like
-        # [root,branch,leaf] representing the path structure and its models, used to
+        # [root, branch, leaf] representing the path structure and its models, used to
         # manipulate ActiveRecord relationships and params hashes and so on.
-        parent_model = routes.last.try(:model)
+        parent_model = routes.last&.model
         return routes if model == parent_model
 
-        name       = reflection_name || model.name.underscore
-        reflection = parent_model.try(:reflections).try(:fetch,reflection_name)
-        many       = parent_model && PLURAL_REFLECTIONS.include?( reflection.class ) ? true : false
-        swaggerKey = IntrospectiveGrape.config.camelize_parameters ? "#{name.singularize.camelize(:lower)}Id" : "#{name.singularize}_id"
+        name        = reflection_name || model.name.underscore
+        reflection  = parent_model&.reflections&.fetch(reflection_name)
+        swagger_key = IntrospectiveGrape.config.camelize_parameters ? "#{name.singularize.camelize(:lower)}Id" : "#{name.singularize}_id"
 
-        routes.push OpenStruct.new(klass: self, name: name, param: "#{name}_attributes", model: model, many?: many, key: "#{name.singularize}_id".to_sym, swaggerKey: swaggerKey, reflection: reflection)
+        routes.push OpenStruct.new(klass: self, name: name, param: "#{name}_attributes", model: model,
+                                   many?: plural?(parent_model, reflection),
+                                   key: "#{name.singularize}_id".to_sym,
+                                   swagger_key: swagger_key, reflection: reflection)
       end
 
+      def plural?(model, reflection)
+        (model && PLURAL_REFLECTIONS.include?(reflection.class))
+      end
 
-      def build_nested_attributes(routes,hash)
+      def build_nested_attributes(routes, hash)
         # Recursively re-express the flat attributes hash from nested routes as nested
         # attributes that can be used to perform an update on the root model.
 
@@ -313,13 +317,12 @@ module IntrospectiveGrape
         end
       end
 
-
-
       def generate_params(dsl, action, model, fields, is_root_endpoint=false)
         # We'll be doing a recursive walk (to handle nested attributes) down the
         # whitelisted params, generating the Grape param definitions by introspecting
         # on the model and its associations.
-        raise "Invalid action: #{action}" unless [:update, :create].include?(action)
+        raise "Invalid action: #{action}" unless %i(update create).include?(action)
+
         # dsl   : The Grape::Validations::ParamsScope object
         # action: create or update
         # model : The ActiveRecord model class
@@ -330,16 +333,16 @@ module IntrospectiveGrape
         fields -= [:id] if is_root_endpoint
 
         fields.each do |field|
-          if field.kind_of?(Hash)
-            generate_nested_params(dsl,action,model,field)
-          elsif (action==:create && param_required?(model,field) )
+          if field.is_a?(Hash)
+            generate_nested_params(dsl, action, model, field)
+          elsif action == :create && param_required?(model, field)
             # All params are optional on an update, only require them during creation.
             # Updating a record with new child models will have to rely on ActiveRecord
             # validations:
-            dsl.requires field, { type: param_type(model,field) }.merge( validations(model, field) )
+            dsl.requires field, { type: param_type(model, field) }.merge( validations(model, field) )
           else
-            #dsl.optional field, *options
-            dsl.optional field, { type: param_type(model,field) }.merge( validations(model, field) )
+            # dsl.optional field, *options
+            dsl.optional field, { type: param_type(model, field) }.merge( validations(model, field) )
           end
         end
       end
@@ -348,25 +351,23 @@ module IntrospectiveGrape
         (model.try(:grape_validations) || {}).with_indifferent_access[field] || {}
       end
 
-      def generate_nested_params(dsl,action,model,fields)
+      def generate_nested_params(dsl, action, model, fields)
         klass = self
-        fields.each do |r,v|
+        fields.each do |r, v|
           # Look at model.reflections to find the association's class name:
-          reflection = r.to_s.sub(/_attributes$/,'') # the reflection name
-          relation = begin model.reflections[reflection].class_name.constantize rescue model end
+          reflection = r.to_s.sub(/_attributes$/, '') # the reflection name
+          relation   = find_relation(model, reflection)
 
-          if is_file_attachment?(model,r)
+          if file_attachment?(model, r)
             # Handle Carrierwave file upload fields
-            s = [:filename, :type, :name, :tempfile, :head]-v
-            if s.present?
-              Rails.logger.warn "Missing required file upload parameters #{s} for uploader field #{r}"
-            end
-          elsif PLURAL_REFLECTIONS.include?( model.reflections[reflection].class )
+            s = %i(filename type name tempfile head) - v
+            Rails.logger.warn "Missing required file upload parameters #{s} for uploader field #{r}" if s.present?
+          elsif plural_reflection?(model, reflection)
             # In case you need a refresher on how these work:
             # http://api.rubyonrails.org/classes/ActiveRecord/NestedAttributes/ClassMethods.html
             dsl.optional r, type: Array do |dl|
-              klass.generate_params(dl,action,relation,v)
-              klass.add_destroy_param(dl,model,reflection) unless action==:create
+              klass.generate_params(dl, action, relation, v)
+              klass.add_destroy_param(dl, model, reflection, action)
             end
           else
             # TODO: handle any remaining correctly. Presently defaults to a Hash
@@ -374,50 +375,80 @@ module IntrospectiveGrape
             # ThroughReflection, HasOneReflection,
             # HasAndBelongsToManyReflection, BelongsToReflection
             dsl.optional r, type: Hash do |dl|
-              klass.generate_params(dl,action,relation,v)
-              klass.add_destroy_param(dl,model,reflection) unless action==:create
+              klass.generate_params(dl, action, relation, v)
+              klass.add_destroy_param(dl, model, reflection, action)
             end
           end
         end
       end
 
-      def is_file_attachment?(model,field)
-        model.respond_to?(:uploaders) && model.uploaders[field.to_sym] || # carrierwave
+      def plural_reflection?(model, reflection)
+        PLURAL_REFLECTIONS.include?( model.reflections[reflection].class )
+      end
+
+      def find_relation(model, reflection)
+        begin
+          model.reflections[reflection].class_name.constantize
+        rescue StandardError
+          model
+        end
+      end
+
+      def file_attachment?(model, field)
+        (model.respond_to?(:uploaders) && model.uploaders[field.to_sym]) || # carrierwave
           (model.respond_to?(:attachment_definitions) && model.attachment_definitions[field.to_sym]) ||
-          defined?(Paperclip::Attachment) && model.send(:new).try(field).kind_of?(Paperclip::Attachment)
+          (defined?(Paperclip::Attachment) && model.send(:new).try(field).is_a?(Paperclip::Attachment))
       end
 
-      def param_type(model,f)
+      def param_type(model, field)
         # Translate from the AR type to the GrapeParam types
-        f       = f.to_s
-        db_type = (model.try(:columns_hash)||{})[f].try(:type)
+        field   = field.to_s
+        db_type = (model&.try(:columns_hash) || {})[field]&.type
 
         # Check if it's a file attachment, look for an override class from the model,
-        # check Pg2Ruby, use the database type, or fail over to a String:
-        ( is_file_attachment?(model,f) && Rack::Multipart::UploadedFile ) ||
-          (model.try(:grape_param_types)||{}).with_indifferent_access[f]  ||
-          Pg2Ruby[db_type]                                                ||
-          begin db_type.to_s.camelize.constantize rescue nil end          ||
-          String
+        # check PG2RUBY, use the database type, or fail over to a String:
+        uploaded_file?(model, field)           ||
+          check_model_for_type(model, field)   ||
+          PG2RUBY[db_type]                     ||
+          db_type_constant(db_type)            ||
+          String # default to String if nothing else works
+      end
+
+      def uploaded_file?(model, field)
+        file_attachment?(model, field) && Rack::Multipart::UploadedFile
       end
 
-      def param_required?(model,f)
+      def check_model_for_type(model, field)
+        (model.try(:grape_param_types) || {}).with_indifferent_access[field]
+      end
+
+      def db_type_constant(db_type)
+        begin
+          db_type.to_s.camelize.constantize
+        rescue StandardError
+          nil
+        end
+      end
+
+      def param_required?(model, field)
         # Detect if the field is a required field for the create action
-        return false if skip_presence_validations.include?(f)
+        return false if skip_presence_validations.include?(field)
 
-        validated_field = f =~ /_id/ ? f.to_s.sub(/_id\z/,'').to_sym : f.to_sym
+        validated_field = field.match?(/_id/) ? field.to_s.sub(/_id\z/, '').to_sym : field.to_sym
 
-        model.validators_on(validated_field).any? {|v| v.kind_of? ActiveRecord::Validations::PresenceValidator }
+        model.validators_on(validated_field).any? {|v| v.is_a? ActiveRecord::Validations::PresenceValidator }
       end
 
-      def add_destroy_param(dsl,model,reflection)
-        raise "#{model} does not accept nested attributes for #{reflection}" if !model.nested_attributes_options[reflection.to_sym]
+      def add_destroy_param(dsl, model, reflection, action)
+        return if action == :create
+
+        raise "#{model} does not accept nested attributes for #{reflection}" unless model.nested_attributes_options[reflection.to_sym]
+
+        return unless model.nested_attributes_options[reflection.to_sym][:allow_destroy]
+
         # If destruction is allowed append the _destroy field
-        if model.nested_attributes_options[reflection.to_sym][:allow_destroy]
-          dsl.optional '_destroy', type: Integer
-        end
+        dsl.optional '_destroy', type: Integer
       end
-
     end
   end
 end

data/lib/introspective_grape/camel_snake.rb

@@ -8,10 +8,10 @@ if IntrospectiveGrape.config.camelize_parameters
     module ParseParamsWithCamelized
       def parse_params(params, path, method, _options = {})
         parsed_params = parse_params_without_camelized(params, path, method)
-        parsed_params.each_with_index do |param|
+        parsed_params.each do |param|
           param[:name] = param[:name]
-            .camelize(:lower)
-            .gsub(/Destroy/,'_destroy')
+                         .camelize(:lower)
+                         .gsub(/Destroy/, '_destroy')
         end
         super(params, path, method, _options = {})
       end
@@ -19,6 +19,7 @@ if IntrospectiveGrape.config.camelize_parameters
 
     module CreateCamelizedDocumentationClass
       private
+
       def create_documentation_class
         doc = super
         doc.class_eval do
@@ -29,6 +30,7 @@ if IntrospectiveGrape.config.camelize_parameters
     end
 
     Grape::API::Instance.singleton_class.send(:prepend, CreateCamelizedDocumentationClass)
+
   else
     module CallWithCamelized
       def call(*args)

data/lib/introspective_grape/create_helpers.rb

@@ -1,18 +1,17 @@
 module IntrospectiveGrape
   module CreateHelpers
-
     def add_new_records_to_root_record(dsl, routes, params, model)
       dsl.send(:authorize, model, :create?)
       ActiveRecord::Base.transaction do
         old = find_leaves(routes, model, params)
-        model.update_attributes( dsl.send(:safe_params,params).permit(whitelist) )
+        model.update_attributes( dsl.send(:safe_params, params).permit(whitelist) )
         new = find_leaves(routes, model, params)
-        old.respond_to?(:size) ? new-old : new
+        old.respond_to?(:size) ? new - old : new
       end
     end
 
     def create_new_record(dsl, routes, params)
-      model = routes.first.model.new( dsl.send(:safe_params,params).permit(whitelist) )
+      model = routes.first.model.new( dsl.send(:safe_params, params).permit(whitelist) )
       dsl.send(:authorize, model, :create?)
       model.save!
 
@@ -22,6 +21,5 @@ module IntrospectiveGrape
 
       find_leaves(routes, model, params)
     end
-
   end
 end

data/lib/introspective_grape/doc.rb

@@ -1,9 +1,23 @@
 module IntrospectiveGrape
   module Doc
-    def index_documentation; end
-    def show_documentation; end
-    def create_documentation; end
-    def update_documentation; end
-    def destroy_documentation; end
+    def index_documentation(name=nil)
+      "returns list of all #{name}"
+    end
+
+    def show_documentation(name=nil)
+      "returns details on a #{name}"
+    end
+
+    def create_documentation(name=nil)
+      "creates a new #{name} record"
+    end
+
+    def update_documentation(name=nil)
+      "updates the details of a #{name}"
+    end
+
+    def destroy_documentation(name=nil)
+      "destroys the details of a #{name}"
+    end
   end
 end