funicular 0.0.1 → 0.1.0

data/mrblib/model.rb

@@ -0,0 +1,146 @@
+module Funicular
+  class Model
+    attr_reader :id
+
+    class << self
+      attr_accessor :schema, :endpoints
+    end
+
+    def self.load_schema(schema_data)
+      @schema = schema_data["attributes"]
+      @endpoints = schema_data["endpoints"]
+
+      # Generate attr_accessor dynamically based on schema
+      @schema.each do |name, config|
+        attr_reader name.to_sym
+
+        unless config["readonly"]
+          define_method("#{name}=") do |value|
+            # @type self: Model
+            instance_variable_set("@#{name}", value)
+            @changed_attributes ||= {} # steep:ignore UnannotatedEmptyCollection
+            @changed_attributes[name] = value
+          end
+        end
+      end
+    end
+
+    def initialize(attributes = {})
+      @changed_attributes = {}
+      # Set attributes based on schema
+      self.class.schema.each do |name, config|
+        value = attributes[name] || attributes[name.to_sym]
+        instance_variable_set("@#{name}", value)
+      end
+    end
+
+    def self.all(params = {}, &block)
+      endpoint = @endpoints["all"]
+      return unless endpoint
+
+      HTTP.get(endpoint["path"]) do |response|
+        if response.error?
+          block.call(nil, response.error_message) if block
+        else
+          instances = response.data.map { |attrs| new(attrs) }
+          block.call(instances, nil) if block
+        end
+      end
+    end
+
+    def self.find(id = nil, endpoint_name: "find", model_class: nil, &block)
+      endpoint = @endpoints[endpoint_name]
+      return unless endpoint
+
+      path = endpoint["path"]
+      path = path.gsub(":id", id.to_s) if id
+
+      HTTP.get(path) do |response|
+        if response.error?
+          block.call(nil, response.error_message) if block
+        else
+          klass = model_class || self
+          instance = klass.new(response.data)
+          block.call(instance, nil) if block
+        end
+      end
+    end
+
+    def self.create(attrs, model_class: nil, &block)
+      endpoint = @endpoints["create"]
+      return unless endpoint
+
+      HTTP.post(endpoint["path"], attrs) do |response|
+        if response.error?
+          block.call(nil, response.error_message) if block
+        else
+          klass = model_class || self
+          instance = klass.new(response.data)
+          block.call(instance, nil) if block
+        end
+      end
+    end
+
+    def self.destroy(id = nil, &block)
+      endpoint = @endpoints["destroy"]
+      return unless endpoint
+
+      path = id ? endpoint["path"].gsub(":id", id.to_s) : endpoint["path"]
+
+      HTTP.delete(path) do |response|
+        if response.error?
+          block.call(false, response.error_message) if block
+        else
+          block.call(true, response.data) if block
+        end
+      end
+    end
+
+    def update(attrs = nil, &block)
+      if attrs
+        attrs.each { |k, v| send("#{k}=", v) }
+      end
+
+      return if @changed_attributes.empty?
+
+      json_attrs = @changed_attributes.reject do |name, value|
+        schema = self.class.schema[name]
+        schema && schema["type"] == "binary"
+      end
+
+      return if json_attrs.empty?
+
+      endpoint = self.class.endpoints["update"]
+      path = endpoint["path"].gsub(":id", @id.to_s)
+
+      HTTP.patch(path, json_attrs) do |response|
+        if response.error?
+          block.call(false, response.error_message) if block
+        else
+          # Update attributes with response data
+          response.data.each do |key, value|
+            instance_variable_set("@#{key}", value)
+          end
+          @changed_attributes = {}
+          block.call(true, response.data) if block
+        end
+      end
+    end
+
+    def destroy(&block)
+      self.class.destroy(@id, &block)
+    end
+
+    def reload(&block)
+      self.class.find(@id) do |instance, error|
+        if instance
+          instance.instance_variables.each do |var|
+            instance_variable_set(var, instance.instance_variable_get(var))
+          end
+          @changed_attributes = {}
+        end
+        block.call(instance, error) if block
+      end
+    end
+  end
+end

