pan_stuff 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 617af704f2bf1397d4013602cdaae42c69b97d12d9025b3c5dca2b63eb06328a
+  data.tar.gz: cc964c632f08f9e7f9a66ae7caa50479ec25f98781a30fe5e26fe2ddc5a18937
+SHA512:
+  metadata.gz: a3608b95a5da82acdebb56893939254730ed81639e969d5fb64c8df48ff793038b00b441c087b9201674598cf37c4222256a891fe56591b94ec7b62f05037372
+  data.tar.gz: 85d7475fdd592331c35e941208fd5a7d32e7fe87e3ed7f3b8e36569250692a3ac050a3fee9f1b4b107afffb08cd663488246e32475c099e5a1af72322c370037

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright Umberto Peserico
+
+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,28 @@
+# PanStuff
+Short description and motivation.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "pan_stuff"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install pan_stuff
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler/setup"
+
+require "bundler/gem_tasks"

data/lib/pan_stuff/active_record_pagination.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module PanStuff
+  module ActiveRecordPagination
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def paginate(current_page:, items_per_page:)
+        limit  = items_per_page
+        offset = (current_page - 1) * items_per_page
+
+        total_count = count
+        total_pages = (total_count.to_d / items_per_page).ceil
+
+        metadata = {
+          total_count:    total_count,
+          total_pages:    total_pages,
+          current_page:   current_page,
+          items_per_page: items_per_page,
+        }
+        [
+          limit(limit).offset(offset),
+          metadata,
+        ]
+      end
+    end
+  end
+end

data/lib/pan_stuff/method_not_overridden_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module PanStuff
+  class MethodNotOverriddenError < StandardError
+    def initialize(method, object)
+      super("Method #{method} not overridden in #{object}")
+    end
+  end
+end

data/lib/pan_stuff/pagination/metadata.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module PanStuff
+  module Pagination
+    class Metadata
+      include ActiveModel::Model
+      include ActiveModel::Attributes
+
+      attribute :total_count
+      attribute :total_pages
+      attribute :current_page
+      attribute :items_per_page
+    end
+  end
+end

data/lib/pan_stuff/pagination/metadata_serializer.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module PanStuff
+  module Pagination
+    class MetadataSerializer
+      include ::PanStuff::Serializer::ObjectSerializer
+
+      attribute :total_count
+      attribute :total_pages
+      attribute :current_page
+      attribute :items_per_page
+    end
+  end
+end

data/lib/pan_stuff/params_helpers.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module PanStuff
+  module ParamsHelpers
+    extend ActiveSupport::Concern
+
+    def request_params
+      request.request_parameters.to_h.deep_symbolize_keys
+    end
+
+    def query_params
+      res = request.query_parameters.deep_transform_keys(&:underscore).deep_symbolize_keys
+
+      parse_query_params(res)
+    end
+
+    private
+
+    def parse_query_params(val)
+      case val
+      when ->(v) { v.is_a?(Hash) }
+        val.transform_values do |val2|
+          parse_query_params(val2)
+        end
+      when ->(v) { v.is_a?(Array) }
+        val.map { |v| parse_query_params(v) }
+      when 'null', 'undefined'
+        nil
+      else
+        val
+      end
+    end
+  end
+end

data/lib/pan_stuff/railtie.rb

@@ -0,0 +1,37 @@
+module PanStuff
+  class Railtie < ::Rails::Railtie
+
+    initializer 'pan_stuff.setup_renderers' do
+      ActionController::Renderers.add :resource do |resource, options|
+        options = options.slice(:serializer, :meta, :message, :context, :message, :location)
+      
+        result = options[:serializer].new(resource, meta: options[:meta], message: options[:message]).as_json
+      
+        self.content_type = Mime[:json]
+      
+        result
+      end
+      
+      ActionController::Renderers.add :resource_errors do |errors, _options|
+        result = PanStuff::Serializer::ResourceErrorsSerializer.new(errors).as_json
+      
+        self.content_type = Mime[:json]
+      
+        result
+      end
+      
+      ActionController::Renderers.add :exception do |exception, options|
+        options = options.slice(:status, :error)
+      
+        result = PanStuff::Serializer::ExceptionSerializer.new(exception: exception, root: false, **options).as_json
+      
+        self.content_type = Mime[:json]
+      
+        result
+      end
+
+      ActiveRecord::Base.send(:include, PanStuff::ActiveRecordPagination)
+    end
+
+  end
+end

