avo 2.45.0 → 3.0.0.beta1

data/lib/avo/concerns/fetches_things.rb

@@ -1,150 +0,0 @@
-module Avo
-  module Concerns
-    module FetchesThings
-      extend ActiveSupport::Concern
-
-      class_methods do
-        # Returns the Avo dashboard by id
-        #
-        # get_dashboard_by_id(:dashy) -> Dashy
-        def get_dashboard_by_id(id)
-          dashboards.find do |dashboard|
-            dashboard.id == id
-          end
-        end
-
-        # Returns the Avo dashboard by name
-        #
-        # get_dashboard_by_name(:dashy) -> instance of Dashy
-        def get_dashboard_by_name(name)
-          dashboards.find do |dashboard|
-            dashboard.name == name
-          end
-        end
-
-        # Filters out the resources that are missing the model_class
-        def valid_resources
-          resources.select { |resource| resource.model_class.present? }.sort_by(&:name)
-        end
-
-        # Returns the Avo resource by camelized name
-        #
-        # get_resource_by_name('User') => instance of UserResource
-        def get_resource(resource)
-          possible_resource = "#{resource}Resource".gsub "ResourceResource", "Resource"
-
-          resources.find do |available_resource|
-            possible_resource.to_s == available_resource.class.to_s
-          end
-        end
-
-        # Returns the Avo resource by singular snake_cased name
-        #
-        # get_resource_by_name('user') => instance of UserResource
-        def get_resource_by_name(name)
-          get_resource name.singularize.camelize
-        end
-
-        # Returns the Avo resource by singular snake_cased name
-        # From all the resources that use the same model_class, it will fetch the first one in alphabetical order
-        #
-        # get_resource_by_name('User') => instance of UserResource
-        # get_resource_by_name(User) => instance of UserResource
-
-        def get_resource_by_model_name(klass)
-          # Fetch the mappings imposed by the user.
-          # If they are present, use those ones.
-          mapping = get_mapping_for_model klass
-          return get_resource(mapping) if mapping.present?
-
-          valid_resources
-            .find do |resource|
-              resource.model_class.model_name.name == klass.to_s
-            end
-        end
-
-        # Returns the Avo resource by singular snake_cased name
-        #
-        # get_resource_by_controller_name('delayed_backend_active_record_jobs') => instance of DelayedJobResource
-        # get_resource_by_controller_name('users') => instance of UserResource
-        def get_resource_by_controller_name(name)
-          valid_resources
-            .find do |resource|
-              resource.model_class.to_s.pluralize.underscore.tr("/", "_") == name.to_s
-            end
-        end
-
-        # Returns the Avo resource by some name
-        def guess_resource(name)
-          get_resource_by_name(name.to_s) || get_resource_by_model_name(name)
-        end
-
-        # Returns the Rails model class by singular snake_cased name
-        #
-        # get_model_class_by_name('user') => User
-        def get_model_class_by_name(name)
-          name.to_s.camelize.singularize
-        end
-
-        def get_available_resources(user = nil)
-          valid_resources
-            .select do |resource|
-            resource.authorization.class.authorize(
-              user,
-              resource.model_class,
-              Avo.configuration.authorization_methods.stringify_keys["index"],
-              raise_exception: false
-            )
-            end
-            .sort_by { |r| r.name }
-        end
-
-        def get_available_dashboards(user = nil)
-          dashboards.sort_by { |r| r.name }
-        end
-
-        def resources_for_navigation(user = nil)
-          get_available_resources(current_user)
-            .select do |resource|
-              resource.visible_on_sidebar
-            end
-        end
-
-        def dashboards_for_navigation(user = nil)
-          return [] if App.license.lacks_with_trial(:resource_ordering)
-
-          get_available_dashboards(user).select do |dashboard|
-            dashboard.is_visible?
-          end
-        end
-
-        # Insert any partials that we find in app/views/avo/sidebar/items.
-        def get_sidebar_partials
-          Dir.glob(Rails.root.join("app", "views", "avo", "sidebar", "items", "*.html.erb"))
-            .map do |path|
-              File.basename path
-            end
-            .map do |filename|
-              # remove the leading underscore (_)
-              filename[0] = ""
-              # remove the extension
-              filename.gsub!(".html.erb", "")
-              filename
-            end
-        end
-
-        def tools_for_navigation
-          return [] if Avo::App.license.lacks_with_trial(:custom_tools)
-
-          get_sidebar_partials
-        end
-
-        private
-
-        def get_mapping_for_model(klass)
-          (Avo.configuration.model_resource_mapping || {}).stringify_keys.transform_values(&:to_s)[klass.to_s]
-        end
-      end
-    end
-  end
-end

data/lib/avo/concerns/handles_field_args.rb

