stream_weaver 0.3.0

data/lib/stream_weaver/resource/default_views.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'cgi'
+
+module StreamWeaver
+  module Resource
+    module DefaultViews
+      include StateKeys
+
+      def self.index(defn, app, items)
+        items ||= []
+        app.instance_exec do
+          header1 defn.plural.capitalize
+
+          button("New #{defn.singular.capitalize}", style: :primary) do |s|
+            s[ACTION]   = :new
+            s[RESOURCE] = defn.name
+          end
+
+          unless items.empty?
+            table(items, markdown: true) do
+              defn.fields.each do |f|
+                column f.name, header: f.name.to_s.tr('_', ' ').capitalize do |item|
+                  CGI.escape_html(item[f.name].to_s)
+                end
+              end
+              column :_sw_actions, header: '' do |item|
+                eid = CGI.escape(item[:id].to_s)
+                s   = defn.singular
+                "[View](/#{s}/#{eid}) [Edit](/#{s}/#{eid}/edit) [Delete](/#{s}/#{eid}/delete)"
+              end
+            end
+          end
+        end
+      end
+
+      def self.show(defn, app, item)
+        return if item.nil?
+
+        app.instance_exec do
+          card do
+            first_field = defn.fields.first
+            first_value = first_field ? item[first_field.name] : item[:id]
+            header3 (first_value || item[:id]).to_s
+
+            defn.fields.each do |field|
+              label = field.name.to_s.tr('_', ' ').capitalize
+              text "#{label}: #{item[field.name]}"
+            end
+
+            hstack do
+              button("Edit") do |s|
+                s[ACTION]   = :edit
+                s[RESOURCE] = defn.name
+                s[ID]       = item[:id]
+              end
+              button("Delete", style: :danger) do |s|
+                s[ACTION]   = :destroy_confirm
+                s[RESOURCE] = defn.name
+                # ID already set
+              end
+            end
+          end
+        end
+      end
+
+      def self.new(defn, app, _data)
+        app.instance_exec do
+          header1 "New #{defn.singular.capitalize}"
+          form_for defn.name
+        end
+      end
+
+      def self.edit(defn, app, item)
+        return if item.nil?
+
+        app.instance_exec do
+          first_field = defn.fields.first
+          title_value = first_field ? item[first_field.name] : item[:id]
+          header1 "Edit #{title_value || item[:id]}"
+          form_for defn.name, record: item
+        end
+      end
+
+      def self.destroy_confirm(defn, app, item)
+        return if item.nil?
+
+        app.instance_exec do
+          first_field = defn.fields.first
+          title_value = first_field ? item[first_field.name] : item[:id]
+
+          alert(variant: :warning) do
+            text "Delete \"#{title_value}\"? This cannot be undone."
+            hstack do
+              button("Confirm Delete", style: :danger) do |s|
+                defn.store.destroy(item[:id])
+                s[ACTION]   = :index
+                s[RESOURCE] = defn.name
+                s[ID]       = nil
+              end
+              button("Cancel") do |s|
+                s[ACTION]   = :index
+                s[RESOURCE] = defn.name
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stream_weaver/resource/field_input.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module StreamWeaver
+  module Resource
+    # Shared field-type-to-widget rendering table (form-for.md §3). Extracted
+    # from DefaultViews so both DefaultViews and `form_for` render fields the
+    # same way -- one type-to-widget mapping, not two.
+    module FieldInput
+      # Proc for rendering a single form field -- called via instance_exec so
+      # DSL methods (text_field, select, etc.) resolve against the App instance.
+      RENDER = proc do |field|
+        label = field.name.to_s.tr('_', ' ').capitalize
+        case field.type
+        when :string           then text_field field.name, label: label, submit: false
+        when :text             then text_area  field.name, label: label, rows: 4, submit: false
+        when :enum             then select     field.name, field.opts[:values] || [], submit: false
+        when :boolean           then checkbox   field.name, label, submit: false
+        when :integer, :number then text_field field.name, submit: false
+        when :date             then date_field field.name, label: label, submit: false
+        else                         text_field field.name, submit: false
+        end
+      end
+    end
+  end
+end

data/lib/stream_weaver/resource/state_keys.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module StreamWeaver
+  module Resource
+    # State keys owned by the resource DSL. All use the _sw_ prefix to avoid
+    # collision with user-managed state. Centralized here so any rename is
+    # a one-line change.
+    #
+    # Include this module to use RESOURCE, ACTION, ID unqualified.
+    module StateKeys
+      RESOURCE = :_sw_resource  # active resource name (Symbol), nil on page routes
+      ACTION   = :_sw_action    # current action (:index/:show/:new/:edit/:destroy_confirm or page name sym)
+      ID       = :_sw_id        # selected record id (String), nil when not applicable
+    end
+  end
+end

