its-showtime 0.1.1

data/lib/showtime/components/charts.rb

@@ -0,0 +1,119 @@
+require_relative "base"
+require "active_support"
+require "showtime/charts"
+
+module Showtime
+  module Components
+    class PlotlyChart < BaseComponent
+      attr_reader :spec, :help
+
+      def initialize(chart_type:, data:, encoding:, colorway: nil, layout: {}, config: {}, key: nil, help: nil)
+        super(key: key)
+        @help = help
+        @spec = build_spec(chart_type, data, encoding, colorway: colorway, layout: layout, config: config)
+      end
+
+      def validate
+        @errors ||= []
+      end
+
+      def to_h
+        super.merge({
+          spec: @spec,
+          help: @help,
+        })
+      end
+
+      private
+
+      def build_spec(chart_type, data, encoding, colorway:, layout:, config:)
+        Showtime::Charts.figure(
+          chart_type: chart_type,
+          data: data,
+          encoding: encoding,
+          colorway: colorway,
+          layout: layout,
+          config: config,
+        )
+      rescue Showtime::Charts::ValidationError => e
+        @errors = [e.message]
+        nil
+      end
+    end
+
+    class LineChart < PlotlyChart
+      def initialize(data, options = {}, key: nil, help: nil)
+        super(chart_type: :line, data: data, encoding: options, key: key, help: help)
+      end
+    end
+
+    class BarChart < PlotlyChart
+      def initialize(data, options = {}, key: nil, help: nil)
+        super(chart_type: :bar, data: data, encoding: options, key: key, help: help)
+      end
+    end
+
+    class ColumnChart < PlotlyChart
+      def initialize(data, options = {}, key: nil, help: nil)
+        super(chart_type: :column, data: data, encoding: options, key: key, help: help)
+      end
+    end
+
+    class AreaChart < PlotlyChart
+      def initialize(data, options = {}, key: nil, help: nil)
+        super(chart_type: :area, data: data, encoding: options, key: key, help: help)
+      end
+    end
+
+    class PieChart < PlotlyChart
+      def initialize(data, options = { label: :label, value: :value }, key: nil, help: nil)
+        enc = (options || {}).transform_keys(&:to_sym)
+        super(chart_type: :pie, data: data, encoding: { label: enc[:label] || "label", value: enc[:value] || "value" }, key: key, help: help)
+      end
+    end
+
+    class ScatterPlot < PlotlyChart
+      def initialize(data, options = {}, key: nil, help: nil)
+        super(chart_type: :scatter, data: data, encoding: options, key: key, help: help)
+      end
+    end
+  end
+
+  module St
+    def self.line_chart(data, options = {}, key: nil, help: nil)
+      component = Showtime::Components::LineChart.new(data, options, key: key, help: help)
+      Showtime::session.add_element(component)
+      component.spec
+    end
+
+    def self.bar_chart(data, options = {}, key: nil, help: nil)
+      component = Showtime::Components::BarChart.new(data, options, key: key, help: help)
+      Showtime::session.add_element(component)
+      component.spec
+    end
+
+    def self.column_chart(data, options = {}, key: nil, help: nil)
+      component = Showtime::Components::ColumnChart.new(data, options, key: key, help: help)
+      Showtime::session.add_element(component)
+      component.spec
+    end
+
+    def self.area_chart(data, options = {}, key: nil, help: nil)
+      component = Showtime::Components::AreaChart.new(data, options, key: key, help: help)
+      Showtime::session.add_element(component)
+      component.spec
+    end
+
+    def self.pie_chart(data, options = { label: :label, value: :value }, key: nil, help: nil)
+      component = Showtime::Components::PieChart.new(data, options, key: key, help: help)
+      Showtime::session.add_element(component)
+      component.spec
+    end
+
+    def self.scatter_plot(data, options = {}, key: nil, help: nil)
+      component = Showtime::Components::ScatterPlot.new(data, options, key: key, help: help)
+      Showtime::session.add_element(component)
+      component.spec
+    end
+  end
+end

data/lib/showtime/components/data.rb

