subroutine 0.10.0.beta → 0.10.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0dbba6e4428e540eddcfb16df3079f0d9c2db2d2
-  data.tar.gz: bd752b132b834c5c35e07fa2434f8d381da3c385
+SHA256:
+  metadata.gz: f2c3e4d90c09ae08102e8ab71974246b2052203ad830d838328e25345d92593e
+  data.tar.gz: a1f1e10be4abe4940ca34811ce4951d498ece0aa3bb2b199c776e3c13e142653
 SHA512:
-  metadata.gz: 439bce703b933575f763ac2aa4428e65babc620275a5ca45cae8ed255592428966867281d20f6093dea7fd2dde8fbc764d82f57dd5bc81e5e21d2562e5f94db0
-  data.tar.gz: 8e95b71122f2dcabf504c5c0f7674f12a79923175434cf65300161cc7251123b11a0f9a797889b4bd71b4a2d823921e3d6026f43e9200d8ffbb1d75f17a1a3a9
+  metadata.gz: 420d85e72ba91cb3f53025fb43d0dd5276bfbc057f3910acba283d53676667408fc4a52cc5ee5f6d18fc00ffd385ba180bf7b2bf62f608a9a0c37f5541b645cb
+  data.tar.gz: 47556a1a5be391f9f0fabad3f656b7a8f813aca312c2a82f278b8f347dddecb024ec5d0cb82d564e7488445ccbac3b50697be68aa769aaa78392d0af8e5186e6

data/.ruby-version

@@ -1 +1 @@
-2.4.6
+2.5.1

data/Gemfile

@@ -1,6 +1,8 @@
-source 'https://rubygems.org'
+# frozen_string_literal: true
+
+source "https://rubygems.org"
 
 # Specify your gem's dependencies in subroutine.gemspec
 gemspec
 
-gem 'activemodel', '~> 5.2.3'
+gem "activemodel", "~> 4.2.11"

data/lib/subroutine/association_fields/component_configuration.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "subroutine/fields/configuration"
+
+module Subroutine
+  module AssociationFields
+    class ComponentConfiguration < ::Subroutine::Fields::Configuration
+
+      def behavior
+        :association_component
+      end
+
+      def association_name
+        config[:association_name]
+      end
+
+    end
+  end
+end

data/lib/subroutine/association_fields/configuration.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "subroutine/fields/configuration"
+require "subroutine/association_fields/component_configuration"
+
+module Subroutine
+  module AssociationFields
+    class Configuration < ::Subroutine::Fields::Configuration
+
+      def validate!
+        super
+
+        if as && foreign_key
+          raise ArgumentError, ":as and :foreign_key options should not be provided together to an association invocation"
+        end
+      end
+
+      def required_modules
+        super + [::Subroutine::AssociationFields]
+      end
+
+      def polymorphic?
+        !!config[:polymorphic]
+      end
+
+      def as
+        config[:as] || field_name
+      end
+
+      def class_name
+        config[:class_name]
+      end
+
+      def inferred_class_name
+        class_name || as.to_s.camelize
+      end
+
+      def foreign_key
+        config[:foreign_key]
+      end
+
+      def foreign_key_method
+        foreign_key || "#{field_name}_id"
+      end
+
+      def foreign_type_method
+        foreign_key_method.gsub(/_id$/, "_type")
+      end
+
+      def build_foreign_key_field
+        build_child_field(foreign_key_method)
+      end
+
+      def build_foreign_type_field
+        build_child_field(foreign_type_method)
+      end
+
+      def unscoped?
+        !!config[:unscoped]
+      end
+
+      def behavior
+        :association
+      end
+
+      protected
+
+      def build_child_field(name)
+        ComponentConfiguration.new(name, inheritable_options.merge(association_name: as))
+      end
+
+    end
+  end
+end

