jav 2.55.4

data/lib/jav/dashboards/chartkick_card.rb

@@ -0,0 +1,69 @@
+module Jav
+  module Dashboards
+    class ChartkickCard < BaseCard
+      class_attribute :chart_type
+      class_attribute :chart_options, default: {}
+      class_attribute :flush, default: true
+      class_attribute :legend, default: false
+      class_attribute :scale, default: false
+      class_attribute :legend_on_left, default: false
+      class_attribute :legend_on_right, default: false
+
+      def chartkick_classes
+        case chart_type
+        when :area_chart, :line_chart, :scatter_chart, :bar_chart, :column_chart
+          if self.class.flush
+            "-mx-1.5 top-auto -bottom-1.5"
+          else
+            "px-2"
+          end
+        else
+          ""
+        end
+      end
+
+      def chartkick_options
+        card_height = 144
+        card_heading = 40
+
+        default = {
+          # figure our the available height for the chart
+          height: "#{(rows * card_height) - card_heading}px",
+          colors: ::Jav.configuration.branding.chart_colors,
+          library: {
+            discrete: false,
+            points: false,
+            animation: true
+          },
+          id: "#{dashboard.id}-#{rand(10_000..99_999)}"
+        }
+
+        no_scale_options = { display: false }
+        no_scale = {
+          library: {
+            scales: {
+              x: no_scale_options,
+              y: no_scale_options
+            }
+          }
+        }
+
+        no_legend = { library: { plugins: { legend: { display: false } } } }
+        legend_on_left = { library: { plugins: { legend: { position: "left" } } } }
+        legend_on_right = { library: { plugins: { legend: { position: "right" } } } }
+
+        # Add chart.js configuration for the different states
+        default = default.deep_merge(no_legend) unless self.class.legend
+
+        default = default.deep_merge(no_scale) unless self.class.scale
+
+        default = default.deep_merge(legend_on_left) if self.class.legend_on_left
+
+        default = default.deep_merge(legend_on_right) if self.class.legend_on_right
+
+        # Add the custom chart options at the end
+        default.deep_merge(self.class.chart_options)
+      end
+    end
+  end
+end

data/lib/jav/dashboards/dashboard_card.rb

@@ -0,0 +1,6 @@
+module Jav
+  module Dashboards
+    class DashboardCard < Jav::BaseCard
+    end
+  end
+end

data/lib/jav/dashboards/metric_card.rb

@@ -0,0 +1,9 @@
+module Jav
+  module Dashboards
+    class MetricCard < BaseCard
+      class_attribute :prefix
+      class_attribute :suffix
+      # @todo: transform 1234 to 1.2K
+    end
+  end
+end

data/lib/jav/dashboards/partial_card.rb

@@ -0,0 +1,7 @@
+module Jav
+  module Dashboards
+    class PartialCard < Jav::BaseCard
+      class_attribute :partial
+    end
+  end
+end

data/lib/jav/dsl/field_parser.rb

@@ -0,0 +1,76 @@
+module Jav
+  module Dsl
+    class FieldParser
+      attr_reader :as, :args, :id, :block, :instance, :order_index
+
+      def initialize(id:, order_index: 0, **args, &block)
+        @id = id
+        @as = args.fetch(:as, nil)
+        @order_index = order_index
+        @args = args
+        @block = block
+        @instance = nil
+      end
+
+      def valid?
+        instance.present?
+      end
+
+      def invalid?
+        !valid?
+      end
+
+      def parse
+        # The field is passed as a symbol eg: :text, :color_picker, :trix
+        @instance = if as.is_a? Symbol
+                      parse_from_symbol
+                    elsif as.is_a? Class
+                      parse_from_class
+                    end
+
+        self
+      end
+
+      private
+
+      def parse_from_symbol
+        field_class = field_class_from_symbol(as)
+
+        if field_class.present?
+          # The field has been registered before.
+          instantiate_field(id, klass: field_class, **args, &block)
+        else
+          # The symbol can be transformed to a class and found.
+          class_name = as.to_s.camelize
+          field_class = "#{class_name}Field"
+
+          # Discover & load custom field classes
+          instantiate_field(id, klass: field_class.safe_constantize, **args, &block) if Object.const_defined? field_class
+        end
+      end
+
+      def parse_from_class
+        # The field has been passed as a class.
+        return unless Object.const_defined? as.to_s
+
+        instantiate_field(id, klass: as, **args, &block)
+      end
+
+      def instantiate_field(id, klass:, **args, &block)
+        if block
+          klass.new(id, **args || {}, &block)
+        else
+          klass.new(id, **args || {})
+        end
+      end
+
+      def field_class_from_symbol(symbol)
+        matched_field = Jav::App.fields.find do |field|
+          field[:name].to_s == symbol.to_s
+        end
+
+        matched_field[:class] if matched_field.present? && matched_field[:class].present?
+      end
+    end
+  end
+end

