labimotion 2.0.0 → 2.1.0.rc11

data/lib/labimotion/libs/xlsx_exporter.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+require 'caxlsx'
+
+module Labimotion
+  ## XlsxExporter
+  # A common utility class for exporting data to Excel (.xlsx) format using the caxlsx gem
+  #
+  # Usage Example:
+  #   exporter = Labimotion::XlsxExporter.new('MyReport')
+  #   exporter.add_worksheet('Sheet1') do |sheet|
+  #     sheet.add_header(['Name', 'Age', 'Email'])
+  #     sheet.add_row(['Jane Smith', 25, 'jane@example.com'])
+  #   end
+  #   exporter.save_to_file('output.xlsx')
+  #   # or get the stream: exporter.to_stream
+  class XlsxExporter
+    attr_reader :package, :workbook
+
+    # Initialize a new XlsxExporter
+    # @param filename [String] optional filename (without extension)
+    def initialize(filename = nil)
+      @filename = filename
+      @package = Axlsx::Package.new
+      @workbook = @package.workbook
+      @workbook.styles.fonts.first.name = 'Calibri'
+      @current_sheet = nil
+    end
+
+    # Add a new worksheet to the workbook
+    # @param sheet_name [String] name of the worksheet
+    # @param options [Hash] additional options for the worksheet
+    # @yield [sheet] gives the SheetBuilder to the block
+    # @return [SheetBuilder] the created sheet builder
+    def add_worksheet(sheet_name, _options = {}, &block)
+      sheet = SheetBuilder.new(@workbook.add_worksheet(name: sheet_name), @workbook)
+      sheet.instance_eval(&block) if block_given?
+      sheet
+    end
+
+    # Get the Excel file as a stream
+    # @return [String] the Excel file stream
+    def to_stream
+      @package.to_stream
+    end
+
+    # Read the Excel file content
+    # @return [String] the Excel file binary content
+    def read
+      @package.to_stream.read
+    end
+
+    # Save the Excel file to disk
+    # @param filepath [String] path where to save the file
+    # @return [Boolean] true if saved successfully
+    def save_to_file(filepath)
+      @package.serialize(filepath)
+      true
+    rescue StandardError => e
+      Labimotion.log_exception(e)
+      false
+    end
+
+    # Get suggested filename with .xlsx extension
+    # @return [String] filename with extension
+    def filename
+      name = @filename || "export_#{Time.now.strftime('%Y%m%d_%H%M%S')}"
+      "#{name}.xlsx"
+    end
+
+    ## SheetBuilder
+    # Helper class to build worksheet content with convenient methods
+    class SheetBuilder
+      attr_reader :sheet, :workbook, :styles
+
+      def initialize(sheet, workbook)
+        @sheet = sheet
+        @workbook = workbook
+        @styles = StyleManager.new(workbook)
+        @current_row = 0
+      end
+
+      # Add a header row with bold styling
+      # @param data [Array] array of header values
+      # @param options [Hash] style options (color, bg_color, bold, etc.)
+      # @return [Integer] row index
+      def add_header(data, options = {})
+        style_options = {
+          bold: true,
+          fg_color: '000000', # Black text
+          bg_color: 'DDDDDD',
+          border: { style: :thin, color: '000000' }
+        }.merge(options)
+
+        style = @styles.create_style(style_options)
+        add_row(data, style: style)
+      end
+
+      # Add a data row
+      # @param data [Array] array of cell values
+      # @param options [Hash] options including :style, :height, :types
+      # @return [Integer] row index
+      def add_row(data, options = {})
+        row_options = {}
+        row_options[:style] = options[:style] if options[:style]
+        row_options[:height] = options[:height] if options[:height]
+        row_options[:types] = options[:types] if options[:types]
+
+        @sheet.add_row(data, row_options)
+        @current_row += 1
+        @current_row - 1
+      end
+
+      # Add multiple rows at once
+      # @param rows [Array<Array>] array of row data
+      # @param options [Hash] options for all rows
+      # @return [Integer] number of rows added
+      def add_rows(rows, options = {})
+        rows.each { |row| add_row(row, options) }
+        rows.length
+      end
+
+      # Add an empty row (for spacing)
+      # @return [Integer] row index
+      def add_blank_row
+        add_row([])
+      end
+
+      # Set column widths
+      # @param widths [Array<Numeric>] array of column widths
+      def set_column_widths(*widths)
+        @sheet.column_widths(*widths)
+      end
+
+      # Auto-fit column widths based on content
+      # @param columns [Array<Integer>] column indices to auto-fit (nil for all)
+      def auto_fit_columns(columns = nil)
+        cols = columns || (0...(@sheet.rows.first&.cells&.length || 0)).to_a
+        cols.each do |col_index|
+          max_width = @sheet.rows.map { |row| row.cells[col_index]&.value.to_s.length || 0 }.max
+          @sheet.column_info[col_index].width = [max_width + 2, 100].min if max_width
+        end
+      end
+
+      # Merge cells in a range
+      # @param start_cell [String] starting cell (e.g., 'A1')
+      # @param end_cell [String] ending cell (e.g., 'C1')
+      def merge_cells(start_cell, end_cell)
+        @sheet.merge_cells("#{start_cell}:#{end_cell}")
+      end
+
+      # Add a titled section (title + data rows)
+      # @param title [String] section title
+      # @param data [Array<Array>] data rows
+      # @param options [Hash] options for the section
+      def add_section(title, data, options = {})
+        add_blank_row if @current_row.positive?
+
+        # Add title
+        title_style = @styles.create_style(
+          bold: true,
+          font_size: 14,
+          bg_color: options[:title_bg_color] || 'CCCCCC'
+        )
+        add_row([title], style: title_style)
+
+        # Add data
+        add_rows(data, options)
+
+        add_blank_row
+      end
+
+      # Freeze panes (typically for freezing header rows)
+      # @param row [Integer] row number to freeze at
+      # @param column [Integer] column number to freeze at
+      def freeze_panes(row = 1, column = 0)
+        @sheet.sheet_view.pane do |pane|
+          pane.top_left_cell = Axlsx.cell_r(column, row)
+          pane.state = :frozen
+          pane.y_split = row
+          pane.x_split = column
+          pane.active_pane = :bottom_right
+        end
+      end
+
+      # Apply auto-filter to a range
+      # @param range [String] range to apply filter (e.g., 'A1:D1')
+      def add_auto_filter(range = nil)
+        if range
+          @sheet.auto_filter = range
+        else
+          # Auto-detect range from first row
+          last_col = (@sheet.rows.first&.cells&.length || 1) - 1
+          @sheet.auto_filter = "A1:#{Axlsx.col_ref(last_col)}1"
+        end
+      end
+
+      # Add a hyperlink to a specific cell
+      # @param row_index [Integer] 0-based row index
+      # @param col_index [Integer] 0-based column index
+      # @param url [String] the URL for the hyperlink
+      # @param display_text [String] optional display text (defaults to cell value)
+      def add_hyperlink(row_index, col_index, url, display_text = nil)
+        cell = @sheet.rows[row_index].cells[col_index]
+        cell.value = display_text if display_text
+        @sheet.add_hyperlink location: url, ref: cell
+      end
+    end
+
+    ## StyleManager
+    # Helper class to manage and create cell styles
+    class StyleManager
+      def initialize(workbook)
+        @workbook = workbook
+        @style_cache = {}
+      end
+
+      # Create or retrieve a cached style
+      # @param options [Hash] style options
+      # @option options [Boolean] :bold
+      # @option options [Boolean] :italic
+      # @option options [String] :font_name
+      # @option options [Integer] :font_size
+      # @option options [String] :fg_color foreground/text color
+      # @option options [String] :bg_color background color
+      # @option options [Symbol] :alignment (:left, :center, :right)
+      # @option options [Hash] :border border options
+      # @option options [String] :format_code number format
+      # @return [Axlsx::Style] the created or cached style
+      def create_style(options = {})
+        cache_key = options.hash
+        return @style_cache[cache_key] if @style_cache[cache_key]
+
+        style_options = {}
+
+        # Font options
+        font_options = {}
+        font_options[:b] = options[:bold] if options.key?(:bold)
+        font_options[:i] = options[:italic] if options.key?(:italic)
+        font_options[:name] = options[:font_name] if options[:font_name]
+        font_options[:sz] = options[:font_size] if options[:font_size]
+        # font_options[:color] = { rgb: options[:fg_color] } if options[:fg_color]
+        style_options[:font] = font_options if font_options.any?
+
+        # Fill/background color
+        if options[:bg_color]
+          style_options[:bg_color] = options[:bg_color]
+          style_options[:fg_color] = options[:fg_color]
+        end
+
+        # Alignment
+        style_options[:alignment] = { horizontal: options[:alignment] } if options[:alignment]
+
+        # Border
+        style_options[:border] = options[:border] if options[:border]
+
+        # Number format
+        style_options[:format_code] = options[:format_code] if options[:format_code]
+
+        @style_cache[cache_key] = @workbook.styles.add_style(style_options)
+      end
+
+      # Common predefined styles
+      def header_style
+        create_style(bold: true, bg_color: 'DDDDDD', alignment: :center)
+      end
+
+      def currency_style
+        create_style(format_code: '$#,##0.00')
+      end
+
+      def percentage_style
+        create_style(format_code: '0.00%')
+      end
+
+      def date_style
+        create_style(format_code: 'yyyy-mm-dd')
+      end
+
+      def datetime_style
+        create_style(format_code: 'yyyy-mm-dd hh:mm:ss')
+      end
+    end
+  end
+end