data/lib/subroutine/association_fields.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "delegate"
+require "active_support/concern"
+require "subroutine/association_fields/configuration"
+
+module Subroutine
+  module AssociationFields
+
+    extend ActiveSupport::Concern
+
+    included do
+      class << self
+
+        alias_method :field_without_association, :field
+        alias_method :field, :field_with_association
+
+      end
+
+      alias_method :set_field_without_association, :set_field
+      alias_method :set_field, :set_field_with_association
+
+      alias_method :get_field_without_association, :get_field
+      alias_method :get_field, :get_field_with_association
+
+      alias_method :clear_field_without_association, :clear_field
+      alias_method :clear_field, :clear_field_with_association
+
+      alias_method :field_provided_without_association?, :field_provided?
+      alias_method :field_provided?, :field_provided_with_association?
+    end
+
+    module ClassMethods
+
+      def association(field_name, opts = {})
+        field(field_name, opts.merge(type: :association))
+      end
+
+      # association :user
+      #  - user_id
+      #  - user_type => "User"
+
+      # association :user, polymorphic: true
+      #  - user_id
+      #  - user_type
+      #  - user => polymorphic_lookup(user_type, user_id)
+
+      # association :inbound_user_request, as: :request
+      #  - inbound_user_request_id
+      #  - inbound_user_request_type => "InboundUserRequest"
+      #  - request => polymorphic_lookup(inbound_user_request_type, inbound_user_request_id)
+
+      # association :inbound_user_request, foreign_key: :request_id
+      #  - request_id
+      #  - request_type
+      #  - inbound_user_request => polymorphic_lookup(request_type, request_id)
+
+      # Other options:
+      # - unscoped => set true if the record should be looked up via Type.unscoped
+
+      def field_with_association(field_name, options = {})
+        if options[:type]&.to_sym == :association
+          config = ::Subroutine::AssociationFields::Configuration.new(field_name, options)
+
+          if config.polymorphic?
+            string config.foreign_type_method, config.build_foreign_type_field
+          else
+            class_eval <<-EV, __FILE__, __LINE__ + 1
+              def #{config.foreign_type_method}
+                #{config.inferred_class_name.inspect}
+              end
+            EV
+          end
+
+          integer config.foreign_key_method, config.build_foreign_key_field
+
+          field_without_association(config.as, config)
+        else
+          field_without_association(field_name, options)
+        end
+      end
+
+    end
+
+    def set_field_with_association(field_name, value, opts = {})
+      config = get_field_config(field_name)
+
+      if config&.behavior == :association
+        set_field(config.foreign_type_method, value&.class&.name, opts) if config.polymorphic?
+        set_field(config.foreign_key_method, value&.id, opts)
+      elsif config&.behavior == :association_component
+        clear_field_without_association(config.association_name)
+      end
+
+      set_field_without_association(field_name, value, opts)
+    end
+
+    def get_field_with_association(field_name)
+      config = get_field_config(field_name)
+
+      if config&.behavior == :association
+        stored_result = get_field_without_association(field_name)
+        return stored_result unless stored_result.nil?
+
+        fk = send(config.foreign_key_method)
+        type = send(config.foreign_type_method)
+
+        result = fetch_association_instance(type, fk, config.unscoped?)
+        set_field_without_association(field_name, result)
+        result
+      else
+        get_field_without_association(field_name)
+      end
+    end
+
+    def clear_field_with_association(field_name)
+      config = get_field_config(field_name)
+
+      if config&.behavior == :association
+        clear_field(config.foreign_type_method) if config.polymorphic?
+        clear_field(config.foreign_key_method)
+      end
+
+      clear_field_without_association(field_name)
+    end
+
+    def field_provided_with_association?(field_name)
+      config = get_field_config(field_name)
+
+      if config&.behavior == :association
+        provided = true
+        provided &&= field_provided?(config.foreign_type_method) if config.polymorphic?
+        provided &&= field_provided?(config.foreign_key_method)
+        provided
+      elsif config&.behavior == :association_component
+        field_provided_without_association?(field_name) ||
+          field_provided_without_association?(config.association_name)
+      else
+        field_provided_without_association?(field_name)
+      end
+    end
+
+    def fetch_association_instance(_type, _fk, _unscoped = false)
+      return nil unless _type && _fk
+
+      klass = _type
+      klass = klass.classify.constantize if klass.is_a?(String)
+
+      return nil unless klass
+
+      scope = klass.all
+      scope = scope.unscoped if _unscoped
+
+      scope.find(_fk)
+    end
+
+  end
+end

data/lib/subroutine/auth.rb

@@ -2,34 +2,37 @@
 
 module Subroutine
   module Auth
+
+    extend ActiveSupport::Concern
+
     class NotAuthorizedError < ::StandardError
+
       def initialize(msg = nil)
-        msg = I18n.t("errors.#{msg}", default: 'Sorry, you are not authorized to perform this action.') if msg.is_a?(Symbol)
-        msg ||= I18n.t('errors.unauthorized', default: 'Sorry, you are not authorized to perform this action.')
+        msg = I18n.t("errors.#{msg}", default: "Sorry, you are not authorized to perform this action.") if msg.is_a?(Symbol)
+        msg ||= I18n.t("errors.unauthorized", default: "Sorry, you are not authorized to perform this action.")
         super msg
       end
 
       def status
         401
       end
+
     end
 
     class AuthorizationNotDeclaredError < ::StandardError
