snfoil-rails 0.8.2 → 1.0.0.pre.1

data/lib/generators/sn_foil/jsonapi_deserializer/jsonapi_deserializer_generator.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module SnFoil
-  class JsonapiDeserializerGenerator < Rails::Generators::Base
-    source_root File.expand_path('templates', __dir__)
-
-    argument :model, type: :string
-
-    class_option :path, desc: 'Base path for file', type: :string, default: 'app/jsonapi_deserializers'
-
-    def add_app_file
-      file_name = if modules.length.zero?
-                    name
-                  else
-                    "#{modules.join('/')}/#{name}"
-                  end
-
-      template('jsonapi_deserializer.erb', "#{options[:path]}/#{file_name}_jsonapi_deserializer.rb")
-    end
-
-    private
-
-    def name
-      @name ||= model.split('/').last.underscore.singularize
-    end
-
-    def class_name
-      @class_name ||= name.camelize
-    end
-
-    def modules
-      @modules ||= model.split('/')[0..-2].map(&:underscore)
-    end
-
-    def class_modules
-      return if modules.length.zero?
-
-      @class_modules ||= "#{modules.map(&:camelize).join('::')}::"
-    end
-  end
-end

data/lib/generators/sn_foil/jsonapi_deserializer/templates/jsonapi_deserializer.erb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-class <%= class_modules %><%= class_name %>JsonapiDeserializer
-  include SnFoil::JsonapiDeserializer
-  
-  # Add attributes of the model you want to serializer with the following syntax
-  attributes :id
-
-  # Add relationships with the following syntax
-  # belongs_to :store, serializer: Jsonapi::StoreJsonapiSerializer
-  # has_many :locations, serializer: Jsonapi::LocationJsonapiSerializer
-end

data/lib/generators/sn_foil/jsonapi_serializer/jsonapi_serializer_generator.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module SnFoil
-  class JsonapiSerializerGenerator < Rails::Generators::Base
-    source_root File.expand_path('templates', __dir__)
-
-    argument :model, type: :string
-
-    class_option :path, desc: 'Base path for file', type: :string, default: 'app/jsonapi_serializers'
-
-    def add_app_file
-      file_name = if modules.length.zero?
-                    name
-                  else
-                    "#{modules.join('/')}/#{name}"
-                  end
-
-      template('jsonapi_serializer.erb', "#{options[:path]}/#{file_name}_jsonapi_serializer.rb")
-    end
-
-    private
-
-    def name
-      @name ||= model.split('/').last.underscore.singularize
-    end
-
-    def class_name
-      @class_name ||= name.camelize
-    end
-
-    def modules
-      @modules ||= model.split('/')[0..-2].map(&:underscore)
-    end
-
-    def class_modules
-      return if modules.length.zero?
-
-      @class_modules ||= "#{modules.map(&:camelize).join('::')}::"
-    end
-  end
-end

data/lib/generators/sn_foil/jsonapi_serializer/templates/jsonapi_serializer.erb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-class <%= class_modules %><%= class_name %>JsonapiSerializer
-  include SnFoil::JsonapiSerializer
-
-  set_id :id
-  set_type :<%= name.pluralize.dasherize %>
-
-  # SnFoil::JsonapiSerializer is just a wrapper for jsonapi-serializer (https://github.com/jsonapi-serializer/jsonapi-serializer)
-  # with some defaults added in
-
-  # Add attributes of the model you want to serializer with the following syntax
-  # attributes :name
-  #            :description
-  #            :logo_url
-
-  # Add relationships with the following syntax
-  # belongs_to :store, serializer: Jsonapi::StoreJsonapiSerializer
-  # has_many :locations, serializer: Jsonapi::LocationJsonapiSerializer
-end

data/lib/generators/sn_foil/policy/policy_generator.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module SnFoil
-  class PolicyGenerator < Rails::Generators::Base
-    source_root File.expand_path('templates', __dir__)
-
-    argument :model, type: :string
-
-    class_option :path, desc: 'Base path for file', type: :string, default: 'app/policies'
-
-    def add_app_file
-      file_name = if modules.length.zero?
-                    name
-                  else
-                    "#{modules.join('/')}/#{name}"
-                  end
-
-      template('policy.erb', "#{options[:path]}/#{file_name}_policy.rb")
-    end
-
-    private
-
-    def name
-      @name ||= model.split('/').last.underscore.singularize
-    end
-
-    def class_name
-      @class_name ||= name.camelize
-    end
-
-    def modules
-      @modules ||= model.split('/')[0..-2].map(&:underscore)
-    end
-
-    def class_modules
-      return if modules.length.zero?
-
-      @class_modules ||= "#{modules.map(&:camelize).join('::')}::"
-    end
-  end
-end