data/lib/labimotion/models/concerns/datasetable.rb

@@ -42,15 +42,15 @@ module Labimotion
       props['identifier'] = klass.identifier if klass.identifier.present?
       props['uuid'] = uuid
       props['klass'] = 'Dataset'
+      props['klass_uuid'] = klass.uuid
       props = Labimotion::VocabularyHandler.update_vocabularies(props, args[:current_user], args[:element])
 
       ds = Labimotion::Dataset.find_by(element_type: self.class.name, element_id: id)
-      if ds.present? && (ds.klass_uuid != props['klass_uuid'] || ds.properties != props)
-        ds.update!(properties_release: klass.properties_release, uuid: uuid, dataset_klass_id: args[:dataset_klass_id], properties: props, klass_uuid: props['klass_uuid'])
+      if ds.present? && (ds.klass_uuid != klass.uuid || ds.properties != props)
+        ds.update!(properties_release: klass.properties_release, uuid: uuid, dataset_klass_id: args[:dataset_klass_id], properties: props, klass_uuid: klass.uuid)
       end
       return if ds.present?
 
-      props['klass_uuid'] = klass.uuid
       Labimotion::Dataset.create!(properties_release: klass.properties_release, uuid: uuid, dataset_klass_id: args[:dataset_klass_id], element_type: self.class.name, element_id: id, properties: props, klass_uuid: klass.uuid)
     end
 