@@ -0,0 +1,328 @@
+require_relative 'base'
+require 'logger'
+
+module Showtime
+  module Components
+    class Json < BaseComponent
+      attr_reader :data
+      
+      def initialize(data)
+        super()
+        @data = data
+      end
+      
+      def to_h
+        super.merge({
+          data: @data.is_a?(String) ? @data : JSON.pretty_generate(@data.as_json)
+        })
+      end
+    end
+    
+    class Table < BaseComponent
+      attr_reader :data, :page_size, :current_page
+      
+      def initialize(data, page_size: 10, current_page: 1, key: nil)
+        super(key: key)
+        @data = data
+        @page_size = page_size
+        @current_page = [current_page, 1].max  # Ensure current_page is at least 1
+        @logger = Showtime::Logger.logger
+        
+        # Calculate total pages
+        total_rows = @data.respond_to?(:height) ? @data.height : (@data.is_a?(Array) ? @data.length : 0)
+        total_pages = (total_rows.to_f / @page_size).ceil
+        total_pages = [total_pages, 1].max  # Ensure at least 1 page
+        
+        # Get pagination state from session with defaults
+        @current_page = St.get("#{@key}_page", @current_page)
+        @page_size = St.get("#{@key}_page_size", @page_size)
+        
+        # Validate and update current_page
+        @current_page = [@current_page, 1].max  # Ensure current_page is at least 1
+        @current_page = [@current_page, total_pages].min  # Ensure current_page doesn't exceed total pages
+        
+        # Update session with validated values
+        St.set("#{@key}_page", @current_page)
+        St.set("#{@key}_page_size", @page_size)
+      end
+      
+      def to_h
+        # Handle DataFrame-like objects that respond to columns and height
+        if @data.respond_to?(:columns) && @data.respond_to?(:height)
+          # Calculate pagination
+          total_rows = @data.height
+          total_pages = (total_rows.to_f / @page_size).ceil  # Calculate total pages
+          @current_page = [@current_page, total_pages].min  # Ensure current_page does not exceed total pages
+          start_idx = [(@current_page - 1) * @page_size, 0].max  # Ensure start_idx is not negative
+          end_idx = [start_idx + @page_size, total_rows].min
+          
+          # Get paginated data
+          length = [end_idx - start_idx, 0].max  # Ensure length is not negative
+          paginated_df = @data.slice(start_idx, length)
+          
+          # Convert to array of hashes
+          rows = []
+          columns = @data.columns
+          
+          # Try multiple methods to convert data to array of hashes
+          begin
+            if paginated_df.respond_to?(:to_h)
+              # Try using to_h method
+              df_hash = paginated_df.to_h
+              rows = []
+              paginated_df.height.times do |i|
+                row_hash = {}
+                columns.each do |col|
+                  row_hash[col] = df_hash[col][i]
+                end
+                rows << row_hash
+              end
+            elsif paginated_df.respond_to?(:rows)
+              # Try using rows method
+              paginated_df.rows.each do |row|
+                row_hash = {}
+                columns.each_with_index do |col, i|
+                  row_hash[col] = row[i]
+                end
+                rows << row_hash
+              end
+            elsif paginated_df.respond_to?(:to_a)
+              # Try using to_a method
+              array_data = paginated_df.to_a
+              array_data.each do |row|
+                row_hash = {}
+                columns.each_with_index do |col, i|
+                  row_hash[col] = row[i]
+                end
+                rows << row_hash
+              end
+            end
+          rescue => e
+            # If all else fails, return empty rows
+            rows = []
+          end
+          
+          super.merge({
+            data: {
+              columns: columns,
+              data: rows,
+              total_rows: total_rows,
+              current_page: @current_page,
+              page_size: @page_size
+            }
+          })
+        elsif @data.is_a?(Array) && @data.first.is_a?(Array)
+          # Handle array of arrays (matrix-like data)
+          total_rows = @data.length
+          total_pages = (total_rows.to_f / @page_size).ceil  # Calculate total pages
+          @current_page = [@current_page, total_pages].min  # Ensure current_page does not exceed total pages
+          start_idx = [(@current_page - 1) * @page_size, 0].max  # Ensure start_idx is not negative
+          end_idx = [start_idx + @page_size, total_rows].min
+          
+          paginated_data = @data[start_idx...end_idx]
+          columns = @data.first
+          data = paginated_data[1..-1] || []
+          
+          super.merge({
+            data: {
+              columns: columns,
+              data: data,
+              total_rows: total_rows,
+              current_page: @current_page,
+              page_size: @page_size
+            }
+          })
+        elsif @data.is_a?(Array) && @data.first.is_a?(Hash)
+          # Handle array of hashes
+          total_rows = @data.length
+          total_pages = (total_rows.to_f / @page_size).ceil  # Calculate total pages
+          @current_page = [@current_page, total_pages].min  # Ensure current_page does not exceed total pages
+          start_idx = [(@current_page - 1) * @page_size, 0].max  # Ensure start_idx is not negative
+          end_idx = [start_idx + @page_size, total_rows].min
+          
+          paginated_data = @data[start_idx...end_idx]
+          columns = @data.first.keys
+          
+          super.merge({
+            data: {
+              columns: columns,
+              data: paginated_data,
+              total_rows: total_rows,
+              current_page: @current_page,
+              page_size: @page_size
+            }
+          })
+        else
+          super.merge({
+            data: @data
+          })
+        end
+      end
+    end
+    
+    class DataFrame < BaseComponent
+      attr_reader :data, :page_size, :current_page
+      
+      def initialize(data, page_size: 10, current_page: 1, key: nil)
+        super(key: key)
+        @data = data
+        @page_size = page_size
+        @current_page = [current_page, 1].max  # Ensure current_page is at least 1
+        @logger = Showtime::Logger.logger
+        
+        # Calculate total pages
+        total_rows = @data.respond_to?(:height) ? @data.height : 0
+        total_pages = (total_rows.to_f / @page_size).ceil
+        total_pages = [total_pages, 1].max  # Ensure at least 1 page
+        
+        # Get pagination state from session with defaults
+        @current_page = St.get("#{@key}_page", @current_page)
+        @page_size = St.get("#{@key}_page_size", @page_size)
+        
+        # Validate and update current_page
+        @current_page = [@current_page, 1].max  # Ensure current_page is at least 1
+        @current_page = [@current_page, total_pages].min  # Ensure current_page doesn't exceed total pages
+        
+        # Update session with validated values
+        St.set("#{@key}_page", @current_page)
+        St.set("#{@key}_page_size", @page_size)
+      end
+      
+      def to_h
+        # Handle DataFrame-like objects that respond to columns and height
+        if @data.respond_to?(:columns) && @data.respond_to?(:height)
+          # Calculate pagination
+          total_rows = @data.height
+          total_pages = (total_rows.to_f / @page_size).ceil  # Calculate total pages
+          @current_page = [@current_page, total_pages].min  # Ensure current_page does not exceed total pages
+          start_idx = [(@current_page - 1) * @page_size, 0].max  # Ensure start_idx is not negative
+          end_idx = [start_idx + @page_size, total_rows].min
+          
+          # Get paginated data
+          length = [end_idx - start_idx, 0].max  # Ensure length is not negative
+          paginated_df = @data.slice(start_idx, length)
+          
+          # Convert to array of hashes
+          rows = []
+          columns = @data.columns
+          
+          # Try multiple methods to convert data to array of hashes
+          begin
+            if paginated_df.respond_to?(:to_h)
+              # Try using to_h method
+              df_hash = paginated_df.to_h
+              rows = []
+              paginated_df.height.times do |i|
+                row_hash = {}
+                columns.each do |col|
+                  row_hash[col] = df_hash[col][i]
+                end
+                rows << row_hash
+              end
+            elsif paginated_df.respond_to?(:rows)
+              # Try using rows method
+              paginated_df.rows.each do |row|
+                row_hash = {}
+                columns.each_with_index do |col, i|
+                  row_hash[col] = row[i]
+                end
+                rows << row_hash
+              end
+            elsif paginated_df.respond_to?(:to_a)
+              # Try using to_a method
+              array_data = paginated_df.to_a
+              array_data.each do |row|
+                row_hash = {}
+                columns.each_with_index do |col, i|
+                  row_hash[col] = row[i]
+                end
+                rows << row_hash
+              end
+            end
+          rescue => e
+            # If all else fails, return empty rows
+            rows = []
+          end
+          
+          super.merge({
+            data: {
+              columns: columns,
+              data: rows,
+              total_rows: total_rows,
+              current_page: @current_page,
+              page_size: @page_size,
+              height: @data.height,
+              width: @data.respond_to?(:width) ? @data.width : columns.length,
+              dtypes: @data.columns.map do |col|
+                begin
+                  [col, @data[col].dtype.to_s]
+                rescue
+                  [col, "unknown"]
+                end
+              end.to_h
+            }
+          })
+        elsif @data.is_a?(Array) && @data.first.is_a?(Array)
+          # Handle array of arrays (matrix-like data)
+          total_rows = @data.length
+          total_pages = (total_rows.to_f / @page_size).ceil  # Calculate total pages
+          @current_page = [@current_page, total_pages].min  # Ensure current_page does not exceed total pages
+          start_idx = [(@current_page - 1) * @page_size, 0].max  # Ensure start_idx is not negative
+          end_idx = [start_idx + @page_size, total_rows].min
+          
+          paginated_data = @data[start_idx...end_idx]
+          columns = @data.first
+          data = paginated_data[1..-1] || []
+          
+          super.merge({
+            data: {
+              columns: columns,
+              data: data,
+              total_rows: total_rows,
+              current_page: @current_page,
+              page_size: @page_size
+            }
+          })
+        elsif @data.is_a?(Array) && @data.first.is_a?(Hash)
+          # Handle array of hashes
+          total_rows = @data.length
+          total_pages = (total_rows.to_f / @page_size).ceil  # Calculate total pages
+          @current_page = [@current_page, total_pages].min  # Ensure current_page does not exceed total pages
+          start_idx = [(@current_page - 1) * @page_size, 0].max  # Ensure start_idx is not negative
+          end_idx = [start_idx + @page_size, total_rows].min
+          
+          paginated_data = @data[start_idx...end_idx]
+          columns = @data.first.keys
+          
+          super.merge({
+            data: {
+              columns: columns,
+              data: paginated_data,
+              total_rows: total_rows,
+              current_page: @current_page,
+              page_size: @page_size
+            }
+          })
+        else
+          super.merge({
+            data: @data
+          })
+        end
+      end
+    end
+  end
+
+  module St
+    def self.json(data)
+      Showtime::session.add_element(Showtime::Components::Json.new(data))
+    end
+    
+    def self.table(data, page_size: 10, current_page: 1, key: nil)
+      Showtime::session.add_element(Showtime::Components::Table.new(data, page_size: page_size, current_page: current_page, key: key))
+    end
+    
+    def self.dataframe(data, page_size: 10, current_page: 1, key: nil)
+      Showtime::session.add_element(Showtime::Components::DataFrame.new(data, page_size: page_size, current_page: current_page, key: key))
+    end
+  end
+end