jav 2.55.4

data/lib/jav/services/authorization_clients/pundit_client.rb

@@ -0,0 +1,51 @@
+module Jav
+  module Services
+    module AuthorizationClients
+      class PunditClient
+        def authorize(user, record, action, policy_class: nil)
+          Pundit.authorize(user, record, action, policy_class: policy_class)
+        rescue Pundit::NotDefinedError => error
+          raise NoPolicyError, error.message
+        rescue Pundit::NotAuthorizedError => error
+          raise NotAuthorizedError, error.message
+        end
+
+        def policy(user, record)
+          Pundit.policy(user, record)
+        end
+
+        def policy!(user, record)
+          Pundit.policy!(user, record)
+        rescue Pundit::NotDefinedError => error
+          raise NoPolicyError, error.message
+        end
+
+        def apply_policy(user, model, policy_class: nil)
+          # Try and figure out the scope from a given policy or auto-detected one
+          scope_from_policy_class = scope_for_policy_class(policy_class)
+
+          # If we discover one use it.
+          # Else fallback to pundit.
+          if scope_from_policy_class.present?
+            scope_from_policy_class.new(user, model).resolve
+          else
+            Pundit.policy_scope!(user, model)
+          end
+        rescue Pundit::NotDefinedError => error
+          raise NoPolicyError, error.message
+        end
+
+        private
+
+        # Fetches the scope for a given policy
+        def scope_for_policy_class(policy_class = nil)
+          return if policy_class.blank?
+
+          return unless policy_class.present? && defined?(policy_class::Scope)
+
+          policy_class::Scope
+        end
+      end
+    end
+  end
+end

data/lib/jav/services/authorization_service.rb

@@ -0,0 +1,133 @@
+module Jav
+  module Services
+    class AuthorizationService
+      attr_accessor :user, :record, :policy_class
+
+      class << self
+        def client
+          client = Jav.configuration.authorization_client
+
+          klass = case client
+                  when nil
+                    nil_client
+                  when :pundit
+                    pundit_client
+                  else
+                    if client.is_a?(String)
+                      client.safe_constantize
+                    else
+                      client
+                    end
+                  end
+
+          klass.new
+        end
+
+        def authorize(user, record, action, policy_class: nil, **args)
+          client.authorize user, record, action, policy_class: policy_class
+
+          true
+        rescue NoPolicyError => error
+          # By default, Jav allows anything if you don't have a policy present.
+          return true unless Jav.configuration.raise_error_on_missing_policy
+
+          raise error
+        rescue StandardError => error
+          raise error unless args[:raise_exception] == false
+
+          false
+        end
+
+        def authorize_action(user, record, action, policy_class: nil, **args)
+          action = Jav.configuration.authorization_methods.stringify_keys[action.to_s] || action
+
+          # If no action passed we should raise error if the user wants that.
+          # If not, just allow it.
+          if action.nil?
+            raise NoPolicyError, "Policy method is missing" if Jav.configuration.raise_error_on_missing_policy
+
+            return true
+          end
+
+          # Add the question mark if it's missing
+          action = "#{action}?" unless action.end_with? "?"
+          authorize(user, record, action, policy_class: policy_class, **args)
+        end
+
+        def apply_policy(user, model, policy_class: nil)
+          client.apply_policy(user, model, policy_class: policy_class)
+        rescue NoPolicyError => error
+          return model unless Jav.configuration.raise_error_on_missing_policy
+
+          raise error
+        end
+
+        def skip_authorization
+          Jav::App.license.lacks_with_trial :authorization
+        end
+
+        def defined_methods(user, record, policy_class: nil, **args)
+          return client.policy!(user, record).methods if policy_class.nil?
+
+          # I'm aware this will not raise a Pundit error.
+          # Should the policy not exist, it will however raise an uninitialized constant error, which is probably what we want when specifying a custom policy
+          policy_class.new(user, record).methods
+        rescue NoPolicyError => error
+          return [] unless Jav.configuration.raise_error_on_missing_policy
+
+          raise error
+        rescue StandardError => error
+          raise error unless args[:raise_exception] == false
+
+          []
+        end
+
+        def pundit_client
+          raise Jav::MissingGemError, "Please add `gem 'pundit'` to your Gemfile." unless defined?(Pundit)
+
+          Jav::Services::AuthorizationClients::PunditClient
+        end
+
+        def nil_client
+          Jav::Services::AuthorizationClients::NilClient
+        end
+      end
+
+      def initialize(user = nil, record = nil, policy_class: nil)
+        @user = user
+        @record = record
+        @policy_class = policy_class || self.class.client.policy(user, record)&.class
+      end
+
+      def set_record(record)
+        @record = record
+
+        self
+      end
+
+      def authorize_action(action, **args)
+        self.class.authorize_action(user, args[:record] || record, action, policy_class: policy_class, **args)
+      end
+
+      def apply_policy(model)
+        self.class.apply_policy(user, model, policy_class: policy_class)
+      end
+
+      def defined_methods(model, **args)
+        self.class.defined_methods(user, model, policy_class: policy_class, **args)
+      end
+
+      def has_method?(method, **args)
+        method = "#{method}?" unless method.to_s.end_with? "?"
+        defined_methods(args[:record] || record, **args).include? method.to_sym
+      end
+
+      # Check the received method to see if the user overrode it in their config and then checks if it's present on the policy.
+      def has_action_method?(method, **args)
+        method = Jav.configuration.authorization_methods.stringify_keys[method.to_s] || method
+
+        has_method? method, **args
+      end
+    end
+  end
+end

