rest_framework 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96d6394bfb8dee90ee31a05289a86db5409a118a3d456b9bf927397ceea055a7
-  data.tar.gz: 6dc5181f02dafae6d0831a7802480375097836eb3e3e799c78076d0331a2f728
+  metadata.gz: 8ef7499f4d1e10af1f2520d3b9847dc7f711bd1c7f4377efe21bd5b60c0dd9a7
+  data.tar.gz: b15a9b0abee58e315fdc3a1157ca04d7051630821d3ed2ca691564966b5fefca
 SHA512:
-  metadata.gz: e811d984f82150ad789d1e3437fc178095dcaffa8270b15b96dd375d7dbf649e0983f8001a4fe09c4ea4abe89ba8c8cad9e44ae25c21bbecb65adf5542efd8fc
-  data.tar.gz: 1d64e212a2bb7331cba06020e9a9405b54ab558e691f4ef349ffc156a702f352209108fc62265b2ff8369a15656bdc4b158db13201b630d0ae3e2853e3b7c553
+  metadata.gz: fb586a083989a67f206d5b5d6c14eb546949569e384d3b44c870de5f49f610b5848d53da87e01234542705304dd7d49bcf6f0037f0b89331c7fa2a1b084422ce
+  data.tar.gz: fe4c960cda0d2a9ba43cb7d5b1cfa84963802800829323c26b350841bbd34290e68cbbc4f14a3138a1cb95a28aafff76b2d9a78a41772950e00ad80159c8f2f3

data/README.md

