lcp 0.1.0

data/lib/lcp_ruby/data_source/rest_json.rb

@@ -0,0 +1,247 @@
+require "net/http"
+require "json"
+require "uri"
+
+module LcpRuby
+  module DataSource
+    # REST/JSON data source adapter. Fetches records from an external REST API.
+    class RestJson < Base
+      attr_reader :config, :model_definition
+
+      def initialize(config, model_definition)
+        @config = config
+        @model_definition = model_definition
+        @field_mapping = config["field_mapping"] || {}
+        @reverse_mapping = @field_mapping.invert
+        @id_field = config["id_field"] || "id"
+        @timeout = config["timeout"] || 30
+      end
+
+      def find(id)
+        endpoint = record_endpoint(id)
+        response = http_get(endpoint)
+        data = navigate_response(response, config.dig("endpoints", "show", "response_path"))
+        hydrate(data)
+      rescue ConnectionError
+        raise
+      rescue => e
+        raise RecordNotFound, "Record #{id} not found: #{e.message}"
+      end
+
+      def find_many(ids)
+        batch_endpoint = config.dig("endpoints", "batch")
+        if batch_endpoint
+          url = build_url(batch_endpoint["path"], ids: ids.join(","))
+          response = http_get(url)
+          items = navigate_response(response, batch_endpoint["response_path"])
+          Array(items).map { |item| hydrate(item) }
+        else
+          super
+        end
+      end
+
+      def search(params = {}, sort: nil, page: 1, per: 25)
+        endpoint_config = config.dig("endpoints", "search") || config.dig("endpoints", "index") || {}
+        method = (endpoint_config["method"] || "GET").upcase
+
+        query_params = build_search_params(params, sort: sort, page: page, per: per)
+
+        if method == "POST"
+          url = build_url(endpoint_config["path"] || collection_path)
+          response = http_post(url, query_params)
+        else
+          url = build_url(collection_path, **query_params)
+          response = http_get(url)
+        end
+
+        items = navigate_response(response, endpoint_config["response_path"] || config["response_path"])
+        total = extract_total_count(response, endpoint_config, items)
+        records = Array(items).map { |item| hydrate(item) }
+
+        SearchResult.new(records: records, total_count: total, current_page: page, per_page: per)
+      end
+
+      def supported_operators
+        config["supported_operators"] || super
+      end
+
+      private
+
+      def collection_path
+        config["resource"] || model_definition.name.pluralize
+      end
+
+      def record_endpoint(id)
+        show_config = config.dig("endpoints", "show") || {}
+        path = show_config["path"] || "#{collection_path}/#{id}"
+        path = path.gsub(":id", id.to_s)
+        build_url(path)
+      end
+
+      def build_url(path, **query_params)
+        base = config["base_url"].to_s.chomp("/")
+        full_path = path.start_with?("/") ? path : "/#{path}"
+        uri = URI("#{base}#{full_path}")
+
+        flat_params = query_params.reject { |_, v| v.nil? }
+        uri.query = URI.encode_www_form(flat_params) if flat_params.any?
+        uri.to_s
+      end
+
+      def build_search_params(filters, sort: nil, page: 1, per: 25)
+        params = {}
+
+        # Pagination
+        pagination_config = config["pagination"] || {}
+        style = pagination_config["style"] || "offset_limit"
+
+        case style
+        when "offset_limit"
+          offset_param = pagination_config["offset_param"] || "offset"
+          limit_param = pagination_config["limit_param"] || "limit"
+          params[offset_param] = (page - 1) * per
+          params[limit_param] = per
+        when "page_number"
+          page_param = pagination_config["page_param"] || "page"
+          size_param = pagination_config["size_param"] || "per_page"
+          params[page_param] = page
+          params[size_param] = per
+        when "cursor"
+          limit_param = pagination_config["limit_param"] || "limit"
+          params[limit_param] = per
+        end
+
+        # Sort
+        if sort
+          sort_param = pagination_config["sort_param"] || "sort"
+          direction = sort[:direction] || "asc"
+          field = map_field_name_to_remote(sort[:field])
+          params[sort_param] = direction == "desc" ? "-#{field}" : field
+        end
+
+        # Filters
+        filters.each do |filter|
+          remote_field = map_field_name_to_remote(filter[:field])
+          params[remote_field] = filter[:value]
+        end if filters.is_a?(Array)
+
+        params
+      end
+
+      def extract_total_count(response, endpoint_config, items)
+        total_path = endpoint_config["total_count_path"] || config["total_count_path"]
+        if total_path
+          navigate_response(response, total_path).to_i
+        else
+          Array(items).size
+        end
+      end
+
+      def navigate_response(data, path)
+        return data unless path
+
+        path.to_s.split(".").reduce(data) do |obj, key|
+          if obj.is_a?(Hash)
+            obj[key] || obj[key.to_sym]
+          elsif obj.is_a?(Array) && key.match?(/\A\d+\z/)
+            obj[key.to_i]
+          else
+            obj
+          end
+        end
+      end
+
+      def hydrate(data)
+        return nil unless data.is_a?(Hash)
+
+        model_class = LcpRuby.registry.model_for(model_definition.name)
+        record = model_class.new
+
+        # Map remote fields to local fields
+        data.each do |remote_key, value|
+          local_key = @reverse_mapping[remote_key.to_s] || remote_key.to_s
+
+          # Map remote ID field to :id
+          if remote_key.to_s == @id_field && @id_field != "id"
+            record.id = value.to_s
+            next
+          end
+
+          if record.respond_to?("#{local_key}=")
+            record.send("#{local_key}=", value)
+          end
+        end
+
+        # Ensure ID is set
+        record.id = data[@id_field]&.to_s || data["id"]&.to_s if record.id.blank?
+
+        record.instance_variable_set(:@persisted, true)
+        record
+      end
+
+      def map_field_name_to_remote(field_name)
+        @field_mapping[field_name.to_s] || field_name.to_s
+      end
+
+      # HTTP methods
+
+      def http_get(url)
+        uri = URI(url)
+        request = Net::HTTP::Get.new(uri)
+        apply_auth(request)
+        execute_request(uri, request)
+      end
+
+      def http_post(url, body)
+        uri = URI(url)
+        request = Net::HTTP::Post.new(uri)
+        request.content_type = "application/json"
+        request.body = body.to_json
+        apply_auth(request)
+        execute_request(uri, request)
+      end
+
+      def execute_request(uri, request)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = @timeout
+        http.read_timeout = @timeout
+
+        response = http.request(request)
+
+        unless response.is_a?(Net::HTTPSuccess)
+          if response.code == "404"
+            raise RecordNotFound, "HTTP 404: #{uri}"
+          else
+            raise ConnectionError, "HTTP #{response.code}: #{uri}"
+          end
+        end
+
+        JSON.parse(response.body)
+      rescue Timeout::Error, Errno::ECONNREFUSED, Errno::ECONNRESET, SocketError => e
+        raise ConnectionError, "Connection failed: #{e.message} (#{uri})"
+      rescue JSON::ParserError => e
+        raise ConnectionError, "Invalid JSON response: #{e.message} (#{uri})"
+      end
+
+      def apply_auth(request)
+        auth_config = config["auth"]
+        return unless auth_config
+
+        case auth_config["type"]
+        when "bearer"
+          token = ENV.fetch(auth_config["token_env"], nil)
+          request["Authorization"] = "Bearer #{token}" if token
+        when "basic"
+          username = ENV.fetch(auth_config["username_env"], nil)
+          password = ENV.fetch(auth_config["password_env"], nil)
+          request.basic_auth(username, password) if username
+        when "header"
+          header_name = auth_config["header_name"] || "X-API-Key"
+          value = ENV.fetch(auth_config["value_env"], nil)
+          request[header_name] = value if value
+        end
+      end
+    end
+  end
+end

