noiseless 0.0.0 → 0.1.0

data/lib/noiseless/dsl.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Noiseless
+  module DSL
+    module ClassMethods
+      def search_index(*names)
+        @index_names = names.flatten.map(&:to_s) if names.any?
+        @index_names
+      end
+
+      def index_name(name = nil)
+        @index_name = name.to_s if name
+        @index_name
+      end
+
+      def searchable_fields(*fields)
+        @searchable_fields = fields if fields.any?
+        @searchable_fields
+      end
+
+      def adapter(name = nil)
+        @adapter_name = name if name
+        @adapter_name || Noiseless.config.default_adapter
+      end
+
+      def connection(name = nil)
+        @connection_name = name if name
+        @connection_name || Noiseless.config.default_connection
+      end
+
+      def mapping(&block)
+        @mapping_block = block if block
+        @mapping_block
+      end
+
+      def import(*, **)
+        BulkImporter.new(self).import(*, **)
+      end
+
+      def import_scoped(scope, **)
+        BulkImporter.new(self).import_scoped(scope, **)
+      end
+
+      def reindex(**)
+        BulkImporter.new(self).reindex(**)
+      end
+
+      def bulk_importer(connection: nil)
+        BulkImporter.new(self, connection: connection)
+      end
+
+      def searchable(**)
+        include Callbacks unless included_modules.include?(Callbacks)
+        include DSL::InstanceMethods unless included_modules.include?(DSL::InstanceMethods)
+
+        auto_index(true, **)
+
+        # Register the model in the global registry
+        Noiseless.register_model(self, searchable: true, **)
+      end
+
+      def multi_search(models: nil, indexes: nil, connection: nil, &block)
+        search_instance = MultiSearch.new(
+          models: models || [self],
+          indexes: indexes,
+          connection: connection || self.connection
+        )
+
+        if block
+          search_instance.search(&block)
+        else
+          search_instance
+        end
+      end
+
+      def page(num = nil)
+        Pagination::SearchPaginator.new(self, page: num)
+      end
+
+      def per(num)
+        Pagination::SearchPaginator.new(self, per_page: num)
+      end
+    end
+
+    module InstanceMethods
+      def index_document(**)
+        DocumentManager.new(self).index_document(**)
+      end
+
+      def update_document(**)
+        DocumentManager.new(self).update_document(**)
+      end
+
+      def delete_document(**)
+        DocumentManager.new(self).delete_document(**)
+      end
+
+      def document_exists?
+        DocumentManager.new(self).document_exists?
+      end
+
+      def document_manager(connection: nil)
+        DocumentManager.new(self, connection: connection)
+      end
+    end
+  end
+end

