flexi_admin 0.0.5

data/lib/flexi_admin/javascript/controllers/trix_controller.js

@@ -0,0 +1,32 @@
+import { Controller } from "@hotwired/stimulus";
+
+// Connects to data-controller="trix"
+export default class extends Controller {
+  static values = { disabled: Boolean, collapsed: Boolean };
+  static targets = ["editor", "trigger", "container"];
+
+  connect() {
+    if (this.disabledValue === false) {
+      // Set background color to white
+      this.editorTarget.style.backgroundColor = "white";
+    }
+  }
+
+  toggleCollapse() {
+    if (this.collapsedValue === true) {
+      this.containerTarget.classList.remove("collapsed");
+      this.containerTarget.classList.add("expanded");
+      this.collapsedValue = false;
+    } else {
+      this.containerTarget.classList.remove("expanded");
+      this.containerTarget.classList.add("collapsed");
+      this.collapsedValue = true;
+    }
+
+    if (this.triggerTarget.innerHTML === "rozbalit") {
+      this.triggerTarget.innerHTML = "skrýt";
+    } else {
+      this.triggerTarget.innerHTML = "rozbalit";
+    }
+  }
+}

data/lib/flexi_admin/javascript/controllers/uploads_controller.js

@@ -0,0 +1,164 @@
+import { Controller } from "@hotwired/stimulus";
+import { CSRFToken } from "../utils";
+
+export default class extends Controller {
+  static targets = [
+    "form",
+    "list",
+    "globalProgress",
+    "globalProgressBar",
+    "resetButton",
+    "filesInput",
+  ];
+
+  connect() {
+    this.element.addEventListener("direct-uploads:start", (event) => {
+      this._initGlobalProgress();
+    });
+
+    this.element.addEventListener("direct-upload:initialize", (event) => {
+      const { id, file } = event.detail;
+      this._initializeFileCard(id, file);
+    });
+
+    this.element.addEventListener("direct-upload:progress", (event) => {
+      const { id, file, progress } = event.detail;
+      this._updateImageProgress(id, progress);
+    });
+
+    this.element.addEventListener("direct-upload:end", (event) => {
+      const { id, file } = event.detail;
+      this._reportCompletion(file, id);
+      this._updateImageProgress(id, 100);
+      this._updateGlobalProgress();
+    });
+
+    this.element.addEventListener("direct-uploads:end", (event) => {
+      this.resetButtonTarget.classList.remove("d-none");
+    });
+
+    this.element.addEventListener("direct-upload:error", (event) => {
+      const { id } = event.detail;
+      this._setErrorProgress(id);
+    });
+  }
+
+  resetForm() {
+    this.formTarget.reset();
+    // hide global progress
+    this.globalProgressTarget.classList.remove("show");
+    // hide reset button
+    this.resetButtonTarget.classList.add("d-none");
+    // reset counters
+    this.totalCount = 0;
+    this.currentCount = 0;
+    // clear list
+    this.listTarget.innerHTML = "";
+    // enable the input field
+    this.filesInputTarget.disabled = false;
+  }
+
+  _initGlobalProgress(totalCount) {
+    const filesInput = this.filesInputTarget;
+    this.totalCount = filesInput.files.length;
+    this.currentCount = 0;
+
+    this.globalProgressTarget.classList.add("show");
+    this.globalProgressBarTarget.style.width = `${0}%`;
+    this.globalProgressBarTarget.setAttribute("aria-valuenow", 0);
+    this.globalProgressBarTarget.textContent = `0/${totalCount}`;
+  }
+
+  _updateGlobalProgress() {
+    const globalProgressBar = this.globalProgressBarTarget;
+    this.currentCount += 1;
+
+    const perCent = (this.currentCount / this.totalCount) * 100;
+    globalProgressBar.style.width = `${perCent}%`;
+    globalProgressBar.setAttribute("aria-valuenow", perCent);
+    globalProgressBar.textContent = `${this.currentCount}/${this.totalCount}`;
+  }
+
+  _setErrorProgress(id) {
+    const element = document.getElementById(`upload-${id}`);
+    const progressBar = element.querySelector(".progress-bar");
+    progressBar.classList.add("bg-danger");
+    progressBar.style.width = "100%";
+    progressBar.setAttribute("aria-valuenow", 100);
+  }
+
+  _updateImageProgress(id, progress) {
+    const element = document.getElementById(`upload-${id}`);
+    const progressBar = element.querySelector(".progress-bar");
+    progressBar.style.width = `${progress}%`;
+    progressBar.setAttribute("aria-valuenow", progress);
+  }
+
+  _switchToVideo(id, url) {
+    const element = document.getElementById(`upload-${id}`);
+    const videoContainer = element.querySelector(".upload-video");
+    const video = element.querySelector(".upload-video video");
+    const icon = element.querySelector(".upload-icon");
+    video.src = url;
+    icon.classList.add("d-none");
+    videoContainer.classList.add("show");
+  }
+
+  _switchToImage(id, url) {
+    const element = document.getElementById(`upload-${id}`);
+    const imageContainer = element.querySelector(".upload-image");
+    const image = element.querySelector(".upload-image img");
+    const icon = element.querySelector(".upload-icon");
+    image.src = url;
+    icon.classList.add("d-none");
+    imageContainer.classList.add("show");
+  }
+
+  _reportCompletion(file, id) {
+    const name = file.name;
+    const size = file.size;
+
+    fetch("/uploads/soft_completed", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-CSRF-Token": CSRFToken(),
+        Accept: "application/json",
+      },
+      body: JSON.stringify({ name, size }),
+    })
+      .then((response) => response.json())
+      .then((data) => {
+        const { url, kind } = data;
+        if (url) {
+          if (kind === "video") {
+            this._switchToVideo(id, url);
+          } else {
+            this._switchToImage(id, url);
+          }
+        }
+      })
+      .catch((error) => console.error("Error:", error));
+  }
+
+  _initializeFileCard(id, file) {
+    const name = file.name;
+    const size = file.size;
+    const contentType = file.type;
+
+    fetch("/uploads/initialize_upload", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-CSRF-Token": CSRFToken(),
+        Accept: "text/html",
+      },
+      body: JSON.stringify({ id, name, size, contentType }),
+    })
+      .then((response) => response.text())
+      .then((html) => {
+        this.listTarget.insertAdjacentHTML("afterbegin", html);
+      })
+      .catch((error) => console.error("Error:", error));
+  }
+}