data/lib/labimotion/models/concerns/element_fetchable.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Labimotion
+  module ElementFetchable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def element_klass
+        Labimotion::ElementKlass.find_by(name: element_klass_name)
+      end
+
+      def fetch_for_user(user_id, name: nil, short_label: nil, limit: 20)
+        # Prevent abuse by capping and validating limit
+        limit = [limit.to_i, 100].min
+        limit = 20 if limit <= 0
+
+        # Build base scope with common filters
+        apply_filters = lambda do |scope|
+          scope = scope.where("#{table_name}.name ILIKE ?", "%#{sanitize_sql_like(name)}%") if name.present?
+          scope = scope.where("#{table_name}.short_label ILIKE ?", "%#{sanitize_sql_like(short_label)}%") if short_label.present? && column_names.include?('short_label')
+          scope
+        end
+
+        # Owned records
+        owned = apply_filters.call(
+          joins(collections: :user).where(collections: { user_id: user_id })
+        )
+
+        # Shared (synced) records
+        shared = apply_filters.call(
+          joins(collections: :sync_collections_users).where(sync_collections_users: { user_id: user_id })
+        )
+
+        # Combine (remove duplicates), order, and limit
+        order_column = column_names.include?('short_label') ? :short_label : :name
+        from("(#{owned.to_sql} UNION #{shared.to_sql}) AS #{table_name}")
+          .order(order_column => :desc)
+          .limit(limit)
+      end
+
+      private
+
+      def element_klass_name
+        raise NotImplementedError, "Subclass must define element_klass_name"
+      end
+    end
+
+    # Instance method to get element_klass for a record
+    def element_klass
+      self.class.element_klass
+    end
+  end
+end

