markdownr 0.7.1 → 0.8.0

data/lib/markdown_server/csv_browser/table_reader.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+require "csv"
+
+module MarkdownServer
+  module CsvBrowser
+    # Reads CSV files and applies view filtering (column subsets).
+    # Coerces values to match schema types (integer, number, string).
+    class TableReader
+      def initialize(table)
+        @table = table
+      end
+
+      # Returns { columns: [{key, title, type}], rows: [[idx, val, ...]] }
+      # for the given view. Each row's first element is its original file index.
+      def read(view_key = nil)
+        view = find_view(view_key)
+        all_data = read_csv
+        apply_view(all_data, view)
+      end
+
+      # Validates changed cells against the table schema.
+      # changes is a hash of { col_key => new_string_value }.
+      # Returns { valid: true } or { valid: false, errors: [...] }.
+      def validate_cells(row_index, changes)
+        rows = read_csv_raw
+        if row_index < 0 || row_index >= rows.length
+          return { valid: false, errors: [{ "message" => "Row not found", "fields" => [] }] }
+        end
+
+        row = rows[row_index]
+        merged = row.to_h.merge(changes)
+
+        # Coerce to schema types for validation (skip blank optional fields
+        # so json_schemer doesn't reject nil as non-string)
+        coerced = {}
+        @table.columns.each do |col|
+          val = coerce_for_validation(merged[col.key], col.type)
+          coerced[col.key] = val unless val.nil?
+        end
+
+        errors = @table.schema.validate(coerced).map { |e| format_error(e) }
+
+        errors.empty? ? { valid: true } : { valid: false, errors: errors }
+      end
+
+      # Validates all rows against the table schema.
+      # Returns { row_index => [error_strings, ...], ... } for failing rows only.
+      def validate_all
+        rows = read_csv_raw
+        errors_by_row = {}
+
+        rows.each_with_index do |row, idx|
+          coerced = {}
+          @table.columns.each do |col|
+            val = coerce_for_validation(row[col.key], col.type)
+            coerced[col.key] = val unless val.nil?
+          end
+
+          errors = @table.schema.validate(coerced).map { |e| format_error(e) }
+
+          errors_by_row[idx] = errors unless errors.empty?
+        end
+
+        errors_by_row
+      end
+
+      # Deletes a row from the CSV file.
+      # Returns { deleted: true } or { deleted: false, error: "..." }.
+      def delete_row(row_index)
+        rows = read_csv_raw
+        return { deleted: false, error: "Row not found" } if row_index < 0 || row_index >= rows.length
+
+        rows.delete_at(row_index)
+        write_csv(rows)
+        { deleted: true }
+      end
+
+      # Inserts a new row. `values` is { col_key => string_value }.
+      # When `at` is nil the row is appended; otherwise it's inserted at that index.
+      # Returns { valid: true, new_index: i } or { valid: false, errors: [...] }.
+      def insert_row(values, at: nil)
+        string_values = values.each_with_object({}) { |(k, v), h| h[k.to_s] = v.nil? ? nil : v.to_s }
+
+        coerced = {}
+        @table.columns.each do |col|
+          val = coerce_for_validation(string_values[col.key], col.type)
+          coerced[col.key] = val unless val.nil?
+        end
+        errors = @table.schema.validate(coerced).map { |e| format_error(e) }
+        return { valid: false, errors: errors } unless errors.empty?
+
+        rows = read_csv_raw
+        headers = @table.columns.map(&:key)
+        new_row = CSV::Row.new(headers, headers.map { |h| string_values[h] })
+
+        if at.nil? || at >= rows.length
+          rows << new_row
+          new_index = rows.length - 1
+        else
+          at = 0 if at < 0
+          rows.insert(at, new_row)
+          new_index = at
+        end
+
+        write_csv(rows)
+        { valid: true, new_index: new_index }
+      end
+
+      # Duplicates a row by inserting an identical copy immediately after it.
+      # Returns { duplicated: true, new_index: row_index + 1 } or
+      # { duplicated: false, error: "..." }.
+      def duplicate_row(row_index)
+        rows = read_csv_raw
+        return { duplicated: false, error: "Row not found" } if row_index < 0 || row_index >= rows.length
+
+        source = rows[row_index]
+        copy = CSV::Row.new(source.headers, source.fields)
+        rows.insert(row_index + 1, copy)
+        write_csv(rows)
+        { duplicated: true, new_index: row_index + 1 }
+      end
+
+      # Updates a row in the CSV file. changes is { col_key => new_string_value }.
+      # Returns { valid: true } or { valid: false, errors: [...] }.
+      def update_row(row_index, changes)
+        result = validate_cells(row_index, changes)
+        return result unless result[:valid]
+
+        rows = read_csv_raw
+        row = rows[row_index]
+        changes.each { |k, v| row[k] = v }
+
+        write_csv(rows)
+        { valid: true }
+      end
+
+      private
+
+      def find_view(view_key)
+        if view_key
+          @table.views.find { |v| v.key == view_key } || @table.views.first
+        else
+          @table.views.first
+        end
+      end
+
+      # Returns array of arrays: [[coerced_val, ...], ...] in column order
+      def read_csv
+        return [] unless File.exist?(@table.csv_path)
+
+        rows = []
+        CSV.foreach(@table.csv_path, headers: true) do |row|
+          rows << @table.columns.map do |col|
+            coerce(row[col.key], col.type)
+          end
+        end
+        rows
+      end
+
+      # Returns array of CSV::Row objects (preserves original string values)
+      def read_csv_raw
+        return [] unless File.exist?(@table.csv_path)
+
+        rows = []
+        CSV.foreach(@table.csv_path, headers: true) do |row|
+          rows << row
+        end
+        rows
+      end
+
+      def write_csv(csv_rows)
+        headers = @table.columns.map(&:key)
+        CSV.open(@table.csv_path, "w") do |csv|
+          csv << headers
+          csv_rows.each do |row|
+            csv << headers.map { |h| row[h] }
+          end
+        end
+      end
+
+      def apply_view(rows, view)
+        visible_columns = if view&.columns
+          @table.columns.select { |c| view.columns.include?(c.key) }
+        else
+          @table.columns
+        end
+
+        col_indices = visible_columns.map { |vc| @table.columns.index(vc) }
+
+        # Prepend original row index to each row
+        filtered_rows = rows.each_with_index.map do |row, idx|
+          [idx] + col_indices.map { |i| row[i] }
+        end
+
+        {
+          columns: visible_columns.map { |c|
+            col = { key: c.key, title: c.title, type: c.type }
+            col[:references] = c.references if c.references
+            col[:constraints] = c.constraints if c.constraints && !c.constraints.empty?
+            col
+          },
+          rows: filtered_rows
+        }
+      end
+
+      # Formats a json_schemer error into a hash with message and affected fields.
+      # Returns { "message" => String, "fields" => [String] }
+      def format_error(error)
+        field = error["data_pointer"].sub(%r{^/}, "")
+        col = @table.columns.find { |c| c.key == field } unless field.empty?
+        label = col ? col.title : field
+        fields = field.empty? ? [] : [field]
+
+        case error["type"]
+        when "required"
+          keys = error.dig("details", "missing_keys") || []
+          titles = keys.map { |k| (@table.columns.find { |c| c.key == k }&.title) || k }
+          { "message" => "missing required: #{titles.join(", ")}", "fields" => keys }
+        when "enum"
+          { "message" => "#{label}: not a valid option", "fields" => fields }
+        when "pattern"
+          { "message" => "#{label}: does not match expected format", "fields" => fields }
+        when "integer", "number"
+          { "message" => "#{label}: must be a #{error["type"]}", "fields" => fields }
+        else
+          msg = col ? "#{label}: #{error["type"]}" : error["error"]
+          { "message" => msg, "fields" => fields }
+        end
+      end
+
+      def coerce(value, type)
+        return nil if value.nil? || value.strip.empty?
+
+        case type
+        when "integer"
+          Integer(value) rescue value
+        when "number"
+          Float(value) rescue value
+        else
+          value
+        end
+      end
+
+      def coerce_for_validation(value, type)
+        return nil if value.nil? || value.to_s.strip.empty?
+
+        case type
+        when "integer"
+          Integer(value) rescue value
+        when "number"
+          Float(value) rescue value
+        else
+          value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/markdown_server/helpers/admin_helpers.rb