data/lib/flexi_admin/javascript/flexi_admin.js

@@ -0,0 +1,4 @@
+import "./controllers";
+import { fetchTurboContent, CSRFToken } from "./utils";
+
+export { fetchTurboContent, CSRFToken };

data/lib/flexi_admin/javascript/utils.js

@@ -0,0 +1,26 @@
+export function CSRFToken() {
+  const metaTag = document.querySelector('meta[name="csrf-token"]');
+  return metaTag ? metaTag.getAttribute("content") : null;
+}
+
+export function fetchTurboContent(event, path) {
+  event.preventDefault();
+
+  fetch(path, {
+    headers: {
+      Accept: "text/vnd.turbo-stream.html",
+    },
+  })
+    .then((response) => response.text())
+    .then((html) => {
+      Turbo.renderStreamMessage(html);
+    })
+    .catch((error) => {
+      console.error("Error fetching content:", error);
+    });
+}
+
+export function markValid(event) {
+  event.target.setCustomValidity("");
+  event.target.checkValidity();
+}

data/lib/flexi_admin/models/concerns/application_resource.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module FlexiAdmin::Models::Concerns::ApplicationResource
+  extend ActiveSupport::Concern
+  include FlexiAdmin::Models::Concerns::Parentable
+
+  def identifier
+    "#{self.class.name.underscore}_#{id}"
+  end
+  alias frame_id identifier
+
+  def form_id
+    "#{identifier}_form"
+  end
+
+  def gid_param
+    gid = to_gid
+
+    URI.encode_www_form_component(gid)
+  end
+
+  def raw(attribute)
+    read_attribute_before_type_cast(attribute)
+  end
+end