data/lib/pan_stuff/resources_controller.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module PanStuff
+  module ResourcesController
+    extend ActiveSupport::Concern
+
+    def index
+      @resource_collection = resource_collection_resolver
+
+      render resource:   @resource_collection,
+             serializer: index_resource_serializer,
+             context:    context,
+             meta:       meta
+    end
+
+    def show
+      @resource = resource_finder
+
+      render resource:   @resource,
+             serializer: show_resource_serializer,
+             context:    context,
+             meta:       meta,
+             location:   resource_location
+    end
+
+    def create
+      @resource = resource_creator
+
+      if @resource.errors.any?
+        render resource_errors: @resource.errors, status: :unprocessable_entity
+      else
+        render resource:   @resource,
+               serializer: create_resource_serializer,
+               context:    context,
+               meta:       meta,
+               message:    create_message,
+               location:   resource_location,
+               status:     :created
+      end
+    end
+
+    def update
+      @resource = resource_updater
+
+      if @resource.errors.any?
+        render resource_errors: @resource.errors, status: :unprocessable_entity
+      else
+        render resource:   @resource,
+               serializer: update_resource_serializer,
+               context:    context,
+               meta:       meta,
+               message:    update_message,
+               location:   resource_location
+      end
+    end
+
+    def destroy
+      @resource = resource_destroyer
+
+      if @resource.errors.any?
+        render resource_errors: @resource.errors, status: :unprocessable_entity
+      else
+        render resource:   @resource,
+               serializer: destroy_resource_serializer,
+               context:    context,
+               meta:       meta,
+               message:    destroy_message,
+               location:   resource_location
+      end
+    end
+
+    protected
+
+    def context
+      @context ||= {}
+    end
+
+    def add_meta(key, value)
+      meta[key] = value
+    end
+
+    def meta
+      @meta ||= {}
+    end
+
+    def resource_service
+      resource_service_class.new
+    end
+
+    def resource_service_class
+      raise MethodNotOverriddenError.new(__method__, self)
+    end
+
+    def resource_serializer
+      raise MethodNotOverriddenError.new(__method__, self)
+    end
+
+    def resource_location
+      raise MethodNotOverriddenError.new(__method__, self)
+    end
+
+    def resource_params_root_key
+      raise MethodNotOverriddenError.new(__method__, self)
+    end
+
+    def create_message
+      nil
+    end
+
+    def update_message
+      nil
+    end
+
+    def destroy_message
+      nil
+    end
+
+    def resource_params
+      @resource_params ||= request_params.fetch(resource_params_root_key)
+    rescue KeyError => e
+      raise ActionController::ParameterMissing, e
+    end
+
+    def context=(context)
+      self.context.merge!(context)
+    end
+
+    def index_resource_serializer
+      resource_serializer
+    end
+
+    def show_resource_serializer
+      resource_serializer
+    end
+
+    def create_resource_serializer
+      resource_serializer
+    end
+
+    def update_resource_serializer
+      resource_serializer
+    end
+
+    def destroy_resource_serializer
+      resource_serializer
+    end
+
+    def resource_collection_resolver
+      resource_service.all(ancestry_key_params)
+    end
+
+    def resource_finder
+      resource_service.find(ancestry_key_params, resource_key_param)
+    end
+
+    def resource_creator
+      resource_service.create(ancestry_key_params, resource_create_params)
+    end
+
+    def resource_updater
+      resource_service.update(ancestry_key_params, resource_key_param, resource_update_params)
+    end
+
+    def resource_destroyer
+      resource_service.destroy(ancestry_key_params, resource_key_param)
+    end
+
+    def resource_key_param
+      params[:id]
+    end
+
+    def ancestry_key_params
+      {}
+    end
+
+    def resource_create_params
+      resource_params
+    end
+
+    def resource_update_params
+      resource_params
+    end
+  end
+end