data/lib/labimotion/models/concerns/generic_klass.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Labimotion
+  ## Generic Klass Helpers
+  module GenericKlass
+    extend ActiveSupport::Concern
+
+    included do
+      # Scope for active and released templates
+      scope :active_and_released, -> { for_list_display.where(is_active: true).where.not(released_at: nil) }
+
+      # Scope for active, released, and generic templates (primarily for ElementKlass)
+      scope :active_released_generic, -> { active_and_released.where(is_generic: true) }
+    end
+  end
+end

data/lib/labimotion/models/concerns/segmentable.rb

@@ -46,11 +46,17 @@ module Labimotion
       end
     end
 
+    def touch_vocabulary(current_user)
+      touch_element_properties(current_user) if instance_of?(::Labimotion::Element)
+      touch_segments_properties(current_user)
+      touch_analyses_properties(current_user)
+    end
+
     def save_segments(**args) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
-      return if args[:segments].nil?
+      args_segments = args[:segments] || []
 
-      segments = []
-      args[:segments]&.each do |seg|
+      current_user = User.find_by(id: args[:current_user_id])
+      args_segments.each do |seg|
         klass = Labimotion::SegmentKlass.find_by(id: seg['segment_klass_id'])
         uuid = SecureRandom.uuid
         props = seg['properties']
@@ -59,21 +65,52 @@ module Labimotion
         props['uuid'] = uuid
         props['klass'] = 'Segment'
         props = Labimotion::SampleAssociation.update_sample_association(props, args[:current_user_id])
-        current_user = User.find_by(id: args[:current_user_id])
-        props = Labimotion::VocabularyHandler.update_vocabularies(props, current_user, self)
+        # props = Labimotion::VocabularyHandler.update_vocabularies(props, current_user, self)
         segment = Labimotion::Segment.where(element_type: self.class.name, element_id: self.id, segment_klass_id: seg['segment_klass_id']).order(id: :desc).first
         if segment.present? && (segment.klass_uuid != props['klass_uuid'] || segment.properties != props)
           segment.update!(properties_release: klass.properties_release, properties: props, uuid: uuid, klass_uuid: props['klass_uuid'])
-          segments.push(segment)
+          # segments.push(segment)
           Labimotion::Segment.where(element_type: self.class.name, element_id: self.id, segment_klass_id: seg['segment_klass_id']).where.not(id: segment.id).destroy_all
         end
         next if segment.present?
 
         props['klass_uuid'] = klass.uuid
         segment = Labimotion::Segment.create!(properties_release: klass.properties_release, segment_klass_id: seg['segment_klass_id'], element_type: self.class.name, element_id: self.id, properties: props, created_by: args[:current_user_id], uuid: uuid, klass_uuid: klass.uuid)
-        segments.push(segment)
+        # segments.push(segment)
       end
+
+      self.reload
+      touch_vocabulary(current_user)
+      self.reload
       segments
     end
+
+    def touch_element_properties(current_user)
+      touch_properties_for_object(self, current_user)
+    end
+
+    def touch_segments_properties(current_user)
+      segments.each do |segment|
+        touch_properties_for_object(segment, current_user)
+      end
+    end
+
+    def touch_analyses_properties(current_user)
+      analyses.each do |analysis|
+        analysis.children.each do |child|
+          dataset = child.dataset
+          next if dataset.nil?
+
+          touch_properties_for_object(dataset, current_user)
+        end
+      end
+    end
+
+    # NOTE: Update bypassing validations, callbacks, and timestamp updates
+    def touch_properties_for_object(object, current_user)
+      props_dup = object.properties.deep_dup
+      Labimotion::VocabularyHandler.update_vocabularies(props_dup, current_user, self)
+      object.update_column(:properties, props_dup) if props_dup != object.properties
+    end
   end
 end

data/lib/labimotion/models/dataset_klass.rb

@@ -1,25 +1,53 @@
 # frozen_string_literal: true
+
 require 'labimotion/models/concerns/generic_klass_revisions'
+require 'labimotion/models/concerns/generic_klass'
 
 module Labimotion
   class DatasetKlass < ApplicationRecord
     acts_as_paranoid
     self.table_name = :dataset_klasses
     include GenericKlassRevisions