data/mrblib/patcher.rb

@@ -0,0 +1,203 @@
+module Funicular
+  module VDOM
+    class Patcher
+      def initialize(doc = nil)
+        @doc = doc || JS.document
+      end
+
+      def apply(element, patches)
+        return element if patches.empty?
+        result = element
+        patches.each do |patch|
+          case patch[0]
+          when :replace
+            new_vnode = patch[1]
+            old_vnode = patch[2]
+            unmount_component(old_vnode)
+            new_element = create_element(new_vnode)
+            if parent = element.parentElement
+              parent.replaceChild(new_element, element)
+              result = new_element
+            end
+          when :props
+            update_props(element, patch[1])
+          when :update_and_rebind
+            instance, internal_patches, new_vdom = patch[1], patch[2], patch[3]
+            old_dom_element = instance.dom_element
+
+            # Apply internal patches and get the potentially new root element
+            new_dom_element = Patcher.new(@doc).apply(old_dom_element, internal_patches)
+
+            # Update the instance's reference to its root DOM element if it changed
+            if new_dom_element != old_dom_element
+              instance.dom_element = new_dom_element
+            end
+
+            # Update the instance's VDOM to the new one AFTER applying patches
+            instance.vdom = new_vdom
+
+            # Re-collect refs using the new DOM element
+            instance.collect_refs(new_dom_element, new_vdom)
+
+            # Re-bind events using the new DOM element
+            instance.cleanup_events
+            instance.bind_events(new_dom_element, new_vdom)
+
+            # Call component_updated on the child instance
+            instance.component_updated if instance.respond_to?(:component_updated)
+          when :update_props
+            # Update component props - element is the component's DOM element
+            # The component instance needs to be retrieved and updated
+            # This is handled at a higher level (in Component#re_render)
+            # For now, we just return the element as-is
+          when :remove
+            old_vnode = patch[1]
+            unmount_component(old_vnode)
+            element.parentElement&.removeChild(element)
+          when Integer
+            child_index = patch[0]
+            child_patches = patch[1]
+            # Use childNodes instead of children to include text nodes
+            child_nodes = element[:childNodes]
+            children = child_nodes.is_a?(JS::Object) ? child_nodes.to_a : [] #: Array[JS::Object]
+            child_element = children[child_index]
+            if child_element.nil?
+              # No existing child at this index - we need to create new elements
+              child_patches.each do |child_patch|
+                case child_patch[0]
+                when :replace
+                  new_child_element = create_element(child_patch[1])
+                  element.appendChild(new_child_element)
+                when :remove
+                  # Nothing to remove if child doesn't exist
+                when Integer
+                  # This shouldn't happen at the top level of child_patches
+                  # But if it does, recursively process it
+                end
+              end
+            else
+              apply(child_element, child_patches)
+            end
+          end
+        end
+        result
+      end
+
+      private
+
+      def unmount_component(vnode)
+        return unless vnode.is_a?(VDOM::Component) && vnode.instance
+        vnode.instance.unmount
+      end
+
+      def update_props(element, props_patch)
+        props_patch.each do |key, value|
+          key_str = key.to_s
+
+          # Skip event handlers (handled by bind_events)
+          next if key_str.start_with?('on')
+
+          # Skip updating value for focused input/textarea elements
+          if key_str == "value"
+            tag_name = element[:tagName].to_s.downcase
+            if (tag_name == "input" || tag_name == "textarea")
+              active_element = @doc[:activeElement]
+              if active_element && element == active_element
+                next
+              end
+              # Use property instead of attribute for value
+              element[:value] = value.to_s
+              next
+            end
+          end
+
+          # Block javascript: URIs in URL attributes
+          if URL_ATTRIBUTES.include?(key_str) && value.to_s.strip.downcase.start_with?('javascript:')
+            puts "[WARN] Funicular: Blocked potentially malicious value for attribute '#{key_str}'."
+            next
+          end
+
+          # Handle boolean attributes
+          if BOOLEAN_ATTRIBUTES.include?(key_str)
+            if value.nil? || value.to_s == "false"
+              element.removeAttribute(key_str)
+            else
+              element.setAttribute(key_str, key_str)
+            end
+          elsif value.nil?
+            element.removeAttribute(key_str)
+          else
+            element.setAttribute(key_str, value.to_s)
+          end
+        end
+      end
+
+      def create_element(vnode)
+        return @doc.createTextNode(vnode) if vnode.is_a?(String)
+        if vnode.is_a?(Array)
+          # Arrays should have been flattened in VDOM::Element.normalize_children
+          # Create a wrapper div as fallback
+          wrapper = @doc.createElement("div")
+          vnode.each do |child|
+            if child.is_a?(VNode)
+              wrapper.appendChild(create_element(child))
+            elsif child.is_a?(String)
+              wrapper.appendChild(@doc.createTextNode(child))
+            end
+          end
+          return wrapper
+        end
+        raise "Invalid vnode: #{vnode.class}" unless vnode.is_a?(VNode)
+        case vnode.type
+        when :text
+          raise "Expected Text vnode" unless vnode.is_a?(Text)
+          @doc.createTextNode(vnode.content)
+        when :element
+          raise "Expected Element vnode" unless vnode.is_a?(Element)
+          element = @doc.createElement(vnode.tag)
+          vnode.props.each do |key, value|
+            key_str = key.to_s
+            next if key_str.start_with?('on')
+            if URL_ATTRIBUTES.include?(key_str) && value.to_s.strip.downcase.start_with?('javascript:')
+              puts "[WARN] Funicular: Blocked potentially malicious value for attribute '#{key_str}'."
+              next
+            end
+            if key_str == "value" && (vnode.tag == "input" || vnode.tag == "textarea")
+              element[:value] = value.to_s
+            elsif BOOLEAN_ATTRIBUTES.include?(key_str)
+              if value.nil? || value.to_s == "false"
+              else
+                element.setAttribute(key_str, key_str)
+              end
+            else
+              element.setAttribute(key_str, value.to_s)
+            end
+          end
+          vnode.children.each do |child|
+            if child.is_a?(VNode)
+              element.appendChild(create_element(child))
+            elsif child.is_a?(String)
+              text_node = @doc.createTextNode(child)
+              element.appendChild(text_node)
+            elsif child.is_a?(Array)
+              child.each do |c|
+                if c.is_a?(VNode)
+                  element.appendChild(create_element(c))
+                elsif c.is_a?(String)
+                  text_node = @doc.createTextNode(c)
+                  element.appendChild(text_node)
+                end
+              end
+            end
+          end
+          element
+        when :component
+          raise "Expected Component vnode" unless vnode.is_a?(Component)
+          Renderer.new(@doc).render(vnode, nil)
+        else
+          raise "Unknown vnode type: #{vnode.type}"
+        end
+      end
+    end
+  end
+end