data/lib/flexi_admin/models/concerns/parentable.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module FlexiAdmin::Models::Concerns::Parentable
+  extend ActiveSupport::Concern
+
+  included do
+    scope :with_parent, lambda { |parent_instance|
+      return all if parent_instance.blank?
+
+      plural_name = parent_instance.class.model_name.plural
+
+      association_name = model.reflect_on_all_associations.find { |a| a.plural_name == plural_name }.name
+
+      joins(association_name).where(association_name => { id: parent_instance.id })
+    }
+  end
+end

data/lib/flexi_admin/models/context_params.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module FlexiAdmin::Models
+  class ContextParams
+    MAP = {
+      scope: 'fa_scope',
+      page: 'fa_page',
+      per_page: 'fa_per_page',
+      parent: 'fa_parent',
+      frame: 'fa_frame', # target turbolinks frame
+      sort: 'fa_sort',
+      order: 'fa_order',
+      form_disabled: 'fa_form_disabled',
+      view: 'fa_view',
+      ac_action: 'ac_action', # autocomplete action
+      ac_fields: { 'ac_fields': [] }, # autocomplete result fields
+      ac_path: 'ac_path' # autocomplete path for opening resource in new window
+    }
+
+    def self.permitted_params_keys
+      MAP.values
+    end
+
+    def self.permitted_keys
+      MAP.keys.map(&:to_sym)
+    end
+
+    def self.params_map
+      MAP.each_with_object({}) do |(key, value), acc|
+        acc[key] = value.is_a?(Hash) ? value.keys.first.to_s : value
+      end
+    end
+
+    attr_reader :params
+
+    def initialize(params)
+      @params = params.to_h.with_indifferent_access.each_with_object({}) do |(key, value), acc|
+        acc[self.class.params_map.invert[key.to_s]] = value
+      end.with_indifferent_access
+    end
+
+    def [](key)
+      @params[key]
+    end
+
+    def merge(params)
+      new_params = @params.dup.merge(params.to_h.with_indifferent_access)
+
+      if params.keys.any? { |key| !self.class.permitted_keys.include?(key.to_sym) }
+        msg = "ContextParams: invalid params: "
+        msg += params.keys.select { |key| !self.class.permitted_keys.include?(key.to_sym) }.join(", ")
+        Rails.logger.warn msg
+      end
+
+      new_params = new_params.transform_keys { |key| self.class.params_map[key.to_sym] || key.to_sym }
+
+      self.class.new(new_params)
+    end
+
+    def with_parent(parent_instance)
+      return self if parent_instance.blank?
+
+      merge(parent: parent_instance.gid_param)
+    end
+
+    def with_parent!(parent_instance)
+      params[:parent] = parent_instance.gid_param
+      self
+    end
+
+    def except(*keys)
+      new_params = @params.dup.except(*keys)
+      new_params = new_params.transform_keys { |key| self.class.params_map.invert[key.to_s] }
+      self.class.new(new_params)
+    end
+
+    def to_params
+      self.class.params_map.map { |k, v| [v, params[k]] }
+          .reject { |_k, v| v.blank? }.to_h
+    end
+
+    def to_path(path)
+      path + "?" + to_params.to_query
+    end
+
+    def parent
+      params[:parent]
+    end
+
+    def per_page
+      params[:per_page] || 13
+    end
+
+    def page
+      params[:page] || 1
+    end
+
+    def frame
+      params[:frame] || '_top'
+    end
+
+    # Not sure if this is needed
+    def scope
+      params[:scope]
+    end
+
+    def form_disabled
+      params[:form_disabled] || false
+    end
+
+    def current_view
+      params[:view]
+    end
+
+    def pagination
+      { page:, per_page: }
+    end
+
+    def sort
+      params[:sort]
+    end
+
+    def order
+      params[:order]
+    end
+  end
+end