+    include GenericKlass
+
     has_many :datasets, dependent: :destroy, class_name: 'Labimotion::Dataset'
     has_many :dataset_klasses_revisions, dependent: :destroy, class_name: 'Labimotion::DatasetKlassesRevision'
 
+    # Scope for displayed_in_list - select only necessary columns for list view
+    scope :for_list_display, lambda {
+      select(:id, :uuid, :label, :desc, :is_active, :version, :place, :released_at,
+             :identifier, :sync_time, :created_at, :updated_at, :ols_term_id)
+    }
+
     def self.init_seeds
       seeds_path = File.join(Rails.root, 'db', 'seeds', 'json', 'dataset_klasses.json')
       seeds = JSON.parse(File.read(seeds_path))
 
       seeds['chmo'].each do |term|
-        next if Labimotion::DatasetKlass.where(ols_term_id: term['id']).count.positive?
+        next if Labimotion::DatasetKlass.where(ols_term_id: term['id']).any?
 
-        attributes = { ols_term_id: term['id'], label: "#{term['label']} (#{term['synonym']})", desc: "#{term['label']} (#{term['synonym']})", place: term['position'], created_by: Admin.first&.id || 0 }
+        attributes = { ols_term_id: term['id'], label: "#{term['label']} (#{term['synonym']})",
+                       desc: "#{term['label']} (#{term['synonym']})", place: term['position'],
+                       created_by: Admin.first&.id || 0 }
         Labimotion::DatasetKlass.create!(attributes)
       end
       true
     end
+
+    def self.find_by_mode(ols_term_id, mode)
+      where(
+        "super_class_of @> jsonb_build_object(:id, jsonb_build_object('mode', :mode))",
+        id: ols_term_id,
+        mode: mode.to_s
+      )
+    end
+
+    def self.find_assigned_templates(ols_term_id)
+      find_by_mode(ols_term_id, 'assigned')
+    end
+
+    def self.find_inferred_templates(ols_term_id)
+      find_by_mode(ols_term_id, 'inferred')
+    end
   end
 end

data/lib/labimotion/models/device_description.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# This file extends the existing DeviceDescription model in the consuming app
+# and defines a Labimotion::DeviceDescription wrapper for convenient access.
+
+ActiveSupport.on_load(:active_record) do
+  if defined?(::DeviceDescription)
+    ::DeviceDescription.class_eval do
+      include Labimotion::ElementFetchable
+
+      def self.element_klass_name
+        'device_description'
+      end
+    end
+  else
+    warn "[Labimotion] DeviceDescription is not defined when Labimotion extension was loaded."
+  end
+end
+
+# Namespace wrapper to keep your preferred call style
+module Labimotion
+  module DeviceDescription
+    # Delegate class methods to ::DeviceDescription
+    def self.method_missing(method, *args, &block)
+      if ::DeviceDescription.respond_to?(method)
+        ::DeviceDescription.public_send(method, *args, &block)
+      else
+        super
+      end
+    end
+
+    def self.respond_to_missing?(method, include_private = false)
+      ::DeviceDescription.respond_to?(method, include_private) || super
+    end
+  end
+end

data/lib/labimotion/models/element.rb

@@ -31,6 +31,7 @@ module Labimotion
 
     belongs_to :element_klass, class_name: 'Labimotion::ElementKlass'
 
+    # has_ancestry ancestry_format: :materialized_path2
     has_ancestry orphan_strategy: :adopt
 
     has_many :collections_elements,  inverse_of: :element, dependent: :destroy, class_name: 'Labimotion::CollectionsElement'
@@ -49,6 +50,7 @@ module Labimotion
     scope :elements_updated_time_to, ->(time) { where('elements.updated_at <= ?', time) }
 
     belongs_to :creator, foreign_key: :created_by, class_name: 'User'
+    before_validation :set_root_ancestry_if_nil
     validates :creator, presence: true
 
     has_many :elements_elements, foreign_key: :parent_id, class_name: 'Labimotion::ElementsElement'
@@ -71,7 +73,7 @@ module Labimotion
     end
 
     def analyses
-      container ? container.analyses : []
+      container ? container.analyses : Container.none
     end
 
     def auto_set_short_label
@@ -108,6 +110,36 @@ module Labimotion
       pids
     end
 