data/lib/lcp_ruby/data_source/setup.rb

@@ -0,0 +1,57 @@
+module LcpRuby
+  module DataSource
+    # Boot-time setup for API-backed data sources.
+    # Called from Engine.load_metadata! after model registration.
+    module Setup
+      def self.apply!(loader)
+        any_api = loader.model_definitions.values.any?(&:api_model?)
+        return unless any_api
+
+        loader.model_definitions.each_value do |model_def|
+          next unless model_def.api_model?
+
+          model_class = LcpRuby.registry.model_for(model_def.name)
+          next unless model_class
+
+          adapter = build_adapter(model_def)
+          model_class.lcp_data_source = adapter
+          Registry.register(model_def.name, adapter)
+        end
+
+        Registry.mark_available!
+
+        # Apply cross-source associations after all data sources are attached
+        ModelFactory::ApiAssociationApplicator.new(loader).apply!
+      end
+
+      def self.build_adapter(model_def)
+        config = model_def.data_source_config
+
+        # Build the core adapter
+        adapter = case model_def.data_source_type
+        when :rest_json
+          RestJson.new(config, model_def)
+        when :host
+          Host.new(config, model_def)
+        else
+          raise MetadataError, "Unknown data source type '#{config['type']}' for model '#{model_def.name}'"
+        end
+
+        # Wrap with caching if configured
+        cache_config = config["cache"]
+        if cache_config
+          adapter = CachedWrapper.new(
+            adapter,
+            model_name: model_def.name,
+            ttl: cache_config["ttl"] || 300,
+            list_ttl: cache_config["list_ttl"] || 60,
+            stale_on_error: cache_config.fetch("stale_on_error", true)
+          )
+        end
+
+        # Wrap with resilience (always outermost)
+        ResilientWrapper.new(adapter, model_name: model_def.name)
+      end
+    end
+  end
+end

