monq 0.1.0

data/lib/monq/environment.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require "mongoid"
+
+module Monq
+  class Environment
+    attr_reader :name, :config, :client_name, :namespace, :client, :ssh_proxy
+
+    def initialize(name, config, first:, model_dir:)
+      @name = name
+      @config = config
+      @first = first
+      @model_dir = model_dir
+      @client_name = Config.client_name_for(name)
+      @namespace = config[:namespace]
+      @models = []
+      @sandbox_session = nil
+    end
+
+    def connect!
+      ensure_ssh_proxy!
+      opts = Config.client_options(client_config)
+      @client = Mongo::Client.new(opts[:hosts], **opts[:options].merge(database: opts[:database]))
+      Mongoid::Clients.set(client_name, @client)
+      Mongoid::Clients.set(:default, @client) if @first
+      hello!
+    end
+
+    def hello!
+      @client.database.command(hello: 1).documents.first
+    end
+
+    def ping?
+      hello!
+      true
+    rescue StandardError
+      false
+    end
+
+    def reconnect!
+      raise Error, "sandbox is active; run sandbox-quit first" if sandbox?
+
+      @ssh_proxy&.reconnect!
+      @client&.close
+      connect!
+    end
+
+    def namespace_module
+      @namespace_module ||= Object.const_set(namespace, Module.new)
+    end
+
+    def sandbox?
+      !@sandbox_session.nil?
+    end
+
+    def bind_session(session)
+      @sandbox_session = session
+      attach_client_session(session)
+    end
+
+    def clear_session
+      if @sandbox_session
+        @sandbox_session.abort_transaction rescue nil
+        @sandbox_session.end_session rescue nil
+        @sandbox_session = nil
+      end
+      detach_client_session
+    end
+
+    def load_models!
+      install_namespace_api!
+      path = File.join(@model_dir, "#{Config.prefix_for(name)}.rb")
+      unless File.file?(path)
+        warn "model file not found: #{path}"
+        return
+      end
+
+      namespace_module.module_eval(File.read(path), path)
+      bind_clients!
+      track_embedded_classes!
+      install_abbreviations!
+    end
+
+    def models
+      namespace_module.constants.filter_map do |const_name|
+        klass = namespace_module.const_get(const_name)
+        next unless klass.is_a?(Class) && klass < Mongoid::Document && !klass.embedded?
+        next unless klass.name.to_s.split("::").last == const_name.to_s
+
+        klass
+      end
+    end
+
+    def redefine!
+      raise Error, "sandbox is active; run sandbox-quit first" if sandbox?
+
+      tracked_classes.each do |klass|
+        Mongoid.models.delete(klass) if Mongoid.models.respond_to?(:delete)
+      end
+      tracked_names.each { |n| namespace_module.send(:remove_const, n) if namespace_module.const_defined?(n, false) }
+      @tracked = []
+      load_models!
+    end
+
+    private
+
+    def attach_client_session(session)
+      return unless @client
+
+      if @client.respond_to?(:session=)
+        @client.session = session
+      else
+        @client.instance_variable_set(:@monq_session, session)
+      end
+    end
+
+    def detach_client_session
+      return unless @client
+
+      if @client.respond_to?(:session=)
+        @client.session = nil
+      elsif @client.instance_variable_defined?(:@monq_session)
+        @client.remove_instance_variable(:@monq_session)
+      end
+    end
+
+    def ensure_ssh_proxy!
+      return unless config[:ssh]
+      return if @ssh_proxy
+
+      target = Config.ssh_forward_target(config)
+      ssh = config[:ssh]
+      @ssh_proxy = SSHProxy.new(
+        host: ssh[:host],
+        user: ssh[:user],
+        password: ssh[:password],
+        port: ssh[:port] || 22,
+        forward_host: target[:host],
+        forward_port: target[:port],
+        local_port: ssh[:local_port]
+      )
+    end
+
+    def client_config
+      return config unless @ssh_proxy
+
+      config.merge(ssh: config[:ssh].merge(local_port: @ssh_proxy.local_port, local_host: "127.0.0.1"))
+    end
+
+    def tracked_names
+      @tracked ||= []
+    end
+
+    def tracked_classes
+      tracked_names.filter_map do |n|
+        namespace_module.const_get(n) if namespace_module.const_defined?(n, false)
+      end.select { |k| k.is_a?(Class) }
+    end
+
+    def bind_clients!
+      namespace_module.constants.each do |const_name|
+        klass = namespace_module.const_get(const_name)
+        next unless klass.is_a?(Class) && klass < Mongoid::Document
+        next if klass.embedded?
+
+        current = klass.storage_options[:client] || klass.storage_options["client"]
+        next if current && current.to_sym != :default
+
+        klass.store_in klass.storage_options.merge(client: client_name)
+        tracked_names << const_name
+      end
+    end
+
+    def track_embedded_classes!
+      models.each do |klass|
+        relations = klass.embedded_relations
+        relations = klass.relations if relations.nil? || (relations.respond_to?(:empty?) && relations.empty? && klass.respond_to?(:relations))
+        Array(relations).each do |entry|
+          relation = entry.is_a?(Array) ? entry.last : entry
+          class_name = relation.respond_to?(:class_name) ? relation.class_name : relation[:class_name]
+          next if class_name.nil? || class_name.to_s.empty?
+
+          embedded = namespace_module.const_get(class_name) rescue nil
+          next unless embedded.is_a?(Class) && embedded < Mongoid::Document
+          next unless embedded.name.to_s.start_with?("#{namespace}::")
+
+          short = embedded.name.split("::").last.to_sym
+          tracked_names << short unless tracked_names.include?(short)
+        end
+      end
+    end
+
+    def install_abbreviations!
+      models.each do |klass|
+        abbr = klass.name.split("::").last.gsub(/[^A-Z]/, "")
+        abbr = "M" if abbr.empty?
+        candidate = abbr
+        n = 2
+        while namespace_module.const_defined?(candidate, false)
+          candidate = "#{abbr}#{n}"
+          n += 1
+        end
+        namespace_module.const_set(candidate, klass)
+        tracked_names << candidate.to_sym
+      end
+    end
+
+    def install_namespace_api!
+      env = self
+      mod = namespace_module
+      mod.define_singleton_method(:client) { env.client }
+      mod.define_singleton_method(:models) { env.models }
+      mod.define_singleton_method(:collections) { env.client.database.collection_names }
+      mod.define_singleton_method(:config) { env.config }
+      mod.define_singleton_method(:q) { |doc| env.client.database.command(doc) }
+    end
+  end
+end

