glimmer-libui-cc-graphs_and_charts 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6c79188349650bf2223b5885ceaff00675197d6f833af8bffbfc15f1dbaaa2a5
+  data.tar.gz: a9d9f4732bdf4b81e20721cdfda4ffab550e6bd82785884db0ccf8f2f43a6d99
+SHA512:
+  metadata.gz: b5db2acfba0997e784840523b3e09154daea02fc78f1eb3726a3fbb50b876fc86aa483eea4f4af44c4eda804087d9c651d9081b81faa362b3fca252c76a8cb97
+  data.tar.gz: f6eba9bdc99d3bd30a17e53cbc81345bddb67c2573a6e51f26af546d56eb5d740e066a582cbaacec31e9f1ef00432f620f50dde58b9c6b83e9994ecf41e9fdcb

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2023 Andy Maleh
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,87 @@
+# Graphs and Charts 0.1.0
+## [Glimmer DSL for LibUI](https://github.com/AndyObtiva/glimmer-dsl-libui) Custom Controls
+[![Gem Version](https://badge.fury.io/rb/glimmer-libui.svg)](http://badge.fury.io/rb/glimmer-dsl-libui)
+[![Join the chat at https://gitter.im/AndyObtiva/glimmer](https://badges.gitter.im/AndyObtiva/glimmer.svg)](https://gitter.im/AndyObtiva/glimmer?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+Graphs and Charts (Custom Controls) for [Glimmer DSL for LibUI](https://github.com/AndyObtiva/glimmer-dsl-libui)
+
+![line graph](/screenshots/glimmer-libui-cc-graphs_and_charts-mac-line-graph.png)
+
+## Setup
+
+Add this line to Bundler `Gemfile`:
+
+```ruby
+gem 'glimmer-libui-cc-graphs_and_charts', '~> 0.1.0'
+```
+
+Run:
+
+```
+bundle
+```
+
+## Usage
+
+### Line Graph
+
+Add this line to your Ruby file:
+
+```ruby
+require 'glimmer/view/line_graph'
+```
+
+Example Glimmer GUI DSL code that can be nested under `window` or some container like `vertical_box`:
+
+```ruby
+line_graph(
+  width: 900,
+  height: 300,
+  lines: [
+    {
+      name: 'Failed',
+      stroke: [163, 40, 39, thickness: 2],
+      x_value_start: Time.now,
+      x_interval_in_seconds: 2,
+      x_value_format: -> (time) {time.strftime("%a %d %b %Y %T GMT")},
+      y_values: [36, 0, 60, 0, 0, 16, 0, 36, 0, 0]
+    },
+    {
+      name: 'Processed',
+      stroke: [47, 109, 104, thickness: 2],
+      x_value_start: Time.now,
+      x_interval_in_seconds: 2,
+      x_value_format: -> (time) {time.strftime("%a %d %b %Y %T GMT")},
+      y_values: [62, 0, 90, 0, 0, 27, 0, 56, 0, 0]
+    },
+  ],
+  display_attributes_on_hover: true,
+)
+```
+
+![line graph](/screenshots/glimmer-libui-cc-graphs_and_charts-mac-line-graph.png)
+
+Contributing to glimmer-libui-cc-graphs_and_charts
+------------------------------------------
+
+-   Check out the latest master to make sure the feature hasn't been
+    implemented or the bug hasn't been fixed yet.
+-   Check out the issue tracker to make sure someone already hasn't
+    requested it and/or contributed it.
+-   Fork the project.
+-   Start a feature/bugfix branch.
+-   Commit and push until you are happy with your contribution.
+-   Make sure to add tests for it. This is important so I don't break it
+    in a future version unintentionally.
+-   Please try not to mess with the Rakefile, version, or history. If
+    you want to have your own version, or is otherwise necessary, that
+    is fine, but please isolate to its own commit so I can cherry-pick
+    around it.
+
+Copyright
+---------
+
+[MIT](LICENSE.txt)
+
+Copyright (c) 2023 Andy Maleh. See
+[LICENSE.txt](LICENSE.txt) for further details.

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/glimmer/view/line_graph.rb

@@ -0,0 +1,410 @@
+module Glimmer
+  module View
+    # General-Purpose Line Graph Custom Control
+    class LineGraph
+      include Glimmer::LibUI::CustomControl
+      
+      DEFAULT_GRAPH_PADDING_WIDTH = 5.0
+      DEFAULT_GRAPH_PADDING_HEIGHT = 5.0
+      DEFAULT_GRAPH_GRID_MARKER_PADDING_WIDTH = 30.0
+      DEFAULT_GRAPH_POINT_DISTANCE = 15.0
+      
+      DEFAULT_GRAPH_STROKE_GRID = [185, 184, 185]
+      DEFAULT_GRAPH_STROKE_MARKER = [185, 184, 185]
+      DEFAULT_GRAPH_STROKE_MARKER_LINE = [217, 217, 217, thickness: 1, dashes: [1, 1]]
+      DEFAULT_GRAPH_STROKE_PERIODIC_LINE = [121, 121, 121, thickness: 1, dashes: [1, 1]]
+      DEFAULT_GRAPH_STROKE_HOVER_LINE = [133, 133, 133]
+      
+      DEFAULT_GRAPH_COLOR_MARKER_TEXT = [96, 96, 96]
+      DEFAULT_GRAPH_COLOR_PERIOD_TEXT = [163, 40, 39]
+      
+      DEFAULT_GRAPH_FONT_MARKER_TEXT = {family: "Arial", size: 14}
+      
+      DEFAULT_GRAPH_STATUS_HEIGHT = 30.0
+      
+      DAY_IN_SECONDS = 60*60*24
+  
+      option :width, default: 600
+      option :height, default: 200
+      
+      # Hash or Array of Hash's like:
+      # {
+      #   name: 'Attribute Name',
+      #   stroke: [28, 34, 89, thickness: 3],
+      #   x_value_start: Time.now,
+      #   x_interval_in_seconds: 2,
+      #   x_value_format: ->(time) {time.strftime('%s')},
+      #   y_values: [...]
+      # }
+      option :lines, default: []
+      
+      option :graph_padding_width, default: DEFAULT_GRAPH_PADDING_WIDTH
+      option :graph_padding_height, default: DEFAULT_GRAPH_PADDING_HEIGHT
+      option :graph_grid_marker_padding_width, default: DEFAULT_GRAPH_GRID_MARKER_PADDING_WIDTH
+      option :graph_point_distance, default: DEFAULT_GRAPH_POINT_DISTANCE
+      
+      option :graph_stroke_grid, default: DEFAULT_GRAPH_STROKE_GRID
+      option :graph_stroke_marker, default: DEFAULT_GRAPH_STROKE_MARKER
+      option :graph_stroke_marker_line, default: DEFAULT_GRAPH_STROKE_MARKER_LINE
+      option :graph_stroke_periodic_line, default: DEFAULT_GRAPH_STROKE_PERIODIC_LINE
+      option :graph_stroke_hover_line, default: DEFAULT_GRAPH_STROKE_HOVER_LINE
+      
+      option :graph_color_marker_text, default: DEFAULT_GRAPH_COLOR_MARKER_TEXT
+      option :graph_color_period_text, default: DEFAULT_GRAPH_COLOR_PERIOD_TEXT
+      
+      option :graph_font_marker_text, default: DEFAULT_GRAPH_FONT_MARKER_TEXT
+      
+      option :graph_status_height, default: DEFAULT_GRAPH_STATUS_HEIGHT
+      
+      option :display_attributes_on_hover, default: false
+      
+      before_body do
+        self.lines = [lines] if lines.is_a?(Hash)
+      end
+      
+      after_body do
+        observe(self, :lines) do
+          clear_drawing_cache
+          body_root.queue_redraw_all
+        end
+        observe(self, :width) do
+          clear_drawing_cache
+        end
+        observe(self, :height) do
+          clear_drawing_cache
+        end
+      end
+  
+      body {
+        area { |graph_area|
+          on_draw do
+            calculate_dynamic_options
+            graph_background
+            grid_lines
+            all_line_graphs
+            periodic_lines
+            hover_stats
+          end
+
+          on_mouse_moved do |event|
+            @hover_point = {x: event[:x], y: event[:y]}
+        
+            if @hover_point && lines && lines[0] && @points && @points[lines[0]] && !@points[lines[0]].empty?
+              x = @hover_point[:x]
+              closest_point_index = @points[lines[0]].each_with_index.min_by { |point, index| (point[:x] - x).abs }[1]
+              if closest_point_index != @closest_point_index
+                @closest_point_index = closest_point_index
+                graph_area.queue_redraw_all
+              end
+            end
+          end
+
+          on_mouse_exited do |outside|
+            if !@hover_point.nil?
+              @hover_point = nil
+              @closest_point_index = nil
+              graph_area.queue_redraw_all
+            end
+          end
+        }
+      }
+      
+      private
+      
+      def clear_drawing_cache
+        @graph_point_distance_per_line = nil
+        @y_value_max_for_all_lines = nil
+        @grid_marker_points = nil
+        @points = nil
+      end
+      
+      def calculate_dynamic_options
+        calculate_graph_point_distance_per_line
+      end
+      
+      def calculate_graph_point_distance_per_line
+        return unless graph_point_distance == :width_divided_by_point_count
+        
+        @graph_point_distance_per_line = lines.inject({}) do |hash, line|
+          hash.merge(line => (width - 2.0*graph_padding_width - graph_grid_marker_padding_width) / (line[:y_values].size - 1).to_f)
+        end
+      end
+      
+      def graph_point_distance_for_line(line)
+        @graph_point_distance_per_line&.[](line) || graph_point_distance
+      end
+      
+      def graph_background
+        rectangle(0, 0, width, height + (display_attributes_on_hover ? graph_status_height : 0)) {
+          fill 255, 255, 255
+        }
+      end
+  
+      def grid_lines
+        line(graph_padding_width, graph_padding_height, graph_padding_width, height - graph_padding_height) {
+          stroke graph_stroke_grid
+        }
+        line(graph_padding_width, height - graph_padding_height, width - graph_padding_width, height - graph_padding_height) {
+          stroke graph_stroke_grid
+        }
+        grid_marker_points.each_with_index do |marker_point, index|
+          grid_marker_number_value = (grid_marker_points.size - index).to_i
+          grid_marker_number = (grid_marker_number_value >= 1000) ? "#{grid_marker_number_value / 1000}K" : grid_marker_number_value.to_s
+          graph_stroke_marker_value = Glimmer::LibUI.interpret_color(graph_stroke_marker)
+          graph_stroke_marker_value[:thickness] = (index != grid_marker_points.size - 1 ? 2 : 1) if graph_stroke_marker_value[:thickness].nil?
+          mod_value = (2 * ((grid_marker_points.size / max_marker_count) + 1))
+          comparison_value = (mod_value > 2) ? 0 : 1
+          if mod_value > 2
+            if grid_marker_number_value % mod_value == comparison_value
+              line(marker_point[:x], marker_point[:y], marker_point[:x] + 4, marker_point[:y]) {
+                stroke graph_stroke_marker_value
+              }
+            end
+          else
+            line(marker_point[:x], marker_point[:y], marker_point[:x] + 4, marker_point[:y]) {
+              stroke graph_stroke_marker_value
+            }
+          end
+          if grid_marker_number_value % mod_value == comparison_value && grid_marker_number_value != grid_marker_points.size
+            line(marker_point[:x], marker_point[:y], marker_point[:x] + width - graph_padding_width, marker_point[:y]) {
+              stroke graph_stroke_marker_line
+            }
+          end
+          if grid_marker_number_value % mod_value == comparison_value
+            grid_marker_number_font = graph_font_marker_text.merge(size: 11)
+            grid_marker_number_width = estimate_width_of_text(grid_marker_number, grid_marker_number_font)
+            text(marker_point[:x] + 4 + 3, marker_point[:y] - 6, grid_marker_number_width) {
+              string(grid_marker_number) {
+                font grid_marker_number_font
+                color graph_color_marker_text
+              }
+            }
+          end
+        end
+      end
+      
+      def grid_marker_points
+        if @grid_marker_points.nil?
+          graph_max = [y_value_max_for_all_lines, 1].max
+          current_graph_height = (height - graph_padding_height * 2)
+          division_height = current_graph_height / graph_max
+          @grid_marker_points = graph_max.to_i.times.map do |marker_index|
+            x = graph_padding_width
+            y = graph_padding_height + marker_index * division_height
+            {x: x, y: y}
+          end
+        end
+        @grid_marker_points
+      end
+      
+      def max_marker_count
+        [(0.15*height).to_i, 1].max
+      end
+      
+      def all_line_graphs
+        lines.each { |graph_line| single_line_graph(graph_line) }
+      end
+
+      def single_line_graph(graph_line)
+        last_point = nil
+        points = calculate_points(graph_line)
+        points.each do |point|
+          if last_point
+            line(last_point[:x], last_point[:y], point[:x], point[:y]) {
+              stroke graph_line[:stroke]
+            }
+          end
+          last_point = point
+        end
+      end
+      
+      def calculate_points(graph_line)
+        @points ||= {}
+        if @points[graph_line].nil?
+          y_values = graph_line[:y_values] || []
+          y_values = y_values[0, max_visible_point_count(graph_line)]
+          graph_max = [y_value_max_for_all_lines, 1].max
+          points = y_values.each_with_index.map do |y_value, index|
+            x = width - graph_padding_width - (index * graph_point_distance_for_line(graph_line))
+            y = ((height - graph_padding_height) - y_value * ((height - graph_padding_height * 2) / graph_max))
+            {x: x, y: y, index: index, y_value: y_value}
+          end
+          @points[graph_line] = translate_points(graph_line, points)
+        end
+        @points[graph_line]
+      end
+      
+      def y_value_max_for_all_lines
+        if @y_value_max_for_all_lines.nil?
+          all_y_values = lines.map { |line| line[:y_values] }.reduce(:+)
+          @y_value_max_for_all_lines = all_y_values.max.to_f
+        end
+        @y_value_max_for_all_lines
+      end
+      
+      def translate_points(graph_line, points)
+        max_job_count_before_translation = ((width / graph_point_distance_for_line(graph_line)).to_i + 1)
+        x_translation = [(points.size - max_job_count_before_translation) * graph_point_distance_for_line(graph_line), 0].max
+        if x_translation > 0
+          points.each do |point|
+            # need to check if point[:x] is present because if the user shrinks the window, we drop points
+            point[:x] = point[:x] - x_translation if point[:x]
+          end
+        end
+        points
+      end
+      
+      def max_visible_point_count(graph_line) = (width / graph_point_distance_for_line(graph_line)).to_i + 1
+
+      def periodic_lines
+        return unless lines && lines[0] && lines[0][:x_interval_in_seconds] && lines[0][:x_interval_in_seconds] == DAY_IN_SECONDS
+        day_count = lines[0][:y_values].size
+        case day_count
+        when ..7
+          @points[lines[0]].each do |point|
+            line(point[:x], graph_padding_height, point[:x], height - graph_padding_height) {
+              stroke graph_stroke_periodic_line
+            }
+            day = calculated_x_value(point[:index]).strftime("%e")
+            font_size = graph_font_marker_text[:size]
+            text(point[:x], height - graph_padding_height - font_size*1.4, font_size*2) {
+              string(day) {
+                font graph_font_marker_text
+                color graph_color_period_text
+              }
+            }
+          end
+        when ..30
+          @points[lines[0]].each_with_index do |point, index|
+            day_number = index + 1
+            if day_number % 7 == 0
+              line(point[:x], graph_padding_height, point[:x], height - graph_padding_height) {
+                stroke graph_stroke_periodic_line
+              }
+              date = calculated_x_value(point[:index]).strftime("%b %e")
+              font_size = graph_font_marker_text[:size]
+              text(point[:x] + 4, height - graph_padding_height - font_size*1.4, font_size*6) {
+                string(date) {
+                  font graph_font_marker_text
+                  color graph_color_period_text
+                }
+              }
+            end
+          end
+        else
+          @points[lines[0]].each do |point|
+            if calculated_x_value(point[:index]).strftime("%d") == "01"
+              line(point[:x], graph_padding_height, point[:x], height - graph_padding_height) {
+                stroke graph_stroke_periodic_line
+              }
+              date = calculated_x_value(point[:index]).strftime("%b")
+              font_size = graph_font_marker_text[:size]
+              text(point[:x] + 4, height - graph_padding_height - font_size*1.4, font_size*6) {
+                string(date) {
+                  font graph_font_marker_text
+                  color graph_color_period_text
+                }
+              }
+            end
+          end
+        end
+      end
+      
+      def hover_stats
+        return unless display_attributes_on_hover
+        
+        require "bigdecimal"
+        require "perfect_shape/point"
+        
+        if @hover_point && lines && lines[0] && @points && @points[lines[0]] && !@points[lines[0]].empty?
+          x = @hover_point[:x]
+          closest_points = lines.map { |line| @points[line][@closest_point_index] }
+          closest_x = closest_points[0]&.[](:x)
+          closest_x_distance = PerfectShape::Point.point_distance(x.to_f, 0, closest_x.to_f, 0)
+          # Today, we make the assumption that all lines have points along the same x-axis values
+          # TODO In the future, we can support different x values along different lines
+          if closest_x_distance < graph_point_distance_for_line(lines[0])
+            line(closest_x, graph_padding_height, closest_x, height - graph_padding_height) {
+              stroke graph_stroke_hover_line
+            }
+            closest_points.each_with_index do |closest_point, index|
+              circle(closest_point[:x], closest_point[:y], 4) {
+                fill lines[index][:stroke]
+              }
+              circle(closest_point[:x], closest_point[:y], 2) {
+                fill :white
+              }
+            end
+            text_label = formatted_x_value(@closest_point_index)
+            text_label_width = estimate_width_of_text(text_label, DEFAULT_GRAPH_FONT_MARKER_TEXT)
+            closest_point_texts = lines.map { |line| "#{line[:name]}: #{line[:y_values][@closest_point_index]}" }
+            closest_point_text_widths = closest_point_texts.map do |text|
+              estimate_width_of_text(text, graph_font_marker_text)
+            end
+            square_size = 12.0
+            square_to_label_padding = 10.0
+            label_padding = 10.0
+            text_label_x = width - graph_padding_width - text_label_width - label_padding -
+              (lines.size*(square_size + square_to_label_padding) + (lines.size - 1)*label_padding + closest_point_text_widths.sum)
+            text_label_y = height + graph_padding_height
+
+            text(text_label_x, text_label_y, text_label_width) {
+              string(text_label) {
+                font DEFAULT_GRAPH_FONT_MARKER_TEXT
+                color graph_color_marker_text
+              }
+            }
+
+            relative_x = text_label_x + text_label_width
+            lines.size.times do |index|
+              square_x = relative_x + label_padding
+
+              square(square_x, text_label_y + 2, square_size) {
+                fill lines[index][:stroke]
+              }
+
+              attribute_label_x = square_x + square_size + square_to_label_padding
+              attribute_text = closest_point_texts[index]
+              attribute_text_width = closest_point_text_widths[index]
+              relative_x = attribute_label_x + attribute_text_width
+
+              text(attribute_label_x, text_label_y, attribute_text_width) {
+                string(attribute_text) {
+                  font graph_font_marker_text
+                  color graph_color_marker_text
+                }
+              }
+            end
+          end
+        end
+      end
+      
+      def formatted_x_value(x_value_index)
+        # Today, we make the assumption that all lines have points along the same x-axis values
+        # TODO In the future, we can support different x values along different lines
+        graph_line = lines[0]
+        x_value_format = graph_line[:x_value_format] || :to_s
+        x_value = calculated_x_value(x_value_index)
+        if (x_value_format.is_a?(Symbol) || x_value_format.is_a?(String))
+          x_value.send(x_value_format)
+        else
+          x_value_format.call(x_value)
+        end
+      end
+      
+      def calculated_x_value(x_value_index)
+        # Today, we make the assumption that all lines have points along the same x-axis values
+        # TODO In the future, we can support different x values along different lines
+        graph_line = lines[0]
+        graph_line[:x_value_start] - (graph_line[:x_interval_in_seconds] * x_value_index)
+      end
+      
+      def estimate_width_of_text(text_string, font_properties)
+        font_size = font_properties[:size] || 16
+        estimated_font_width = 0.6 * font_size
+        text_string.chars.size * estimated_font_width
+      end
+      
+    end
+  end
+end

data/lib/glimmer-libui-cc-graphs_and_charts.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift(File.expand_path('..', __FILE__))
+
+require 'glimmer-dsl-libui'
+require 'glimmer/view/graphs_and_charts'

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: glimmer-libui-cc-graphs_and_charts
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andy Maleh
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-12-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: glimmer-dsl-libui
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+- !ruby/object:Gem::Dependency
+  name: juwelier
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.4.9
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.4.9
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Graphs And Charts - Glimmer DSL for LibUI Custom Controls
+email: andy.am@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- LICENSE.txt
+- README.md
+- VERSION
+- lib/glimmer-libui-cc-graphs_and_charts.rb
+- lib/glimmer/view/line_graph.rb
+homepage: http://github.com/AndyObtiva/glimmer-libui-cc-graphs_and_charts
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.6
+signing_key:
+specification_version: 4
+summary: Graphs And Charts - Glimmer DSL for LibUI Custom Controls
+test_files: []