@@ -2,6 +2,7 @@
 
 [![Gem Version](https://badge.fury.io/rb/rest_framework.svg)](https://badge.fury.io/rb/rest_framework)
 [![Build Status](https://travis-ci.org/gregschmit/rails-rest-framework.svg?branch=master)](https://travis-ci.org/gregschmit/rails-rest-framework)
+[![Coverage Status](https://coveralls.io/repos/github/gregschmit/rails-rest-framework/badge.svg?branch=master)](https://coveralls.io/github/gregschmit/rails-rest-framework?branch=master)
 
 A framework for DRY RESTful APIs in Ruby on Rails.
 
@@ -78,8 +79,8 @@ class Api::ReadOnlyMoviesController < ApiController
 end
 ```
 
-Note that you can also override `get_model` and `get_recordset` instance methods to override the API
-behavior dynamically per-request.
+Note that you can also override the `get_recordset` instance method to override the API behavior
+dynamically per-request.
 
 ### Routing
 

data/lib/rest_framework.rb

@@ -4,8 +4,10 @@ end
 
 require_relative "rest_framework/controller_mixins"
 require_relative "rest_framework/engine"
+require_relative "rest_framework/errors"
 require_relative "rest_framework/filters"
 require_relative "rest_framework/paginators"
 require_relative "rest_framework/routers"
 require_relative "rest_framework/serializers"
 require_relative "rest_framework/version"
+require_relative "rest_framework/generators"

data/lib/rest_framework/VERSION_STAMP

@@ -1 +1 @@
-0.1.3
+0.2.0

data/lib/rest_framework/controller_mixins/base.rb

@@ -1,3 +1,4 @@
+require_relative '../errors'
 require_relative '../serializers'
 
 
@@ -33,6 +34,9 @@ module RESTFramework::BaseControllerMixin
 
       # Add class attributes (with defaults) unless they already exist.
       {
+        filter_pk_from_request_body: true,
+        exclude_body_fields: [:created_at, :created_by, :updated_at, :updated_by],
+        accept_generic_params_as_body_params: true,
         extra_actions: nil,
         extra_member_actions: nil,
         filter_backends: nil,
@@ -42,14 +46,16 @@ module RESTFramework::BaseControllerMixin
         page_size_query_param: 'page_size',
         max_page_size: nil,
         serializer_class: nil,
+        serialize_to_json: true,
+        serialize_to_xml: true,
         singleton_controller: nil,
         skip_actions: nil,
       }.each do |a, default|
         unless base.respond_to?(a)
           base.class_attribute(a)
 
-          # Set default manually so we can still support Rails 4. Maybe later we can use the
-          # default parameter on `class_attribute`.
+          # Set default manually so we can still support Rails 4. Maybe later we can use the default
+          # parameter on `class_attribute`.
           base.send(:"#{a}=", default)
         end
       end
@@ -60,10 +66,10 @@ module RESTFramework::BaseControllerMixin
         base.alias_method(:extra_collection_actions=, :extra_actions=)
       end
 
-      # skip csrf since this is an API
+      # Skip csrf since this is an API.
       base.skip_before_action(:verify_authenticity_token) rescue nil
 
-      # handle some common exceptions
+      # Handle some common exceptions.
       base.rescue_from(ActiveRecord::RecordNotFound, with: :record_not_found)
       base.rescue_from(ActiveRecord::RecordInvalid, with: :record_invalid)
       base.rescue_from(ActiveRecord::RecordNotSaved, with: :record_not_saved)
@@ -129,39 +135,42 @@ module RESTFramework::BaseControllerMixin
 
   # Helper to render a browsable API for `html` format, along with basic `json`/`xml` formats, and
   # with support or passing custom `kwargs` to the underlying `render` calls.
-  def api_response(payload, html_kwargs: nil, json_kwargs: nil, xml_kwargs: nil, **kwargs)
+  def api_response(payload, html_kwargs: nil, **kwargs)
     html_kwargs ||= {}
-    json_kwargs ||= {}
-    xml_kwargs ||= {}
-
-    # allow blank (no-content) responses
-    @blank = kwargs[:blank]
+    json_kwargs = kwargs.delete(:json_kwargs) || {}
+    xml_kwargs = kwargs.delete(:xml_kwargs) || {}
+
+    # Raise helpful error if payload is nil. Usually this happens when a record is not found (e.g.,
+    # when passing something like `User.find_by(id: some_id)` to `api_response`). The caller should
+    # actually be calling `find_by!` to raise ActiveRecord::RecordNotFound and allowing the REST
+    # framework to catch this error and return an appropriate error response.
+    if payload.nil?
+      raise RESTFramework::NilPassedToAPIResponseError
+    end
 
     respond_to do |format|
-      if @blank
-        format.json {head :no_content}
-        format.xml {head :no_content}
+      if payload == ''
+        format.json {head :no_content} if self.serialize_to_json
+        format.xml {head :no_content} if self.serialize_to_xml
       else
-        if payload.respond_to?(:to_json)
-          format.json {
-            jkwargs = kwargs.merge(json_kwargs)
-            render(json: payload, layout: false, **jkwargs)
-          }
-        end
-        if payload.respond_to?(:to_xml)
-          format.xml {
-            xkwargs = kwargs.merge(xml_kwargs)
-            render(xml: payload, layout: false, **xkwargs)
-          }
-        end
+        format.json {
+          jkwargs = kwargs.merge(json_kwargs)
+          render(json: payload, layout: false, **jkwargs)
+        } if self.serialize_to_json
+        format.xml {
+          xkwargs = kwargs.merge(xml_kwargs)
+          render(xml: payload, layout: false, **xkwargs)
+        } if self.serialize_to_xml
+        # TODO: possibly support more formats here if supported?
       end
       format.html {
         @payload = payload
-        @json_payload = ''
-        @xml_payload = ''
-        unless @blank
-          @json_payload = payload.to_json if payload.respond_to?(:to_json)
-          @xml_payload = payload.to_xml if payload.respond_to?(:to_xml)
+        if payload == ''
+          @json_payload = '' if self.serialize_to_json
+          @xml_payload = '' if self.serialize_to_xml
+        else
+          @json_payload = payload.to_json if self.serialize_to_json
+          @xml_payload = payload.to_xml if self.serialize_to_xml
         end
         @template_logo_text ||= "Rails REST Framework"
         @title ||= self.controller_name.camelize

data/lib/rest_framework/controller_mixins/models.rb

@@ -16,17 +16,18 @@ module RESTFramework::BaseModelControllerMixin
         model: nil,
         recordset: nil,
 
-        # Attributes for create/update parameters.
-        allowed_parameters: nil,
-        allowed_action_parameters: nil,
-
         # Attributes for configuring record fields.
         fields: nil,
         action_fields: nil,
 
+        # Attributes for create/update parameters.
+        allowed_parameters: nil,
+        allowed_action_parameters: nil,
+
         # Attributes for the default native serializer.
         native_serializer_config: nil,
-        native_serializer_action_config: nil,
+        native_serializer_singular_config: nil,
+        native_serializer_plural_config: nil,
 
         # Attributes for default model filtering (and ordering).
         filterset_fields: nil,
@@ -34,13 +35,13 @@ module RESTFramework::BaseModelControllerMixin
         ordering_query_param: 'ordering',
 
         # Other misc attributes.
-        disable_creation_from_recordset: nil,  # Option to disable `recordset.create` behavior.
+        disable_creation_from_recordset: false,  # Option to disable `recordset.create` behavior.
       }.each do |a, default|
         unless base.respond_to?(a)
           base.class_attribute(a)
 
-          # Set default manually so we can still support Rails 4. Maybe later we can use the
-          # default parameter on `class_attribute`.
+          # Set default manually so we can still support Rails 4. Maybe later we can use the default
+          # parameter on `class_attribute`.
           base.send(:"#{a}=", default)
         end
       end
@@ -49,36 +50,34 @@ module RESTFramework::BaseModelControllerMixin
 
   protected
 
-  # Get a native serializer config for the current action.
-  # @return [RESTFramework::NativeSerializer]
-  def get_native_serializer_config
-    action_serializer_config = self.class.native_serializer_action_config || {}
-    action = self.action_name.to_sym
-
-    # Handle case where :index action is not defined.
-    if action == :index && !action_serializer_config.key?(:index)
-      # Default is :show if `singleton_controller`, otherwise :list.
-      action = self.class.singleton_controller ? :show : :list
-    end
+  def _get_specific_action_config(action_config_key, generic_config_key)
+    action_config = self.class.send(action_config_key) || {}
+    action = self.action_name&.to_sym
 
-    return (action_serializer_config[action] if action) || self.class.native_serializer_config
-  end
+    # Index action should use :list serializer if :index is not provided.
+    action = :list if action == :index && !action_config.key?(:index)
 
-  # Helper to get the configured serializer class, or `NativeSerializer` as a default.
-  # @return [RESTFramework::BaseSerializer]
-  def get_serializer_class
-    return self.class.serializer_class || RESTFramework::NativeSerializer
+    return (action_config[action] if action) || self.class.send(generic_config_key)
   end
 
   # Get a list of parameters allowed for the current action.
   def get_allowed_parameters
-    allowed_action_parameters = self.class.allowed_action_parameters || {}
-    action = self.action_name.to_sym
+    return _get_specific_action_config(:allowed_action_parameters, :allowed_parameters)&.map(&:to_s)
+  end
 
-    # index action should use :list allowed parameters if :index is not provided
-    action = :list if action == :index && !allowed_action_parameters.key?(:index)
+  # Get a list of fields for the current action.
+  def get_fields
+    return (
+      _get_specific_action_config(:action_fields, :fields)&.map(&:to_s) ||
+      self.get_model&.column_names ||
+      []
+    )
+  end
 
-    return (allowed_action_parameters[action] if action) || self.class.allowed_parameters
+  # Helper to get the configured serializer class, or `NativeSerializer` as a default.
+  # @return [RESTFramework::BaseSerializer]
+  def get_serializer_class
+    return self.class.serializer_class || RESTFramework::NativeSerializer
   end
 
   # Get the list of filtering backends to use.
@@ -89,70 +88,81 @@ module RESTFramework::BaseModelControllerMixin
     ]
   end
 
-  # Get a list of fields for the current action.
-  def get_fields
-    action_fields = self.class.action_fields || {}
-    action = self.action_name.to_sym
+  # Filter the request body for keys in current action's allowed_parameters/fields config.
+  def get_body_params
+    return @_get_body_params ||= begin
+      fields = self.get_allowed_parameters || self.get_fields
+
+      # Filter the request body.
+      body_params = request.request_parameters.select { |p|
+        fields.include?(p)
+      }
+
+      # Add query params in place of missing body params, if configured.
+      if self.class.accept_generic_params_as_body_params
+        (fields - body_params.keys).each do |k|
+          if (value = params[k])
+            body_params[k] = value
+          end
+        end
+      end
 
-    # index action should use :list fields if :index is not provided
-    action = :list if action == :index && !action_fields.key?(:index)
+      # Filter primary key if configured.
+      if self.class.filter_pk_from_request_body
+        body_params.delete(self.get_model&.primary_key)
+      end
 
-    return (action_fields[action] if action) || self.class.fields || []
-  end
+      # Filter fields in exclude_body_fields.
+      (self.class.exclude_body_fields || []).each do |f|
+        body_params.delete(f.to_s)
+      end
 
-  # Filter the request body for keys in current action's allowed_parameters/fields config.
-  def get_body_params
-    fields = self.get_allowed_parameters || self.get_fields
-    return @get_body_params ||= (request.request_parameters.select { |p|
-      fields.include?(p.to_sym) || fields.include?(p.to_s)
-    })
+      body_params
+    end
   end
   alias :get_create_params :get_body_params
   alias :get_update_params :get_body_params
 
-  # Get a record by the primary key from the filtered recordset.
+  # Get a record by the primary key from the (non-filtered) recordset.
   def get_record
-    records = self.get_filtered_data(self.get_recordset)
     if pk = params[self.get_model.primary_key]
-      return records.find(pk)
+      return self.get_recordset.find(pk)
     end
     return nil
   end
 
-  # Internal interface for get_model, protecting against infinite recursion with get_recordset.
-  def _get_model(from_internal_get_recordset: false)
+  # Get the model for this controller.
+  def get_model(from_get_recordset: false)
     return @model if instance_variable_defined?(:@model) && @model
     return (@model = self.class.model) if self.class.model
-    unless from_internal_get_recordset  # prevent infinite recursion
-      recordset = self._get_recordset(from_internal_get_model: true)
-      return (@model = recordset.klass) if recordset
+
+    # Delegate to the recordset's model, if it's defined.
+    unless from_get_recordset  # prevent infinite recursion
+      if (recordset = self.get_recordset)
+        return @model = recordset.klass
+      end
     end
+
+    # Try to determine model from controller name.
     begin
       return (@model = self.class.name.demodulize.match(/(.*)Controller/)[1].singularize.constantize)
     rescue NameError
     end
+
     return nil
   end
 
-  # Internal interface for get_recordset, protecting against infinite recursion with get_model.
-  def _get_recordset(from_internal_get_model: false)
+  # Get the set of records this controller has access to.
+  def get_recordset
     return @recordset if instance_variable_defined?(:@recordset) && @recordset
     return (@recordset = self.class.recordset) if self.class.recordset
-    unless from_internal_get_model  # prevent infinite recursion
-      model = self._get_model(from_internal_get_recordset: true)
-      return (@recordset = model.all) if model
-    end
-    return nil
-  end
 
-  # Get the model for this controller.
-  def get_model
-    return _get_model
-  end
+    # If there is a model, return that model's default scope (all records by default).
+    if (model = self.get_model(from_get_recordset: true))
+      return @recordset = model.all
+    end
 
-  # Get the set of records this controller has access to.
-  def get_recordset
-    return _get_recordset
+    return nil
   end
 end
 
@@ -219,7 +229,7 @@ module RESTFramework::DestroyModelMixin
   def destroy
     @record = self.get_record
     @record.destroy!
-    api_response(nil)
+    api_response('')
   end
 end
 

data/lib/rest_framework/errors.rb

@@ -0,0 +1,26 @@
+# Top-level class for all REST Framework errors.
+class RESTFramework::Error < StandardError
+end
+
+class RESTFramework::NilPassedToAPIResponseError < RESTFramework::Error
+  def message
+    return <<~MSG.split("\n").join(' ')
+      Payload of `nil` was passed to `api_response`; this is unsupported. If you want a blank
+      response, pass `''` (an empty string) as the payload. If this was the result of a `find_by`
+      (or similar Active Record method) not finding a record, you should use the bang version (e.g.,
+      `find_by!`) to raise `ActiveRecord::RecordNotFound`, which the REST controller will catch and
+      return an appropriate error response.
+    MSG
+  end
+end
+
+class RESTFramework::UnserializableError < RESTFramework::Error
+  def initialize(object)
+    @object = object
+    return super
+  end
+
+  def message
+    return "Unable to serialize `#{@object.inspect}` (of type `#{@object.class}`)."
+  end
+end

data/lib/rest_framework/filters.rb

@@ -14,10 +14,10 @@ end
 class RESTFramework::ModelFilter < RESTFramework::BaseFilter
   # Filter params for keys allowed by the current action's filterset_fields/fields config.
   def _get_filter_params
-    fields = @controller.class.filterset_fields || @controller.send(:get_fields)
+    fields = @controller.class.filterset_fields&.map(&:to_s) || @controller.send(:get_fields)
     return @controller.request.query_parameters.select { |p|
-      fields.include?(p.to_sym) || fields.include?(p.to_s)
-    }.to_hash.symbolize_keys
+      fields.include?(p)
+    }.to_h.symbolize_keys  # convert from HashWithIndifferentAccess to Hash w/keys
   end
 
   # Filter data according to the request query parameters.

data/lib/rest_framework/generators.rb

@@ -0,0 +1,5 @@
+module RESTFramework::Generators
+end
+
+
+require_relative 'generators/controller_generator'

data/lib/rest_framework/generators/controller_generator.rb

@@ -0,0 +1,26 @@
+require 'rails/generators'
+
+
+class RESTFramework::Generators::ControllerGenerator < Rails::Generators::Base
+  desc <<~END
+    Description:
+      Stubs out a active_scaffolded controller. Pass the model name,
+      either CamelCased or under_scored.
+      The controller name is retrieved as a pluralized version of the model
+      name.
+      To create a controller within a module, specify the model name as a
+      path like 'parent_module/controller_name'.
+      This generates a controller class in app/controllers and invokes helper,
+      template engine and test framework generators.
+    Example:
+      `rails generate rest_framework:controller CreditCard`
+      Credit card controller with URLs like /credit_card/debit.
+          Controller:      app/controllers/credit_cards_controller.rb
+          Functional Test: test/functional/credit_cards_controller_test.rb
+          Helper:          app/helpers/credit_cards_helper.rb
+  END
+
+  def create_controller_file
+    create_file "app/controllers/some_controller.rb", "# Add initialization content here"
+  end
+end

data/lib/rest_framework/routers.rb

@@ -1,5 +1,6 @@
 require 'action_dispatch/routing/mapper'
 
+
 module ActionDispatch::Routing
   class Mapper
     # Internal helper to take extra_actions hash and convert to a consistent format.

data/lib/rest_framework/serializers.rb

@@ -1,6 +1,4 @@
 class RESTFramework::BaseSerializer
-  attr_reader :errors
-
   def initialize(object: nil, controller: nil, **kwargs)
     @object = object
     @controller = controller
@@ -8,9 +6,8 @@ class RESTFramework::BaseSerializer
 end
 
 
-# This serializer uses `.as_json` to serialize objects. Despite the name, `.as_json` is an
-# `ActiveModel` method which converts objects to Ruby primitives (with the top-level being either
-# an array or a hash).
+# This serializer uses `.serializable_hash` to convert objects to Ruby primitives (with the
+# top-level being either an array or a hash).
 class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
   class_attribute :config
   class_attribute :singular_config
@@ -21,12 +18,17 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
     super(**kwargs)
 
     if many.nil?
-      @many = @object.respond_to?(:count) ? @object.count : nil
+      # Determine if we are dealing with many objects or just one.
+      @many = @object.is_a?(Enumerable)
     else
       @many = many
     end
 
-    @model = model || (@controller ? @controller.send(:get_model) : nil)
+    # Determine model either explicitly, or by inspecting @object or @controller.
+    @model = model
+    @model ||= @object.class if @object.is_a?(ActiveRecord::Base)
+    @model ||= @object[0].class if @many && @object[0].is_a?(ActiveRecord::Base)
+    @model ||= @controller.send(:get_model) if @controller
   end
 
   # Get controller action, if possible.
@@ -34,8 +36,8 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
     return @controller&.action_name&.to_sym
   end
 
-  # Get a locally defined configuration, if one is defined.
-  def get_local_serializer_config
+  # Get a locally defined native serializer configuration, if one is defined.
+  def get_local_native_serializer_config
     action = self.get_action
 
     if action && self.action_config
@@ -45,43 +47,70 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
       return self.action_config[action] if self.action_config[action]
     end
 
-    # No action_config, so try singular/plural config.
-    return self.plural_config if @many && self.plural_config
-    return self.singular_config if !@many && self.singular_config
+    # No action_config, so try singular/plural config if explicitly instructed to via @many.
+    return self.plural_config if @many == true && self.plural_config
+    return self.singular_config if @many == false && self.singular_config
+
+    # Lastly, try returning the default config, or singular/plural config in that order.
+    return self.config || self.singular_config || self.plural_config
+  end
+
+  # Helper to get a native serializer configuration from the controller.
+  def get_controller_native_serializer_config
+    return nil unless @controller
+
+    if @many == true
+      controller_serializer = @controller.try(:native_serializer_plural_config)
+    elsif @many == false
+      controller_serializer = @controller.try(:native_serializer_singular_config)
+    end
 
-    # Lastly, try returning the default config.
-    return self.config
+    return controller_serializer || @controller.try(:native_serializer_config)
   end
 
-  # Get a configuration passable to `as_json` for the object.
+  # Get a configuration passable to `serializable_hash` for the object.
   def get_serializer_config
     # Return a locally defined serializer config if one is defined.
-    if local_config = self.get_local_serializer_config
+    if local_config = self.get_local_native_serializer_config
       return local_config
     end
 
-    # Return a serializer config if one is defined.
-    if serializer_config = @controller.send(:get_native_serializer_config)
+    # Return a serializer config if one is defined on the controller.
+    if serializer_config = get_controller_native_serializer_config
       return serializer_config
     end
 
     # If the config wasn't determined, build a serializer config from model fields.
-    fields = @controller.try(:get_fields) if @controller
-    unless fields.blank?
-      columns, methods = fields.partition { |f| f.to_s.in?(@model.column_names) }
+    fields = @controller.send(:get_fields) if @controller
+    if fields
+      if @model
+        columns, methods = fields.partition { |f| f.in?(@model.column_names) }
+      else
+        columns = fields
+        methods = []
+      end
+
       return {only: columns, methods: methods}
     end
 
+    # By default, pass an empty configuration, allowing the serialization of all columns.
     return {}
   end
 
   # Convert the object (record or recordset) to Ruby primitives.
   def serialize
     if @object
-      @many = @object.respond_to?(:each) if @many.nil?
-      return @object.as_json(self.get_serializer_config)
+      begin
+        if @object.is_a?(Enumerable)
+          return @object.map { |r| r.serializable_hash(self.get_serializer_config) }
+        end
+        return @object.serializable_hash(self.get_serializer_config)
+      rescue NoMethodError
+      end
     end
-    return nil
+
+    # Raise an error if we cannot serialize the object.
+    raise RESTFramework::UnserializableError.new(@object)
   end
 
   # Allow a serializer instance to be used as a hash directly in a nested serializer config.
@@ -113,6 +142,18 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
   end
 end
 
+
+# :nocov:
 # Alias NativeModelSerializer -> NativeSerializer.
 class RESTFramework::NativeModelSerializer < RESTFramework::NativeSerializer
+  def initialize(**kwargs)
+    super
+    ActiveSupport::Deprecation.warn(
+      <<~MSG.split("\n").join(' ')
+        RESTFramework::NativeModelSerializer is deprecated and will be removed in future versions of
+        REST Framework; you should use RESTFramework::NativeSerializer instead.
+      MSG
+    )
+  end
 end
+# :nocov:

data/lib/rest_framework/version.rb

@@ -2,19 +2,21 @@ module RESTFramework
   module Version
     @_version = nil
 
-    def self.get_version
+    def self.get_version(skip_git: false)
       # Return cached @_version, if available.
       return @_version if @_version
 
       # First, attempt to get the version from git.
-      begin
-        version = `git describe 2>/dev/null`.strip
-        raise "blank version" if version.nil? || version.match(/^\w*$/)
-        # Check for local changes.
-        changes = `git status --porcelain 2>/dev/null`
-        version << '.localchanges' if changes.strip.length > 0
-        return version
-      rescue
+      unless skip_git
+        begin
+          version = `git describe 2>/dev/null`.strip
+          raise "blank version" if version.nil? || version.match(/^\w*$/)
+          # Check for local changes.
+          changes = `git status --porcelain 2>/dev/null`
+          version << '.localchanges' if changes.strip.length > 0
+          return version
+        rescue
+        end
       end
 
       # Git failed, so try to find a VERSION_STAMP.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rest_framework
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Gregory N. Schmit
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-03-07 00:00:00.000000000 Z
+date: 2021-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -43,7 +43,10 @@ files:
 - lib/rest_framework/controller_mixins/base.rb
 - lib/rest_framework/controller_mixins/models.rb
 - lib/rest_framework/engine.rb
+- lib/rest_framework/errors.rb
 - lib/rest_framework/filters.rb
+- lib/rest_framework/generators.rb
+- lib/rest_framework/generators/controller_generator.rb
 - lib/rest_framework/paginators.rb
 - lib/rest_framework/routers.rb
 - lib/rest_framework/serializers.rb