data/lib/flexi_admin/models/resources/context.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module FlexiAdmin::Models::Resources
+  class Context
+    attr_reader :resources, :scope, :params, :options
+
+    def initialize(resources, scope, params, options)
+      @resources = resources
+      @scope = scope
+      @params = params
+      @options = options
+    end
+
+    def resource
+      resources
+    end
+
+    def self.build(resource: nil, scope: nil, params: FlexiAdmin::Models::ContextParams.new({}), **options)
+      new(resource, scope, params, options)
+    end
+
+    def self.from_params(context_params, resources = nil)
+      parent = load_parent(context_params)
+
+      new(
+        resources,
+        context_params.scope,
+        context_params,
+        {}.merge(parent:)
+      )
+    end
+
+    def self.load_parent(context_params)
+      return nil if context_params.parent.blank?
+
+      gid = URI.decode_www_form_component(context_params.parent)
+
+      GlobalID::Locator.locate(gid)
+    end
+
+    def views
+      options[:views] || %w[list]
+    end
+
+    def paginate?
+      options.key?(:paginate) || true
+    end
+
+    def parent
+      options[:parent]
+    end
+
+    def to_params
+      params.merge(scope:)
+            .with_parent(parent)
+            .to_params
+    end
+  end
+end

data/lib/flexi_admin/models/struct.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module FlexiAdmin::Models
+  class Struct
+    def self.new(*positional_attrs, **keyword_attrs)
+      Class.new do
+        attr_reader(*positional_attrs, *keyword_attrs.keys)
+
+        define_method :initialize do |*args, **kwargs|
+          if args.size != positional_attrs.size
+            raise ArgumentError, "wrong number of arguments (given #{args.size}, expected #{positional_attrs.size})"
+          end
+
+          unknown_kwargs = kwargs.keys - keyword_attrs.keys
+          raise ArgumentError, "unknown keywords: #{unknown_kwargs.join(", ")}" unless unknown_kwargs.empty?
+
+          positional_attrs.zip(args).each do |attr, value|
+            instance_variable_set("@#{attr}", value)
+          end
+
+          keyword_attrs.each do |attr, default|
+            value = kwargs.key?(attr) ? kwargs[attr] : default
+            instance_variable_set("@#{attr}", value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flexi_admin/models/toast.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module FlexiAdmin::Models
+  class Toast
+    DELAY = 4
+    attr_reader :message, :options, :autohide, :delay_sec
+
+    def initialize(message, **options)
+      @message = message
+      @options = options
+      @autohide = options.fetch(:autohide, true)
+      @delay_sec = options.fetch(:delay, DELAY)
+    end
+
+    def to_s
+      message
+    end
+
+    def delay
+      delay_sec * 1000
+    end
+  end
+end

data/lib/flexi_admin/models.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module FlexiAdmin
+  module Models
+    module Concerns; end
+    module Resources; end
+  end
+end
+
+# Core
+require_relative "models/context_params"
+require_relative "models/struct"
+require_relative "models/toast"
+
+# Concerns
+require_relative "models/concerns/parentable"
+require_relative "models/concerns/application_resource"
+
+# Resources
+require_relative "models/resources/context"

data/lib/flexi_admin/prompts/codegen-system-prompt.md

@@ -0,0 +1,50 @@
+# Act as a Code Generation Assistant
+
+- **You are** an advanced **Code Generation Assistant** skilled in generating structured code based on provided application architecture patterns in the following technologies: Ruby on Rails, Javascript (Stimulus JS) and Bootstrap.
+- follow instructions in the <Task> section.
+
+## Objective
+
+Your objective is to:
+
+1. **Identify** which files need to be created based on the <Task> description, <CodeSamples> and known Rails file conventions.
+2. **Generate** code for each file with patterns similar to the provided examples in <CodeSamples> section, following naming conventions, structural organization and class inheritance.
+
+## Task Requirements
+
+1. **Adhere** to comments provided in the file samples in <CodeSamples> section, tagged with "CodeGen:"
+2. **Omit** any comments marked as "CodeGen:" in the final output.
+3. **Return** a array of JSON objects, where each object always includes:
+   - **filename**: the determined filename for the generated code.
+   - **code**: the generated code as per the task requirements.
+
+## Output schema
+
+```json
+{
+  "files": [
+    {
+      "filename": "string",
+      "code": "string"
+    }
+  ]
+}
+```
+
+---
+
+<CodeSamples>
+
+```plaintext
+{{sample_files}}
+```
+
+</CodeSamples>
+
+---
+
+<Task>
+
+{{task}}
+
+</Task>

data/lib/flexi_admin/railtie.rb

@@ -0,0 +1,78 @@
+require "rails"
+
+# Don't need this for now
+# require "flexi_admin/engine"
+
+module FlexiAdmin
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load "tasks/flexi_admin.rake"
+    end
+
+    initializer "flexi_admin.asset_paths" do |_app|
+      # This enables
+      setup_node_path
+      setup_sass_path
+    end
+
+    initializer "flexi_admin.configure" do |app|
+      # Add any additional configuration here
+    end
+
+    initializer "flexi_admin.assets" do |app|
+      # Add asset paths to host application
+      app.config.assets.paths << absolute_gem_path("lib/flexi_admin/javascript")
+      app.config.assets.paths << absolute_gem_path("app/assets/stylesheets")
+    end
+
+    # # Configure importmap if using it
+    # initializer "flexi_admin.importmap", before: "importmap" do |app|
+    #   if app.config.respond_to?(:importmap)
+    #     app.config.importmap.paths << absolute_gem_path("app/flexi_admin/javascript")
+    #   end
+    # end
+
+    # initializer "flexi_admin.helpers" do
+    #   ActiveSupport.on_load(:action_controller) do
+    #     include FlexiAdmin::Helpers::ApplicationHelper
+    #   end
+    # end
+
+    initializer "flexi_admin.add_view_paths" do |_app|
+      # Assuming your gem has a `app/views` directory
+      custom_views_path = File.expand_path("../flexi_admin/views", __dir__)
+
+      # Add the path to the application's view paths
+      ActiveSupport.on_load(:action_controller) do
+        ActionController::Base.prepend_view_path(custom_views_path)
+      end
+    end
+
+    def absolute_gem_path(path)
+      [Gem::Specification.find_by_name("flexi_admin").gem_dir, path].join("/")
+    end
+
+    def setup_node_path
+      node_paths ||= []
+      node_paths << "./node_modules"
+      node_paths << absolute_gem_path("lib/flexi_admin/javascript")
+      ENV["NODE_PATH"] = node_paths.join(":")
+
+      # Set the NODE_PATH for the current bash session
+      # https://nodejs.org/api/modules.html#loading-from-the-global-folders
+      system("export NODE_PATH=#{ENV["NODE_PATH"]}")
+    end
+
+    def setup_sass_path
+      sass_paths ||= []
+      sass_paths << "./node_modules"
+      sass_paths << absolute_gem_path("app/assets/stylesheets")
+      sass_paths << absolute_gem_path("app/assets/stylesheets/components")
+      ENV["SASS_PATH"] = sass_paths.join(":")
+
+      # Set the SASS_PATH for the current bash session
+      # https://sass-lang.com/documentation/cli/ruby-sass/#load-path
+      system("export SASS_PATH=#{ENV["SASS_PATH"]}")
+    end
+  end
+end

data/lib/flexi_admin/routes.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module FlexiAdmin
+  module Routes
+    def self.extended(router)
+      router.instance_eval do
+        concern :flexi_admin_resourceful do
+          post :bulk_action, on: :collection
+          get :datalist, on: :collection
+          get :autocomplete, on: :collection
+        end
+      end
+    end
+  end
+end