rest_framework 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c71a3fea7904490cd834aff65231d4a18804e8cd487a07314e475a73d9a6500e
+  data.tar.gz: bde5421c92b4c960bc9b09b369a36b2d4df463b0722490c35cbaf00cdb6b6a66
+SHA512:
+  metadata.gz: 21db95368e8223a1b086e63b9724eb7cb35cb5eb42db9eedb5eca557662be24363f225ab69fb98d2996152c69d58218a5156fdaba1345330660c974313b3f912
+  data.tar.gz: 2f32d14d77eb8f60b29019afd81f6b926e2bd97268b2cd6d4828698adf4b66debea2959f00403913a6e74a970f858d960a4d3c9268a1f6fcccd9549c1aca992e

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Gregory N. Schmit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,46 @@
+# REST Framework
+
+REST Framework helps you build awesome APIs in Ruby on Rails.
+
+**The Problem**: Building controllers for APIs usually involves writing a lot of redundant CRUD
+logic, and routing them can be obnoxious.
+
+**The Solution**: This gem handles the common logic so you can focus on the parts of your API which
+make it unique.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rest_framework'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself with:
+
+    $ gem install rest_framework
+
+## Development/Testing
+
+After you clone the repository, cd'ing into the directory should create a new gemset if you are
+using RVM. Then run `bundle install` to install the appropriate gems.
+
+To run the full test suite:
+
+    $ rake test
+
+To run unit tests:
+
+    $ rake test:unit
+
+To run integration tests on a sample app:
+
+    $ rake test:app
+
+To run that sample app live:
+
+    $ rake test:app:run

data/lib/rest_framework.rb

@@ -0,0 +1,6 @@
+module RESTFramework
+end
+
+require_relative "rest_framework/controllers"
+require_relative "rest_framework/routers"
+require_relative "rest_framework/version"

data/lib/rest_framework/VERSION_STAMP

@@ -0,0 +1 @@
+0.0.0

data/lib/rest_framework/controllers.rb

@@ -0,0 +1,2 @@
+require_relative 'controllers/base'
+require_relative 'controllers/models'

data/lib/rest_framework/controllers/base.rb

@@ -0,0 +1,66 @@
+module RESTFramework
+
+  module ClassMethodHelpers
+    def _restframework_attr_reader(property, default: nil)
+      method = <<~RUBY
+        def #{property}
+          return _restframework_try_class_level_variable_get(
+            #{property.inspect},
+            default: #{default.inspect},
+          )
+        end
+      RUBY
+      self.module_eval(method)
+    end
+  end
+
+  module BaseControllerMixin
+    # Default action for API root.
+    # TODO: use api_response and show sub-routes.
+    def root
+      render inline: "This is the root of your awesome API!"
+    end
+
+    protected
+
+    module ClassMethods
+      extend ClassMethodHelpers
+
+      # Interface for getting class-level instance/class variables.
+      private def _restframework_try_class_level_variable_get(name, default: nil)
+        begin
+          v = instance_variable_get("@#{name}")
+          return v unless v.nil?
+        rescue NameError
+        end
+        begin
+          v = class_variable_get("@@#{name}")
+          return v unless v.nil?
+        rescue NameError
+        end
+        return default
+      end
+
+      # Interface for registering exceptions handlers.
+      # private def _restframework_register_exception_handlers
+      #   rescue_from
+      # end
+
+      _restframework_attr_reader(:extra_actions, default: {})
+      _restframework_attr_reader(:skip_actions, default: [])
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    # Helper alias for `respond_to`/`render`, and replace nil responses with blank ones.
+    def api_response(value, **kwargs)
+      respond_to do |format|
+        format.html
+        format.json { render json: value || '', **kwargs }
+      end
+    end
+  end
+
+end

data/lib/rest_framework/controllers/models.rb