data/lib/lcp_ruby/dev_toolbar.rb

@@ -0,0 +1,8 @@
+module LcpRuby
+  module DevToolbar
+    def self.enabled?
+      LcpRuby.configuration.dev_toolbar == true &&
+        defined?(Rails) && Rails.env.development?
+    end
+  end
+end

data/lib/lcp_ruby/display/base_renderer.rb

@@ -0,0 +1,21 @@
+module LcpRuby
+  module Display
+    class BaseRenderer
+      # @param value [Object] resolved field value
+      # @param options [Hash] renderer options from presenter config
+      # @param record [ActiveRecord::Base, nil] full record (for context-aware renderers)
+      # @param view_context [ActionView::Base, nil] for HTML helpers
+      # @return [String] rendered output (HTML-safe)
+      def render(value, options = {}, record: nil, view_context: nil)
+        raise NotImplementedError
+      end
+
+      # Whether this renderer emits its own <a> anchor in its output.
+      # Used by ConfigurationValidator (V11) to reject combining a link-emitting
+      # renderer with link:/link_through:/link_to: :show — nested <a> is invalid.
+      def link_producing?
+        false
+      end
+    end
+  end
+end

data/lib/lcp_ruby/display/count_badge.rb

@@ -0,0 +1,11 @@
+module LcpRuby
+  module Display
+    class CountBadge < BaseRenderer
+      def render(value, options = {}, record: nil, view_context: nil)
+        return nil unless value.is_a?(Integer) && value > 0
+
+        view_context.content_tag(:span, value.to_s, class: "lcp-menu-badge")
+      end
+    end
+  end
+end

data/lib/lcp_ruby/display/icon_badge.rb

@@ -0,0 +1,17 @@
+module LcpRuby
+  module Display
+    class IconBadge < BaseRenderer
+      def render(value, options = {}, record: nil, view_context: nil)
+        icon = value.is_a?(Hash) ? value["icon"] : value.to_s
+        color = value.is_a?(Hash) ? value["color"] : options["color"]
+        return nil if icon.blank?
+
+        opts = { class: "lcp-menu-badge lcp-menu-badge-icon" }
+        opts[:style] = "color:#{color}" if color
+        view_context.content_tag(:span, opts) do
+          view_context.content_tag(:i, "", class: "lcp-icon lcp-icon-#{icon}")
+        end
+      end
+    end
+  end
+end

data/lib/lcp_ruby/display/renderer_registry.rb