data/lib/jav/services/encryption_service.rb

@@ -0,0 +1,41 @@
+module Jav
+  module Services
+    class EncryptionService
+      attr_reader :message, :purpose, :crypt
+
+      class << self
+        def encrypt(message:, purpose:)
+          new(message: message, purpose: purpose).encrypt
+        end
+
+        def decrypt(message:, purpose:)
+          new(message: message, purpose: purpose).decrypt
+        end
+      end
+
+      def initialize(message:, purpose:)
+        @message = message
+        @purpose = purpose
+        @crypt = ActiveSupport::MessageEncryptor.new(encryption_key)
+      end
+
+      def encrypt
+        crypt.encrypt_and_sign(message, purpose: purpose)
+      end
+
+      def decrypt
+        crypt.decrypt_and_verify(message, purpose: purpose)
+      end
+
+      private
+
+      def encryption_key
+        Rails.application.secret_key_base[0..31]
+      rescue StandardError
+        # This will fail the decryption process.
+        # It's here only to keep Jav from crashing
+        SecureRandom.random_bytes(32)
+      end
+    end
+  end
+end

data/lib/jav/services/uri_service.rb

@@ -0,0 +1,74 @@
+module Jav
+  module Services
+    class URIService
+      class << self
+        def parse(path)
+          new path
+        end
+      end
+
+      attr_reader :uri
+
+      def initialize(path = "")
+        @uri = Addressable::URI.parse(path)
+      end
+
+      def call
+        to_s
+      end
+
+      def append_paths(*paths)
+        paths = Array.wrap(paths).flatten
+
+        return self if paths.blank?
+
+        # Add the intermediary forward slash
+        @uri.path.concat("/") unless @uri.path.ends_with? "/"
+
+        # Add the paths to the URI
+        @uri.merge!(path: @uri.path.concat(join_paths(paths)))
+
+        self
+      end
+      alias append_path append_paths
+
+      def append_query(params)
+        params = if params.is_a? Hash
+                   params.map do |key, value|
+                     "#{key}=#{value}"
+                   end
+                 else
+                   {}
+                 end
+
+        return self if params.blank?
+
+        # Add the query params to the URI
+        @uri.merge!(query: [@uri.query, *params].compact.join("&"))
+
+        self
+      end
+
+      def to_s
+        @uri.to_s
+      end
+
+      private
+
+      def join_paths(paths)
+        paths
+          .map do |path|
+            sanitize_path path
+          end
+          .join("/")
+      end
+
+      # Removes the forward slash if it's present at the start of the path
+      def sanitize_path(path)
+        path = path[1..] if path.to_s.starts_with? "/"
+
+        ERB::Util.url_encode path
+      end
+    end
+  end
+end

data/lib/jav/sidebar.rb