@@ -0,0 +1,222 @@
+require_relative 'base'
+
+module RESTFramework
+
+  module BaseModelControllerMixin
+    include BaseControllerMixin
+
+    # By default (and for now), we will just use `as_json`, but we should consider supporting:
+    #   active_model_serializers (problem:
+    #     https://github.com/rails-api/active_model_serializers#whats-happening-to-ams)
+    #   fast_jsonapi (really good and fast serializers)
+    #@serializer
+    #@list_serializer
+    #@show_serializer
+    #@create_serializer
+    #@update_serializer
+
+    module ClassMethods
+      extend ClassMethodHelpers
+      include BaseControllerMixin::ClassMethods
+
+      _restframework_attr_reader(:model)
+      _restframework_attr_reader(:recordset)
+      _restframework_attr_reader(:singleton_controller)
+
+      _restframework_attr_reader(:fields)
+      _restframework_attr_reader(:list_fields)
+      _restframework_attr_reader(:show_fields)
+      _restframework_attr_reader(:create_fields)
+      _restframework_attr_reader(:update_fields)
+
+      _restframework_attr_reader(:extra_member_actions, default: {})
+
+      # For model-based mixins, `@extra_collection_actions` is synonymous with `@extra_actions`.
+      def extra_actions
+        return (
+          _restframework_try_class_level_variable_get(:extra_collection_actions) ||
+          _restframework_try_class_level_variable_get(:extra_actions, default: {})
+        )
+      end
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    protected
+
+    # Get a list of fields for the current action.
+    def get_fields
+      return @fields if @fields
+
+      # index action should use list_fields
+      name = (action_name == 'index') ? 'list' : action_name
+
+      begin
+        @fields = self.class.send("#{name}_fields")
+      rescue NameError
+      end
+      @fields ||= self.class.fields || []
+
+      return @fields
+    end
+
+    # Get a configuration passable to `as_json` for the model.
+    def get_model_serializer_config
+      fields = self.get_fields
+      unless fields.blank?
+        columns, methods = fields.partition { |f| f.to_s.in?(self.get_model.column_names) }
+        return {only: columns, methods: methods}
+      end
+      return {}
+    end
+
+    # Filter the request body for keys allowed by the current action's field config.
+    def _get_field_values_from_request_body
+      return @_get_field_values_from_request_body ||= (request.request_parameters.select { |p|
+        self.get_fields.include?(p.to_sym) || self.get_fields.include?(p.to_s)
+      })
+    end
+    alias :get_create_params :_get_field_values_from_request_body
+    alias :get_update_params :_get_field_values_from_request_body
+
+    # Filter params for keys allowed by the current action's field config.
+    def _get_field_values_from_params
+      return @_get_field_values_from_params ||= params.permit(*self.get_fields)
+    end
+    alias :get_lookup_params :_get_field_values_from_params
+    alias :get_filter_params :_get_field_values_from_params
+
+    # Get the recordset, filtered by the filter params.
+    def get_filtered_recordset
+      filter_params = self.get_filter_params
+      unless filter_params.blank?
+        return self.get_recordset.where(**self.get_filter_params)
+      end
+      return self.get_recordset
+    end
+
+    # Get a record by `id` or return a single record if recordset is filtered down to a single record.
+    def get_record
+      records = self.get_filtered_recordset
+      if params['id']  # direct lookup
+        return records.find(params['id'])
+      elsif records.length == 1
+        return records[0]
+      end
+      return nil
+    end
+
+    # Internal interface for get_model, protecting against infinite recursion with get_recordset.
+    private def _get_model(from_internal_get_recordset: false)
+      return @model if @model
+      return self.class.model if self.class.model
+      unless from_get_recordset  # prevent infinite recursion
+        recordset = self._get_recordset(from_internal_get_model: true)
+        return (@model = recordset.klass) if recordset
+      end
+      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.
+    private def _get_recordset(from_internal_get_model: false)
+      return @recordset if @recordset
+      return self.class.recordset if self.class.recordset
+      unless from_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
+
+    # Get the base set of records this controller has access to.
+    def get_recordset
+      return _get_recordset
+    end
+  end
+
+  module ListModelMixin
+    # TODO: pagination classes like Django
+    def index
+      @records = self.get_filtered_recordset
+      api_response(@records, **self.get_model_serializer_config)
+    end
+  end
+
+  module ShowModelMixin
+    def show
+      @record = self.get_record
+      api_response(@record, **self.get_model_serializer_config)
+    end
+  end
+
+  module CreateModelMixin
+    def create
+      begin
+        @record = self.get_model.create!(self.get_create_params)
+      rescue ActiveRecord::RecordInvalid => e
+        api_response(e.record.messages, status: 400)
+      end
+      api_response(@record, **self.get_model_serializer_config)
+    end
+  end
+
+  module UpdateModelMixin
+    def update
+      @record = self.get_record
+      if @record
+        @record.attributes(self.get_update_params)
+        @record.save!
+        api_response(@record, **self.get_model_serializer_config)
+      else
+        api_response({detail: "Record not found."}, status: 404)
+      end
+    end
+  end
+
+  module DestroyModelMixin
+    def destroy
+      @record = self.get_record
+      if @record
+        @record.destroy!
+        api_response('')
+      else
+        api_response({detail: "Method 'DELETE' not allowed."}, status: 405)
+      end
+    end
+  end
+
+  module ReadOnlyModelControllerMixin
+    include BaseModelControllerMixin
+    def self.included(base)
+      base.extend BaseModelControllerMixin::ClassMethods
+    end
+
+    include ListModelMixin
+    include ShowModelMixin
+  end
+
+  module ModelControllerMixin
+    include BaseModelControllerMixin
+    def self.included(base)
+      base.extend BaseModelControllerMixin::ClassMethods
+    end
+
+    include ListModelMixin
+    include ShowModelMixin
+    include CreateModelMixin
+    include UpdateModelMixin
+    include DestroyModelMixin
+  end
+
+end