data/lib/generators/sn_foil/policy/templates/policy.erb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-class <%= class_modules %><%= class_name %>Policy
-  include SnFoil::Policy
-  # A SnFoil::Policy is just a Pundit policy (https://github.com/varvet/pundit)
-  # with some defaults
-  # Available methods: show?, create?, update?, destroy?, index?, associate?
-
-  #  def show?
-  #    true
-  #  end
-
-  # class Scope
-  #   # available read-only attributes
-  #   # - scope: the default scope passed into the policy (ex: an ActiveRecord::Relation)
-  #   # - entity: the object that the scope is build around (ex: a User)
-
-  #   def resolve
-  #     # the new default scope
-  #   end
-  # end
-end

data/lib/generators/sn_foil/searcher/searcher_generator.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module SnFoil
-  class SearcherGenerator < Rails::Generators::Base
-    source_root File.expand_path('templates', __dir__)
-
-    argument :model, type: :string
-
-    class_option :path, desc: 'Base path for file', type: :string, default: 'app/searchers'
-
-    def add_app_file
-      file_name = if modules.length.zero?
-                    name
-                  else
-                    "#{modules.join('/')}/#{name}"
-                  end
-
-      template('searcher.erb', "#{options[:path]}/#{file_name}_searcher.rb")
-    end
-
-    private
-
-    def name
-      @name ||= model.split('/').last.underscore.pluralize
-    end
-
-    def class_name
-      @class_name ||= name.camelize
-    end
-
-    def modules
-      @modules ||= model.split('/')[0..-2].map(&:underscore)
-    end
-
-    def class_modules
-      return if modules.length.zero?
-
-      @class_modules ||= "#{modules.map(&:camelize).join('::')}::"
-    end
-  end
-end

data/lib/generators/sn_foil/searcher/templates/searcher.erb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-class <%= class_modules %><%= class_name %>Searcher
-  include SnFoil::Searcher
-  
-  model <%= class_name.singularize %>
-end

data/lib/sn_foil/configuration/lazy_jsonapi_serializer.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-module SnFoil
-  module Configuration
-    module LazyJsonapiSerializer
-      extend ActiveSupport::Concern
-
-      class << self
-        def belongs_to(relationship_name, options = {}, &block)
-          block = belongs_to_optimized_block(relationship_name, options, &block)
-          super(relationship_name, options, &block)
-        end
-
-        def has_one(relationship_name, options = {}, &block) # rubocop:disable Naming/PredicateName reason: method override
-          super(relationship_name, has_relation_optimized_options(relationship_name, options), &block)
-        end
-
-        def has_many(relationship_name, options = {}, &block) # rubocop:disable Naming/PredicateName reason: method override
-          super(relationship_name, has_relation_optimized_options(relationship_name, options), &block)
-        end
-
-        private
-
-        # We need to parse the include block because FastJsonAPI does not allow access to the pre-parsed includes
-        def parse_include(params)
-          return [] unless params[:include]
-
-          if params[:include].is_a?(String)
-            params[:include].split(',')
-          else
-            params[:include]
-          end.map { |r| r.to_s.dasherize }.join(',')
-        end
-
-        def lookup_full_object_for_belongs_to(record, relationship_name, options, params)
-          return unless parse_include(params).include?(relationship_name.to_s.dasherize)
-
-          record.send(options[:object_method_name] || relationship_name)
-        end
-
-        def create_substitute_object_for_belongs_to(record, relationship_name, options)
-          relationship_id = options[:id_method_name] || "#{relationship_name}_id".to_sym
-          OpenStruct.new(id: record.send(relationship_id))
-        end
-
-        def belongs_to_optimized_block(relationship_name, options = {}, &block)
-          return block if options[:skip_optimization] == true || block
-
-          proc do |record, params|
-            if params && params[:include]
-              lookup_full_object(record_for_belongs_to, relationship_name, options, params)
-            else
-              create_substitute_object_for_belongs_to(record, relationship_name, options)
-            end
-          end
-        end
-
-        def create_included_proc_for_has_relation(relationship_name)
-          proc do |_record, params|
-            if params && params[:include]
-              parse_include(params).include?(relationship_name.to_s.dasherize)
-            else
-              false
-            end
-          end
-        end
-
-        def create_if_proc_for_has_relation(if_proc, included_proc)
-          if if_proc.present?
-            proc do |record, params|
-              FastJsonapi.call_proc(included_proc, record, params) && FastJsonapi.call_proc(if_proc, record, params)
-            end
-          else
-            included_proc
-          end
-        end
-
-        def has_relation_optimized_options(relationship_name, options) # rubocop:disable Naming/PredicateName reason: method override
-          return options if options[:skip_optimization] == true
-
-          options[:if] = create_if_proc_for_has_relation(options[:if], create_included_proc_for_has_relation(relationship_name))
-          options
-        end
-      end
-    end
-  end
-end