@@ -0,0 +1,29 @@
+class Jav::Sidebar
+  include Jav::Concerns::IsResourceItem
+  include Jav::Concerns::VisibleItems
+  include Jav::Fields::FieldExtensions::VisibleInDifferentViews
+
+  class_attribute :item_type, default: :sidebar
+  delegate :items, :add_item, to: :items_holder
+
+  attr_reader :name, :view
+  attr_accessor :items_holder
+
+  def initialize(name: nil, view: nil, **args)
+    # Initialize the visibility markers
+    super
+
+    @name = name
+    @items_holder = Jav::ItemsHolder.new
+    @view = view
+
+    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 empty?
+    visible_items.blank?
+  end
+end

data/lib/jav/sidebar_builder.rb

@@ -0,0 +1,24 @@
+class Jav::SidebarBuilder
+  class << self
+    def parse_block(**args, &block)
+      Docile.dsl_eval(new(**args), &block).build
+    end
+  end
+
+  attr_reader :items_holder
+
+  delegate :field, to: :items_holder
+  delegate :items, to: :items_holder
+  delegate :heading, to: :items_holder
+
+  def initialize(name: nil, **args)
+    @sidebar = Jav::Sidebar.new(**args)
+    @items_holder = Jav::ItemsHolder.new
+  end
+
+  # Fetch the sidebar
+  def build
+    @sidebar.items_holder = @items_holder
+    @sidebar
+  end
+end

data/lib/jav/svg_finder.rb

@@ -0,0 +1,46 @@
+class Jav::SvgFinder
+  def self.find_asset(filename)
+    new(filename)
+  end
+
+  def initialize(filename)
+    @filename = filename
+  end
+
+  # Use the default static finder logic. If that doesn't find anything, search according to our pattern:
+  def pathname
+    found_asset = default_strategy
+
+    # Use the found asset
+    return found_asset if found_asset.present?
+
+    paths = [
+      Rails.root.join("app", "assets", "svgs", @filename).to_s,
+      Rails.root.join(@filename).to_s,
+      Jav::Engine.root.join("app", "assets", "svgs", @filename).to_s,
+      Jav::Engine.root.join("app", "assets", "svgs", "heroicons", "outline", @filename).to_s,
+      Jav::Engine.root.join(@filename).to_s
+    ]
+
+    paths.find do |path|
+      File.exist? path
+    end
+  end
+
+  def default_strategy
+    # If the app uses Propshaft, grab it from there
+    if defined?(Propshaft)
+      asset_path = ::Rails.application.assets.load_path.find(@filename)
+      asset_path&.path
+    elsif ::Rails.application.config.assets.compile
+      # Grab the asset from the compiled asset manifest
+      asset = ::Rails.application.assets[@filename]
+      Pathname.new(asset.filename) if asset.present?
+    else
+      # Grab the asset from the manifest
+      manifest = ::Rails.application.assets_manifest
+      asset_path = manifest.assets[@filename]
+      ::Rails.root.join(manifest.directory, asset_path) unless asset_path.nil?
+    end
+  end
+end

data/lib/jav/tab.rb

@@ -0,0 +1,71 @@
+class Jav::Tab
+  include Jav::Concerns::IsResourceItem
+  include Jav::Concerns::VisibleItems
+  include Jav::Fields::FieldExtensions::VisibleInDifferentViews
+
+  class_attribute :item_type, default: :tab
+  delegate :items, :add_item, to: :items_holder
+
+  attr_reader :view, :identity_name
+  attr_accessor :description, :items_holder, :holds_one_field
+
+  def initialize(name: nil, description: nil, view: nil, holds_one_field: false, **args)
+    # Initialize the visibility markers
+    super
+
+    @name = name
+    @description = description
+    @holds_one_field = holds_one_field
+    @items_holder = Jav::ItemsHolder.new
+    @view = view
+
+    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?
+    @identity_name = args[:identity_name]
+  end
+
+  def name
+    if @name.respond_to?(:call)
+      Jav::Hosts::BaseHost.new(block: @name).handle
+    else
+      @name
+    end
+  end
+
+  def hydrate(view: nil)
+    @view = view
+
+    items_holder.items.grep(Jav::Panel).each do |panel|
+      panel.hydrate(view: view)
+    end
+
+    self
+  end
+
+  def turbo_frame_id(parent: nil)
+    id = "#{Jav::Tab.to_s.parameterize} #{name} #{@identity_name}".parameterize
+
+    return id if parent.nil?
+
+    "#{parent.turbo_frame_id} #{id}".parameterize
+  end
+
+  def empty?
+    visible_items.blank?
+  end
+
+  # Checks for visibility on itself or on theone field it holds
+  def visible_on?(view)
+    if holds_one_field
+      super && items.first.visible_on?(view)
+    else
+      super
+    end
+  end
+
+  def has_a_single_item?
+    items.count == 1
+  end
+end