data/lib/stream_weaver/resource/store.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module StreamWeaver
+  module Resource
+    module Store
+      REQUIRED_METHODS = %i[all find create update destroy].freeze
+
+      def self.validate!(store, resource_name)
+        missing = REQUIRED_METHODS.reject { |m| store.respond_to?(m) }
+        return if missing.empty?
+        raise ArgumentError,
+          "StreamWeaver resource :#{resource_name} — store #{store.inspect} " \
+          "is missing required methods: #{missing.join(', ')}. " \
+          "Store must respond to: #{REQUIRED_METHODS.join(', ')}"
+      end
+    end
+  end
+end

data/lib/stream_weaver/resource.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'cgi'
+require_relative 'resource/state_keys'
+require_relative 'resource/store'
+require_relative 'resource/field_input'
+require_relative 'resource/default_views'
+
+module StreamWeaver
+  RouteRule = Struct.new(:parser, :builder, :source, keyword_init: true)
+  Field     = Struct.new(:name, :type, :opts)
+
+  class ResourceDefinition
+    include Resource::StateKeys
+
+    attr_reader :name, :singular, :plural, :store, :fields
+
+    def initialize(name, store, plural: nil)
+      @name      = name.to_sym
+      @singular  = name.to_s
+      @plural    = plural&.to_s || "#{@singular}s"
+      @store     = store
+      @fields    = []
+      @edit_view = :modal
+      @new_view  = :modal
+      @only      = %i[index show new edit destroy destroy_confirm]
+      @overrides = {}
+
+      # Memoize member-route regexes — built once, matched on every request
+      esc = Regexp.escape(@singular)
+      @edit_re    = %r{\A/#{esc}/([^/]+)/edit\z}
+      @delete_re  = %r{\A/#{esc}/([^/]+)/delete\z}
+      @show_re    = %r{\A/#{esc}/([^/]+)\z}
+
+      Resource::Store.validate!(store, name)
+    end
+
+    # DSL methods (dual-purpose: reader when called with no args, setter with args)
+    def field(name, type, **opts); @fields << Field.new(name, type, opts); end
+    def edit_view(style = nil);    style.nil? ? @edit_view : (@edit_view = style); end
+    def new_view(style = nil);     style.nil? ? @new_view  : (@new_view  = style); end
+    def only(actions = nil);       actions.nil? ? @only : (@only = Array(actions)); end
+    def except(actions);           @only -= Array(actions);                end
+    def index(&blk); @overrides[:index] = blk; end
+    def show(&blk);  @overrides[:show]  = blk; end
+    def new(&blk);   @overrides[:new]   = blk; end
+    def edit(&blk);  @overrides[:edit]  = blk; end
+
+    def overrides; @overrides; end
+
+    # Routing
+    def parse_path(path)
+      case path
+      when "/#{@plural}"     then sw_state(:index)
+      when "/#{@plural}/new" then sw_state(:new)
+      when @edit_re          then sw_state(:edit,           CGI.unescape($1))
+      when @delete_re        then sw_state(:destroy_confirm, CGI.unescape($1))
+      when @show_re          then sw_state(:show,           CGI.unescape($1))
+      end
+    end
+
+    def build_path(st)
+      return nil unless st[RESOURCE] == @name
+      id = st[ID]
+      case st[ACTION]
+      when :index then "/#{@plural}"
+      when :new   then "/#{@plural}/new"
+      when :show            then id && "/#{@singular}/#{CGI.escape(id.to_s)}"
+      when :edit            then id && "/#{@singular}/#{CGI.escape(id.to_s)}/edit"
+      when :destroy_confirm then id && "/#{@singular}/#{CGI.escape(id.to_s)}/delete"
+      end
+    end
+
+    # Rendering — called every rebuild; dispatches to DefaultViews or override block
+    def render_if_active(app)
+      st = app.state
+      return unless st[RESOURCE] == @name && @only.include?(st[ACTION])
+      id = st[ID]
+      case st[ACTION]
+      when :index           then render_action(:index,           app, @store.all)
+      when :show            then render_action(:show,            app, @store.find(id))
+      when :new             then render_action(:new,             app, nil)
+      when :edit            then render_action(:edit,            app, @store.find(id))
+      when :destroy_confirm then render_action(:destroy_confirm, app, @store.find(id))
+      end
+    end
+
+    def render_action(action, app, data)
+      if (override = @overrides[action])
+        app.with_clean_form_context { app.instance_exec(data, &override) }
+      else
+        Resource::DefaultViews.send(action, self, app, data)
+      end
+    end
+
+    private
+
+    def sw_state(action, id = nil)
+      h = { RESOURCE => @name, ACTION => action }
+      h[ID] = id if id
+      h
+    end
+  end
+end