scarpe 0.1.0 → 0.2.0

data/lib/scarpe/display_service.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+# Scarpe Shoes apps operate in multiple layers. A Shoes widget tree exists as fairly
+# plain, simple Ruby objects. And then a display-service widget tree integrates with
+# the display technology, initially Webview. This lets us use Ruby as our API while
+# not tying it too closely to the limitations of Webview.
+#
+# ## Choosing Display Services
+#
+# Before running a Scarpe app, you can set SCARPE_DISPLAY_SERVICE. If you
+# set it to "whatever_service", Scarpe will require "scarpe/whatever_service",
+# which can be supplied by the Scarpe gem or another Scarpe-based gem.
+# Currently leaving the environment variable empty is equivalent to requesting
+# local Webview.
+#
+# ## Events
+#
+# Events are a lot of what tie the Shoes widgets and the display service together.
+#
+# Scarpe widgets *expect* to operate in a fairly "hands off" mode where they record
+# to an event queue to send to the display service, and the display service records
+# events to send back.
+#
+# When a Shoes handler takes an action (e.g. some_para.replace(),) the relevant
+# call will be dispatched as a :display event, to be sent to the display service.
+# And when a display-side event occurs (e.g. user pushes a button,) it will be
+# dispatched as a :shoes event, to be sent to the Shoes tree of widgets.
+#
+# It is normally assumed that there will only be a single 'real' consumer for each
+# queue. You wouldn't usually want multiple display services sending back click
+# events, for example. But that's not a technical limitation of the system.
+# You could have no display service and not get any events back, or a debug
+# display service that just records what happened. But in real situations,
+# exactly one display service is a reasonable and appropriate assumption.
+#
+# The event types are "queues" in the sense that they're separate from each
+# other. You need to subscribe separately to :shoes and :display events if
+# you want both. But internally they're immediately dispatched as events
+# rather than keeping a literal array of items.
+#
+class Scarpe
+  class DisplayService
+    class << self
+      # This is in the eigenclass/metaclass, *not* instances of DisplayService
+      include Scarpe::Log
+
+      attr_accessor :json_debug_serialize
+
+      # An event_target may be nil, to indicate there is no target.
+      def dispatch_event(event_name, event_target, *args, **kwargs)
+        @@display_event_handlers ||= {}
+
+        unless @log
+          log_init("DisplayService")
+        end
+
+        raise "Cannot dispatch on event_name :any!" if event_name == :any
+
+        @log.debug("Dispatch event: #{event_name.inspect} T: #{event_target.inspect} A: #{args.inspect} KW: #{kwargs.inspect}")
+
+        if DisplayService.json_debug_serialize
+          args = JSON.parse JSON.dump(args)
+          new_kw = {}
+          kwargs.each do |k, v|
+            new_kw[k] = JSON.parse JSON.dump(v)
+          end
+          kwargs = new_kw
+        end
+
+        same_name_handlers = @@display_event_handlers[event_name] || {}
+        any_name_handlers = @@display_event_handlers[:any] || {}
+
+        # Do we have any keys, in same_name_handlers or any_name_handlers, matching the target or :any?
+        # Note that "nil" is a target like any other for these purposes -- subscribing to a nil target
+        # won't get you non-nil-target events and vice-versa.
+        handlers = [
+          same_name_handlers[:any],           # Same name, any target
+          same_name_handlers[event_target],   # Same name, same target
+          any_name_handlers[:any],            # Any name, any target
+          any_name_handlers[event_target],    # Any name, same target
+        ].compact.inject([], &:+)
+        kwargs[:event_name] = event_name
+        kwargs[:event_target] = event_target if event_target
+        handlers.each { |h| h[:handler].call(*args, **kwargs) }
+      end
+
+      # It's permitted to subscribe to event_name :any for all event names, and event_target :any for all targets.
+      # An event_target of nil means "no target", and only matches events dispatched with a nil target.
+      def subscribe_to_event(event_name, event_target, &handler)
+        @@display_event_handlers ||= {}
+        @@display_event_unsub_id ||= 0
+        unless handler
+          raise "Must pass a block as a handler to DisplayService.subscribe_to_event!"
+        end
+
+        unless @log
+          log_init("DisplayService")
+        end
+
+        @log.debug("Subscribe to event: #{event_name.inspect} T: #{event_target.inspect}")
+
+        id = @@display_event_unsub_id
+        @@display_event_unsub_id += 1
+
+        @@display_event_handlers[event_name] ||= {}
+        @@display_event_handlers[event_name][event_target] ||= []
+        @@display_event_handlers[event_name][event_target] << { handler:, unsub_id: id }
+
+        id
+      end
+
+      def unsub_from_events(unsub_id)
+        raise "Must provide an unsubscribe ID!" if unsub_id.nil?
+
+        @@display_event_handlers.each do |_e_name, target_hash|
+          target_hash.each do |_target, h_list|
+            h_list.delete_if { |item| item[:unsub_id] == unsub_id }
+          end
+        end
+      end
+
+      def full_reset!
+        @@display_event_handlers = {}
+        @json_debug_serialize = nil
+      end
+
+      def set_display_service_class(klass)
+        raise "Can only set a single display service class!" if @display_service_klass
+
+        @display_service_klass = klass
+      end
+
+      def display_service
+        return @service if @service
+
+        raise "No display service was set!" unless @display_service_klass
+
+        @service = @display_service_klass.new
+      end
+    end
+
+    # This is for objects that can be referred to via events, using their
+    # IDs. There are also convenience functions for binding and sending
+    # events.
+    class Linkable
+      attr_reader :linkable_id
+
+      def initialize(linkable_id: object_id)
+        @linkable_id = linkable_id
+      end
+
+      def send_self_event(*args, event_name:, **kwargs)
+        DisplayService.dispatch_event(event_name, self.linkable_id, *args, **kwargs)
+      end
+
+      def send_shoes_event(*args, event_name:, target: nil, **kwargs)
+        DisplayService.dispatch_event(event_name, target, *args, **kwargs)
+      end
+
+      def bind_shoes_event(event_name:, target: nil, &handler)
+        DisplayService.subscribe_to_event(event_name, target, &handler)
+      end
+    end
+
+    # These methods are an interface to DisplayService objects.
+
+    def create_display_widget_for(widget_class_name, widget_id, properties)
+      raise "Override in DisplayService implementation!"
+    end
+
+    def set_widget_pairing(id, display_widget)
+      @display_widget_for ||= {}
+      @display_widget_for[id] = display_widget
+    end
+
+    def query_display_widget_for(id, nil_ok: false)
+      display_widget = @display_widget_for[id]
+      unless display_widget || nil_ok
+        raise "Could not find display widget for linkable ID #{id.inspect}!"
+      end
+
+      display_widget
+    end
+
+    def destroy
+      raise "Override in DisplayService implementation!"
+    end
+  end
+end