@@ -1,47 +0,0 @@
-module Avo
-  module Concerns
-    module HandlesFieldArgs
-      extend ActiveSupport::Concern
-
-      private
-
-      # Add an instance variable from args
-      # That may be a string, boolean, or array
-      # Each args should also have a default value
-      def add_prop_from_args(args = {}, name: nil, type: :string, default: nil)
-        value = default
-
-        if type == :boolean
-          case args[name.to_sym]
-          when nil
-            value = default
-          when false
-            value = false
-          when true
-            value = true
-          end
-        else
-          value = args[name.to_sym] unless args.dig(name.to_sym).nil?
-        end
-
-        instance_variable_set(:"@#{name}", value)
-      end
-
-      def add_boolean_prop(args, name, default = false)
-        add_prop_from_args args, name: name, default: default, type: :boolean
-      end
-
-      def add_array_prop(args, name, default = [])
-        add_prop_from_args args, name: name, default: default, type: :array
-      end
-
-      def add_object_prop(args, name, default = {})
-        add_prop_from_args args, name: name, default: default, type: :object
-      end
-
-      def add_string_prop(args, name, default = nil)
-        add_prop_from_args args, name: name, default: default, type: :string
-      end
-    end
-  end
-end

data/lib/avo/concerns/has_editable_controls.rb

@@ -1,34 +0,0 @@
-module Avo
-  module Concerns
-    module HasEditableControls
-      extend ActiveSupport::Concern
-
-      included do
-        class_attribute :show_controls
-        class_attribute :show_controls_holder
-        class_attribute :show_controls_holder_called, default: false
-      end
-
-      def has_show_controls?
-        return false if ::Avo::App.license.lacks_with_trial(:resource_show_controls)
-
-        self.class.show_controls.present?
-      end
-
-      def render_show_controls
-        return [] if ::Avo::App.license.lacks_with_trial(:resource_show_controls)
-
-        if show_controls.present?
-          Avo::Resources::Controls::ExecutionContext.new(
-            block: show_controls,
-            resource: self,
-            record: model,
-            view: view
-          ).handle&.items || []
-        else
-          []
-        end
-      end
-    end
-  end
-end

data/lib/avo/concerns/has_fields.rb