data/lib/jav/dynamic_router.rb

@@ -0,0 +1,19 @@
+module Jav
+  class DynamicRouter
+    def self.routes
+      Jav::Engine.routes.draw do
+        scope "resources", as: "resources" do
+          # Check if the user chose to manually register the resource files.
+          # If so, eager_load the resources dir.
+
+          Jav::App.eager_load(:resources) if Jav.configuration.resources.nil? && !Rails.application.config.eager_load
+
+          Jav::App.fetch_resources
+                  .reject { |resource| resource == :BaseResource }
+                  .select { |resource| resource.is_a? Class }
+                  .map { |resource| resources resource.new.route_key }
+        end
+      end
+    end
+  end
+end

data/lib/jav/engine.rb

@@ -0,0 +1,87 @@
+# requires all dependencies
+Gem.loaded_specs["jav"].dependencies.each do |d|
+  case d.name
+  when "activerecord"
+    require "active_record/railtie"
+  when "actionview"
+    require "action_view/railtie"
+  when "activestorage"
+    require "active_storage/engine"
+  when "actiontext"
+    require "action_text/engine"
+  else
+    require d.name
+  end
+end
+
+module Jav
+  class Engine < ::Rails::Engine
+    isolate_namespace Jav
+
+    config.after_initialize do
+      # Boot Jav
+      ::Jav::App.boot
+    end
+
+    initializer "jav.autoload" do |_|
+      Jav::ENTITIES.each_value do |path_params|
+        path = Rails.root.join(*path_params)
+        File.directory?(path.to_s) && Rails.autoloaders.main.push_dir(path.to_s)
+      end
+    end
+
+    initializer "jav.init_fields" do |_|
+      # Init the fields
+      ::Jav::App.init_fields
+    end
+
+    initializer "jav.reloader" do |app|
+      Jav::Reloader.new.tap do |reloader|
+        reloader.execute
+        app.reloaders << reloader
+        app.reloader.to_run { reloader.execute }
+      end
+    end
+
+    initializer "debug_exception_response_format" do |app|
+      app.config.debug_exception_response_format = :api
+      # app.config.logger = ::Logger.new(STDOUT)
+    end
+
+    initializer "jav.test_buddy" do |_|
+      Rails.autoloaders.main.push_dir Jav::Engine.root.join("spec", "helpers") if Jav::IN_DEVELOPMENT
+    end
+
+    config.app_middleware.use(
+      Rack::Static,
+      urls: ["/jav-assets"],
+      root: Jav::Engine.root.join("public")
+    )
+
+    config.generators do |g|
+      g.test_framework :rspec, view_specs: false
+    end
+
+    generators do |app|
+      Rails::Generators.configure! app.config.generators
+      require_relative "../generators/model_generator"
+    end
+
+    initializer "jav.locales" do |_|
+      I18n.load_path += Dir[Jav::Engine.root.join("lib", "generators", "jav", "templates", "locales", "*.{rb,yml}")]
+    end
+
+    # After deploy we want to make sure the license response is being cleared.
+    # We need a fresh license response.
+    # This is disabled in development because the initialization process might be triggered more than once.
+    config.after_initialize do
+      unless Rails.env.development?
+        begin
+          Licensing::HQ.new.clear_response
+        rescue StandardError => exception
+          Rails.logger.info { "Failed to clear Jav HQ response: #{exception.message}" }
+        end
+      end
+    end
+  end
+end