data/lib/scarpe/document_root.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class Scarpe
+  class DocumentRoot < Scarpe::Widget
+    include Scarpe::Background
+
+    def initialize
+      super
+
+      create_display_widget
+    end
+
+    # This can be absolutely huge in console output, and it's frequently printed.
+    def inspect
+      "<Scarpe::DocumentRoot>"
+    end
+
+    alias_method :info, :puts
+  end
+end

data/lib/scarpe/edit_box.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class Scarpe
+  class EditBox < Scarpe::Widget
+    display_properties :text, :height, :width
+
+    def initialize(text = nil, height: nil, width: nil, &block)
+      @text = text.nil? ? block&.call : text || ""
+
+      super
+
+      bind_self_event("change") do |new_text|
+        self.text = new_text
+        @callback&.call(new_text)
+      end
+
+      create_display_widget
+    end
+
+    def change(&block)
+      @callback = block
+    end
+  end
+end

data/lib/scarpe/edit_line.rb

@@ -1,39 +1,25 @@
-module Scarpe
-  class EditLine
-    def initialize(app, &block)
-      @app = app
-      @block = block
-      @text = ""
-      @app.append(render)
-    end
+# frozen_string_literal: true
 
-    def function_name
-      object_id
-    end
+class Scarpe
+  class EditLine < Scarpe::Widget
+    display_properties :text, :width
 
-    def change(&block)
+    def initialize(text = "", width: nil, &block)
       @block = block
-    end
-    
-    def text
-      @text
-    end
-
-    def text=(text)
       @text = text
-      if @app.window.is_running
-        @app.window.eval("document.getElementById(#{object_id}).value = \"#{@text}\";")
+
+      super
+
+      bind_self_event("change") do |new_text|
+        self.text = new_text
+        @block&.call(new_text)
       end
+
+      create_display_widget
     end
 