data/lib/jav/tab_builder.rb

@@ -0,0 +1,25 @@
+class Jav::TabBuilder
+  class << self
+    def parse_block(**args, &block)
+      Docile.dsl_eval(new(**args), &block).build
+    end
+  end
+
+  attr_reader :items_holder
+
+  delegate :field, to: :items_holder
+  delegate :tool, to: :items_holder
+  delegate :panel, to: :items_holder
+  delegate :items, to: :items_holder
+
+  def initialize(name: nil, **args)
+    @tab = Jav::Tab.new(name: name, **args)
+    @items_holder = Jav::ItemsHolder.new
+  end
+
+  # Fetch the tab
+  def build
+    @tab.items_holder = @items_holder
+    @tab
+  end
+end

data/lib/jav/tab_group.rb

@@ -0,0 +1,33 @@
+class Jav::TabGroup
+  include Jav::Concerns::HasFields
+  include Jav::Concerns::IsResourceItem
+
+  class_attribute :item_type, default: :tab_group
+
+  attr_reader :view
+  attr_accessor :index, :items_holder, :style
+
+  def initialize(index: 0, view: nil, style: nil)
+    @index = index
+    @items_holder = Jav::ItemsHolder.new
+    @view = view
+    @style = style
+  end
+
+  def hydrate(view: nil)
+    @view = view
+
+    self
+  end
+
+  def visible_items
+    items
+      .map { |item| item.hydrate view: view }
+      .select { |item| item.visible_on? view } # Remove items hidden in this view
+      .reject(&:empty?) # Remove empty items
+  end
+
+  def turbo_frame_id
+    "#{Jav::TabGroup.to_s.parameterize} #{index}".parameterize
+  end
+end

data/lib/jav/tab_group_builder.rb

@@ -0,0 +1,43 @@
+class Jav::TabGroupBuilder
+  class << self
+    def parse_block(**args, &block)
+      Docile.dsl_eval(new(**args), &block).build
+    end
+  end
+
+  attr_reader :items_holder
+
+  delegate :tab, to: :items_holder
+
+  def initialize(style: nil)
+    @group = Jav::TabGroup.new(style: style)
+    @items_holder = Jav::ItemsHolder.new
+  end
+
+  def field(field_name, **args, &block)
+    parsed = Jav::Dsl::FieldParser.new(id: field_name, order_index: @items_index, **args, &block).parse
+    field_instance = parsed.instance
+
+    name = -> { field_instance.name }
+    tab = Jav::Tab.new name: name
+
+    if field_instance.has_own_panel?
+      tab.items_holder.add_item parsed.instance
+      tab.holds_one_field = true
+    else
+      # If the field is not in a panel, create one and add it
+      panel = Jav::Panel.new name: name
+      panel.items_holder.add_item parsed.instance
+      # Add that panel to the bag
+      tab.items_holder.add_item panel
+    end
+
+    @items_holder.tabs tab
+  end
+
+  # Fetch the tab
+  def build
+    @group.items_holder = @items_holder
+    @group
+  end
+end

data/lib/jav/tools_manager.rb

@@ -0,0 +1,9 @@
+module Jav
+  class ToolsManager
+    def self.get_tools
+      Jav::Tools.constants.map do |c|
+        "Jav::Tools::#{c}".safe_constantize if Jav::Tools.const_get(c).is_a?(Class)
+      end
+    end
+  end
+end

data/lib/jav/version.rb