data/lib/rest_framework/routers.rb

@@ -0,0 +1,132 @@
+require 'rails'
+require 'action_dispatch/routing/mapper'
+
+module ActionDispatch::Routing
+  class Mapper
+    # Private interface to get the controller class from the name and current scope.
+    protected def _get_controller_class(name, pluralize: true, fallback_reverse_pluralization: true)
+      # get class name
+      name = name.to_s.camelize  # camelize to leave plural names plural
+      name = name.pluralize if pluralize
+      if name == name.pluralize
+        name_reverse = name.singularize
+      else
+        name_reverse = name.pluralize
+      end
+      name += "Controller"
+      name_reverse += "Controller"
+
+      # get scope for the class
+      if @scope[:module]
+        mod = @scope[:module].to_s.classify.constantize
+      else
+        mod = Object
+      end
+
+      # convert class name to class
+      begin
+        controller = mod.const_get(name, false)
+      rescue NameError
+        if fallback_reverse_pluralization
+          controller = mod.const_get(name_reverse, false)
+        else
+          raise
+        end
+      end
+
+      return controller
+    end
+
+    # Core implementation of the `rest_resource(s)` router, both singular and plural.
+    # @param default_singular [Boolean] the default plurality of the resource if the plurality is
+    #   not otherwise defined by the controller
+    # @param name [Symbol] the resource name, from which path and controller are deduced by default
+    protected def _rest_resources(default_singular, name, **kwargs, &block)
+      controller = kwargs[:controller] || name
+      if controller.is_a?(Class)
+        controller_class = controller
+      else
+        controller_class = _get_controller_class(controller, pluralize: !default_singular)
+      end
+
+      # set controller if it's not explicitly set
+      unless kwargs[:controller]
+        kwargs[:controller] = name
+      end
+
+      # determine plural/singular resource
+      if kwargs.delete(:force_singular)
+        singular = true
+      elsif kwargs.delete(:force_plural)
+        singular = false
+      elsif !controller_class.singleton_controller.nil?
+        singular = controller_class.singleton_controller
+      else
+        singular = default_singular
+      end
+      resource_method = singular ? :resource : :resources
+
+      # call either `resource` or `resources`, passing appropriate modifiers
+      public_send(resource_method, name, except: controller_class.skip_actions, **kwargs) do
+        if controller_class.respond_to?(:extra_member_actions)
+          member do
+            controller_class.extra_member_actions.each do |action, methods|
+              methods = [methods] if methods.is_a?(Symbol) || methods.is_a?(String)
+              methods.each do |m|
+                public_send(m, action)
+              end
+            end
+          end
+        end
+
+        collection do
+          controller_class.extra_actions.each do |action, methods|
+            methods = [methods] if methods.is_a?(Symbol) || methods.is_a?(String)
+            methods.each do |m|
+              public_send(m, action)
+            end
+          end
+        end
+
+        yield if block_given?
+      end
+    end
+
+    # Public interface for creating singular RESTful resource routes.
+    def rest_resource(*names, **kwargs, &block)
+      names.each do |n|
+        self._rest_resources(true, n, **kwargs, &block)
+      end
+    end
+
+    # Public interface for creating plural RESTful resource routes.
+    def rest_resources(*names, **kwargs, &block)
+      names.each do |n|
+        self._rest_resources(false, n, **kwargs, &block)
+      end
+    end
+
+    # Route a controller's `#root` to '/' in the current scope/namespace, along with other actions.
+    # @param label [Symbol] the snake_case name of the controller
+    def rest_root(path=nil, **kwargs, &block)
+      # by default, use RootController#root
+      root_action = kwargs.delete(:action) || :root
+      controller = kwargs.delete(:controller) || path || :root
+      path = path.to_s
+
+      # route the root
+      get path, controller: controller, action: root_action
+
+      # route any additional actions
+      controller_class = self._get_controller_class(controller, pluralize: false)
+      controller_class.extra_actions.each do |action, methods|
+        methods = [methods] if methods.is_a?(Symbol) || methods.is_a?(String)
+        methods.each do |m|
+          public_send(m, File.join(path, action.to_s), controller: controller, action: action)
+        end
+        yield if block_given?
+      end
+    end
+
+  end
+end