@@ -0,0 +1,138 @@
+module LcpRuby
+  module Display
+    class RendererRegistry
+      BUILT_IN_RENDERERS = {
+        "heading"            => "LcpRuby::Display::Renderers::Heading",
+        "badge"              => "LcpRuby::Display::Renderers::Badge",
+        "collection"         => "LcpRuby::Display::Renderers::Collection",
+        "truncate"           => "LcpRuby::Display::Renderers::Truncate",
+        "boolean_icon"       => "LcpRuby::Display::Renderers::BooleanIcon",
+        "progress_bar"       => "LcpRuby::Display::Renderers::ProgressBar",
+        "image"              => "LcpRuby::Display::Renderers::Image",
+        "avatar"             => "LcpRuby::Display::Renderers::Avatar",
+        "currency"           => "LcpRuby::Display::Renderers::Currency",
+        "percentage"         => "LcpRuby::Display::Renderers::Percentage",
+        "number"             => "LcpRuby::Display::Renderers::Number",
+        "date"               => "LcpRuby::Display::Renderers::Date",
+        "datetime"           => "LcpRuby::Display::Renderers::Datetime",
+        "relative_date"      => "LcpRuby::Display::Renderers::RelativeDate",
+        "email_link"         => "LcpRuby::Display::Renderers::EmailLink",
+        "phone_link"         => "LcpRuby::Display::Renderers::PhoneLink",
+        "url_link"           => "LcpRuby::Display::Renderers::UrlLink",
+        "external_link"      => "LcpRuby::Display::Renderers::UrlLink",
+        "boolean"            => "LcpRuby::Display::Renderers::BooleanIcon",
+        "email"              => "LcpRuby::Display::Renderers::EmailLink",
+        "phone"              => "LcpRuby::Display::Renderers::PhoneLink",
+        "url"                => "LcpRuby::Display::Renderers::UrlLink",
+        "json"               => "LcpRuby::Display::Renderers::Code",
+        "text"               => "LcpRuby::Display::Renderers::Text",
+        "color_swatch"       => "LcpRuby::Display::Renderers::ColorSwatch",
+        "rating"             => "LcpRuby::Display::Renderers::Rating",
+        "code"               => "LcpRuby::Display::Renderers::Code",
+        "copy_code"          => "LcpRuby::Display::Renderers::CopyCode",
+        "file_size"          => "LcpRuby::Display::Renderers::FileSize",
+        "rich_text"          => "LcpRuby::Display::Renderers::RichText",
+        "attachment_preview" => "LcpRuby::Display::Renderers::AttachmentPreview",
+        "attachment_list"    => "LcpRuby::Display::Renderers::AttachmentList",
+        "attachment_link"    => "LcpRuby::Display::Renderers::AttachmentLink",
+        "link"               => "LcpRuby::Display::Renderers::Link",
+        "markdown"           => "LcpRuby::Display::Renderers::Markdown",
+        "internal_link"      => "LcpRuby::Display::Renderers::InternalLink",
+        "workflow_badge"     => "LcpRuby::Display::Renderers::WorkflowBadge",
+        "workflow_timeline"  => "LcpRuby::Display::Renderers::WorkflowTimeline",
+        "count_badge"        => "LcpRuby::Display::CountBadge",
+        "text_badge"         => "LcpRuby::Display::TextBadge",
+        "icon_badge"         => "LcpRuby::Display::IconBadge",
+        "record_link"        => "LcpRuby::Display::Renderers::RecordLink",
+        "link_list"          => "LcpRuby::Display::Renderers::LinkList"
+      }.freeze
+
+      class << self
+        # Phase 4 of type-system defaults — Decision 4 revised. Resolves a
+        # renderer key to a renderer instance via two layers:
+        #
+        # 1. Registered renderers (explicit hash lookup) — covers built-in
+        #    renderer keys ("badge", "boolean_icon", "truncate", …) AND the
+        #    pre-existing alias entries (`"boolean" => BooleanIcon`,
+        #    `"email" => EmailLink`, etc., from BUILT_IN_RENDERERS). This
+        #    layer wins.
+        # 2. Type-name fallback (new in Phase 4) — when the key isn't in
+        #    the registered table, consult Types::TypeRegistry.renderer_for
+        #    to resolve `:enum → "badge"`, `:rating (custom type with
+        #    base_type: :integer) → its declared renderer`, etc. Re-looks
+        #    up the resolved key in the registered table to return the
+        #    actual renderer instance. So `renderer: :enum` in a hand-
+        #    written presenter resolves to a BadgeRenderer at runtime
+        #    without anyone having registered "enum" explicitly.
+        #
+        # Existing alias precedence is preserved — `text → passthrough`
+        # (alias) wins over `text → truncate` (type registry's default for
+        # the :text base type) because the alias is in the registered
+        # table. Two contexts, same string, two correct answers — explicit
+        # alias wins over type-driven default.
+        #
+        # Returns nil when neither layer resolves — preserves today's
+        # "unknown renderer" behavior so genuinely-bogus keys still hit
+        # the value-shape heuristic in the view template.
+        def renderer_for(key)
+          return unless key
+
+          registered = registry[key.to_s]
+          return registered if registered
+
+          type_renderer_key = Types::TypeRegistry.renderer_for(key.to_s)
+          registry[type_renderer_key.to_s] if type_renderer_key
+        end
+
+        def register(key, renderer_class)
+          registry[key.to_s] = renderer_class.new
+        end
+
+        def registered?(key)
+          registry.key?(key.to_s)
+        end
+
+        def keys
+          registry.keys
+        end
+
+        def register_built_ins!
+          BUILT_IN_RENDERERS.each do |key, class_name|
+            register(key, class_name.constantize)
+          rescue NameError => e
+            LcpRuby.record_error(e, subsystem: "renderer", renderer: class_name)
+          end
+        end
+
+        def discover!(base_path)
+          renderers_path = File.join(base_path, "renderers")
+          return unless File.directory?(renderers_path)
+
+          Dir[File.join(renderers_path, "**", "*.rb")].sort.each do |file|
+            require file
+
+            relative = file.sub("#{renderers_path}/", "").sub(/\.rb$/, "")
+            class_name = "LcpRuby::HostRenderers::#{relative.split('/').map(&:camelize).join('::')}"
+
+            begin
+              renderer_class = class_name.constantize
+              register(relative, renderer_class)
+            rescue NameError => e
+              LcpRuby.record_error(e, subsystem: "renderer", renderer: class_name)
+            end
+          end
+        end
+
+        def clear!
+          @registry = {}
+        end
+
+        private
+
+        def registry
+          @registry ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/lcp_ruby/display/renderers/attachment_link.rb

