glib-web 0.5.96 → 0.5.97

data/app/models/glib/active_storage/attachment.rb

@@ -1,9 +1,9 @@
-module Glib
-  module ActiveStorage
-    class Attachment < ::ActiveStorage::Attachment
-      if Glib::DynamicText::Config.database_url.present?
-        connects_to database: { writing: :dynamic_text, reading: :dynamic_text }
-      end
-    end
-  end
-end
+module Glib
+  module ActiveStorage
+    class Attachment < ::ActiveStorage::Attachment
+      if Glib::DynamicText::Config.database_url.present?
+        connects_to database: { writing: :dynamic_text, reading: :dynamic_text }
+      end
+    end
+  end
+end

data/app/models/glib/active_storage/blob.rb

@@ -1,9 +1,9 @@
-module Glib
-  module ActiveStorage
-    class Blob < ::ActiveStorage::Blob
-      if Glib::DynamicText::Config.database_url.present?
-        connects_to database: { writing: :dynamic_text, reading: :dynamic_text }
-      end
-    end
-  end
-end
+module Glib
+  module ActiveStorage
+    class Blob < ::ActiveStorage::Blob
+      if Glib::DynamicText::Config.database_url.present?
+        connects_to database: { writing: :dynamic_text, reading: :dynamic_text }
+      end
+    end
+  end
+end

data/app/models/glib/application_record.rb

@@ -1,18 +1,18 @@
-module Glib
-  class ApplicationRecord < ActiveRecord::Base
-    self.abstract_class = true
-
-    scope :created_asc, -> { order(created_at: :asc) }
-    scope :created_desc, -> { order(created_at: :desc) }
-
-    def glib_enum_humanize(enum_name, default_value = nil)
-      self.class.glib_enum_humanize(enum_name, send(enum_name), default_value)
-    end
-
-    def self.glib_enum_humanize(enum_name, enum_value, default_value = nil)
-      if enum_value
-        I18n.t("activerecord.attributes.#{model_name.i18n_key}.#{enum_name.to_s.pluralize}.#{enum_value}", default: default_value)
-      end
-    end
-  end
-end
+module Glib
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+
+    scope :created_asc, -> { order(created_at: :asc) }
+    scope :created_desc, -> { order(created_at: :desc) }
+
+    def glib_enum_humanize(enum_name, default_value = nil)
+      self.class.glib_enum_humanize(enum_name, send(enum_name), default_value)
+    end
+
+    def self.glib_enum_humanize(enum_name, enum_value, default_value = nil)
+      if enum_value
+        I18n.t("activerecord.attributes.#{model_name.i18n_key}.#{enum_name.to_s.pluralize}.#{enum_value}", default: default_value)
+      end
+    end
+  end
+end

data/app/models/glib/dynamic_text_record.rb

@@ -1,9 +1,9 @@
-module Glib
-  class DynamicTextRecord < ActiveRecord::Base
-    self.abstract_class = true
-
-    if Glib::DynamicText::Config.database_url.present?
-      connects_to database: { writing: :dynamic_text, reading: :dynamic_text }
-    end
-  end
-end
+module Glib
+  class DynamicTextRecord < ActiveRecord::Base
+    self.abstract_class = true
+
+    if Glib::DynamicText::Config.database_url.present?
+      connects_to database: { writing: :dynamic_text, reading: :dynamic_text }
+    end
+  end
+end

data/app/models/glib/text.rb