data/lib/sn_foil/controller/api.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-require 'action_controller/api'
-require_relative 'base'
-
-module SnFoil
-  module Controller
-    class API < SnFoil::Controller::Base
-      class << self
-        attr_reader :i_serializer, :i_deserializer
-
-        def serializer(klass = nil)
-          @i_serializer = klass
-        end
-
-        def deserializer(klass = nil)
-          @i_deserializer = klass
-        end
-      end
-
-      def serializer(**options)
-        options[:serializer] || self.class.i_serializer
-      end
-
-      def deserializer(**options)
-        options[:deserializer] || self.class.i_deserializer
-      end
-
-      def setup_options(**options)
-        inject_deserialized_params(super)
-      end
-
-      def setup_create(**options)
-        super(**options.merge(deserialize: true))
-      end
-
-      def setup_update(**options)
-        super(**options.merge(deserialize: true))
-      end
-
-      def render_change(model, **options)
-        if model.errors.empty?
-          params
-          render json: serializer(**options).new(model,
-                                                 **options,
-                                                 params: (options[:controller_params] || options[:params] || {})
-                                                           .merge(current_entity: context_entity)).serializable_hash
-        else
-          render json: model.errors, status: :unprocessable_entity
-        end
-      end
-
-      def render_destroy(model, **_options)
-        if model.errors.empty?
-          render json: {}, status: :no_content
-        else
-          render json: model.errors, status: :unprocessable_entity
-        end
-      end
-
-      def render_index(results, **options)
-        render json: serializer(**options).new(paginate(results, **options),
-                                               **options,
-                                               params: (options[:controller_params] || options[:params] || {})
-                                                         .merge(current_entity: context_entity),
-                                               meta: meta(results, **options))
-                                          .serializable_hash
-      end
-
-      def render_show(model, **options)
-        render json: serializer(**options).new(model,
-                                               **options,
-                                               params: (options[:controller_params] || options[:params] || {})
-                                                         .merge(current_entity: context_entity)).serializable_hash
-      end
-
-      private
-
-      def inject_deserialized_params(**options)
-        return options unless options[:params].present? && options[:deserialize] == true
-        return options unless deserializer(**options)
-
-        options[:params] = deserializer(**options).new(options[:params], **options).to_h
-        options
-      end
-    end
-  end
-end

data/lib/sn_foil/controller/base.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'concerns/create_controller_concern'
-require_relative 'concerns/destroy_controller_concern'
-require_relative 'concerns/index_controller_concern'
-require_relative 'concerns/show_controller_concern'
-require_relative 'concerns/update_controller_concern'
-
-module SnFoil
-  module Controller
-    class Base < ActionController::Base # rubocop:disable Rails/ApplicationController
-      include Concerns::CreateControllerConcern
-      include Concerns::DestroyControllerConcern
-      include Concerns::IndexControllerConcern
-      include Concerns::ShowControllerConcern
-      include Concerns::UpdateControllerConcern
-    end
-  end
-end

data/lib/sn_foil/controller/concerns/change_controller_concern.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/concern'
-
-module SnFoil
-  module Controller
-    module Concerns
-      module ChangeControllerConcern
-        extend ActiveSupport::Concern
-
-        def render_change(model, **_options)
-          if model.errors.empty?
-            render model
-          else
-            render model.errors, status: :unprocessable_entity
-          end
-        end
-      end
-    end
-  end
-end

data/lib/sn_foil/controller/concerns/create_controller_concern.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/concern'
-require_relative 'setup_controller_concern'
-require_relative 'change_controller_concern'
-
-module SnFoil
-  module Controller
-    module Concerns
-      module CreateControllerConcern
-        extend ActiveSupport::Concern
-
-        included do
-          include SetupControllerConcern
-          include ChangeControllerConcern
-        end
-
-        def create(**options)
-          options = setup_create(**options)
-          model = process_create(**options)
-          render_create(model, **options)
-        end
-
-        def setup_create(**options)
-          setup_options(**options)
-        end
-
-        def process_create(**options)
-          current_context(**options).create(**options)
-        end
-
-        def render_create(model, **options)
-          render_change(model, **options)
-        end
-      end
-    end
-  end
-end