-    def render
-      @app.bind(function_name) do |text|
-        @text = text
-        if @block
-          @block.call(text)
-        end
-      end
-      "<input id=#{object_id} oninput='scarpeHandler(#{function_name}, this.value)' value='#{@text}'></input>"
+    def change(&block)
+      @block = block
     end
   end
-end
+end

data/lib/scarpe/fill.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class Scarpe
+  class Fill < Scarpe::Widget
+    display_properties :color
+
+    def initialize(color)
+      @color = color
+      super
+      create_display_widget
+    end
+
+    def element
+      HTML.render do |h|
+        h.style(<<~CSS)
+          ##{html_id} {
+            background-color: #{@color};
+          }
+        CSS
+      end
+    end
+  end
+end

data/lib/scarpe/flow.rb

@@ -1,16 +1,19 @@
-module Scarpe
-    class Flow
-      include Scarpe::Container
-      
-      attr_reader :app
-      def initialize(app, &block)
-        @app = app
-        @app.append(render)
-        append(&block)
-      end
-  
-      def render
-        "<div style='display: flex; flex-direction: row' id=#{object_id}></div>"
-      end
+# frozen_string_literal: true
+
+class Scarpe
+  class Flow < Scarpe::Widget
+    include Scarpe::Background
+    include Scarpe::Border
+
+    display_properties :width, :height, :margin, :padding
+
+    def initialize(width: nil, height: "100%", margin: nil, padding: nil, &block)
+      super
+
+      # Create the display-side widget *before* instance_eval, which will add child widgets with their display widgets
+      create_display_widget
+
+      instance_eval(&block)
     end
-  end
+  end
+end

data/lib/scarpe/glibui/README.md

@@ -0,0 +1,34 @@
+## IN DEVELOPMENT
+
+Glimmer LibUI is a fully functioning way to build desktop applications in Ruby.
+
+One possible way to make this work would be a parser-compiler setup to essentially _transform_ shoes app text into GlimmerLibUI text. Which should be abstract enough that we wouldn't have to go more bare metal and use the ruby dependency LibUI.
+
+Hello world example:
+
+```ruby
+# parser/compiler example:
+
+Shoes.app do
+  para "Hello World"
+end
+
+# becomes
+
+include Glimmer
+
+window {
+  area {
+    text {
+      string "Hello World"
+    }
+  }
+}.show
+```
+
+# GLibUI Finished Examples
+
+* /examples/hello_world.rb
+* /examples/title_and_resize.rb
+* /examples/stack/raw_stack.rb
+* /examples/raw_flow.rb

data/lib/scarpe/glibui/alert.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+class Scarpe
+  class GlimmerLibUIAlert < GlimmerLibUIWidget
+    def initialize(properties)
+      super
+
+      bind("click") do
+        send_self_event(event_name: "click")
+      end
+    end
+
+    def element
+      onclick = handler_js_code("click")
+
+      HTML.render do |h|
+        h.div(id: html_id, style: overlay_style) do
+          h.div(style: modal_style) do
+            h.div(style: text_style) { @text }
+            h.button(style: button_style, onclick: onclick) { "OK" }
+          end
+        end
+      end
+    end
+
+    private
+
+    def overlay_style
+      {
+        position: "fixed",
+        top: "0",
+        left: "0",
+        width: "100%",
+        height: "100%",
+        overflow: "auto",
+        "z-index": "1",
+        background: "rgba(0,0,0,0.4)",
+        display: "flex",
+        "align-items": "center",
+        "justify-content": "center",
+      }
+    end
+
+    def modal_style
+      {
+        "min-width": "200px",
+        "min-height": "50px",
+        padding: "10px",
+        display: "flex",
+        background: "#fefefe",
+        "flex-direction": "column",
+        "justify-content": "space-between",
+        "border-radius": "9px",
+      }
+    end
+
+    def text_style
+      {}
+    end
+
+    def button_style
+      {}
+    end
+  end
+end

data/lib/scarpe/glibui/app.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "glimmer-dsl-libui"
+
+class Scarpe
+  # Scarpe::GlimmerLibUIApp must only be used from the main thread, due to GTK+ limitations.
+  class GlimmerLibUIApp < GlimmerLibUIWidget
+    include Glimmer
+
+    attr_reader :debug
+    attr_writer :shoes_linkable_id
+
+    def initialize(properties)
+      super
+
+      bind_shoes_event(event_name: "run") do
+        code = @document_root.display(properties)
+        puts code
+        # This is for if I want to confirm textual output. But not actually fire up the service.
+        exit if ENV["NO_RUN"]
+        eval code
+      end
+    end
+
+    attr_writer :document_root
+  end
+end