@@ -1,3 +1,5 @@
+require "ipaddr"
+
 module MarkdownServer
   module Helpers
     module AdminHelpers
@@ -25,7 +27,7 @@ module MarkdownServer
         adm = setup_config["admin"]
         return false unless adm.is_a?(Hash)
 
-        return true if adm["ip"].to_s.strip == client_ip
+        return true if ip_allowed?(adm["ip"], client_ip)
 
         if adm["user"] && adm["pw"]
           auth = request.env["HTTP_AUTHORIZATION"].to_s
@@ -37,6 +39,18 @@ module MarkdownServer
 
         false
       end
+
+      private
+
+      def ip_allowed?(allowed, ip)
+        return false unless allowed && ip
+
+        entries = allowed.is_a?(Array) ? allowed : [allowed]
+        client = IPAddr.new(ip.to_s.strip)
+        entries.any? { |entry| IPAddr.new(entry.to_s.strip).include?(client) }
+      rescue IPAddr::InvalidAddressError
+        false
+      end
     end
   end
 end

data/lib/markdown_server/plugin.rb

@@ -33,6 +33,10 @@ module MarkdownServer
 
     # Hook: post-process rendered markdown HTML (runs after render_markdown)
     def post_render(html, meta, app) html end
+
+    # Hook: claim a file for custom popup rendering in /browser
+    # Return { type:, title:, ... } hash or nil to pass
+    def browser_render(relative_path, real_path, app) nil end
   end
 
   class PluginRegistry
@@ -53,6 +57,13 @@ module MarkdownServer
         end
 
         config = resolve_config(root_dir, cli_overrides)
+        known_names = registered.map(&:plugin_name)
+        config.each do |name, cfg|
+          next unless cfg.is_a?(Hash) && cfg["enabled"]
+          unless known_names.include?(name)
+            $stderr.puts "\n\e[1;33mWarning: unknown plugin '#{name}' (available: #{known_names.join(", ")})\e[0m\n\n"
+          end
+        end
         registered.filter_map do |klass|
           plugin_config = config.fetch(klass.plugin_name, {})
           enabled = plugin_config.fetch("enabled", klass.enabled_by_default?)

data/lib/markdown_server/version.rb

@@ -1,3 +1,3 @@
 module MarkdownServer
-  VERSION = "0.7.1"
+  VERSION = "0.8.0"
 end