data/lib/pan_stuff/serializer/base.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module PanStuff
+  module Serializer
+    module Base
+      extend ActiveSupport::Concern
+
+      TRANSFORMS_MAPPING = {
+        camel_lower: %i[camelize lower],
+        underscore:  :underscore,
+      }.freeze
+
+      included do
+        cattr_accessor :transform_method_value, default: TRANSFORMS_MAPPING[:camel_lower]
+      end
+
+      def as_json(opts = nil)
+        JSON.generate(result, opts)
+      end
+
+      def to_h
+        result
+      end
+
+      alias to_hash to_h
+
+      def serializable_hash!
+        nil
+      end
+
+      def run_key_transform!(key)
+        key.to_s.send(*transform_method_value).to_sym
+      end
+
+      class_methods do
+        def transform_method(transform_method)
+          unless TRANSFORMS_MAPPING.key?(transform_method)
+            raise StandardError, "Transform method must be equal to #{TRANSFORMS_MAPPING.keys}"
+          end
+
+          self.transform_method_value = TRANSFORMS_MAPPING[transform_method]
+        end
+
+        def collection?(resource)
+          resource.is_a?(Enumerable) && !resource.respond_to?(:each_pair)
+        end
+      end
+
+      private
+
+      def result
+        @result ||= serializable_hash!
+      end
+    end
+  end
+end

data/lib/pan_stuff/serializer/exception_serializer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module PanStuff
+  module Serializer
+    class ExceptionSerializer
+      include Base
+
+      attr_reader :error, :status, :exception, :root
+
+      def initialize(status: nil, error: nil, exception: nil, root: true)
+        @error     = error
+        @status    = status
+        @exception = exception
+        @root      = root
+      end
+
+      protected
+
+      def serializable_hash!
+        data   = {}
+        result = {}
+
+        data[run_key_transform!(:status)]    = status
+        data[run_key_transform!(:error)]     = error if error
+        data[run_key_transform!(:exception)] = exception if exception
+
+        if root
+          result[run_key_transform!(:validation_response)] = data
+          result
+        else
+          data
+        end
+      end
+    end
+  end
+end

data/lib/pan_stuff/serializer/hash_serializer.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module PanStuff
+  module Serializer
+    class HashSerializer
+      include Base
+
+      attr_reader :hash, :meta, :message, :root
+
+      def initialize(resource, meta: nil, message: nil, context: nil, root: true)
+        @hash     = resource
+        @resource = resource
+        @meta     = meta
+        @message  = message
+        @context  = context || {}
+        @root     = root
+      end
+
+      def data
+        hash
+      end
+
+      protected
+
+      def serializable_hash!
+        if root
+          result = {}
+
+          result[run_key_transform!(:data)]    = serialize_data
+          result[run_key_transform!(:meta)]    = meta&.deep_transform_keys { |key| run_key_transform!(key) } if meta
+          result[run_key_transform!(:message)] = message if message
+
+          result
+        else
+          serialize_data
+        end
+      end
+
+      def serialize_data
+        if self.class.collection? @resource
+          @resource.map { |o| o.deep_transform_keys { |key| run_key_transform!(key) } }
+        else
+          @resource&.deep_transform_keys { |key| run_key_transform!(key) }
+        end
+      end
+    end
+  end
+end

