its-showtime 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 17624f4f4049dda21e1a632de6eb5d26b0be8eff514a245e3376c80e3b99780a
+  data.tar.gz: f7d5e81323a64db1c34847f50786eb3fb757ee9ff05161a62ffa44503877aeb0
+SHA512:
+  metadata.gz: 8c094fd17bcd86de2c44955ae3c0965bf3c9d5d7847207d26bf20f87a8989ef408685fc018c79e2e5badc1b60bb3d8fbbe53d2aa2b058d68c71b60d76faab8a5
+  data.tar.gz: d26a3220bfdf20264b4ae1385faa8cfc2800a5dfe9a23f206150225dd4298f0174fa0052f0affad508c0476f015bfb8a032ea5f887abc00b9fd5030050dde0a2

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Showtime Team
+
+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,179 @@
+![showtime logo](/showtime.png)
+
+# Showtime
+
+Showtime is a Ruby framework for building interactive data visualization UIs, inspired by Python's Streamlit. It allows you to easily create web applications with just a few lines of Ruby code, without needing to know HTML, CSS, or JavaScript.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'its-showtime'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install its-showtime
+```
+
+## Features
+
+- Simple, intuitive API similar to Streamlit
+- Interactive components like buttons, sliders, and input fields
+- Support for displaying data frames via ruby-polars
+- Plotly-first charts with a Rails-friendly contract
+- Auto-reloading when code changes
+- Sidebar for organizing controls
+- No frontend experience required
+
+## Quick Start
+
+Create a file named `app.rb` with the following content:
+
+```ruby
+require 'showtime'
+
+# Display a title
+St.title("My First Showtime App")
+
+# Add a text input box
+name = St.text_input("What's your name?")
+
+# Use the input to personalize a greeting
+if name.empty?
+  St.write("Please enter your name")
+else
+  St.write("Hello, #{name}!")
+end
+
+# Create a button
+if St.button("Click me")
+  St.success("Button clicked!")
+end
+
+# Display a dataframe (if polars is installed)
+begin
+  require 'polars-df'
+  
+  df = Polars::DataFrame.new({
+    'Name' => ['John', 'Alice', 'Bob'],
+    'Age' => [28, 24, 32],
+    'City' => ['New York', 'Paris', 'London']
+  })
+  
+  St.dataframe(df)
+rescue LoadError
+  St.error("Polars not installed. Run 'gem install polars-df' to use dataframes.")
+end
+
+# Plotly-first charts (data frames, hashes, arrays, grouped counts all work)
+sales = [
+  { region: "North", quarter: "Q1", revenue: 10 },
+  { region: "South", quarter: "Q1", revenue: 5 },
+  { region: "North", quarter: "Q2", revenue: 12 },
+]
+
+St.bar_chart(
+  sales,
+  encoding: { x: :quarter, y: :revenue, series: :region, stack: true },
+  colorway: ["#2563eb", "#10b981"],
+  layout: { title: "Revenue by Quarter" },
+)
+
+# You can override axis/layout if needed (defaults are sensible)
+spec = St.bar_chart(
+  [{ ticker: "AAPL", volume: 100_000 }, { ticker: "AMZN", volume: 6_000 }],
+  { x: :volume, y: :ticker, layout: { xaxis: { type: "linear" }, yaxis: { type: "category" } } }
+)
+```
+
+Then run your app with:
+
+```bash
+$ showtime app.rb
+```
+
+Visit `http://localhost:8501` in your web browser to see your app in action.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/glmaljkovich/showtime.
+
+### Development Requirements
+
+For development, you'll need:
+- Ruby (see .ruby-version for specific version)
+- Node.js and pnpm (for frontend development)
+- Git
+
+### Development Setup
+
+1. Clone the repository
+```bash
+git clone https://github.com/glmaljkovich/showtime.git
+cd showtime
+```
+
+2. Install Ruby dependencies
+```bash
+bundle install
+```
+
+3. Install frontend dependencies
+```bash
+cd frontend
+pnpm install
+cd ..
+```
+
+### Frontend Development
+
+The frontend is built with React and Vite. The build process is automated, and compiled assets are generated during gem packaging.
+
+To modify the frontend:
+1. Make changes in the `/frontend` directory
+2. Test your changes with `rake build_frontend` (assets will be built to `lib/showtime/public/assets/`)
+3. Only commit your source changes - compiled assets are gitignored and will be built during gem packaging
+
+For development workflow:
+```bash
+# Start with clean assets
+rake clean_frontend
+
+# Install frontend dependencies (only needed once or when dependencies change)
+rake install_frontend
+
+# Build frontend assets for testing
+rake build_frontend
+
+# Or use build_dev to install dependencies and build in one step
+rake build_dev
+```
+
+The compiled assets in `lib/showtime/public/assets/` are automatically included in the gem package when building, so end users don't need Node.js installed.
+
+### Testing Changes
+
+To test your changes locally:
+
+```bash
+# Only needed for the first time or when react dependencies change
+rake install_frontend
+
+# Compile frontend assets and install gem and dependencies globally for testing
+rake build_cli
+```
+
+Note: `rake build_cli` installs dependencies in the global namespace, so don't use `bundle exec`.
+
+## License
+
+The gem is available as open source under the terms of the MIT License.