data/lib/jav/execution_context.rb

@@ -0,0 +1,41 @@
+module Jav
+  class ExecutionContext
+    attr_accessor :target, :context, :params, :view_context, :current_user, :request, :include, :main_app, :jav
+
+    def initialize(**args)
+      # Extend the class with custom modules if required.
+      if args[:include].present?
+        args[:include].each do |mod|
+          self.class.send(:include, mod)
+        end
+      end
+
+      # If you want this block to behave like a view you can delegate the missing methods to the view_context
+      #
+      # Ex: Jav::ExecutionContext.new(target: ..., delegate_missing_to: :view_context).handle
+      self.class.send(:delegate_missing_to, args[:delegate_missing_to]) if args[:delegate_missing_to].present?
+
+      # If target doesn't respond to call, we don't need to initialize the others attr_accessors.
+      return unless (@target = args[:target]).respond_to? :call
+
+      args.except(:target).each do |key, value|
+        singleton_class.class_eval { attr_accessor key }
+        instance_variable_set(:"@#{key}", value)
+      end
+
+      # Set defaults on not initialized accessors
+      @context ||= Jav::App.context
+      @params ||= Jav::App.params
+      @view_context ||= Jav::App.view_context
+      @current_user ||= Jav::App.current_user
+      @request ||= view_context&.request
+      @main_app ||= view_context&.main_app
+      @jav ||= view_context&.jav
+    end
+
+    # Return target if target is not callable, otherwise, execute target on this instance context
+    def handle
+      target.respond_to?(:call) ? instance_exec(&target) : target
+    end
+  end
+end

data/lib/jav/fields/area_field.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Jav
+  module Fields
+    class AreaField < BaseField
+      attr_reader :mapkick_options, :datapoint_options
+
+      def initialize(id, **args, &block)
+        hide_on :index
+
+        super
+
+        @geometry = args[:geometry].presence || :polygon # Accepts: `:polygon` or `:multi_polygon`
+        @mapkick_options = args[:mapkick_options].presence || {}
+        @datapoint_options = args[:datapoint_options].presence || {}
+      end
+
+      def map_data
+        data_source = {
+          geometry: {
+            type: @geometry.to_s.classify,
+            coordinates: value
+          }
+        }
+
+        [data_source.merge(datapoint_options)]
+      end
+
+      def coordinates
+        value.present? ? JSON.parse(value) : []
+      end
+
+      def geometry
+        @geometry.to_s.classify
+      end
+    end
+  end
+end

data/lib/jav/fields/badge_field.rb

@@ -0,0 +1,16 @@
+module Jav
+  module Fields
+    class BadgeField < BaseField
+      attr_reader :options
+
+      def initialize(id, **args, &block)
+        super
+
+        hide_on %i[edit new]
+
+        default_options = { info: :info, success: :success, danger: :danger, warning: :warning, neutral: :neutral }
+        @options = args[:options].present? ? default_options.merge(args[:options]) : default_options
+      end
+    end
+  end
+end

data/lib/jav/fields/base_field.rb