data/lib/pan_stuff/serializer/money_serializer.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module PanStuff
+  module Serializer
+    class MoneySerializer
+      include ObjectSerializer
+
+      attribute :cents, method: :cents
+      attribute :amount, method: :amount
+      attribute :currency, method: :currency
+      attribute :formatted_text, method: :formatted_text
+      attribute :symbol, method: :symbol
+
+      def cents(record)
+        record.cents
+      end
+
+      def amount(record)
+        record.to_f
+      end
+
+      def currency(record)
+        record.currency.iso_code
+      end
+
+      def formatted_text(record)
+        record.format(symbol: "#{record.currency.symbol} ")
+      end
+
+      def symbol(record)
+        record.currency.symbol
+      end
+    end
+  end
+end

data/lib/pan_stuff/serializer/object_serializer.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module PanStuff
+  module Serializer
+    module ObjectSerializer
+      extend ActiveSupport::Concern
+      include Base
+
+      included do
+        class << self
+          attr_writer :attributes_to_serialize
+
+          def attributes_to_serialize
+            @attributes_to_serialize ||= []
+          end
+        end
+
+        attr_reader :resource, :message, :context, :root
+      end
+
+      def initialize(resource, meta: nil, message: nil, context: nil, root: true)
+        @resource = resource
+        @meta     = meta
+        @message  = message
+        @context  = context || {}
+        @root     = root
+      end
+
+      class_methods do
+        def attribute(key, options = {})
+          attributes_to_serialize.push({
+                                         name: key,
+                                         **options.slice(:method, :serializer, :serialize_if),
+                                       })
+        end
+      end
+
+      def data
+        if self.class.collection? @resource
+          data_for_collection
+        else
+          data_for_one_record
+        end
+      end
+
+      def meta
+        @meta&.deep_transform_keys do |k|
+          run_key_transform!(k)
+        end
+      end
+
+      def serializable_hash!
+        if root
+          use_root
+        else
+          data
+        end
+      end
+
+      private
+
+      def data_for_collection
+        @resource.map { |el| build_record(el) }
+      end
+
+      def data_for_one_record
+        build_record(@resource) if @resource
+      end
+
+      def build_record(record)
+        self.class.attributes_to_serialize.each_with_object({}) do |attr, hash|
+          name         = attr[:name]
+          serializer   = attr[:serializer]
+          method       = attr[:method]
+          serialize_if = attr[:serialize_if]
+
+          next if serialize_if && !serialize_if.call(context)
+
+          hash[run_key_transform!(name)] = if serializer.present?
+                                             attr[:serializer].new(record.send(name), root: false, context: context)
+                                               .to_h
+                                           elsif method.present?
+                                             send(method, record)
+                                           else
+                                             record.send(name)
+                                           end
+        end
+      end
+
+      def use_root
+        result = {}
+
+        result[run_key_transform!(:data)]    = data
+        result[run_key_transform!(:meta)]    = meta if @meta.present?
+        result[run_key_transform!(:message)] = message if @message.present?
+
+        result
+      end
+    end
+  end
+end

data/lib/pan_stuff/serializer/resource_errors_serializer.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module PanStuff
+  module Serializer
+    class ResourceErrorsSerializer
+      include Base
+
+      def initialize(errors)
+        @resource             = errors
+      end
+
+      private
+
+      def errors
+        @resource.full_messages
+      end
+
+      def details
+        @resource.details.each_with_object({}) do |error, result|
+          field                             = error[0]
+          errors                            = error[1]
+          result[run_key_transform!(field)] = errors.map do |e|
+            e.each_with_object({}) do |obj, result2|
+              if obj[0] == :error
+                result2[:error] = run_key_transform!(obj[1])
+              else
+                result2[run_key_transform!(obj[0])] = obj[1]
+              end
+            end
+          end
+        end
+      end
+
+      def serializable_hash!
+        result = {}
+
+        result[run_key_transform!(:errors)]  = errors
+        result[run_key_transform!(:details)] = details
+
+        result
+      end
+    end
+  end
+end