data/bin/showtime

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "showtime"
+require "optparse"
+
+options = {
+  port: 8501,
+  host: "localhost"
+}
+
+# Parse command line arguments
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: showtime [options] <script_file>"
+  
+  opts.on("-p", "--port PORT", Integer, "Port to run the server on (default: 8501)") do |p|
+    options[:port] = p
+  end
+  
+  opts.on("-h", "--host HOST", "Host to bind the server to (default: localhost)") do |h|
+    options[:host] = h
+  end
+  
+  opts.on("--help", "Prints this help") do
+    puts opts
+    exit
+  end
+end
+
+parser.parse!
+
+# Get the script file from command line arguments
+script_file = ARGV[0]
+
+if script_file.nil?
+  puts "Error: Script file is required"
+  puts parser
+  exit 1
+end
+
+unless File.exist?(script_file)
+  puts "Error: Script file '#{script_file}' does not exist"
+  exit 1
+end
+
+# Run the showtime application
+Showtime.run(script_file, port: options[:port], host: options[:host]) 

data/lib/showtime/app.rb

@@ -0,0 +1,399 @@
+require 'rack/handler/puma'
+require 'puma'
+require 'rack'
+require 'sinatra/base'
+require 'sinatra/json'
+require 'sinatra/reloader'
+require 'securerandom'
+require 'json'
+require 'logger'
+require 'faye/websocket'
+require 'listen'
+require 'tmpdir'
+require 'pastel'
+require_relative 'helpers'
+require_relative 'session' # Assuming session.rb contains Showtime::Session and Showtime::BaseSession
+require_relative 'logger'  # Assuming logger.rb defines Showtime::Logger
+
+# Forward declare ScriptContext if it's not in a separate file yet or defined globally
+module Showtime
+  class ScriptContext
+  end
+end
+
+module Showtime
+  class App < Sinatra::Base
+    helpers Showtime::Helpers
+    # Assuming vite_ruby is available in the Rails context,
+    # otherwise, Vite::Helpers might need to be conditionally included or handled differently.
+    # For now, let's assume it's handled by the host Rails app.
+    helpers Vite::Helpers
+
+    attr_reader :script_path, :options, :color, :websocket_connections, :client_sessions, :client_last_seen, :main_session, :file_watcher, :cleanup_thread, :cleanup_mutex
+
+    # Session timeout in seconds (5 minutes)
+    SESSION_TIMEOUT = 300
+    # Cleanup interval in seconds (1 minute)
+    CLEANUP_INTERVAL = 60
+
+    # Configure Sinatra settings at the class level
+    set :public_folder, File.expand_path(File.join(File.dirname(__FILE__), 'public'))
+    set :views, File.expand_path(File.join(File.dirname(__FILE__), 'views'))
+    set :sessions, key: 'showtime_app_session', secret: ENV.fetch('SESSION_SECRET_SHOWTIME_APP') { SecureRandom.hex(64) }
+
+    # Development-specific settings
+    if ENV['RACK_ENV'] == 'development'
+      register Sinatra::Reloader if defined?(Sinatra::Reloader)
+      # Reloader might need specific configuration for script_path
+      # settings.also_reload @script_path # @script_path is an instance variable, cannot be used here directly
+    end
+
+    def initialize(app = nil, script_path:, **options)
+      super(app) # Call Sinatra::Base's initialize
+      @script_path = File.expand_path(script_path)
+      @options = options
+      @color = Pastel.new
+
+      Showtime::Logger.info("Initializing Showtime::App for script: #{@color.cyan(@script_path)}")
+
+      # Instance-specific state
+      @websocket_connections = {}
+      @client_sessions = {}
+      @client_last_seen = {}
+      @main_session = nil
+      @file_watcher = nil
+      @cleanup_thread = nil
+      @cleanup_mutex = Mutex.new
+
+      # Initialize the main session for this script instance
+      @main_session = Showtime::BaseSession.new
+      @main_session.main_script_path = @script_path
+
+      # Load the script, start file watcher, and cleanup thread for this instance
+      load_script(@main_session)
+      @main_session.component_registry.clear_dirty
+
+      start_file_watcher(@script_path)
+      start_cleanup_thread
+    end
+
+    # --- Sinatra Routes (adapted from Showtime::Server) ---
+    get '/' do
+      # `request.script_name` will hold the base path where this app is mounted.
+      # This is crucial for `index.erb` to set `window.SHOWTIME_BASE_PATH`.
+      erb :index
+    end
+
+    get '/ws' do
+      if Faye::WebSocket.websocket?(request.env)
+        query_string = request.env['QUERY_STRING']
+        query_params = Rack::Utils.parse_query(query_string)
+        client_id = query_params['client_id']
+
+        connection_session_id = SecureRandom.uuid # Unique ID for this specific WS connection
+
+        ws = Faye::WebSocket.new(request.env, nil, {
+          ping: 30,
+          max_length: 10 * 1024 * 1024
+        })
+
+        connection_session_object = nil
+
+        @client_last_seen[client_id] = Time.now if client_id
+
+        if client_id && @client_sessions.key?(client_id)
+          Showtime::Logger.debug("Reusing existing session for client [#{client_id}] in app for #{@script_path}")
+          connection_session_object = @client_sessions[client_id]
+        else
+          client_id_to_use = client_id || SecureRandom.uuid
+          Showtime::Logger.debug("Creating new session for client [#{client_id_to_use}] in app for #{@script_path}")
+          connection_session_object = create_session_for_connection
+          @client_sessions[client_id_to_use] = connection_session_object
+          @client_last_seen[client_id_to_use] = Time.now
+          client_id = client_id_to_use # Ensure client_id is set if it was nil
+        end
+
+        @websocket_connections[connection_session_id] = {
+          ws: ws,
+          session: connection_session_object,
+          client_id: client_id
+        }
+
+        ws.on :open do |event|
+          Showtime::Logger.debug("WebSocket connection opened [#{connection_session_id}] for client [#{client_id}] in app for #{@script_path}")
+          response = Showtime.with_session(connection_session_object) do
+            JSON.parse(connection_session_object.to_json)
+          end
+          response['client_id'] = client_id
+          ws.send(response.to_json)
+        end
+
+        ws.on :ping do |event|
+          Showtime::Logger.debug("Received ping from client [#{client_id}] in app for #{@script_path}")
+          @client_last_seen[client_id] = Time.now if client_id # Update for this specific client_id
+        end
+
+        ws.on :message do |event|
+          begin
+            message_start_time = Time.now
+            data = JSON.parse(event.data)
+            key = data['key']
+            value = data['value']
+
+            Showtime::Logger.info("Received WebSocket message: key=#{@color.bright_yellow(key)}, value=#{@color.bright_yellow(value)} for script #{@script_path}")
+
+            current_client_id = @websocket_connections[connection_session_id][:client_id]
+            @client_last_seen[current_client_id] = Time.now if current_client_id
+
+            session_for_message = @websocket_connections[connection_session_id][:session]
+            handle_component_update(session_for_message, key, value)
+
+            Showtime.with_session(session_for_message) do
+              ws.send(session_for_message.to_json)
+            end
+
+            message_time = ((Time.now - message_start_time) * 1000).round(2)
+            Showtime::Logger.debug("Message processed in #{message_time}ms for script #{@script_path}")
+          rescue => e
+            Showtime::Logger.error("Error handling WebSocket message for script #{@script_path}: #{e.message}")
+            Showtime::Logger.error(e.backtrace.join("\n"))
+          end
+        end
+
+        ws.on :close do |event|
+          Showtime::Logger.debug("WebSocket connection closed [#{connection_session_id}] for client [#{client_id}] in app for #{@script_path}")
+          @websocket_connections.delete(connection_session_id)
+        end
+
+        ws.rack_response
+      else
+        # Handle non-WebSocket requests to /ws if necessary, or let them 404
+        status 400
+        body "This endpoint is for WebSocket connections only."
+      end
+    end
+
+    post '/api/upload' do
+      # Ensure this uses instance-specific logic if needed, though file uploads might be generic
+      # `request.script_name` can be used to build URLs if files are served relative to the mount path.
+      begin
+        upload_dir = File.join(Dir.tmpdir, "showtime-uploads-#{script_path.gsub(/[^0-9a-zA-Z]/, '')}") # Instance specific tmp dir
+        FileUtils.mkdir_p(upload_dir)
+
+        file = params[:file][:tempfile]
+        filename = params[:file][:filename]
+
+        unique_filename = "#{SecureRandom.uuid}-#{filename}"
+        file_path = File.join(upload_dir, unique_filename)
+
+        FileUtils.cp(file.path, file_path)
+
+        content_type :json
+        {
+          status: 'success',
+          file: {
+            name: filename,
+            path: file_path, # This path is server-local. Client might need a relative URL.
+            size: File.size(file_path),
+            type: params[:file][:type] || 'application/octet-stream'
+          }
+        }.to_json
+      rescue => e
+        status 500
+        content_type :json
+        { status: 'error', message: e.message }.to_json
+      end
+    end
+
+    get '/api/ping' do
+      content_type :json
+      { status: 'ok', timestamp: Time.now.to_i, script_path: script_path }.to_json
+    end
+
+    not_found do
+      content_type :json
+      { error: 'Not found in Showtime::App', script_path: script_path }.to_json
+    end
+
+    error do
+      content_type :json
+      { error: env['sinatra.error'].message, script_path: script_path }.to_json
+    end
+
+    # --- Instance Methods (adapted from Showtime::Server static methods) ---
+    def load_script(session, preserve_values = false)
+      session.set_script_error(nil)
+      start_time = Time.now
+      context = ScriptContext.new # Or Showtime::ScriptContext.new
+
+      begin
+        # Ensure @script_path is used
+        script_content = File.read(@script_path)
+        if preserve_values
+          session.clear_elements
+          Showtime.with_session(session) do
+            session.reset_counters
+            context.instance_eval(script_content, @script_path) # Pass @script_path for error reporting
+          end
+        else
+          session.clear
+          Showtime.with_session(session) do
+            context.instance_eval(script_content, @script_path)
+          end
+        end
+      rescue => e
+        Showtime::Logger.error("Error executing script #{@script_path}: #{e.message}")
+        Showtime::Logger.error(e.backtrace.join("\n"))
+        session.set_script_error({ message: e.message, backtrace: e.backtrace, script_path: @script_path })
+      end
+
+      execution_time = ((Time.now - start_time) * 1000).round(2)
+      Showtime::Logger.info("⏱️  Script #{@script_path} execution completed in #{@color.magenta(execution_time)}ms")
+    end
+
+    def handle_component_update(session, key, value)
+      session.update_value(key, value)
+
+      if key.to_s.start_with?('button_')
+        load_script(session, true)
+        session.component_registry.clear_dirty
+        session.update_value(key, false)
+      else
+        load_script(session, true)
+        session.component_registry.clear_dirty
+      end
+    end
+
+    def create_session_for_connection
+      session = Showtime::BaseSession.new # Use BaseSession for new connections
+      session.main_script_path = @script_path
+      load_script(session)
+      session.component_registry.clear_dirty # Ensure clean state after initial load
+      return session
+    end
+
+    def start_file_watcher(script_path_to_watch)
+      return if @file_watcher # Already started for this instance
+
+      script_dir = File.dirname(script_path_to_watch)
+      script_filename = File.basename(script_path_to_watch)
+
+      Showtime::Logger.info("Starting file watcher for #{@color.cyan(script_path_to_watch)} (instance)")
+
+      @file_watcher = Listen.to(script_dir, force_polling: true, latency: 0.5) do |modified, added, removed|
+        if modified.any? { |f| File.basename(f) == script_filename && File.expand_path(f) == script_path_to_watch }
+          Showtime::Logger.info("🔄 Script file changed, reloading: #{@color.yellow(script_path_to_watch)} (instance)")
+
+          @cleanup_mutex.synchronize do
+            @client_sessions.each do |client_id, session|
+              load_script(session, true)
+              session.component_registry.clear_dirty
+            end
+
+            load_script(@main_session, true) if @main_session
+            @main_session.component_registry.clear_dirty if @main_session
+
+            @websocket_connections.each do |conn_id, connection|
+              begin
+                Showtime::Logger.debug("Sending updated state to client [#{connection[:client_id]}]")
+                Showtime.with_session(connection[:session]) do
+                  connection[:ws].send(connection[:session].to_json)
+                end
+              rescue => e
+                Showtime::Logger.error("Error sending update to client for #{@script_path}: #{e.message}")
+              end
+            end
+          end
+        end
+      end
+      @file_watcher.start
+      Showtime::Logger.info("🔍 File watcher started successfully for #{@script_path}")
+    end
+
+    def start_cleanup_thread
+      return if @cleanup_thread && @cleanup_thread.alive?
+
+      @cleanup_thread = Thread.new do
+        begin
+          loop do
+            sleep CLEANUP_INTERVAL
+            @cleanup_mutex.synchronize do
+              cleanup_stale_sessions
+            end
+          end
+        rescue => e
+          Showtime::Logger.error("Error in cleanup thread for #{@script_path}: #{e.message}")
+          Showtime::Logger.error(e.backtrace.join("\n"))
+          # Consider whether to retry or let the thread die for instance-specific cleanup
+        end
+      end
+    end
+
+    def cleanup_stale_sessions
+      current_time = Time.now
+      stale_count = 0
+
+      stale_clients = @client_last_seen.select do |client_id, last_seen|
+        (current_time - last_seen) > SESSION_TIMEOUT
+      end
+
+      stale_clients.each do |client_id, _|
+        has_active_connection = @websocket_connections.values.any? { |conn| conn[:client_id] == client_id }
+
+        unless has_active_connection
+          Showtime::Logger.debug("Cleaning up abandoned session for client [#{client_id}] in app for #{@script_path}")
+          @client_sessions.delete(client_id)
+          @client_last_seen.delete(client_id)
+          stale_count += 1
+        end
+      end
+
+      active_conn_count = @websocket_connections.size
+      session_count = @client_sessions.size
+      Showtime::Logger.debug("Session stats for #{@script_path}: #{@color.magenta(active_conn_count)} active, #{@color.magenta(session_count)} sessions, #{@color.magenta(stale_count)} cleaned")
+    end
+
+    # This method might be called when the Rails server shuts down,
+    # or when an instance of Showtime::App is explicitly stopped.
+    def shutdown
+      Showtime::Logger.info("Shutting down Showtime::App for script: #{@color.cyan(@script_path)}")
+      @file_watcher&.stop
+      @cleanup_thread&.kill # Or a more graceful shutdown signal
+      @websocket_connections.each_value do |conn|
+        conn[:ws].close if conn[:ws] && conn[:ws].respond_to?(:close)
+      end
+      Showtime::Logger.info("Showtime::App for script #{@color.cyan(@script_path)} shut down.")
+    end
+
+    def self.start(script_path, port: 8501, host: 'localhost')
+      app_instance = new(script_path: script_path)
+
+      print_banner(host, port)
+
+      Rack::Handler::Puma.run(
+        app_instance,
+        Port: port,
+        Host: host,
+        Silent: true
+      )
+    end
+
+    def self.print_banner(host, port)
+      logo = <<~LOGO
+\n
+  ______ _                       _
+ / _____) |                  _  (_)
+( (____ | |__   ___  _ _ _ _| |_ _ ____  _____
+ \\____ \\|  _ \\ / _ \\| | | (_   _) |    \\| ___ |
+ _____) ) | | | |_| | | | | | |_| | | | | ____|
+(______/|_| |_|\\___/ \\___/   \\__)_|_|_|_|_____)
+LOGO
+
+      Showtime::Logger.info(Pastel.new.red(logo))
+      Showtime::Logger.info("#{Pastel.new.bold('Showtime')} is running at #{Pastel.new.bright_blue("http://#{host}:#{port}")}\n")
+    end
+
+
+
+  end
+end