lacci 0.2.1

data/lib/scarpe/download.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "openssl"
+require "nokogiri"
+
+module Shoes
+  class Widget
+    class ResponseWrapper
+      attr_reader :response
+
+      def initialize(response)
+        @response = response
+      end
+
+      def headers
+        @response.each_header.to_h
+      end
+
+      def body
+        @response.body
+      end
+    end
+
+    def download(url, method: "GET", save: nil, styles: {}, &block)
+      @block = block
+
+      Thread.new do
+        logger = Scarpe::Logger.logger("Shoes::App#download")
+        begin
+          uri = URI(url)
+          response = perform_request(uri, method, styles)
+
+          if response.is_a?(Net::HTTPRedirection)
+            new_location = response["location"]
+            new_uri = URI(new_location)
+            response = perform_request(new_uri, method, styles)
+          end
+
+          wrapped_response = ResponseWrapper.new(response) # Wrap the response
+          handle_response(wrapped_response, save, styles)
+        rescue Net::HTTPError, Net::OpenTimeout, Net::ReadTimeout => e
+          handle_error(e, logger)
+        rescue StandardError => e
+          handle_error(e.message, logger) # Pass the error message as a string
+        end
+      end
+    end
+
+    private
+
+    def perform_request(uri, method, styles)
+      port = uri.port || (uri.scheme == "https" ? 443 : 80)
+      http = Net::HTTP.start(uri.host, port, use_ssl: uri.scheme == "https", verify_mode: OpenSSL::SSL::VERIFY_NONE)
+
+      request = Net::HTTP.const_get(method.capitalize).new(uri.request_uri)
+      apply_styles(request, styles)
+
+      http.request(request)
+    end
+
+    def apply_styles(request, styles)
+      headers = styles[:headers]
+      request["Content-Type"] = headers["Content-Type"] if headers && headers["Content-Type"]
+      request.body = styles[:body] if styles[:body]
+      # Add more custom styles to the request as needed
+    end
+
+    def handle_response(response, save, styles)
+      case response.response.code.to_i
+      when 200..299
+        content = response.body
+        # headers = response.headers # Access headers directly
+        if save
+          save_content(content, save)
+          parse_rss(content) # Parse the downloaded XML content
+        else
+          handle_finish_event(response) # Pass response and headers to handle_finish_event
+        end
+      else
+        handle_failure(response.response.code)
+      end
+    end
+
+    def save_content(content, file_name)
+      file = nil
+      begin
+        file = File.open(file_name, "w")
+        file.write(content)
+      rescue Errno::EACCES, Errno::ENOENT => e
+        raise FileError, "File error occurred: #{e.message}"
+      else
+        @block&.call
+      ensure
+        file&.close
+      end
+    end
+
+    def handle_finish_event(response)
+      passed = Struct.new(:response).new(response) # Create a new Struct with response attribute
+      @block&.call(passed) # Pass it ok
+    end
+
+    def handle_failure(code, logger)
+      logger.error("Failed to download content. Response code: #{code}")
+    end
+
+    def handle_error(error, logger)
+      logger.error("An error occurred while downloading: #{error}")
+    end
+
+    def parse_rss(content)
+      doc = Nokogiri::XML(content)
+      items = doc.xpath("//item")
+      items.each do |item|
+        item.xpath("title").text
+        item.xpath("link").text
+        item.xpath("description").text
+        # Do something with the parsed content or use it if needed
+      end
+    end
+  end
+end

data/lib/scarpe/edit_box.rb

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

data/lib/scarpe/edit_line.rb

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

data/lib/scarpe/fill.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class Scarpe
+  class Fill < Shoes::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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class Scarpe
+  class Flow < Shoes::Slot
+    display_properties :width, :height, :margin, :padding
+
+    def initialize(width: nil, height: nil, margin: nil, padding: nil, **options, &block)
+      @options = options
+
+      super
+
+      # Create the display-side widget *before* instance_eval, which will add child widgets with their display widgets
+      create_display_widget
+
+      Shoes::App.instance.with_slot(self, &block) if block_given?
+    end
+  end
+end

data/lib/scarpe/font.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class Scarpe
+  class Font < Shoes::Widget
+    display_properties :font
+
+    def initialize(font)
+      @font = font
+      super
+
+      create_display_widget
+    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

data/lib/scarpe/glibui/edit_line.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+class Scarpe
+  class GlimmerLibUIEditLine < GlimmerLibUIWidget
+    attr_reader :text, :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.input(id: html_id, oninput: oninput, value: @text, style: style)
+      end
+    end
+
+    private
+
+    def style
+      styles = {}
+
+      styles[:width] = Dimensions.length(@width) if @width
+
+      styles
+    end
+  end
+end

data/lib/scarpe/glibui/flow.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class Scarpe
+  class GlimmerLibUIFlow < Scarpe::GlimmerLibUIWidget
+    include Scarpe::GlimmerLibUIBackground
+    include Scarpe::GlimmerLibUIBorder
+
+    def initialize(properties)
+      super
+    end
+
+    def display(properties = {})
+      <<~GTEXT
+        horizontal_box {
+          #{@children.map(&:display).join}
+        }.show
+      GTEXT
+    end
+
+    # Marker from webview
+    # def style
+    #   styles = super
+
+    #   styles[:display] = "flex"
+    #   styles["flex-direction"] = "row"
+    #   styles["flex-wrap"] = "wrap"
+    #   styles[:width] = Dimensions.length(@width) if @width
+    #   styles[:height] = Dimensions.length(@height) if @height
+
+    #   styles
+    # end
+  end
+end