@@ -0,0 +1,300 @@
+module Jav
+  module Fields
+    class BaseField
+      extend ActiveSupport::DescendantsTracker
+      extend Jav::Fields::FieldExtensions::HasFieldName
+
+      include Jav::Concerns::IsResourceItem
+      include Jav::Concerns::HandlesFieldArgs
+
+      include ActionView::Helpers::UrlHelper
+      include Jav::Fields::FieldExtensions::VisibleInDifferentViews
+
+      include Jav::Concerns::HasHTMLAttributes
+      include Jav::Fields::Concerns::IsRequired
+      include Jav::Fields::Concerns::IsReadonly
+      include Jav::Fields::Concerns::IsDisabled
+      include Jav::Fields::Concerns::HasDefault
+
+      delegate :view_context, to: ::Jav::App
+      delegate :simple_format, :content_tag, to: :view_context
+      delegate :main_app, to: :view_context
+      delegate :jav, to: :view_context
+      delegate :t, to: ::I18n
+
+      attr_reader :id, :block, :required, :readonly, :sortable, :nullable, :null_values, :format_using, :autocomplete, :help, :default, :visible, :as_label, :as_avatar, :as_description, :index_text_align, :stacked, :in_sidebar, :computed, :computed_value, :view, :resource, :action, :user, :panel_name
+
+      # Private options
+      attr_reader :computable # if allowed to be computable # if block is present # the value after computation
+
+      # Hydrated payload
+      attr_reader :model
+
+      class_attribute :field_name_attribute
+      class_attribute :item_type, default: :field
+
+      def initialize(id, **args, &block)
+        super
+        @id = id
+        @name = args[:name]
+        @translation_key = args[:translation_key]
+        @block = block
+        @required = args[:required] # Value if :required present on args, nil otherwise
+        @readonly = args[:readonly] || false
+        @disabled = args[:disabled] || false
+        @sortable = args[:sortable] || false
+        @nullable = args[:nullable] || false
+        @null_values = args[:null_values] || [nil, ""]
+        @format_using = args[:format_using] || nil
+        @update_using = args[:update_using] || nil
+        @placeholder = args[:placeholder]
+        @autocomplete = args[:autocomplete] || nil
+        @help = args[:help] || nil
+        @default = args[:default] || nil
+        @visible = args[:visible]
+        @as_label = args[:as_label] || false
+        @as_avatar = args[:as_avatar] || false
+        @as_description = args[:as_description] || false
+        @index_text_align = args[:index_text_align] || :left
+        @html = args[:html] || nil
+        @view = args[:view] || nil
+        @value = args[:value] || nil
+        @stacked = args[:stacked] || nil
+        @resource = args[:resource]
+        @action = args[:action]
+        @in_sidebar = args[:in_sidebar]
+
+        @args = args
+
+        @computable = true
+        @computed = block.present?
+        @computed_value = nil
+
+        # Set the visibility
+        show_on args[:show_on] if args[:show_on].present?
+        hide_on args[:hide_on] if args[:hide_on].present?
+        only_on args[:only_on] if args[:only_on].present?
+        except_on args[:except_on] if args[:except_on].present?
+      end
+
+      def hydrate(**kwargs)
+        # List of permitted keyword argument keys as symbols
+        permited_kwargs_keys = %i[model resource action view panel_name user]
+
+        # Check for unrecognized keys
+        unrecognized_keys = kwargs.keys - permited_kwargs_keys
+        raise ArgumentError, "Unrecognized argument(s): #{unrecognized_keys.join(', ')}" if unrecognized_keys.any?
+
+        # Set instance variables with provided values
+        kwargs.each do |key, value|
+          instance_variable_set(:"@#{key}", value)
+        end
+
+        # Return self for method chaining, if desired
+        self
+      end
+
+      def translation_key
+        return @translation_key if @translation_key.present?
+
+        "jav.field_translations#{@args[:translation_scope]}.#{@id}"
+      end
+
+      # Getting the name of the resource (user/users, post/posts)
+      # We'll first check to see if the user passed a name
+      # Secondly we'll try to find a translation key
+      # We'll fallback to humanizing the id
+      def name
+        return @name if custom_name?
+
+        if translation_key && ::Jav::App.translation_enabled
+          t(translation_key, count: 1, default: default_name).humanize
+        else
+          default_name
+        end
+      end
+
+      def plural_name
+        default = name.pluralize
+
+        if translation_key && ::Jav::App.translation_enabled
+          t(translation_key, count: 2, default: default).humanize
+        else
+          default
+        end
+      end
+
+      def custom_name?
+        @name.present?
+      end
+
+      def default_name
+        @id.to_s.humanize(keep_id_suffix: true)
+      end
+
+      def placeholder
+        return Jav::Hosts::ResourceViewRecordHost.new(block: @placeholder, record: @model, resource: @resource, view: @view).handle if @placeholder.respond_to?(:call)
+
+        @placeholder || name
+      end
+
+      def visible?
+        return true if visible.nil?
+
+        if visible.respond_to?(:call)
+          visible.call resource: @resource
+        else
+          visible
+        end
+      end
+
+      def value(property = nil)
+        return @value if @value.present?
+
+        property ||= id
+
+        # Get model value
+        final_value = @model.send(property) if is_model?(@model) && @model.respond_to?(property)
+
+        # On new views and actions modals we need to prefill the fields with the default value
+        final_value = computed_default_value if should_fill_with_default_value? && default.present?
+
+        # Run computable callback block if present
+        final_value = instance_exec(@model, @resource, @view, self, &block) if computable && block.present?
+
+        if @format_using.present?
+          # Apply the changes in the
+          Jav::ExecutionContext.new(
+            target: @format_using,
+            model: model,
+            key: property,
+            value: final_value,
+            resource: resource,
+            view: view,
+            field: self,
+            delegate_missing_to: :view_context,
+            include: self.class.included_modules
+          ).handle
+        else
+          final_value
+        end
+      end
+
+      # Fills the model with the received value on create and update actions.
+      def fill_field(model, key, value, params)
+        return model unless model.methods.include? key.to_sym
+
+        value = update_using(model, key, value, params) if @update_using.present?
+
+        model.public_send(:"#{key}=", value)
+
+        model
+      end
+
+      def update_using(model, key, value, params)
+        Jav::ExecutionContext.new(
+          target: @update_using,
+          model: model,
+          key: key,
+          value: value,
+          resource: resource,
+          field: self,
+          include: self.class.included_modules
+        ).handle
+      end
+
+      # Try to see if the field has a different database ID than it's name
+      def database_id
+        foreign_key
+      rescue StandardError
+        id
+      end
+
+      def has_own_panel?
+        false
+      end
+
+      def resolve_attribute(value)
+        value
+      end
+
+      def to_permitted_param
+        id.to_sym
+      end
+
+      def view_component_name
+        "#{type.camelize}Field"
+      end
+
+      # Try and build the component class or fallback to a blank one
+      def component_for_view(view = :index)
+        # Use the edit variant for all "update" views
+        view = :edit if view.in? %i[new create update]
+
+        component_class = "::Jav::Fields::#{view_component_name}::#{view.to_s.camelize}Component"
+        component_class.constantize
+      rescue StandardError
+        # When returning nil, a race condition happens and throws an error in some environments.
+        # See https://github.com/jav-hq/jav/pull/365
+        ::Jav::BlankFieldComponent
+      end
+
+      def model_errors
+        model.nil? ? {} : model.errors
+      end
+
+      def type
+        self.class.name.demodulize.to_s.underscore.gsub("_field", "")
+      end
+
+      def custom?
+        method(:initialize).source_location.first.exclude?("lib/jav/field")
+      rescue StandardError
+        true
+      end
+
+      def visible_in_reflection?
+        true
+      end
+
+      def hidden_in_reflection?
+        !visible_in_reflection?
+      end
+
+      def updatable
+        !is_readonly? && visible?
+      end
+
+      # Used by Jav to fill the record with the default value on :new and :edit views
+      def assign_value(record:, value:)
+        id = type == "belongs_to" ? foreign_key : database_id
+
+        return unless record.send(id).nil?
+
+        record.send(:"#{id}=", value)
+      end
+
+      private
+
+      def model_or_class(model)
+        model.instance_of?(String) ? "class" : "model"
+      end
+
+      def is_model?(model)
+        model_or_class(model) == "model"
+      end
+
+      def should_fill_with_default_value?
+        on_create? || in_action?
+      end
+
+      def on_create?
+        @view.in?(%i[new create])
+      end
+
+      def in_action?
+        @action.present?
+      end
+    end
+  end
+end