its-showtime 0.1.1

data/lib/showtime/release.rb

@@ -0,0 +1,108 @@
+module Showtime
+  module Release
+    VERSION_REGEX = /\A\d+\.\d+\.\d+\z/
+    RELEASE_BRANCH_REGEX = /\Arelease\/\d+\.\d+\.(x|\d+)\z/
+    TAG_REGEX = /\Av\d+\.\d+\.\d+\z/
+    DATE_REGEX = /\A\d{4}-\d{2}-\d{2}\z/
+
+    def self.current_version(version_path: default_version_path)
+      contents = File.read(version_path)
+      match = contents.match(/VERSION\s*=\s*"([^"]+)"/)
+      raise ArgumentError, "VERSION not found in #{version_path}" unless match
+
+      match[1]
+    end
+
+    def self.valid_release_branch?(branch_name)
+      !!(branch_name =~ RELEASE_BRANCH_REGEX)
+    end
+
+    def self.valid_tag_for_version?(tag, version)
+      tag == "v#{version}"
+    end
+
+    def self.valid_version?(version)
+      !!(version =~ VERSION_REGEX)
+    end
+
+    def self.ensure_version_bumped!(previous_version:, new_version:)
+      if compare_versions(new_version, previous_version) <= 0
+        raise ArgumentError, "Version must be greater than #{previous_version}"
+      end
+
+      true
+    end
+
+    def self.bump_version!(level, version_path: default_version_path)
+      version = current_version(version_path: version_path)
+      new_version = bump_version_string(version, level)
+
+      contents = File.read(version_path)
+      updated = contents.sub(/VERSION\s*=\s*"[^"]+"/, "VERSION = \"#{new_version}\"")
+      File.write(version_path, updated)
+
+      new_version
+    end
+
+    def self.update_changelog!(version:, changes:, release_date:, changelog_path: "CHANGELOG.md")
+      raise ArgumentError, "Invalid version #{version}" unless version =~ VERSION_REGEX
+      raise ArgumentError, "Release date must be YYYY-MM-DD" unless release_date =~ DATE_REGEX
+      raise ArgumentError, "Changelog not found at #{changelog_path}" unless File.exist?(changelog_path)
+
+      content = File.read(changelog_path)
+      marker = "## [Unreleased]"
+      index = content.index(marker)
+      raise ArgumentError, "Missing [Unreleased] section in #{changelog_path}" unless index
+
+      changes_text = changes.to_s.strip
+      changes_text = "#{changes_text}\n" unless changes_text.end_with?("\n")
+      release_section = "\n\n## [#{version}] - #{release_date}\n#{changes_text}"
+      updated = content.insert(index + marker.length, release_section)
+      File.write(changelog_path, updated)
+
+      updated
+    end
+
+    def self.compare_versions(a, b)
+      a_parts = parse_version(a)
+      b_parts = parse_version(b)
+      a_parts.zip(b_parts).each do |left, right|
+        return left <=> right if left != right
+      end
+      0
+    end
+
+    def self.parse_version(version)
+      raise ArgumentError, "Invalid version #{version}" unless version =~ VERSION_REGEX
+
+      version.split(".").map(&:to_i)
+    end
+    private_class_method :parse_version
+
+    def self.bump_version_string(version, level)
+      major, minor, patch = parse_version(version)
+
+      case level.to_s
+      when "patch"
+        patch += 1
+      when "minor"
+        minor += 1
+        patch = 0
+      when "major"
+        major += 1
+        minor = 0
+        patch = 0
+      else
+        raise ArgumentError, "Unknown bump level #{level}"
+      end
+
+      [major, minor, patch].join(".")
+    end
+    private_class_method :bump_version_string
+
+    def self.default_version_path
+      File.expand_path("version.rb", __dir__)
+    end
+    private_class_method :default_version_path
+  end
+end

data/lib/showtime/session.rb