@@ -0,0 +1,3 @@
+module Jav
+  VERSION = "2.55.4" unless const_defined?(:VERSION)
+end

data/lib/jav.rb

@@ -0,0 +1,39 @@
+require "zeitwerk"
+require_relative "jav/version"
+require_relative "jav/engine" if defined?(Rails)
+
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect(
+  "html" => "HTML",
+  "uri_service" => "URIService",
+  "has_html_attributes" => "HasHTMLAttributes"
+)
+loader.ignore("#{__dir__}/generators")
+loader.setup
+module Jav
+  ROOT_PATH = Pathname.new(File.join(__dir__, ".."))
+  IN_DEVELOPMENT = ENV["JAV_IN_DEVELOPMENT"] == "1"
+  PACKED = !IN_DEVELOPMENT
+  COOKIES_KEY = "jav"
+  ENTITIES = {
+    cards: %w[app jav cards],
+    fields: %w[app jav fields],
+    filters: %w[app jav filters],
+    actions: %w[app jav actions],
+    resources: %w[app jav resources],
+    dashboards: %w[app jav dashboards],
+    resource_tools: %w[app jav resource_tools]
+  }
+
+  class LicenseVerificationTemperedError < StandardError; end
+
+  class LicenseInvalidError < StandardError; end
+
+  class NotAuthorizedError < StandardError; end
+
+  class NoPolicyError < StandardError; end
+
+  class MissingGemError < StandardError; end
+end
+
+loader.eager_load

data/lib/tasks/jav_tasks.rake

@@ -0,0 +1,38 @@
+# desc 'Explaining what the task does'
+# task :jav do
+#   # Task goes here
+# end
+
+desc "Installs Jav assets and bundles them for when you want to use the GitHub repo in your app"
+task "jav:build-assets" do
+  spec = get_gem_spec "jav"
+  # Uncomment to enable only when the source is github.com
+  # enabled = spec.source.to_s.include?('https://github.com/jav-hq/jav')
+  enabled = true
+
+  if enabled
+    puts "Starting jav:build-assets"
+    path = spec.full_gem_path
+
+    Dir.chdir(path) do
+      system "yarn"
+      system "yarn prod:build"
+    end
+
+    puts "Done"
+  else
+    puts "Not starting jav:build-assets"
+  end
+end
+
+# From
+# https://stackoverflow.com/questions/9322078/programmatically-determine-gems-path-using-bundler
+def get_gem_spec(name)
+  spec = Bundler.load.specs.find { |s| s.name == name }
+  raise GemNotFound, "Could not find gem '#{name}' in the current bundle." unless spec
+  if spec.name == "bundler"
+    return File.expand_path("../../../", __FILE__)
+  end
+
+  spec
+end

data/lib/tasks/tailwindcss_rails.rake

@@ -0,0 +1,24 @@
+# Use the user provided asset or use the default
+ASSET_FILE = ARGV[0] || "app/assets/builds/jav.tailwind.css"
+# Se the tailwindcss-rails package name
+TAILWINDCSS_RAILS = "tailwindcss-rails"
+
+# Check if tailwindcss-rails is being used
+if Gem.loaded_specs.key? TAILWINDCSS_RAILS
+  # Get the path
+  GEM_PATH = Gem.loaded_specs[TAILWINDCSS_RAILS].full_gem_path
+  # Compose the compile command
+  JAV_TAILWIND_COMPILE_COMMAND = "#{RbConfig.ruby} #{Pathname.new(GEM_PATH)}/exe/tailwindcss -i '#{Rails.root.join("app/assets/stylesheets/jav.tailwind.css")}' -o '#{Rails.root.join(ASSET_FILE)}' -c '#{Rails.root.join("config/tailwind.config.js")}' --minify"
+
+  namespace "jav:tailwindcss" do
+    desc "Build your Tailwind CSS"
+    task :build do
+      system(JAV_TAILWIND_COMPILE_COMMAND, exception: true)
+    end
+
+    desc "Watch and build your Tailwind CSS on file changes"
+    task :watch do
+      system "#{JAV_TAILWIND_COMPILE_COMMAND} -w"
+    end
+  end
+end