@@ -1,334 +0,0 @@
-module Avo
-  module Concerns
-    module HasFields
-      extend ActiveSupport::Concern
-
-      included do
-        class_attribute :items_holder
-        class_attribute :items_index, default: 0
-        class_attribute :tabs_holder
-        class_attribute :tabs_tabs_holder
-        class_attribute :raw_tabs
-        class_attribute :tools_holder
-      end
-
-      class_methods do
-        # DSL methods
-        def field(name, **args, &block)
-          ensure_items_holder_initialized
-
-          items_holder.field name, **args, &block
-        end
-
-        def panel(name = nil, **args, &block)
-          ensure_items_holder_initialized
-
-          items_holder.panel name, **args, &block
-        end
-
-        def row(**args, &block)
-          ensure_items_holder_initialized
-
-          items_holder.row(**args, &block)
-        end
-
-        def tabs(**args, &block)
-          ensure_items_holder_initialized
-
-          items_holder.tabs Avo::TabGroupBuilder.parse_block(**args, &block)
-        end
-
-        def tool(klass, **args)
-          ensure_items_holder_initialized
-
-          items_holder.tool klass, **args
-        end
-
-        def heading(body, **args)
-          ensure_items_holder_initialized
-
-          items_holder.heading body, **args
-        end
-
-        def sidebar(**args, &block)
-          ensure_items_holder_initialized
-
-          items_holder.sidebar Avo::SidebarBuilder.parse_block(**args, &block)
-        end
-        # END DSL methods
-
-        def items
-          if items_holder.present?
-            items_holder.items
-          else
-            []
-          end
-        end
-
-        def tools
-          tools_holder
-        end
-
-        # Dives deep into panels and tabs to fetch all the fields for a resource.
-        def fields(only_root: false)
-          fields = []
-
-          items.each do |item|
-            next if item.nil?
-
-            unless only_root
-              # Dive into panels to fetch their fields
-              if item.is_panel?
-                fields << extract_fields_from_items(item)
-              end
-
-              # Dive into tabs to fetch their fields
-              if item.is_tab_group?
-                item.items.map do |tab|
-                  fields << extract_fields_from_items(tab)
-                end
-              end
-
-              # Dive into sidebar to fetch their fields
-              if item.is_sidebar?
-                fields << extract_fields_from_items(item)
-              end
-            end
-
-            if item.is_field?
-              fields << item
-            end
-
-            if item.is_row?
-              fields << extract_fields_from_items(tab)
-            end
-          end
-
-          fields.flatten
-        end
-
-        def tab_groups
-          items.select do |item|
-            item.instance_of? Avo::TabGroup
-          end
-        end
-
-        private
-
-        def extract_fields_from_items(thing)
-          fields = []
-
-          thing.items.each do |item|
-            if item.is_field?
-              fields << item
-            elsif item.is_panel? || item.is_row?
-              fields << extract_fields_from_items(item)
-            end
-          end
-
-          fields
-        end
-
-        def ensure_items_holder_initialized
-          self.items_holder ||= Avo::ItemsHolder.new
-        end
-
-        def add_to_fields(instance)
-          self.items ||= []
-          self.items << instance
-          increment_order_index
-        end
-
-        def increment_order_index
-          self.items_index += 1
-        end
-      end
-
-      delegate :invalid_fields, to: :items_holder
-      delegate :items, to: :items_holder
-
-      def hydrate_fields(model: nil, view: nil)
-        fields.map do |field|
-          field.hydrate(model: @model, view: @view, resource: self)
-        end
-
-        self
-      end
-
-      def get_tabs
-        tabs_holder
-      end
-
-      def fields(**args)
-        self.class.fields(**args)
-      end
-
-      def tab_groups
-        self.class.tab_groups
-      end
-
-      def get_field_definitions(only_root: false)
-        fields = self.fields(only_root: only_root)
-
-        return [] if fields.blank?
-
-        fields.map do |field|
-          field.hydrate(resource: self, user: user, view: view)
-        end
-      end
-
-      def get_fields(panel: nil, reflection: nil, only_root: false)
-        fields = get_field_definitions(only_root: only_root)
-          .select do |field|
-            field.visible_on?(view)
-          end
-          .select do |field|
-            field.visible?
-          end
-          .select do |field|
-            is_valid = true
-
-            # Strip out the reflection field in index queries with a parent association.
-            if reflection.present?
-              # regular non-polymorphic association
-              # we're matching the reflection inverse_of foriegn key with the field's foreign_key
-              if field.is_a?(Avo::Fields::BelongsToField)
-                if field.respond_to?(:foreign_key) &&
-                    reflection.inverse_of.present? &&
-                    reflection.inverse_of.respond_to?(:foreign_key) &&
-                    reflection.inverse_of.foreign_key == field.foreign_key
-                  is_valid = false
-                end
-
-                # polymorphic association
-                if field.respond_to?(:foreign_key) &&
-                    field.is_polymorphic? &&
-                    reflection.respond_to?(:polymorphic?) &&
-                    reflection.inverse_of.respond_to?(:foreign_key) &&
-                    reflection.inverse_of.foreign_key == field.reflection.foreign_key
-                  is_valid = false
-                end
-              end
-            end
-
-            is_valid
-          end
-
-        if panel.present?
-          fields = fields.select do |field|
-            field.panel_name == panel
-          end
-        end
-
-        hydrate_fields(model: @model, view: @view)
-
-        fields
-      end
-
-      def get_field(id)
-        get_field_definitions.find do |f|
-          f.id == id.to_sym
-        end
-      end
-
-      def tools
-        check_license
-
-        return [] if App.license.lacks_with_trial :resource_tools
-        return [] if self.class.tools.blank?
-
-        self.items
-          .select do |item|
-            next if item.nil?
-
-            item.is_tool?
-          end
-          .map do |tool|
-            tool.hydrate view: view
-            tool
-          end
-          .select do |item|
-            item.visible_on?(view)
-          end
-      end
-
-      # Separates the fields that are in a panel and those that are just hanging out.
-      # Take the ones that aren't placed into a panel and add them to the "default" panel.
-      # This is to keep compatibility with the versions before 2.10 when you didn't have the ability to add fields to panels.
-      def get_items
-        panelless_items = []
-        panelfull_items = []
-
-        items.each do |item|
-          if item.respond_to? :hydrate
-            item.hydrate(view: view)
-          end
-
-          # fields and tabs can be hidden on some views
-          if item.respond_to? :visible_on?
-            next unless item.visible_on?(view)
-          end
-          # each field has it's own visibility checker
-          if item.respond_to? :visible?
-            item.hydrate(view: view) if item.view.nil?
-
-            next unless item.visible?
-          end
-          # check if the user is authorized to view it
-          if item.respond_to? :authorized?
-            next unless item.hydrate(model: @model).authorized?
-          end
-
-          if item.is_field?
-            if item.has_own_panel?
-              panelfull_items << item
-            else
-              panelless_items << item
-            end
-          else
-            panelfull_items << item
-          end
-        end
-
-        # Make sure all tabs panelfull_items are setted as inside tabs
-        panelfull_items.grep(Avo::TabGroup).each do |tab_group|
-          tab_group.items.grep(Avo::Tab).each do |tab|
-            tab.items.grep(Avo::Panel).each do |panel|
-              set_target_to_top panel.items.grep(Avo::Fields::BelongsToField)
-
-              panel.items.grep(Avo::Row).each do |row|
-                set_target_to_top row.items.grep(Avo::Fields::BelongsToField)
-              end
-            end
-          end
-        end
-
-        # Add all the panelles fields to a new panel
-        main_panel_holder = Avo::ItemsHolder.new
-        main_panel_holder.items = panelless_items
-
-        # Add that panel to the main panel
-        main_panel = Avo::MainPanel.new
-        main_panel.items_holder = main_panel_holder
-
-        # Return all the items but this time with all the panelless ones inside the main panel
-        [main_panel, *panelfull_items]
-      end
-
-      private
-
-      def set_target_to_top(fields)
-        fields.each do |field|
-          field.target = :_top
-        end
-      end
-
-      def check_license
-        if !Rails.env.production? && App.license.present? && App.license.lacks(:resource_tools)
-          # Add error message to let the developer know the resource tool will not be available in a production environment.
-          Avo::App.error_messages.push "Warning: Your license is invalid or doesn't support resource tools. The resource tools will not be visible in a production environment."
-        end
-      end
-    end
-  end
-end