+
       def initialize(msg = nil)
-        super(msg || 'Authorization management has not been declared on this class')
+        super(msg || "Authorization management has not been declared on this class")
       end
-    end
 
-    def self.included(base)
-      base.instance_eval do
-        extend ::Subroutine::Auth::ClassMethods
+    end
 
-        class_attribute :authorization_declared, instance_writer: false
-        self.authorization_declared = false
+    included do
+      class_attribute :authorization_declared, instance_writer: false
+      self.authorization_declared = false
 
-        class_attribute :user_class_name, instance_writer: false
-        self.user_class_name = "User"
-      end
+      class_attribute :user_class_name, instance_writer: false
+      self.user_class_name = "User"
     end
 
     module ClassMethods
@@ -38,7 +41,6 @@ module Subroutine
         [user_class_name, "Integer", "NilClass"].compact
       end
 
-
       def authorize(validation_name)
         validate validation_name, unless: :skip_auth_checks?
       end
@@ -96,17 +98,19 @@ module Subroutine
           end
         end
       end
+
     end
 
     def initialize(*args, &block)
       raise Subroutine::Auth::AuthorizationNotDeclaredError unless self.class.authorization_declared
 
       super(args.extract_options!, &block)
+
       @skip_auth_checks = false
       @current_user = args.shift
 
-      unless self.class.supported_user_class_names.include?(@current_user.class.name)
-        raise ArgumentError, "current_user must be one of the following types {#{self.class.supported_user_class_names.join(",")}} but was #{@current_user.class.name}"
+      unless self.class.supported_user_class_names.include?(current_user.class.name)
+        raise ArgumentError, "current_user must be one of the following types {#{self.class.supported_user_class_names.join(",")}} but was #{current_user.class.name}"
       end
     end
 
@@ -120,7 +124,7 @@ module Subroutine
     end
 
     def current_user
-      @current_user = self.user_class_name.constantize.find(@current_user) if ::Integer === @current_user
+      @current_user = user_class_name.constantize.find(@current_user) if ::Integer === @current_user
       @current_user
     end
 
@@ -128,5 +132,6 @@ module Subroutine
       reason ||= :unauthorized
       raise ::Subroutine::Auth::NotAuthorizedError, reason
     end
+
   end
 end

data/lib/subroutine/fields/configuration.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module Subroutine
+  module Fields
+    class Configuration < ::SimpleDelegator
+
+      PROTECTED_GROUP_IDENTIFIERS = %i[all original default].freeze
+      INHERITABLE_OPTIONS = %i[mass_assignable field_reader field_writer].freeze
+
+      def self.from(field_name, options)
+        case options
+        when Subroutine::Fields::Configuration
+          options.class.new(field_name, options)
+        else
+          new(field_name, options)
+        end
+      end
+
+      attr_reader :field_name
+
+      def initialize(field_name, options)
+        @field_name = field_name
+        config = sanitize_options(options)
+        super(config)
+        validate!
+      end
+
+      alias config __getobj__
+
+      def required_modules
+        []
+      end
+
+      def behavior
+        nil
+      end
+
+      def inheritable_options
+        config.slice(*INHERITABLE_OPTIONS)
+      end
+
+      def mass_assignable?
+        config[:mass_assignable] != false
+      end
+
+      def field_writer?
+        config[:field_writer] != false
+      end
+
+      def field_reader?
+        config[:field_reader] != false
+      end
+
+      def parent_field
+        config[:parent_field]
+      end
+
+      def groups
+        config[:groups]
+      end
+
+      def in_group?(group_name)
+        groups.include?(group_name.to_sym)
+      end
+
+      def validate!
+        PROTECTED_GROUP_IDENTIFIERS.each do |group_name|
+          next unless in_group?(group_name)
+
+          raise ArgumentError, "Cannot assign a field to protected group `#{group}`. Protected groups are: #{PROTECTED_GROUP_IDENTIFIERS.join(", ")}"
+        end
+      end
+
+      def sanitize_options(options)
+        opts = (options || {}).to_h.dup
+        groups = opts[:group] || opts[:groups]
+        opts[:groups] = Array(groups).map(&:to_sym)
+        opts.delete(:group)
+        opts
+      end
+
+      def inspect
+        "#<#{self.class}:#{object_id} name=#{field_name} config=#{config.inspect}>"
+      end
+
+    end
+  end
+end

data/lib/subroutine/fields/mass_assignment_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Subroutine
+  module Fields
+    class MassAssignmentError < ::StandardError
+
+      def initialize(field_name)
+        super("`#{field_name}` is not mass assignable")
+      end
+
+    end
+  end
+end