data/mrblib/router.rb

@@ -0,0 +1,229 @@
+module Funicular
+  class Router
+    attr_reader :routes, :current_component, :current_path
+
+    def initialize(container)
+      @container = container
+      @routes = []
+      @default_route = nil
+      @current_component = nil
+      @current_path = nil
+      @popstate_callback_id = nil
+      @url_helpers = Module.new
+      Funicular.const_set(:RouteHelpers, @url_helpers) unless Funicular.const_defined?(:RouteHelpers)
+    end
+
+    # Rails-style DSL methods
+    def get(path, to:, as: nil, constraints: nil)
+      add_route_with_method(:get, path, to, as, constraints)
+    end
+
+    def post(path, to:, as: nil, constraints: nil)
+      add_route_with_method(:post, path, to, as, constraints)
+    end
+
+    def put(path, to:, as: nil, constraints: nil)
+      add_route_with_method(:put, path, to, as, constraints)
+    end
+
+    def patch(path, to:, as: nil, constraints: nil)
+      add_route_with_method(:patch, path, to, as, constraints)
+    end
+
+    def delete(path, to:, as: nil, constraints: nil)
+      add_route_with_method(:delete, path, to, as, constraints)
+    end
+
+    # Add a route (backward compatibility)
+    def add_route(path, component_class, as: nil, constraints: nil)
+      add_route_with_method(:get, path, component_class, as, constraints)
+    end
+
+    # Set default route (used when path is empty)
+    def set_default(path)
+      @default_route = path
+    end
+
+    # Start listening to popstate
+    def start
+      # Clean up existing listener if any (prevents duplicate registration)
+      if @popstate_callback_id
+        JS::Object.removeEventListener(@popstate_callback_id)
+        @popstate_callback_id = nil
+      end
+
+      # Set up popstate listener
+      @popstate_callback_id = JS.global.addEventListener('popstate') do |event|
+        handle_route_change
+      end
+
+      # Handle initial route
+      if current_location_path == '/' && @default_route
+        # Use replaceState to not add a new entry to the history
+        JS.global.history.replaceState(JS::Bridge.to_js({}), '', @default_route)
+      end
+      handle_route_change
+    end
+
+    # Stop listening to popstate
+    def stop
+      if @popstate_callback_id
+        JS::Object.removeEventListener(@popstate_callback_id)
+        @popstate_callback_id = nil
+      end
+
+      unmount_current_component
+    end
+
+    # Navigate to a path programmatically using History API
+    def navigate(path)
+      JS.global.history.pushState(JS::Bridge.to_js({}), '', path)
+      # Manually trigger route change because pushState doesn't fire popstate
+      handle_route_change
+    end
+
+    # Get current path from location
+    def current_location_path
+      js_path_obj = JS.global.location.pathname
+      path = js_path_obj.to_s
+      path.empty? ? '/' : path
+    end
+
+    private
+
+    # Handle route change
+    def handle_route_change
+      path = current_location_path
+
+      # Find matching route
+      component_class, params = find_route(path)
+
+      unless component_class
+        # Maybe render a 404 component?
+        return
+      end
+
+      # Don't remount if already on this path
+      return if @current_path == path
+
+      # Unmount current component
+      unmount_current_component
+
+      # Mount new component
+      @current_path = path
+      @current_component = component_class.new(params)
+      # @type ivar @current_component: Funicular::Component
+      @current_component.mount(@container)
+    end
+
+    # Unmount current component
+    def unmount_current_component
+      @current_component&.unmount
+      @current_component = nil
+      @current_path = nil
+    end
+
+    private
+
+    def add_route_with_method(method, path, component_class, name = '', constraints = nil)
+      pattern_segments = path.split('/').reject { |s| s.empty? }
+      route = {
+        method: method,
+        path: path,
+        component: component_class,
+        name: name,
+        pattern_segments: pattern_segments,
+        constraints: constraints || {}
+      }
+      # @type var route: Funicular::route_definition_t
+      @routes << route
+
+      # Generate URL helper if name is provided
+      generate_url_helper(name, path) if name
+    end
+
+    def generate_url_helper(name, path_pattern)
+      helper_method_name = "#{name}_path".to_sym
+
+      # Check for duplicate helper names
+      if @url_helpers.instance_methods.include?(helper_method_name)
+        raise "URL helper '#{helper_method_name}' is already defined"
+      end
+
+      # Extract parameter names from path pattern (without regex)
+      param_names = extract_param_names(path_pattern)
+
+      # Define the helper method
+      if param_names.empty?
+        # No parameters - return static path
+        @url_helpers.module_eval do
+          define_method(helper_method_name) do # steep:ignore
+            path_pattern
+          end
+        end
+      else
+        # With parameters
+        @url_helpers.module_eval do
+          define_method(helper_method_name) do |*args| # steep:ignore
+            # Handle model objects with id method
+            if args.length == 1 && args[0].respond_to?(:id) && param_names.length == 1
+              args = [args[0].id]
+            elsif args.length != param_names.length
+              raise ArgumentError, "#{helper_method_name} expects #{param_names.length} argument(s), got #{args.length}"
+            end
+
+            result = path_pattern.dup
+            param_names.each_with_index do |param, idx|
+              result = result.sub(":#{param}", args[idx].to_s)
+            end
+            result
+          end
+        end
+      end
+    end
+
+    def extract_param_names(path_pattern)
+      path_pattern.split('/').select { |s|
+        s.start_with?(':')
+      }.map {
+        |s| s[1..-1]&.to_sym
+      }.compact
+    end
+
+    def find_route(path)
+      path_segments = path.split('/').reject { |s| s.empty? }
+      params = {} #: Hash[Symbol, untyped]
+
+      @routes.each do |route|
+        pattern_segments = route[:pattern_segments]
+        next if pattern_segments.length != path_segments.length
+
+        match = true
+
+        pattern_segments.each_with_index do |pattern_segment, index|
+          path_segment = path_segments[index]
+
+          if pattern_segment.start_with?(':')
+            param_name = pattern_segment[1..-1]&.to_sym
+            if param_name.nil?
+              raise "Invalid parameter name in route pattern: #{route[:path]}"
+            end
+            constraint = route[:constraints][param_name]
+            if constraint && !constraint.match?(path_segment)
+              match = false
+              break
+            end
+            params[param_name] = path_segment
+          elsif pattern_segment != path_segment
+            match = false
+            break
+          end
+        end
+
+        return [route[:component], params] if match
+      end
+
+      [nil, params] # No route found
+    end
+  end
+end