data/lib/avo/concerns/has_html_attributes.rb

@@ -1,108 +0,0 @@
-module Avo
-  module Concerns
-    module HasHTMLAttributes
-      extend ActiveSupport::Concern
-
-      attr_reader :html
-
-      # Used to get attributes for elements and views
-      #
-      # examples:
-      # get_html :data, view: :edit, element: :input
-      # get_html :classes, view: :show, element: :wrapper
-      # get_html :styles, view: :index, element: :wrapper
-      def get_html(name = nil, element:, view:)
-        if [view, element].any?(&:nil?) || Avo::App.license.lacks_with_trial(:stimulus_js_integration)
-          default_attribute_value name
-        end
-
-        parsed = parse_html
-
-        attributes = if parsed.is_a? Hash
-          get_html_from_hash name, element: element, hash: parsed, view: view
-        elsif parsed.is_a? Avo::HTML::Builder
-          get_html_from_block name, element: element, html_builder: parsed, view: view
-        elsif parsed.nil?
-          # Handle empty parsed by returning an empty state
-          default_attribute_value name
-        end
-
-        add_default_data_attributes attributes, name, element, view
-      end
-
-      private
-
-      # Returns Hash, HTML::Builder, or nil.
-      def parse_html
-        return if @html.nil?
-
-        if @html.is_a? Hash
-          @html
-        elsif @html.respond_to? :call
-          Avo::HTML::Builder.parse_block(record: model, resource: resource, &@html)
-        end
-      end
-
-      def default_attribute_value(name)
-        name == :data ? {} : ""
-      end
-
-      def add_default_data_attributes(attributes, name, element, view)
-        if !attributes.nil? && name == :data && element == :input && view.in?([:edit, :new]) && resource.present? && resource.respond_to?(:get_stimulus_controllers)
-          extra_attributes = resource.get_stimulus_controllers
-            .split(" ")
-            .map do |controller|
-              [:"#{controller}-target", "#{id.to_s.underscore}_#{type.to_s.underscore}_input".camelize(:lower)]
-            end
-            .to_h
-
-          attributes.merge extra_attributes
-        else
-          attributes
-        end
-      end
-
-      def get_html_from_block(name = nil, element:, html_builder:, view:)
-        values = []
-
-        # get view ancestor
-        values << html_builder.dig_stack(view, element, name)
-        # get element ancestor
-        values << html_builder.dig_stack(element, name)
-        # get direct ancestor
-        values << html_builder.dig_stack(name)
-
-        values_type = if name == :data
-          :hash
-        else
-          :string
-        end
-
-        merge_values_as(as: values_type, values: values)
-      end
-
-      def get_html_from_hash(name = nil, element:, hash:, view:)
-        # @todo: what if this is not a Hash but a string?
-        hash.dig(view, element, name) || {}
-      end
-
-      # Merge the values from all possible locations.
-      # If the result is "blank", return nil so the attributes are not outputted to the DOM.
-      #
-      # Ex: if the style attribute is empty return `nil` instead of an empty space `" "`
-      def merge_values_as(as: :array, values: [])
-        result = if as == :array
-          values.flatten
-        elsif as == :string
-          values.select do |value|
-            value.is_a? String
-          end.join " "
-        elsif as == :hash
-          values.reduce({}, :merge)
-        end
-
-        result if result.present?
-      end
-    end
-  end
-end