data/lib/pan_stuff/serializer/smart_hash_serializer.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module PanStuff
+  module Serializer
+    class SmartHashSerializer < HashSerializer
+      def initialize(resource, meta: nil, message: nil, context: nil, root: true)
+        super(
+          check_type(resource),
+          meta:    meta,
+          message: message,
+          context: context,
+          root:    root,
+        )
+      end
+
+      private
+
+      def check_type(stuff)
+        case stuff
+        when Array
+          stuff.map { |s| check_type(s) }
+        when Hash
+          stuff.transform_values { |v| check_type(v) }
+        when Money
+          MoneySerializer.new(stuff, root: false).data
+        else
+          stuff
+        end
+      end
+    end
+  end
+end

data/lib/pan_stuff/serializer/validation_response.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module PanStuff
+  module Serializer
+    class ValidationResponse
+      include ActiveModel::Model
+      include ActiveModel::Attributes
+      include ActiveModel::Serialization
+
+      attribute :id, type: :string
+      attribute :status, type: :integer
+      attribute :message, type: :string
+    end
+  end
+end

data/lib/pan_stuff/serializer/validation_response_serializer.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module PanStuff
+  module Serializer
+    class ValidationResponseSerializer
+      include Base
+
+      attr_reader :message
+
+      def initialize(resource, message = nil)
+        @resource             = resource
+        @message              = message
+      end
+
+      protected
+
+      def validation_response
+        @resource.attributes.symbolize_keys.deep_transform_keys do |k|
+          run_key_transform!(k)
+        end
+      end
+
+      def serializable_hash!
+        result = {}
+
+        result[run_key_transform!(:validation_response)] = validation_response
+        result[run_key_transform!(:message)]             = message if message
+
+        result
+      end
+    end
+  end
+end

data/lib/pan_stuff/serializer.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module PanStuff
+  module Serializer
+  end
+end

data/lib/pan_stuff/version.rb

@@ -0,0 +1,3 @@
+module PanStuff
+  VERSION = "0.1.0"
+end

data/lib/pan_stuff.rb

@@ -0,0 +1,12 @@
+require "zeitwerk"
+
+require 'active_model'
+require 'json'
+require 'money'
+
+loader = Zeitwerk::Loader.for_gem
+loader.setup
+loader.eager_load
+
+module PanStuff
+end

data/lib/tasks/pan_stuff_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :pan_stuff do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: pan_stuff
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Umberto Peserico
+- Alessio Bussolari
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-09-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: money
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.19'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8'
+description: Description of PanStuff.
+email:
+- umberto.peserico@pandev.it
+- alessio.bussolari@pandev.it
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/pan_stuff.rb
+- lib/pan_stuff/active_record_pagination.rb
+- lib/pan_stuff/method_not_overridden_error.rb
+- lib/pan_stuff/pagination/metadata.rb
+- lib/pan_stuff/pagination/metadata_serializer.rb
+- lib/pan_stuff/params_helpers.rb
+- lib/pan_stuff/railtie.rb
+- lib/pan_stuff/resources_controller.rb
+- lib/pan_stuff/serializer.rb
+- lib/pan_stuff/serializer/base.rb
+- lib/pan_stuff/serializer/exception_serializer.rb
+- lib/pan_stuff/serializer/hash_serializer.rb
+- lib/pan_stuff/serializer/money_serializer.rb
+- lib/pan_stuff/serializer/object_serializer.rb
+- lib/pan_stuff/serializer/resource_errors_serializer.rb
+- lib/pan_stuff/serializer/smart_hash_serializer.rb
+- lib/pan_stuff/serializer/validation_response.rb
+- lib/pan_stuff/serializer/validation_response_serializer.rb
+- lib/pan_stuff/version.rb
+- lib/tasks/pan_stuff_tasks.rake
+homepage: https://bitbucket.org/pandev-srl/pan-stuff
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  homepage_uri: https://bitbucket.org/pandev-srl/pan-stuff
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.17
+signing_key:
+specification_version: 4
+summary: Summary of PanStuff.
+test_files: []