data/lib/monq/errors.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Monq
+  class Error < StandardError; end
+end

data/lib/monq/ext/array.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+class Array
+  def t
+    puts Monq::Ext.table_for(hash_docs)
+    nil
+  end
+
+  def v
+    Monq::Ext.vertical(hash_docs)
+  end
+
+  # visidata comes later; always print the table so vd works without the binary.
+  def vd
+    t
+  end
+
+  def write_csv(filename)
+    require "csv"
+    docs = respond_to?(:hash_docs, true) ? hash_docs : self
+    File.open(filename, "w:UTF-8") do |file|
+      csv = CSV.new(file)
+      return if docs.empty?
+
+      keys = docs.first.keys
+      csv << keys.map(&:to_s)
+      docs.each { |row| csv << keys.map { |k| row[k].to_s } }
+    end
+  end
+
+  def write_excel(filename, sheet_name: "Sheet1")
+    require "caxlsx"
+    docs = hash_docs
+    package = Axlsx::Package.new
+    package.workbook.add_worksheet(name: sheet_name) do |sheet|
+      next if docs.empty?
+
+      keys = docs.first.keys
+      sheet.add_row(keys.map(&:to_s))
+      docs.each { |row| sheet.add_row(keys.map { |k| row[k].to_s }) }
+    end
+    package.serialize(filename)
+  end
+
+  private
+
+  def hash_docs
+    return self if empty?
+    return self if first.is_a?(Hash)
+
+    if first.respond_to?(:attributes)
+      map { |item| item.attributes }
+    else
+      self
+    end
+  end
+end

data/lib/monq/ext/criteria.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Monq
+  module Ext
+    module Criteria
+      def t
+        Monq::Ext.display_criteria(self)
+      end
+
+      def v
+        docs, = Monq::Ext.materialize(self)
+        docs.v
+      end
+
+      def vd
+        t
+      end
+
+      # Full result set. Display methods cap at 500; export must not.
+      def write_csv(filename)
+        to_a.write_csv(filename)
+      end
+
+      def write_excel(filename, sheet_name: "Sheet1")
+        to_a.write_excel(filename, sheet_name: sheet_name)
+      end
+    end
+  end
+end
+
+Mongoid::Criteria.include(Monq::Ext::Criteria)

