glib-web 0.5.5

data/app/helpers/glib/json_ui/view_builder/panels.rb

@@ -0,0 +1,219 @@
+class Glib::JsonUi::ViewBuilder
+  module Panels
+    class Form < View
+      action :onSubmit
+      string :paramNameForFormData
+      # boolean :local
+
+      def is_array_association?(prop)
+        # # Not all model is ActiveRecord
+        # if @model.class.respond_to?(:reflect_on_association)
+        #   return @model.class.reflect_on_association(prop).macro
+        # end
+        # false
+
+        # Not all model is ActiveRecord
+        @model.class.try(:reflect_on_association, prop)&.macro == :has_many
+      end
+
+      def field_name(prop, multiple)
+        suffix = is_array_association?(prop) || multiple ? '[]' : ''
+        "#{@model_name}[#{prop}]#{suffix}"
+      end
+
+      def field_value(prop)
+        if is_array_association?(prop)
+          @model.send(prop)&.map { |record| record.id }
+        else
+          @model.send(prop)
+        end
+      end
+
+      def field_label(prop, args)
+        I18n.t("dt_models.#{@model_name}.#{prop}.label", args.merge(default: nil)) || I18n.t("activerecord.attributes.#{@model_name}.#{prop}", args)
+      end
+
+      def hint_label(prop, args)
+        I18n.t("dt_models.#{@model_name}.#{prop}.hint", args.merge(default: nil))
+      end
+
+      def placeholder_label(prop, args)
+        I18n.t("dt_models.#{@model_name}.#{prop}.placeholder", args.merge(default: nil))
+      end
+
+      def url(url)
+        @url = url
+      end
+
+      def method(method)
+        @method = method
+      end
+
+      def as(model_name)
+        @model_name = model_name
+      end
+
+      def model(models)
+        @models = models
+      end
+
+      # Override
+      def created
+        if @models
+          @model = @models.is_a?(Array) ? @models.last : @models
+          @model_name ||= @model.class.model_name.singular
+          @url ||= page.context.polymorphic_url(@models)
+          @method ||= if @model.persisted?
+            :patch
+          else
+            :post
+          end
+        end
+
+        @method ||= :get
+
+        json.url @url
+        json.method @method
+
+        json.childViews do
+          if @method != :get
+            json.child! do
+              json.view 'fields/hidden-v1'
+              json.name 'authenticity_token'
+              json.value page.context.form_authenticity_token
+            end
+          end
+
+          # NOTE: this pattern will not work for views that can be nested. Luckily forms shouldn't be nested anyway.
+          page.current_form = self
+          @childViewsBlock.call(page.view_builder)
+          page.current_form = nil
+        end
+
+      end
+
+      def childViews(block)
+        @childViewsBlock = block
+      end
+    end
+
+    class List < View
+      hash :nextPage
+      action :onScrollToTop
+      action :onScrollToBottom
+
+      def firstSection(block)
+        json.sections [1] do
+          block.call page.list_section_builder
+        end
+      end
+
+      def sections(blocks)
+        json.sections do
+          blocks.each do |block|
+            json.child! do
+              block.call page.list_section_builder
+            end
+          end
+        end
+      end
+    end
+
+    class Table < View
+      hash :nextPage
+      hash :export
+      hash :import
+      action :onScrollToTop
+      action :onScrollToBottom
+
+      def firstSection(block)
+        json.sections [1] do
+          block.call page.table_section_builder
+        end
+      end
+
+      def sections(blocks)
+        json.sections do
+          blocks.each do |block|
+            json.child! do
+              block.call page.table_section_builder
+            end
+          end
+        end
+      end
+    end
+
+    class Scroll < View
+      views :childViews
+    end
+
+    class Split < View
+      def content(block)
+        block.call page.split_content_builder
+      end
+    end
+
+    class Responsive < View
+      views :childViews
+      string :align
+    end
+
+    class Column < View
+      hash :xl
+      hash :lg
+      hash :md
+      hash :sm
+      hash :xs
+      views :childViews
+    end
+
+    class Vertical < View
+      views :childViews
+      string :distribution
+      string :align
+    end
+
+    class Horizontal < View
+      views :childViews
+      string :distribution
+      string :align
+    end
+
+    class Flow < View
+      views :childViews
+    end
+
+    class Carousel < View
+      views :childViews
+      string :distribution
+    end
+
+    # # TODO: Deprecate in favour of styleClasses
+    # class Card < View
+    #   views :childViews
+    # end
+
+    class Custom < View
+      string :template
+      hash :data
+      action :onClick
+
+      def content(block)
+        json.data do
+          block.call page.view_builder
+        end
+      end
+    end
+
+    class Ul < View
+      views :childViews
+
+      # def buttons(block)
+      #   json.buttons do
+      #     block.call page.menu_builder
+      #   end
+      # end
+    end
+
+  end
+end

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

@@ -0,0 +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

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

@@ -0,0 +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

data/app/models/glib/dynamic_text_record.rb

@@ -0,0 +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

data/app/models/glib/text.rb

@@ -0,0 +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
+end

data/app/policies/glib/application_policy.rb

@@ -0,0 +1,164 @@
+# 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
+
+    private
+    def initialize(user, record, policy_name, controller, request, params)
+      @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
+    end
+
+    class << self
+      attr_reader :catch_all
+
+      # 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
+    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
+
+    # TODO: Remove. Deprecated
+    private  # Used by child
+    def public?
+      true
+    end
+
+    private  # Used by child
+    def everyone
+      true
+    end
+
+    # TODO: Deprecate `user()`
+    private  # Used by child
+    def current_user
+      user
+    end
+
+    # # TODO: Revise because it seems there is no justification for allowing owner to see any of the deleted entities, which include User, Guild, and Post
+    # private  # Used by child
+    # def not_deleted_unless_owner_or_moderator?(&block)
+    #   block ||= lambda { |unused_arg| @user.moderator? }
+    #   !@record.deleted? || (@user && (@user.id == @record.user_owner_id || block.call(@record)))
+    # end
+
+    # private  # Used by child
+    # def not_deleted_unless_moderator?(&block)
+    #   block ||= lambda { |unused_arg| @user.moderator? }
+    #   !@record.deleted? || (@user && block.call(@record))
+    # end
+
+    public
+    def self.args_builder
+      Proc.new { |controller| [] }
+    end
+
+    class Scope
+      attr_reader :user, :scope
+
+      def initialize(user, scope)
+        @user = user
+        @scope = scope
+      end
+
+      def resolve
+        scope.none
+      end
+    end
+  end
+end