@@ -1,96 +1,96 @@
-module Glib
-  class Text < Glib::DynamicTextRecord
-    class << self
-      def dt_has_many_attached(name, dependent: :purge_later)
-        generated_association_methods.class_eval <<-CODE, __FILE__, __LINE__ + 1
-          def #{name}
-            @active_storage_attached_#{name} ||= ::ActiveStorage::Attached::Many.new("#{name}", self)
-          end
-
-          def #{name}=(attachables)
-            if ActiveStorage.replace_on_assign_to_many
-              attachment_changes["#{name}"] =
-                if Array(attachables).none?
-                  ::ActiveStorage::Attached::Changes::DeleteMany.new("#{name}", self)
-                else
-                  ::ActiveStorage::Attached::Changes::CreateMany.new("#{name}", self, attachables)
-                end
-            else
-              if Array(attachables).any?
-                attachment_changes["#{name}"] =
-                  ::ActiveStorage::Attached::Changes::CreateMany.new("#{name}", self, #{name}.blobs + attachables)
-              end
-            end
-          end
-        CODE
-
-        has_many :"#{name}_attachments", -> { where(name: name) }, as: :record, class_name: "Glib::ActiveStorage::Attachment", inverse_of: :record, dependent: :destroy do
-          def purge
-            each(&:purge)
-            reset
-          end
-
-          def purge_later
-            each(&:purge_later)
-            reset
-          end
-        end
-        has_many :"#{name}_blobs", through: :"#{name}_attachments", class_name: "Glib::ActiveStorage::Blob", source: :blob
-
-        scope :"with_attached_#{name}", -> { includes("#{name}_attachments": :blob) }
-
-        after_save { attachment_changes[name.to_s]&.save }
-
-        after_commit(on: %i[ create update ]) { attachment_changes.delete(name.to_s).try(:upload) }
-
-        ActiveRecord::Reflection.add_attachment_reflection(
-          self,
-          name,
-          ActiveRecord::Reflection.create(:has_many_attached, name, nil, { dependent: dependent }, self)
-        )
-      end
-    end
-
-    dt_has_many_attached :images
-
-    validates :scope, presence: true
-    validates :lang, presence: true
-    validates :key, presence: true, uniqueness: { scope: [:scope, :lang] }
-    validates :content, presence: true
-
-    after_save :update_to_redis
-
-    def self.redis
-      Glib::DynamicText::Config.redis
-    end
-
-    def self.get_content(key, default_value, options:)
-      scope_key = "#{options[:scope]}.#{options[:lang]}.#{key}"
-
-      content = redis.get(scope_key)
-      text = find_by(scope: options[:scope], lang: options[:lang], key: key)
-
-      if !(content && text)
-        if text = find_by(scope: options[:scope], lang: options[:lang], key: key)
-          update_content(scope_key, text.content)
-          content = text.content
-        else
-          text = create(scope: options[:scope], lang: options[:lang], key: key, content: default_value)
-          update_content(scope_key, default_value)
-          content = default_value
-        end
-      end
-
-      [content, text]
-    end
-
-    private
-      def self.update_content(scope_key, content)
-        redis.set(scope_key, content)
-      end
-
-      def update_to_redis
-        Glib::Text.update_content("#{scope}.#{lang}.#{key}", content)
-      end
-  end
+module Glib
+  class Text < Glib::DynamicTextRecord
+    class << self
+      def dt_has_many_attached(name, dependent: :purge_later)
+        generated_association_methods.class_eval <<-CODE, __FILE__, __LINE__ + 1
+          def #{name}
+            @active_storage_attached_#{name} ||= ::ActiveStorage::Attached::Many.new("#{name}", self)
+          end
+
+          def #{name}=(attachables)
+            if ActiveStorage.replace_on_assign_to_many
+              attachment_changes["#{name}"] =
+                if Array(attachables).none?
+                  ::ActiveStorage::Attached::Changes::DeleteMany.new("#{name}", self)
+                else
+                  ::ActiveStorage::Attached::Changes::CreateMany.new("#{name}", self, attachables)
+                end
+            else
+              if Array(attachables).any?
+                attachment_changes["#{name}"] =
+                  ::ActiveStorage::Attached::Changes::CreateMany.new("#{name}", self, #{name}.blobs + attachables)
+              end
+            end
+          end
+        CODE
+
+        has_many :"#{name}_attachments", -> { where(name: name) }, as: :record, class_name: "Glib::ActiveStorage::Attachment", inverse_of: :record, dependent: :destroy do
+          def purge
+            each(&:purge)
+            reset
+          end
+
+          def purge_later
+            each(&:purge_later)
+            reset
+          end
+        end
+        has_many :"#{name}_blobs", through: :"#{name}_attachments", class_name: "Glib::ActiveStorage::Blob", source: :blob
+
+        scope :"with_attached_#{name}", -> { includes("#{name}_attachments": :blob) }
+
+        after_save { attachment_changes[name.to_s]&.save }
+
+        after_commit(on: %i[ create update ]) { attachment_changes.delete(name.to_s).try(:upload) }
+
+        ActiveRecord::Reflection.add_attachment_reflection(
+          self,
+          name,
+          ActiveRecord::Reflection.create(:has_many_attached, name, nil, { dependent: dependent }, self)
+        )
+      end
+    end
+
+    dt_has_many_attached :images
+
+    validates :scope, presence: true
+    validates :lang, presence: true
+    validates :key, presence: true, uniqueness: { scope: [:scope, :lang] }
+    validates :content, presence: true
+
+    after_save :update_to_redis
+
+    def self.redis
+      Glib::DynamicText::Config.redis
+    end
+
+    def self.get_content(key, default_value, options:)
+      scope_key = "#{options[:scope]}.#{options[:lang]}.#{key}"
+
+      content = redis.get(scope_key)
+      text = find_by(scope: options[:scope], lang: options[:lang], key: key)
+
+      if !(content && text)
+        if text = find_by(scope: options[:scope], lang: options[:lang], key: key)
+          update_content(scope_key, text.content)
+          content = text.content
+        else
+          text = create(scope: options[:scope], lang: options[:lang], key: key, content: default_value)
+          update_content(scope_key, default_value)
+          content = default_value
+        end
+      end
+
+      [content, text]
+    end
+
+    private
+      def self.update_content(scope_key, content)
+        redis.set(scope_key, content)
+      end
+
+      def update_to_redis
+        Glib::Text.update_content("#{scope}.#{lang}.#{key}", content)
+      end
+  end
 end

data/app/policies/glib/application_policy.rb

@@ -1,191 +1,191 @@
-# The main purpose of this is for security. If it is important to display useful error message or to provide a "banana", then
-# it's better to perform an explicit check (e.g. as a validation in the model or using a before_action).
-module Glib
-  class ApplicationPolicy
-    attr_reader :user, :record, :policy_name, :controller, :request, :params
-    class_attribute :should_exist_attributes, instance_writer: false, default: []
-
-    private
-      def initialize(user, record, policy_name, controller, request, params, attributes: {})
-        @user = user
-        @record = record
-        @controller = controller
-        @request = request
-        # Don't get params from request because we might not have a proper request object. This might execute in Sidekiq.
-        # See Presenter::Model::inside_mock_controller()
-        @params = params
-        @policy_name = policy_name
-
-        if attributes.present? && controller.action_name != 'index'
-          self.class.module_eval { attr_accessor(*attributes.keys) }
-          attributes.each do |key, value|
-            send("#{key}=", value)
-          end
-        end
-
-        if controller.user_signed_in?
-          should_exist_attributes.each do |attribute|
-            if try(attribute).blank? && !['index'].include?(controller.action_name)
-              raise "Attribute #{attribute} is blank, policy will not working properly"
-            end
-          end
-        end
-      end
-
-      class << self
-        attr_reader :catch_all
-
-        def inherited(base)
-          base.should_exist_attributes = should_exist_attributes.dup
-          super
-        end
-
-        # This is to define the authorization logic for an action (or a group of actions). It's different from controller's
-        # authorize().
-        private  # Used by child
-          def authorize(*actions, &block)
-            actions.each do |action|
-              if action == :glib_all
-                # Serve as a catch-all to all actions that have not been specified in the policy.
-                @catch_all = block
-              else
-                method_name = "#{action}?"
-                # Avoid accidentally redefining multiple times from child policies. But it's okay if the child policy
-                # wants to override the parent's authorization method.
-                raise "Action authorization has been declared: #{action}" if instance_methods(false).include?(method_name.to_sym)
-                define_method method_name, &block
-              end
-            end
-          end
-
-          def should_exist(*attributes)
-            should_exist_attributes.push(*attributes)
-          end
-      end
-
-    private
-      def catch_all
-        self.class.catch_all
-      end
-
-    private
-      # To ensure the block is called on the policy's instance instead class.
-      def call_catch_all
-        instance_eval(&catch_all)
-      end
-
-      authorize :index do
-        # We need this line because in `index` action, this method will be called instead of method_missing().
-        # Having this line ensures that the catch_all behaviour works according to the priority below:
-        # - child_policy#index?
-        # - child_policy#manage? -- catch_all
-        # - application_policy@index?
-        return call_catch_all if catch_all
-
-        false
-      end
-
-      authorize :show do
-        return call_catch_all if catch_all
-
-        scope.where(id: record.id).exists?
-      end
-
-      authorize :create do
-        return call_catch_all if catch_all
-
-        false
-      end
-
-      authorize :new do
-        return call_catch_all if catch_all
-
-        create?
-      end
-
-      authorize :update do
-        return call_catch_all if catch_all
-
-        false
-      end
-
-      authorize :edit do
-        return call_catch_all if catch_all
-
-        update?
-      end
-
-      authorize :destroy do
-        return call_catch_all if catch_all
-
-        false
-      end
-
-    public
-    def method_missing(name, *args, &block)
-      if name.to_s.end_with?('?') && catch_all
-        call_catch_all
-      else
-        super
-      end
-    end
-
-    public
-    def scope
-      policy_scope_class = Pundit::PolicyFinder.new(@policy_name).scope
-      return unless policy_scope_class
-
-      controller.policy_scope(record.class, policy_scope_class: policy_scope_class)
-    end
-
-    public
-    def self.args_builder
-      Proc.new { |controller| [] }
-    end
-
-    public
-    def helpers
-      controller.helpers
-    end
-
-    # TODO: Remove. Deprecated
-    # private  # Used by child
-    # def public?
-    #   true
-    # end
-
-    class Scope
-      attr_reader :user, :scope
-
-      def initialize(user, scope)
-        @user = user
-        @scope = scope
-      end
-
-      # def current_user
-      #   user
-      # end
-
-      # To be overridden
-      def resolve
-        scope.none
-      end
-    end
-
-    private  # Used by child
-      def everyone
-        true
-      end
-
-      # def current_user
-      #   user
-      # end
-
-      # TODO: Bad pattern. Implement explicit policy parameter instead.
-      # - E.g. can? :destroy, :service_subscription_auto_renewal, { service_subscription: @service_subscription }
-      # - E.g. super class: :service_subscription_auto_renewal, { service_subscription: @service_subscription }
-      def controller_var(name)
-        controller.instance_variable_get(:"@#{name}")
-      end
-  end
-end
+# The main purpose of this is for security. If it is important to display useful error message or to provide a "banana", then
+# it's better to perform an explicit check (e.g. as a validation in the model or using a before_action).
+module Glib
+  class ApplicationPolicy
+    attr_reader :user, :record, :policy_name, :controller, :request, :params
+    class_attribute :should_exist_attributes, instance_writer: false, default: []
+
+    private
+      def initialize(user, record, policy_name, controller, request, params, attributes: {})
+        @user = user
+        @record = record
+        @controller = controller
+        @request = request
+        # Don't get params from request because we might not have a proper request object. This might execute in Sidekiq.
+        # See Presenter::Model::inside_mock_controller()
+        @params = params
+        @policy_name = policy_name
+
+        if attributes.present? && controller.action_name != 'index'
+          self.class.module_eval { attr_accessor(*attributes.keys) }
+          attributes.each do |key, value|
+            send("#{key}=", value)
+          end
+        end
+
+        if controller.user_signed_in?
+          should_exist_attributes.each do |attribute|
+            if try(attribute).blank? && !['index'].include?(controller.action_name)
+              raise "Attribute #{attribute} is blank, policy will not working properly"
+            end
+          end
+        end
+      end
+
+      class << self
+        attr_reader :catch_all
+
+        def inherited(base)
+          base.should_exist_attributes = should_exist_attributes.dup
+          super
+        end
+
+        # This is to define the authorization logic for an action (or a group of actions). It's different from controller's
+        # authorize().
+        private  # Used by child
+          def authorize(*actions, &block)
+            actions.each do |action|
+              if action == :glib_all
+                # Serve as a catch-all to all actions that have not been specified in the policy.
+                @catch_all = block
+              else
+                method_name = "#{action}?"
+                # Avoid accidentally redefining multiple times from child policies. But it's okay if the child policy
+                # wants to override the parent's authorization method.
+                raise "Action authorization has been declared: #{action}" if instance_methods(false).include?(method_name.to_sym)
+                define_method method_name, &block
+              end
+            end
+          end
+
+          def should_exist(*attributes)
+            should_exist_attributes.push(*attributes)
+          end
+      end
+
+    private
+      def catch_all
+        self.class.catch_all
+      end
+
+    private
+      # To ensure the block is called on the policy's instance instead class.
+      def call_catch_all
+        instance_eval(&catch_all)
+      end
+
+      authorize :index do
+        # We need this line because in `index` action, this method will be called instead of method_missing().
+        # Having this line ensures that the catch_all behaviour works according to the priority below:
+        # - child_policy#index?
+        # - child_policy#manage? -- catch_all
+        # - application_policy@index?
+        return call_catch_all if catch_all
+
+        false
+      end
+
+      authorize :show do
+        return call_catch_all if catch_all
+
+        scope.where(id: record.id).exists?
+      end
+
+      authorize :create do
+        return call_catch_all if catch_all
+
+        false
+      end
+
+      authorize :new do
+        return call_catch_all if catch_all
+
+        create?
+      end
+
+      authorize :update do
+        return call_catch_all if catch_all
+
+        false
+      end
+
+      authorize :edit do
+        return call_catch_all if catch_all
+
+        update?
+      end
+
+      authorize :destroy do
+        return call_catch_all if catch_all
+
+        false
+      end
+
+    public
+    def method_missing(name, *args, &block)
+      if name.to_s.end_with?('?') && catch_all
+        call_catch_all
+      else
+        super
+      end
+    end
+
+    public
+    def scope
+      policy_scope_class = Pundit::PolicyFinder.new(@policy_name).scope
+      return unless policy_scope_class
+
+      controller.policy_scope(record.class, policy_scope_class: policy_scope_class)
+    end
+
+    public
+    def self.args_builder
+      Proc.new { |controller| [] }
+    end
+
+    public
+    def helpers
+      controller.helpers
+    end
+
+    # TODO: Remove. Deprecated
+    # private  # Used by child
+    # def public?
+    #   true
+    # end
+
+    class Scope
+      attr_reader :user, :scope
+
+      def initialize(user, scope)
+        @user = user
+        @scope = scope
+      end
+
+      # def current_user
+      #   user
+      # end
+
+      # To be overridden
+      def resolve
+        scope.none
+      end
+    end
+
+    private  # Used by child
+      def everyone
+        true
+      end
+
+      # def current_user
+      #   user
+      # end
+
+      # TODO: Bad pattern. Implement explicit policy parameter instead.
+      # - E.g. can? :destroy, :service_subscription_auto_renewal, { service_subscription: @service_subscription }
+      # - E.g. super class: :service_subscription_auto_renewal, { service_subscription: @service_subscription }
+      def controller_var(name)
+        controller.instance_variable_get(:"@#{name}")
+      end
+  end
+end