data/lib/rest_framework/version.rb

@@ -0,0 +1,35 @@
+module RESTFramework
+  module Version
+    @_version = nil
+
+    def self.get_version
+      # Return cached @_version, if available.
+      return @_version if @_version
+
+      # First, attempt to get the version from git.
+      begin
+        version = `git describe`.strip
+        raise "blank version" if version.nil? || version.match(/^\w*$/)
+        # Check for local changes.
+        changes = `git status --porcelain`
+        version << '.localchanges' if changes.strip.length > 0
+        return version
+      rescue
+      end
+
+      # Git failed, so try to find a VERSION_STAMP.
+      begin
+        version = File.read(File.expand_path("VERSION_STAMP", __dir__))
+        unless version.nil? || version.match(/^\w*$/)
+          return (@_version = version)  # cache VERSION_STAMP content in @_version
+        end
+      rescue
+      end
+
+      # No VERSION_STAMP, so version is unknown.
+      return '0.unknown'
+    end
+  end
+
+  VERSION = Version.get_version()
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: rest_framework
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Gregory N. Schmit
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-09-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: A framework for DRY RESTful APIs in Ruby on Rails.
+email:
+- schmitgreg@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/rest_framework.rb
+- lib/rest_framework/VERSION_STAMP
+- lib/rest_framework/controllers.rb
+- lib/rest_framework/controllers/base.rb
+- lib/rest_framework/controllers/models.rb
+- lib/rest_framework/routers.rb
+- lib/rest_framework/version.rb
+homepage: https://github.com/gregschmit/rails-rest-framework
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/gregschmit/rails-rest-framework
+  source_code_uri: https://github.com/gregschmit/rails-rest-framework
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.8
+signing_key:
+specification_version: 4
+summary: A framework for DRY RESTful APIs in Ruby on Rails.
+test_files: []