@@ -0,0 +1,26 @@
+module LcpRuby
+  module Display
+    module Renderers
+      class AttachmentLink < BaseRenderer
+        include Concerns::AttachmentHelpers
+
+        def render(value, options = {}, record: nil, view_context: nil)
+          attachment = resolve_attachment(value, record)
+          return view_context.content_tag(:span, I18n.t("lcp_ruby.file_upload.no_file", default: "No file"), class: "lcp-no-attachment") unless attachment_present?(attachment)
+
+          att = attachment.respond_to?(:blob) ? attachment : attachment.first
+          return view_context.content_tag(:span, I18n.t("lcp_ruby.file_upload.no_file", default: "No file"), class: "lcp-no-attachment") unless att&.respond_to?(:blob)
+
+          view_context.link_to(att.blob.filename.to_s, attachment_url(att, disposition: :attachment), class: "lcp-attachment-download")
+        rescue ActiveStorage::Error, ActionController::UrlGenerationError, NoMethodError => e
+          LcpRuby.record_error(e, subsystem: "renderer")
+          view_context.content_tag(:span, "Download", class: "lcp-attachment-download")
+        end
+
+        def link_producing?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/lcp_ruby/display/renderers/attachment_list.rb

@@ -0,0 +1,32 @@
+module LcpRuby
+  module Display
+    module Renderers
+      class AttachmentList < BaseRenderer
+        include Concerns::AttachmentHelpers
+
+        def render(value, options = {}, record: nil, view_context: nil)
+          attachment = resolve_attachment(value, record)
+          return view_context.content_tag(:span, I18n.t("lcp_ruby.file_upload.no_file", default: "No file"), class: "lcp-no-attachment") unless attachment_present?(attachment)
+
+          items = attachment.respond_to?(:each) ? attachment.to_a : [ attachment ]
+          view_context.content_tag(:ul, class: "lcp-attachment-list") do
+            view_context.safe_join(items.select { |att| att.respond_to?(:blob) }.map { |att|
+              view_context.content_tag(:li) do
+                view_context.link_to(att.blob.filename.to_s, attachment_url(att), target: "_blank", rel: "noopener") +
+                  " " +
+                  view_context.content_tag(:span, "(#{view_context.number_to_human_size(att.blob.byte_size)})", class: "lcp-attachment-size")
+              end
+            })
+          end
+        rescue ActiveStorage::Error, ActionController::UrlGenerationError, NoMethodError => e
+          LcpRuby.record_error(e, subsystem: "renderer")
+          view_context.content_tag(:span, "Attachments", class: "lcp-attachment-list")
+        end
+
+        def link_producing?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/lcp_ruby/display/renderers/attachment_preview.rb