data/lib/monq/ext/document.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Monq
+  module Ext
+    module Document
+      def t
+        [attributes].t
+      end
+
+      def v
+        [attributes].v
+      end
+
+      def vd
+        [attributes].vd
+      end
+
+      def write_csv(filename)
+        [self].write_csv(filename)
+      end
+
+      def write_excel(filename, sheet_name: "Sheet1")
+        [self].write_excel(filename, sheet_name: sheet_name)
+      end
+    end
+  end
+end
+
+Mongoid::Document.include(Monq::Ext::Document)

data/lib/monq/ext/kernel.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Kernel
+  def models
+    Monq::App.instance.environments.flat_map { |env| env.models }
+  rescue StandardError
+    []
+  end
+
+  def model_names
+    models.map(&:name)
+  end
+
+  def within_namespace(pattern, &block)
+    if pattern.is_a?(Module)
+      pattern.module_eval(&block)
+      return
+    end
+
+    env = find_environment { |candidate| name_matches?(candidate.namespace, pattern) }
+    unless env
+      $stderr.puts "Namespace #{pattern.inspect} not found"
+      return
+    end
+
+    env.namespace_module.module_eval(&block)
+  end
+
+  def within_env(pattern, &block)
+    env = find_environment { |candidate| name_matches?(candidate.name, pattern) }
+    unless env
+      $stderr.puts "Environment #{pattern.inspect} not found"
+      return
+    end
+
+    env.namespace_module.module_eval(&block)
+  end
+
+  def env_config(regexp)
+    env = find_environment { |candidate| candidate.name.to_s =~ regexp }
+    env&.config
+  end
+
+  def q(doc)
+    environments = Monq::App.instance.environments
+    if environments.size != 1
+      $stderr.puts "use Namespace.q"
+      return nil
+    end
+
+    environments.first.client.database.command(doc)
+  end
+
+  private
+
+  def find_environment(&block)
+    Monq::App.instance.environments.find(&block)
+  end
+
+  def name_matches?(value, pattern)
+    case pattern
+    when Symbol, String
+      value.to_s == pattern.to_s
+    when Regexp
+      value.to_s =~ pattern
+    else
+      false
+    end
+  end
+end

data/lib/monq/ext/object.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class Object
+  def self.const_missing(name)
+    app = Monq::App.instance if defined?(Monq::App)
+    if app&.environments
+      app.environments.each do |env|
+        mod = env.namespace_module
+        return mod.const_get(name) if mod.const_defined?(name, false)
+      end
+    end
+    super
+  end
+end

data/lib/monq/ext/view.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Monq
+  module Ext
+    module View
+      def t
+        materialized_docs.t
+      end
+
+      def v
+        materialized_docs.v
+      end
+
+      def vd
+        materialized_docs.vd
+      end
+
+      # Full result set. Display methods cap at 500; export must not.
+      def write_csv(filename)
+        to_a.write_csv(filename)
+      end
+
+      def write_excel(filename, sheet_name: "Sheet1")
+        to_a.write_excel(filename, sheet_name: sheet_name)
+      end
+
+      private
+
+      def materialized_docs
+        view = self
+        if respond_to?(:options) && respond_to?(:limit) && Monq::Ext.limit_unset?(options)
+          view = limit(Monq::Ext::CAP)
+        end
+        view.to_a
+      end
+    end
+  end
+end
+
+Mongo::Collection::View.include(Monq::Ext::View)

data/lib/monq/ext.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Monq
+  module Ext
+    CAP = 500
+
+    def self.materialize(criteria)
+      capped = limit_unset?(criteria.options)
+      criteria = criteria.limit(CAP) if capped
+      [criteria.to_a, capped]
+    end
+
+    def self.display_criteria(criteria)
+      docs, capped = materialize(criteria)
+      puts table_for(docs)
+      puts "showing #{docs.size} rows (capped at #{CAP})" if capped
+      nil
+    end
+
+    def self.table_for(docs)
+      rows = Presenter.rows(docs)
+      Table.new do |table|
+        table.headers = rows.first || []
+        table.body = rows[1..] || []
+      end.to_terminal
+    end
+
+    def self.vertical(docs)
+      rows = Presenter.rows(docs)
+      return [] if rows.empty?
+
+      keys = rows.first
+      [keys, nil, *rows[1..]]
+    end
+
+    def self.limit_unset?(options)
+      return true if options.nil?
+
+      options[:limit].nil? && options["limit"].nil?
+    end
+  end
+end