+    # Fetch elements for a user (owned + shared)
+    def self.fetch_for_user(user_id, name: nil, short_label: nil, klass_id: nil, limit: 20)
+      # Prevent abuse by capping and validating limit
+      limit = [limit.to_i, 100].min
+      limit = 20 if limit <= 0
+
+      # Build base scope with common filters
+      apply_filters = lambda do |scope|
+        scope = scope.where('elements.name ILIKE ?', "%#{sanitize_sql_like(name)}%") if name.present?
+        scope = scope.where('elements.short_label ILIKE ?', "%#{sanitize_sql_like(short_label)}%") if short_label.present?
+        scope = scope.by_klass_id(klass_id) if klass_id.present?
+        scope
+      end
+
+      # Owned elements
+      owned = apply_filters.call(
+        joins(collections: :user).where(collections: { user_id: user_id })
+      )
+
+      # Shared (synced) elements
+      shared = apply_filters.call(
+        joins(collections: :sync_collections_users).where(sync_collections_users: { user_id: user_id })
+      )
+
+      # Combine (remove duplicates), order, and limit
+      from("(#{owned.to_sql} UNION #{shared.to_sql}) AS elements")
+        .order(short_label: :desc)
+        .limit(limit)
+    end
+
     def thumb_svg
       image_atts = attachments.select(&:type_image?)
       attachment = image_atts[0] || attachments[0]
@@ -148,5 +180,9 @@ module Labimotion
         attachments.each(&:destroy!)
       end
     end
+
+    def set_root_ancestry_if_nil
+      self.ancestry ||= '/'
+    end
   end
 end

data/lib/labimotion/models/element_klass.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
+
 require 'labimotion/conf'
 require 'labimotion/models/concerns/generic_klass_revisions'
+require 'labimotion/models/concerns/generic_klass'
 require 'labimotion/models/concerns/workflow'
 
 module Labimotion
@@ -8,11 +10,21 @@ module Labimotion
     self.table_name = :element_klasses
     acts_as_paranoid
     include GenericKlassRevisions
+    include GenericKlass
     include Workflow
     has_many :elements, dependent: :destroy, class_name: 'Labimotion::Element'
     has_many :segment_klasses, dependent: :destroy, class_name: 'Labimotion::SegmentKlass'
     has_many :element_klasses_revisions, dependent: :destroy, class_name: 'Labimotion::ElementKlassesRevision'
 
+    validates :name, presence: true, uniqueness: { conditions: -> { where(deleted_at: nil) }, message: 'is already in use.' }
+
+    # Scope for displayed_in_list - select only necessary columns for list view
+    scope :for_list_display, lambda {
+      select(:id, :uuid, :label, :desc, :is_active, :version, :place, :released_at,
+             :identifier, :sync_time, :created_at, :updated_at, :name, :icon_name,
+             :klass_prefix, :is_generic)
+    }
+
     def self.gen_klasses_json
       klasses = where(is_active: true, is_generic: true).order('place')&.pluck(:name) || []
     rescue ActiveRecord::StatementInvalid, PG::ConnectionBad, PG::UndefinedTable
@@ -24,6 +36,5 @@ module Labimotion
         klasses&.to_json || []
       )
     end
-
   end
 end

data/lib/labimotion/models/reaction.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# This file extends the existing Reaction model in the consuming app
+# and defines a Labimotion::Reaction wrapper for convenient access.
+
+ActiveSupport.on_load(:active_record) do
+  if defined?(::Reaction)
+    ::Reaction.class_eval do
+      include Labimotion::ElementFetchable
+
+      def self.element_klass_name
+        'reaction'
+      end
+    end
+  else
+    warn "[Labimotion] Reaction is not defined when Labimotion extension was loaded."
+  end
+end
+
+# Namespace wrapper to keep your preferred call style
+module Labimotion
+  module Reaction
+    # Delegate class methods to ::Reaction
+    def self.method_missing(method, *args, &block)
+      if ::Reaction.respond_to?(method)
+        ::Reaction.public_send(method, *args, &block)
+      else
+        super
+      end
+    end
+
+    def self.respond_to_missing?(method, include_private = false)
+      ::Reaction.respond_to?(method, include_private) || super
+    end
+  end
+end