@@ -0,0 +1,26 @@
+module LcpRuby
+  module Display
+    module Renderers
+      class AttachmentPreview < BaseRenderer
+        include Concerns::AttachmentHelpers
+
+        def render(value, options = {}, record: nil, view_context: nil)
+          attachment = resolve_attachment(value, record)
+          return view_context.content_tag(:span, I18n.t("lcp_ruby.file_upload.no_file", default: "No file"), class: "lcp-no-attachment") unless attachment_present?(attachment)
+
+          if single_attachment?(attachment)
+            render_single_preview(attachment, options, view_context: view_context)
+          else
+            view_context.content_tag(:div, class: "lcp-attachment-preview") do
+              view_context.safe_join(attachment.map { |att| render_single_preview(att, options, view_context: view_context) })
+            end
+          end
+        end
+
+        def link_producing?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/lcp_ruby/display/renderers/avatar.rb

@@ -0,0 +1,14 @@
+module LcpRuby
+  module Display
+    module Renderers
+      class Avatar < BaseRenderer
+        def render(value, options = {}, record: nil, view_context: nil)
+          return nil if value.blank?
+
+          avatar_size = options["size"] || "32"
+          view_context.tag.img(src: value, class: "lcp-avatar", style: "width: #{avatar_size}px; height: #{avatar_size}px;", alt: "")
+        end
+      end
+    end
+  end
+end

data/lib/lcp_ruby/display/renderers/badge.rb

@@ -0,0 +1,43 @@
+module LcpRuby
+  module Display
+    module Renderers
+      class Badge < BaseRenderer
+        NAMED_COLORS = {
+          "green" => "#28a745", "red" => "#dc3545", "blue" => "#007bff",
+          "yellow" => "#ffc107", "orange" => "#fd7e14", "purple" => "#6f42c1",
+          "gray" => "#6c757d", "teal" => "#20c997", "cyan" => "#17a2b8",
+          "pink" => "#e83e8c"
+        }.freeze
+
+        def render(value, options = {}, record: nil, view_context: nil)
+          color_map = options["color_map"] || {}
+          color = color_map[value.to_s]
+          style = badge_style(color)
+          display_text = options["label"] || value
+          view_context.content_tag(:span, display_text, class: "badge", style: style)
+        end
+
+        private
+
+        SAFE_COLOR_PATTERN = /\A#[0-9a-fA-F]{3,8}\z/
+
+        def badge_style(color)
+          return nil unless color.present?
+
+          bg = NAMED_COLORS[color.to_s] || sanitize_color(color.to_s)
+          return nil unless bg
+
+          text_color = %w[yellow].include?(color.to_s) ? "#333" : "#fff"
+          "background: #{bg}; color: #{text_color};"
+        end
+
+        def sanitize_color(value)
+          return value if SAFE_COLOR_PATTERN.match?(value)
+
+          Rails.logger.warn("[LcpRuby] Badge: rejected invalid color value: #{value.inspect}")
+          nil
+        end
+      end
+    end
+  end
+end