data/lib/noiseless/generators/application_search_generator.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module Noiseless
+  module Generators
+    class ApplicationSearchGenerator < Rails::Generators::Base
+      desc "Generate ApplicationSearch class for your application"
+
+      source_root File.expand_path("templates", __dir__)
+
+      def create_application_search
+        create_file "app/search/application_search.rb", <<~RUBY
+          # frozen_string_literal: true
+
+          # Base class for all search models
+          class ApplicationSearch < Noiseless::Model
+            # Inherits static and dynamic search methods using default_connection
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/noiseless/instrumentation.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module Noiseless
+  # Instrumentation via ActiveSupport
+  module Instrumentation
+    def instrument(event, payload = {})
+      start_time = Time.current
+      payload = payload.merge(
+        adapter: self.class.name,
+        connection: connection_info,
+        start_time: start_time
+      )
+
+      result = ActiveSupport::Notifications.instrument("noiseless.#{event}", payload) do
+        yield if block_given?
+      end
+
+      # Update runtime tracking for Rails
+      add_to_runtime(Time.current - start_time) if defined?(Rails) && Rails.respond_to?(:application) && Rails.application
+
+      result
+    end
+
+    private
+
+    def connection_info
+      {
+        hosts: @hosts&.take(3), # Limit to first 3 hosts for brevity
+        adapter_class: self.class.name
+      }
+    rescue StandardError
+      { adapter_class: self.class.name }
+    end
+
+    def add_to_runtime(duration)
+      Thread.current[:noiseless_runtime] ||= 0
+      Thread.current[:noiseless_runtime] += duration * 1000 # Convert to milliseconds
+    end
+  end
+
+  # Log subscriber for Rails integration
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def search(event)
+      return unless logger.debug?
+
+      indexes = event.payload[:indexes]&.join(", ") || "unknown"
+      duration = event.duration.round(2)
+
+      debug "Noiseless Search (#{duration}ms) indexes=[#{indexes}] #{query_summary(event.payload[:query])}"
+    end
+
+    def bulk(event)
+      return unless logger.debug?
+
+      actions_count = event.payload[:actions_count] || 0
+      duration = event.duration.round(2)
+
+      debug "Noiseless Bulk (#{duration}ms) actions=#{actions_count}"
+    end
+
+    def index_document(event)
+      return unless logger.debug?
+
+      index = event.payload[:index]
+      id = event.payload[:id]
+      duration = event.duration.round(2)
+
+      debug "Noiseless Index Document (#{duration}ms) index=#{index} id=#{id}"
+    end
+
+    def update_document(event)
+      return unless logger.debug?
+
+      index = event.payload[:index]
+      id = event.payload[:id]
+      changes_count = event.payload[:changes_count] || 0
+      duration = event.duration.round(2)
+
+      debug "Noiseless Update Document (#{duration}ms) index=#{index} id=#{id} changes=#{changes_count}"
+    end
+
+    def delete_document(event)
+      return unless logger.debug?
+
+      index = event.payload[:index]
+      id = event.payload[:id]
+      duration = event.duration.round(2)
+
+      debug "Noiseless Delete Document (#{duration}ms) index=#{index} id=#{id}"
+    end
+
+    def create_index(event)
+      return unless logger.debug?
+
+      index = event.payload[:index]
+      duration = event.duration.round(2)
+
+      debug "Noiseless Create Index (#{duration}ms) index=#{index}"
+    end
+
+    def delete_index(event)
+      return unless logger.debug?
+
+      index = event.payload[:index]
+      duration = event.duration.round(2)
+
+      debug "Noiseless Delete Index (#{duration}ms) index=#{index}"
+    end
+
+    private
+
+    def query_summary(query)
+      return "empty" unless query.is_a?(Hash)
+
+      parts = []
+
+      if query[:query]&.dig(:bool, :must)&.any?
+        must_count = query[:query][:bool][:must].size
+        parts << "must:#{must_count}"
+      end
+
+      if query[:query]&.dig(:bool, :filter)&.any?
+        filter_count = query[:query][:bool][:filter].size
+        parts << "filter:#{filter_count}"
+      end
+
+      if query[:sort]&.any?
+        sort_count = query[:sort].size
+        parts << "sort:#{sort_count}"
+      end
+
+      if query[:from] || query[:size]
+        parts << "from:#{query[:from] || 0}"
+        parts << "size:#{query[:size] || 20}"
+      end
+
+      parts.join(" ")
+    end
+  end
+
+  # Runtime tracking for Rails
+  module ControllerRuntime
+    extend ActiveSupport::Concern
+
+    protected
+
+    def append_info_to_payload(payload)
+      super
+      payload[:noiseless_runtime] = noiseless_runtime
+    end
+
+    def cleanup_view_runtime
+      runtime_before_render = noiseless_runtime
+      runtime = super
+      runtime_after_render = noiseless_runtime
+      runtime + runtime_after_render - runtime_before_render
+    end
+
+    private
+
+    def noiseless_runtime
+      Thread.current[:noiseless_runtime] ||= 0
+    end
+
+    module ClassMethods
+      def log_process_action(payload)
+        messages = super
+        runtime = payload[:noiseless_runtime]
+        messages << ("Noiseless: %.1fms" % runtime) if runtime&.positive?
+        messages
+      end
+    end
+  end
+end