data/mrblib/styles.rb

@@ -0,0 +1,83 @@
+module Funicular
+  class StyleValue
+    attr_reader :value
+
+    def initialize(value)
+      @value = value.to_s
+    end
+
+    def |(other)
+      case other
+      when StyleValue
+        StyleValue.new("#{@value} #{other.value}".strip)
+      when String
+        StyleValue.new("#{@value} #{other}".strip)
+      when nil
+        self
+      else
+        other = other #: untyped
+        StyleValue.new("#{@value} #{other.to_s}".strip)
+      end
+    end
+
+    def to_s
+      @value
+    end
+  end
+
+  class StyleAccessor
+    def initialize(definitions)
+      @definitions = definitions
+    end
+
+    def method_missing(name, *args)
+      style = @definitions[name]
+      return StyleValue.new("") unless style
+
+      if args.empty?
+        # No arguments: return base or value
+        StyleValue.new(style[:base] || style[:value] || "")
+      elsif args[0] == true || args[0] == false
+        # Boolean argument: base + active (if true)
+        # JS::Object#== now supports direct comparison with Ruby true/false
+        base = style[:base] || ""
+        active_class = (args[0] == true) ? (style[:active] || "") : ""
+        StyleValue.new("#{base} #{active_class}".strip)
+      elsif args[0].is_a?(Symbol)
+        # Symbol argument: base + variants[symbol]
+        base = style[:base] || ""
+        variant_class = style[:variants] ? (style[:variants][args[0]] || "") : ""
+        StyleValue.new("#{base} #{variant_class}".strip)
+      else
+        # Other types: just return base
+        StyleValue.new(style[:base] || style[:value] || "")
+      end
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      @definitions.key?(name) || super
+    end
+  end
+
+  class StyleBuilder
+    def initialize
+      @definitions = {}
+    end
+
+    def method_missing(name, *args)
+      if args.size == 1 && args[0].is_a?(String)
+        # Simple style: name "class-string"
+        @definitions[name] = { value: args[0] }
+      elsif args.size == 1 && args[0].is_a?(Hash)
+        # Complex style with base/active/variants
+        @definitions[name] = args[0]
+      else
+        raise ArgumentError, "Invalid style definition for #{name}"
+      end
+    end
+
+    def to_definitions
+      @definitions
+    end
+  end
+end