data/lib/sn_foil/controller/concerns/destroy_controller_concern.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/concern'
-require_relative 'setup_controller_concern'
-
-module SnFoil
-  module Controller
-    module Concerns
-      module DestroyControllerConcern
-        extend ActiveSupport::Concern
-
-        included do
-          include SetupControllerConcern
-        end
-
-        def destroy(**options)
-          options = setup_destroy(**options)
-          model = process_destroy(**options)
-          render_destroy(model, **options)
-        end
-
-        def setup_destroy(**options)
-          setup_options(**options)
-        end
-
-        def process_destroy(**options)
-          current_context(**options).destroy(**options)
-        end
-
-        def render_destroy(model, **_options)
-          if model.errors.empty?
-            render nil
-          else
-            render model.errors, status: :unprocessable_entity
-          end
-        end
-      end
-    end
-  end
-end

data/lib/sn_foil/controller/concerns/index_controller_concern.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/concern'
-require_relative 'setup_controller_concern'
-
-module SnFoil
-  module Controller
-    module Concerns
-      module IndexControllerConcern
-        extend ActiveSupport::Concern
-
-        included do
-          include SetupControllerConcern
-        end
-
-        def index(**options)
-          options = setup_index(**options)
-          results = process_index(**options)
-          render_index(results, **options)
-        end
-
-        def setup_index(**options)
-          setup_options(**options)
-        end
-
-        def process_index(**options)
-          current_context(**options).index(options)
-        end
-
-        def render_index(results, **options)
-          render paginate(results, **options), meta: meta(results, options)
-        end
-
-        def paginate(results, **options)
-          return results unless results.respond_to?(:page)
-
-          results.page(page(**options))
-                 .per(per_page(**options))
-        end
-
-        def page(**options)
-          (options.dig(:params, :page) || 1).to_i
-        end
-
-        def per_page(**options)
-          per_page_param = (options.dig(:params, :per_page) || 10).to_i
-          return 1000 if per_page_param.zero? || per_page_param > 1000
-
-          per_page_param
-        end
-
-        def meta(results, **options)
-          results = paginate(results, **options)
-          total_pages = results.respond_to?(:total_pages) ? results.total_pages : nil
-          total_count = results.respond_to?(:total_count) ? results.total_count : nil
-
-          {
-            page: page(**options),
-            pages: total_pages,
-            total: total_count,
-            per: per_page(**options)
-          }
-        end
-      end
-    end
-  end
-end

data/lib/sn_foil/controller/concerns/setup_controller_concern.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/concern'
-
-module SnFoil
-  module Controller
-    module Concerns
-      module SetupControllerConcern
-        extend ActiveSupport::Concern
-
-        class_methods do
-          attr_reader :i_context
-
-          def context(klass = nil)
-            @i_context = klass
-          end
-        end
-
-        def context(**options)
-          options[:context] || self.class.i_context
-        end
-
-        def setup_options(**options)
-          options = inject_params(**options)
-          options = inject_id(**options)
-          options = inject_includes(**options)
-          inject_controller_action(**options)
-        end
-
-        def current_context(**options)
-          @current_context ||= context(**options).new(context_entity)
-        end
-
-        protected
-
-        def pundit_not_authorized
-          head :forbidden
-        end
-
-        private
-
-        # Grab the rails params and inject them into the options
-        def inject_params(**options)
-          return options if options[:params]
-          return options unless params
-
-          options[:params] = params.to_unsafe_h.deep_symbolize_keys
-          options[:controller_params] = options[:params]
-          options
-        end
-
-        def inject_id(**options)
-          return options if options[:id]
-
-          options[:id] = id if defined? id
-          options[:id] ||= options[:params][:id]
-          options
-        end
-
-        def inject_includes(**options)
-          return options if options[:include]
-          return options unless options.dig(:params, :include)
-
-          options[:include] = options.dig(:params, :include)
-                                     .split(',')
-                                     .map { |item| item.underscore.to_sym }
-          options
-        end
-
-        def inject_controller_action(**options)
-          return options if options[:controller_action]
-          return options unless options.dig(:params, :action)
-
-          options[:controller_action] = options[:params][:action]
-          options
-        end
-
-        def context_entity
-          return current_entity if defined? current_entity
-          return current_user if defined? current_user
-        end
-      end
-    end
-  end
-end