data/lib/noiseless/introspection/console.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module Noiseless
+  module Introspection
+    class Console
+      def self.inspect_adapter(adapter)
+        puts "[INSPECT] Adapter Introspection"
+        puts "=" * 50
+
+        info = adapter.adapter_info
+
+        puts "Adapter Type: #{info[:adapter_type]}"
+        puts "Execution Mode: #{info[:execution_mode]}"
+        puts "Engine Name: #{info[:engine_name]}"
+        puts "Capabilities: #{info[:capabilities].join(', ')}"
+
+        puts "\nExecution Modules:"
+        info[:execution_module].each do |mod|
+          puts "  - #{mod[:name]}"
+        end
+
+        puts "\n#{'=' * 50}"
+      end
+
+      def self.compare_query_across_engines(ast_node, **)
+        puts "[COMPARE] Cross-Engine Query Comparison"
+        puts "=" * 60
+
+        comparison = QueryVisualizer.compare_across_engines(ast_node, **)
+
+        puts "Original AST:"
+        puts JSON.pretty_generate(comparison[:original_ast])
+
+        puts "\nEngine Translations:"
+        comparison[:engine_translations].each do |engine, data|
+          puts "\n#{engine.to_s.humanize}:"
+          if data[:error]
+            puts "  [ERROR] #{data[:error]}"
+          else
+            puts "  [OK] Available"
+            puts "  Performance Score: #{data[:estimated_performance][:estimated_score]}"
+            puts "  Query Differences: #{data[:query_differences].size} found"
+          end
+        end
+
+        puts "\nCompatibility Analysis:"
+        analysis = comparison[:compatibility_analysis]
+        puts "  Compatible Engines: #{analysis[:compatible_engines].join(', ')}"
+        puts "  Common Features: #{analysis[:common_features]&.join(', ') || 'None'}"
+
+        if analysis[:potential_issues].any?
+          puts "  [WARN] Potential Issues:"
+          analysis[:potential_issues].each do |issue|
+            puts "    - #{issue[:description]} (#{issue[:severity]})"
+          end
+        end
+
+        puts "\nRecommendations:"
+        comparison[:recommendations].each do |rec|
+          puts "  [TIP] #{rec[:recommendation]}"
+        end
+
+        puts "\n#{'=' * 60}"
+      end
+
+      def self.visualize_ast(ast_node, format: :tree)
+        puts "[AST] Visualization (#{format})"
+        puts "=" * 40
+
+        visualization = QueryVisualizer.visualize_ast(ast_node, format: format)
+        puts visualization
+
+        puts "=" * 40
+      end
+
+      def self.explain_query_execution(ast_node, adapter)
+        puts "[EXPLAIN] Query Execution Explanation"
+        puts "=" * 50
+
+        flow_info = QueryVisualizer.explain_query_flow(ast_node, adapter)
+        explanation = flow_info[:explanation]
+
+        puts "Adapter: #{explanation[:adapter][:adapter_type]} (#{explanation[:adapter][:execution_mode]})"
+        puts "Engine: #{explanation[:adapter][:engine_name]}"
+
+        puts "\nExecution Plan:"
+        explanation[:execution_plan].each_with_index do |step, index|
+          puts "  #{index + 1}. #{step[:description]}"
+          puts "     Cost: #{step[:estimated_cost]}"
+        end
+
+        puts "\nPerformance Breakdown:"
+        flow_info[:performance_breakdown].each do |metric|
+          puts "  #{metric[:metric]}: #{metric[:value]} #{metric[:unit]}"
+        end
+
+        if flow_info[:optimization_suggestions].any?
+          puts "\nOptimization Suggestions:"
+          flow_info[:optimization_suggestions].each do |suggestion|
+            puts "  [TIP] #{suggestion[:suggestion]} (Impact: #{suggestion[:impact]})"
+          end
+        end
+
+        puts "\n#{'=' * 50}"
+      end
+
+      def self.profile_query_performance(ast_node, adapter, iterations: 10)
+        puts "[PROFILE] Query Performance Profile"
+        puts "=" * 50
+
+        puts "Running #{iterations} iterations on #{adapter.adapter_info[:adapter_type]} (#{adapter.adapter_info[:execution_mode]})..."
+
+        profile = adapter.profile_query(ast_node, iterations: iterations)
+        summary = profile[:summary]
+
+        puts "\nPerformance Summary:"
+        puts "  Minimum: #{summary[:min_ms]}ms"
+        puts "  Maximum: #{summary[:max_ms]}ms"
+        puts "  Average: #{summary[:avg_ms]}ms"
+        puts "  Median: #{summary[:median_ms]}ms"
+        puts "  Std Dev: #{summary[:std_dev_ms]}ms"
+
+        # Show distribution
+        puts "\nTime Distribution:"
+        bins = create_histogram_bins(profile[:measurements].pluck(:total_time_ms))
+        bins.each do |bin|
+          bar = "█" * (bin[:count] * 50 / iterations)
+          puts "  #{bin[:range]}: #{bar} (#{bin[:count]})"
+        end
+
+        puts "\n#{'=' * 50}"
+      end
+
+      def self.compatibility_matrix
+        puts "[MATRIX] Adapter Compatibility Matrix"
+        puts "=" * 60
+
+        matrix = Noiseless::Adapter.new.compatibility_matrix
+
+        matrix.each do |adapter_key, info|
+          status = info[:available] ? "[OK]" : "[X]"
+          name = adapter_key.to_s.humanize
+
+          puts "#{status} #{name}"
+          if info[:available]
+            puts "    Engine: #{info[:engine_name]}"
+            puts "    Capabilities: #{info[:capabilities].join(', ')}"
+          else
+            puts "    Error: #{info[:error]}"
+          end
+          puts
+        end
+
+        puts "=" * 60
+      end
+
+      def self.interactive_mode
+        puts "[INTERACTIVE] Noiseless Interactive Introspection Mode"
+        puts "Type 'help' for available commands or 'exit' to quit"
+        puts "=" * 60
+
+        loop do
+          print "noiseless> "
+          input = gets.chomp.strip
+
+          case input
+          when "help"
+            show_help
+          when "adapters"
+            compatibility_matrix
+          when "exit", "quit"
+            puts "Goodbye!"
+            break
+          when /^profile\s+(.+)/
+            # TODO: Parse query and run profile
+            puts "Profile command not yet implemented"
+          when /^compare\s+(.+)/
+            # TODO: Parse query and run comparison
+            puts "Compare command not yet implemented"
+          else
+            puts "Unknown command: #{input}. Type 'help' for available commands."
+          end
+        end
+      end
+
+      def self.create_histogram_bins(values, bin_count: 5)
+        return [] if values.empty?
+
+        min_val = values.min
+        max_val = values.max
+        bin_size = (max_val - min_val) / bin_count.to_f
+
+        bins = Array.new(bin_count) do |i|
+          range_start = min_val + (i * bin_size)
+          range_end = min_val + ((i + 1) * bin_size)
+          {
+            range: "#{range_start.round(2)}-#{range_end.round(2)}ms",
+            count: 0
+          }
+        end
+
+        values.each do |value|
+          bin_index = ((value - min_val) / bin_size).floor
+          bin_index = [bin_index, bin_count - 1].min # Ensure we don't exceed bounds
+          bins[bin_index][:count] += 1
+        end
+
+        bins
+      end
+
+      def self.show_help
+        puts <<~HELP
+          Available Commands:
+
+          help         - Show this help message
+          adapters     - Show adapter compatibility matrix
+          exit/quit    - Exit interactive mode
+
+          Coming Soon:
+          profile <query>    - Profile query performance
+          compare <query>    - Compare query across engines
+          explain <query>    - Explain query execution
+          visualize <query>  - Visualize AST structure
+        HELP
+      end
+    end
+  end
+end