@@ -0,0 +1,131 @@
+require 'json'
+require 'securerandom'
+require 'set'
+require 'showtime/component_registry'
+require 'polars-df'
+
+module Showtime
+  # Base session class without Singleton
+  class BaseSession
+    attr_reader :elements, :sidebar_elements, :values, :script_error
+    attr_accessor :main_script_path # Added main_script_path
+    
+    def initialize
+      @script_error = nil
+      @main_script_path = nil # Initialize main_script_path
+      clear
+      reset_counters # Initialize counters
+      @component_registry = ComponentRegistry.new
+    end
+
+    attr_reader :component_registry
+    
+    def clear
+      @elements = []
+      @sidebar_elements = []
+      @values = {}
+      @current_container = :main
+      @container_stack = []
+      @script_error = nil
+      reset_counters # Also reset counters on full clear
+    end
+
+    def reset_counters
+      @component_counters = Hash.new(0) # Default new component types to counter 0
+    end
+
+    def next_counter_for(component_type)
+      @component_counters[component_type.to_s] += 1
+      @component_counters[component_type.to_s]
+    end
+    
+    def clear_elements
+      @elements = []
+      @sidebar_elements = []
+    end
+    
+    def clear_values
+      @values = {}
+    end
+    
+    def add_element(element)
+      if @current_container == :sidebar
+        @sidebar_elements << element
+      elsif @container_stack.empty?
+        @elements << element
+      else
+        # Add to the current container's children
+        @container_stack.last.children << element
+      end
+      element
+    end
+    
+    def with_container(container)
+      old_container = @current_container
+      old_stack = @container_stack.dup
+      
+      # Push the container onto the stack
+      @container_stack.push(container)
+      
+      yield
+      
+      # Restore the previous state
+      @container_stack = old_stack
+      @current_container = old_container
+    end
+    
+    def update_value(key, value)
+      old_value = @values[key]
+      
+      # Skip equality comparison for DataFrame objects since they may have different schemas
+      unless value.is_a?(Polars::DataFrame) && old_value.is_a?(Polars::DataFrame)
+        return value if old_value == value
+      end
+      
+      @values[key] = value
+      @component_registry.mark_dirty(key)
+      value
+    end
+    
+    def has_value?(key)
+      @values.has_key?(key)
+    end
+
+    def in_sidebar?
+      @current_container == :sidebar
+    end
+    
+    def get_value(key, default = nil)
+      if @values.has_key?(key)
+        @values[key]
+      else
+        default
+      end
+    end
+
+    def set_script_error(error)
+      @script_error = error
+    end
+    
+    def with_sidebar
+      old_container = @current_container
+      @current_container = :sidebar
+      yield
+      @current_container = old_container
+    end
+    
+    def to_json
+      {
+        elements: @elements.map(&:to_h),
+        sidebar_elements: @sidebar_elements.map(&:to_h),
+        values: @values,
+        script_error: @script_error
+      }.to_json
+    end
+  end
+
+  # Named session class for compatibility with prior references.
+  class Session < BaseSession
+    # No need to redefine methods, they're inherited from BaseSession.
+  end
+end

data/lib/showtime/version.rb

@@ -0,0 +1,3 @@
+module Showtime
+  VERSION = "0.1.1"
+end 

data/lib/showtime/views/index.erb

@@ -0,0 +1,32 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Showtime</title>
+  <link rel="icon" type="image/svg+xml" href="<%= (request&.script_name&.to_s + '/letter.png').squeeze('/') %>" />
+  
+  <link rel="preconnect" href="https://fonts.googleapis.com">
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+  <link href="https://fonts.googleapis.com/css2?family=Montserrat:ital,wght@0,100..900;1,100..900&display=swap" rel="stylesheet">
+
+  <script>
+    window.SHOWTIME_BASE_PATH = "<%= request&.script_name %>";
+  </script>
+  
+  <!-- Vite generated assets -->
+  <% entry = vite_manifest_entry('index') %>
+  <% if entry["css"] %>
+    <% entry["css"].each do |css_file| %>
+      <link rel="stylesheet" href="<%= (request&.script_name&.to_s + '/' + css_file).squeeze('/') %>">
+    <% end %>
+  <% end %>
+</head>
+<body>
+  <div id="root"></div>
+  <script type="module" src="<%= vite_asset_path('react') %>"></script>
+  <script type="module" src="<%= vite_asset_path('antd') %>"></script>
+  <script type="module" src="<%= vite_asset_path('charts') %>"></script>
+  <script type="module" src="<%= vite_asset_path('index') %>"></script>
+</body>
+</html>

data/lib/showtime.rb