data/lib/scarpe/glibui/background.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class Scarpe
+  module GlimmerLibUIBackground
+    def style
+      styles = (super if defined?(super)) || {}
+      return styles unless @background_color
+
+      color = if @background_color.is_a?(Range)
+        "linear-gradient(45deg, #{@background_color.first}, #{@background_color.last})"
+      else
+        @background_color
+      end
+
+      styles.merge(background: color)
+    end
+  end
+end

data/lib/scarpe/glibui/border.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Scarpe
+  module GlimmerLibUIBorder
+    def style
+      styles = (super if defined?(super)) || {}
+      return styles unless @border_color
+
+      border_color = if @border_color.is_a?(Range)
+        { "border-image": "linear-gradient(45deg, #{@border_color.first}, #{@border_color.last}) 1" }
+      else
+        { "border-color": @border_color }
+      end
+
+      styles.merge(
+        "border-style": "solid",
+        "border-width": "#{@options[:strokewidth] || 1}px",
+        "border-radius": "#{@options[:curve] || 0}px",
+      ).merge(border_color)
+    end
+  end
+end

data/lib/scarpe/glibui/button.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class Scarpe
+  class GlimmerLibUIButton < GlimmerLibUIWidget
+    def initialize(properties)
+      super
+
+      # Bind to display-side handler for "click"
+      bind("click") do
+        # This will be sent to the bind_self_event in Button
+        send_self_event(event_name: "click")
+      end
+    end
+
+    def element
+      HTML.render do |h|
+        h.button(id: html_id, onclick: handler_js_code("click"), style: style) do
+          @text
+        end
+      end
+    end
+
+    private
+
+    def style
+      styles = {}
+
+      styles[:width] = Dimensions.length(@width) if @width
+      styles[:height] = Dimensions.length(@height) if @height
+
+      styles[:top] = Dimensions.length(@top) if @top
+      styles[:left] = Dimensions.length(@left) if @left
+      styles[:position] = "absolute" if @top || @left
+
+      styles
+    end
+  end
+end

data/lib/scarpe/glibui/dimensions.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Scarpe
+  class Dimensions
+    class << self
+      def length(value)
+        case value
+        when Integer
+          if value < 0
+            "calc(100% - #{value.abs}px)"
+          else
+            "#{value}px"
+          end
+        when Float
+          "#{value * 100}%"
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/scarpe/glibui/document_root.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class Scarpe
+  class GlimmerLibUIDocumentRoot < Scarpe::GlimmerLibUIWidget
+    include Scarpe::GlimmerLibUIBackground
+
+    attr_reader :debug
+
+    def initialize(properties)
+      @callbacks = {}
+      super
+    end
+
+    def display(properties = {})
+      <<~GTEXT
+        window("#{properties["title"] || "Scarpe with GlimmerLibUI"}", #{properties["width"] || 640}, #{properties["height"] || 480}) {
+          horizontal_box {
+            #{@children.map(&:display).join}
+          }
+        }.show
+      GTEXT
+    end
+
+    def element(&blck)
+      window(&blck).show
+    end
+
+    # Bind a Scarpe callback name; see Scarpe::Widget for how the naming is set up
+    def bind(name, &block)
+      @callbacks[name] = block
+    end
+  end
+end

data/lib/scarpe/glibui/edit_box.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+class Scarpe
+  class GlimmerLibUIEditBox < Scarpe::GlimmerLibUIWidget
+    attr_reader :text, :height, :width
+
+    def initialize(properties)
+      super
+
+      # The JS handler sends a "change" event, which we forward to the Shoes widget tree
+      bind("change") do |new_text|
+        send_self_event(new_text, event_name: "change")
+      end
+    end
+
+    def properties_changed(changes)
+      t = changes.delete("text")
+      if t
+        html_element.value = t
+      end
+
+      super
+    end
+
+    def element
+      oninput = handler_js_code("change", "this.value")
+
+      HTML.render do |h|
+        h.textarea(id: html_id, oninput: oninput, style: style) { text }
+      end
+    end
+
+    private
+
+    def style
+      styles = {}
+
+      styles[:height] = Dimensions.length(height)
+      styles[:width] = Dimensions.length(width)
+
+      styles.compact
+    end
+  end
+end