data/lib/monq/multi_io.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Monq
+  class MultiIO
+    ANSI = /\e\[(\d+)(?:;\d+)*m/.freeze
+
+    def initialize(*targets)
+      @targets = targets
+    end
+
+    def write(*args)
+      @targets.each do |target|
+        if tty?(target)
+          target.write(*args)
+        else
+          target.write(*args.map { |str| strip_ansi(str) })
+        end
+        target.flush if target.respond_to?(:flush)
+      end
+    end
+
+    def <<(target)
+      @targets << target
+      self
+    end
+
+    def close
+      @targets.each { |target| target.close if target.respond_to?(:close) }
+    end
+
+    def delete(io)
+      @targets.delete(io)
+    end
+
+    def include?(io)
+      @targets.include?(io)
+    end
+
+    private
+
+    def tty?(target)
+      target.respond_to?(:isatty) ? target.isatty : false
+    end
+
+    def strip_ansi(value)
+      value.to_s.gsub(ANSI, "")
+    end
+  end
+end

data/lib/monq/presenter.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "json"
+require "bson"
+
+module Monq
+  module Presenter
+    module_function
+
+    def scalar(value)
+      case value
+      when BSON::ObjectId
+        value.to_s
+      when Time, Date
+        value.strftime("%Y-%m-%d %H:%M:%S")
+      when BSON::Binary
+        "#<BSON::Binary type=#{value.type} size=#{value.data.bytesize}>"
+      when BSON::Decimal128
+        value.to_s
+      when Hash, Array
+        json = JSON.generate(as_json_tree(value))
+        json.length > 120 ? "#{json[0, 120]}…" : json
+      else
+        value.respond_to?(:as_json) ? value.as_json : value.to_s
+      end
+    end
+
+    def rows(docs)
+      return [] if docs.nil? || docs.empty?
+
+      keys = docs.first.keys
+      body = docs.map { |doc| keys.map { |key| scalar(doc[key]) } }
+      [keys, *body]
+    end
+
+    def as_json_tree(value)
+      case value
+      when BSON::ObjectId, BSON::Decimal128
+        value.to_s
+      when BSON::Binary
+        "#<BSON::Binary type=#{value.type} size=#{value.data.bytesize}>"
+      when Time, Date
+        value.strftime("%Y-%m-%d %H:%M:%S")
+      when Hash
+        value.each_with_object({}) { |(key, item), hash| hash[key] = as_json_tree(item) }
+      when Array
+        value.map { |item| as_json_tree(item) }
+      else
+        value.respond_to?(:as_json) ? value.as_json : value.to_s
+      end
+    end
+    private_class_method :as_json_tree
+  end
+end

data/lib/monq/repl.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "pry"
+require "rainbow"
+require_relative "commands"
+
+module Monq
+  class Repl
+    def start
+      Commands.register_pry_commands!
+      unless App.instance.options.babel_compatable
+        Pry.config.prompt = Pry::Prompt.new("monq", "monq", prompt)
+      end
+      Pry.start
+    end
+
+    def prompt
+      [proc do |obj, nest_level, pry_instance|
+        names = App.instance.environments.map(&:name).join("+")
+        "%s#{Rainbow('@').green}%s%s%s [%d] %s " % [
+          Rainbow("MONQ").red,
+          Rainbow(names).yellow,
+          sandbox_indicator,
+          context_prompt(obj, nest_level),
+          pry_instance.input_ring.count,
+          Rainbow("❯").green
+        ]
+      end]
+    end
+
+    def context_prompt(obj, nest_level)
+      if nest_level.zero?
+        "(#{obj})"
+      else
+        "(#{obj}:#{nest_level})"
+      end
+    end
+
+    def sandbox_indicator
+      return "" unless App.instance.environments.any?(&:sandbox?)
+
+      " [%s] " % Rainbow("sandbox").green.bright
+    end
+  end
+end

data/lib/monq/ssh_proxy.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "net/ssh/gateway"
+
+module Monq
+  class SSHProxy
+    attr_reader :local_port
+
+    def initialize(host:, user:, forward_host:, forward_port:, port: 22, password: nil, local_port: nil)
+      @host = host
+      @user = user
+      @forward_host = forward_host
+      @forward_port = forward_port
+      @opts = { port: port }
+      @opts[:password] = password if password
+      open_gateway!(local_port)
+    end
+
+    def database_host_port
+      { host: "127.0.0.1", port: @local_port }
+    end
+
+    def active?
+      @gateway.active?
+    end
+
+    def reconnect
+      reconnect! unless active?
+    end
+
+    def reconnect!
+      @gateway.shutdown!
+      open_gateway!(@local_port)
+    end
+
+    private
+
+    def open_gateway!(local_port)
+      @gateway = Net::SSH::Gateway.new(@host, @user, @opts)
+      @local_port = @gateway.open(@forward_host, @forward_port, local_port)
+    end
+  end
+end