@@ -0,0 +1,157 @@
+require 'active_support/all'
+
+require "showtime/version"
+require "showtime/logger"
+require "showtime/app"
+require "showtime/components"
+require "showtime/charts"
+require "showtime/session"
+require "showtime/helpers"
+require "showtime/compute_tracker"
+require "showtime/release"
+require "pastel"
+
+module Showtime
+  class Error < StandardError; end
+
+  # Configure the framework
+  def self.configure
+    yield(config) if block_given?
+    Logger.configure
+  end
+
+  def self.config
+    @config ||= {
+      logger: {}
+    }
+  end
+
+  # Add session context management
+  def self.with_session(session)
+    old_session = Thread.current[:showtime_session]
+    Thread.current[:showtime_session] = session
+    yield
+  ensure
+    Thread.current[:showtime_session] = old_session
+  end
+
+  def self.current_session
+    session = Thread.current[:showtime_session]
+    return session if session
+
+    raise Error, "No current session. Use Showtime.with_session or run via Showtime::App."
+  end
+  
+  # Global state accessor methods
+  def self.session
+    Showtime.current_session
+  end
+  
+  # Main entry point for the framework
+  def self.run(file_path = nil, port: 8501, host: "localhost")
+    # Initialize logger if not already configured
+    Logger.configure unless Logger.logger
+
+    # Get the calling script path if not provided
+    file_path ||= caller_locations.first&.path
+
+    # If we're already running (i.e. being called from within a script), just return
+    return if @server_started
+
+    # Try to find the script file
+    search_paths = []
+    
+    if file_path
+      # If file_path is provided, try it directly and with pwd
+      search_paths << file_path
+      search_paths << File.expand_path(file_path)
+      search_paths << File.join(Dir.pwd, file_path)
+    else
+      # If no file_path, try to get it from caller_locations
+      caller_path = caller_locations.first&.path
+      if caller_path && caller_path != "(eval)"
+        search_paths << caller_path
+        search_paths << File.expand_path(caller_path)
+      end
+    end
+    
+    search_paths.compact!
+    search_paths.uniq!
+    
+    script_path = search_paths.find { |path| File.exist?(path) }
+    
+    if script_path.nil?
+      raise Error, "Script file not found. Searched in:\n#{search_paths.join("\n")}"
+    end
+
+    @server_started = true
+    App.start(script_path, port: port, host: host)
+  end
+  
+  # The main module for streamlit-like API
+  module St
+    @@color = Pastel.new
+    # Get a value from the cache, recomputing only if dependencies changed
+    def self.compute(key, &block)
+      session = Showtime.session
+      registry = session.component_registry
+      
+      # If a cached value exists and the component (key) is NOT in the dirty set,
+      # we can use the cached value. ComponentRegistry#mark_dirty handles propagation.
+      if session.has_value?(key) && !registry.dirty_components.include?(key)
+        Showtime::Logger.debug("Cache hit for key: #{@@color.bright_yellow(key)} (is present and not marked dirty).")
+        return session.get_value(key)
+      end
+      
+      # Log reason for recomputation if we reach here.
+      if !session.has_value?(key)
+        Showtime::Logger.debug("Cache miss for key: #{@@color.bright_yellow(key)}. Recomputing.")
+      else # Implies session.has_value?(key) is true AND registry.dirty_components.include?(key) is true
+        Showtime::Logger.debug("Key #{@@color.bright_yellow(key)} is marked dirty. Recomputing.")
+      end
+      
+      tracker = ComputeTracker.new do
+        result = block.call
+        session.update_value(key, result) # Store/update the computed value
+        result
+      end
+      
+      registry.register_dependencies(key, tracker.accessed_keys)
+      
+      tracker.result
+    end
+    
+    def self.get(key, default = nil, &block)
+      session = Showtime.session
+      
+      # Track this access for dependency tracking
+      Thread.current[:compute_tracker]&.accessed_keys&.add(key)
+      
+      # Return cached value if available
+      if session.has_value?(key)
+        Showtime::Logger.debug("Cache hit for key: #{@@color.bright_yellow(key)}")
+        return session.get_value(key, default) 
+      end
+      
+      # If block given, compute and cache
+      return compute(key, &block) if block_given?
+      
+      default
+    end
+
+    def self.set(key, value)
+      Showtime.session.update_value(key, value)
+    end
+
+    def self.clear_session
+      Showtime.session.clear_values
+    end
+
+    def self.path(relative_path)
+      Showtime::Helpers.absolute_path(relative_path)
+    end
+  end
+end
+
+# Make the St module accessible globally
+St = Showtime::St