arql 0.1.30

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/arql.gemspec

@@ -0,0 +1,40 @@
+require_relative 'lib/arql/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "arql"
+  spec.version       = Arql::VERSION
+  spec.authors       = ["Liu Xiang"]
+  spec.email         = ["liuxiang921@gmail.com"]
+
+  spec.summary       = %{Rails ActiveRecord + Pry is the best SQL query editor}
+  spec.description   = %{Use ActiveRecord and Pry as your favorite SQL query editor.}
+  spec.homepage      = "https://github.com/lululau/arql"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'mysql2', '~> 0.5.3'
+  # spec.add_dependency 'pg', '>= 0.18', '< 2.0'
+  spec.add_dependency 'sqlite3', '~> 1.4'
+  # spec.add_dependency 'activerecord-sqlserver-adapter'
+  # spec.add_dependency 'activerecord-oracle_enhanced-adapter'
+  spec.add_dependency 'activerecord', '~> 6.0.3'
+  spec.add_dependency 'activesupport', '~> 6.0.3'
+  spec.add_dependency 'net-ssh-gateway', '~> 2.0.0'
+  spec.add_dependency 'pry', '~> 0.13.1'
+  spec.add_dependency 'pry-byebug', '~> 3.9.0'
+  spec.add_dependency 'pry-doc', '~> 1.1.0'
+  spec.add_dependency 'rainbow', '~> 3.0.0'
+  spec.add_dependency 'terminal-table', '~> 1.8.0'
+  spec.add_dependency 'table_print', '~> 1.5.6'
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "arql"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/arql

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+ArqlSetsidWrrapper = File.dirname(File.absolute_path(__FILE__)) + '/arql_setsid_wrapper'
+
+require "arql"
+
+Arql::Cli.start

data/exe/arql_setsid_wrapper

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+Process.setsid
+
+exec(*ARGV)

data/lib/arql.rb

@@ -0,0 +1,12 @@
+require 'table_print'
+require "arql/version"
+require 'arql/id'
+require 'arql/multi_io'
+require 'arql/ext'
+require "arql/repl"
+require "arql/ssh_proxy"
+require "arql/app"
+require "arql/cli"
+
+module Arql
+end

data/lib/arql/app.rb

@@ -0,0 +1,137 @@
+require 'net/ssh/gateway'
+
+module Arql
+  class App
+
+    class << self
+      attr_accessor :log_io, :env
+
+      def config
+        @@effective_config
+      end
+    end
+
+    def initialize(options)
+      require 'active_support/all'
+      require 'active_record'
+      require "arql/connection"
+      require "arql/definition"
+      @options = options
+      App.env = @options.env
+      Connection.open(connect_options)
+      @definition = Definition.new(effective_config)
+      load_initializer!
+    end
+
+    def connect_options
+      connect_conf = effective_config.slice(:adapter, :host, :username,
+                             :password, :database, :encoding,
+                             :pool, :port, :socket)
+      if effective_config[:ssh].present?
+        connect_conf.merge!(start_ssh_proxy!)
+      end
+
+      connect_conf
+    end
+
+    def load_initializer!
+      return unless effective_config[:initializer]
+      initializer_file = File.expand_path(effective_config[:initializer])
+      unless File.exists?(initializer_file)
+        STDERR.puts "Specified initializer file not found, #{effective_config[:initializer]}"
+        exit(1)
+      end
+      load(initializer_file)
+    end
+
+    def start_ssh_proxy!
+      ssh_config = effective_config[:ssh]
+      local_ssh_proxy_port = Arql::SSHProxy.connect(ssh_config.slice(:host, :user, :port, :password).merge(
+                                                                                                           forward_host: effective_config[:host],
+                                                                                                           forward_port: effective_config[:port],
+                                                                                                           local_port: ssh_config[:local_port]))
+      {
+        host: '127.0.0.1',
+        port: local_ssh_proxy_port
+      }
+    end
+
+    def config
+      @config ||= YAML.load(IO.read(File.expand_path(@options.config_file))).with_indifferent_access
+    end
+
+    def selected_config
+      if @options.env.present? && !config[@options.env].present?
+        STDERR.puts "Specified ENV `#{@options.env}' not exists"
+      end
+      if env = @options.env
+        config[env]
+      else
+        {}
+      end
+    end
+
+    def effective_config
+      @@effective_config ||= nil
+      unless @@effective_config
+        @@effective_config = selected_config.deep_merge(@options.to_h)
+        if @@effective_config[:adapter].blank?
+          @@effective_config[:adapter] = 'sqlite3'
+        end
+        @@effective_config[:database] = File.expand_path(@@effective_config[:database]) if @@effective_config[:adapter] == 'sqlite3'
+      end
+      @@effective_config
+    end
+
+    def run!
+      show_sql if should_show_sql?
+      write_sql if should_write_sql?
+      append_sql if should_append_sql?
+      if effective_config[:code].present?
+        eval(effective_config[:code])
+      elsif effective_config[:args].present?
+        effective_config[:args].each { |rb| load(rb) }
+      elsif STDIN.isatty
+        run_repl!
+      else
+        eval(STDIN.read)
+      end
+    end
+
+    def run_repl!
+      Repl.new
+    end
+
+    def should_show_sql?
+      effective_config[:show_sql]
+    end
+
+    def should_write_sql?
+      effective_config[:write_sql]
+    end
+
+    def should_append_sql?
+      effective_config[:append_sql]
+    end
+
+    def show_sql
+      App.log_io ||= MultiIO.new
+      ActiveRecord::Base.logger = Logger.new(App.log_io)
+      App.log_io << STDOUT
+    end
+
+    def write_sql
+      write_sql_file = effective_config[:write_sql]
+      App.log_io ||= MultiIO.new
+      ActiveRecord::Base.logger = Logger.new(App.log_io)
+      App.log_io << File.new(write_sql_file, 'w')
+    end
+
+    def append_sql
+      write_sql_file = effective_config[:append_sql]
+      App.log_io ||= MultiIO.new
+      ActiveRecord::Base.logger = Logger.new(App.log_io)
+      App.log_io << File.new(write_sql_file, 'a')
+    end
+  end
+end

data/lib/arql/cli.rb

@@ -0,0 +1,141 @@
+require 'optparse'
+require 'ostruct'
+
+module Arql
+  class Cli
+    class << self
+      def start
+        parse_options!
+        App.new(@options).run!
+      end
+
+      def parse_options!
+        @options = OpenStruct.new(config_file: default_config_file,
+                                  initializer: default_initializer,
+                                  ssh: {})
+
+
+        OptionParser.new do |opts|
+          opts.banner = <<~EOF
+          Usage: arql [options] [ruby file]
+
+            If neither [ruby file] nor -e option specified, and STDIN is not a tty, a Pry REPL will be launched,
+            otherwise the specified ruby file or -e option value or ruby code read from STDIN will be run, and no REPL launched
+
+          EOF
+
+          opts.on('-cCONFIG_FILE', '--conf=CONFIG_FILE', 'Specify config file, default is $HOME/.arql.yml, or $HOME/.arql.d/init.yml.') do |config_file|
+            @options.config_file = config_file
+          end
+
+          opts.on('-iINITIALIZER', '--initializer=INITIALIZER', 'Specify initializer ruby file, default is $HOME/.arql.rb, or $HOME/.arql.d/init.rb.') do |initializer|
+            @options.initializer = initializer
+          end
+
+          opts.on('-eENVIRON', '--env=ENVIRON', 'Specify config environment.') do |env|
+            @options.env = env
+          end
+
+          opts.on('-aDB_ADAPTER', '--db-adapter=DB_ADAPTER', 'Specify database Adapter, default is mysql2') do |db_adapter|
+            @options.dapter = db_adapter
+          end
+
+          opts.on('-hDB_HOST', '--db-host=DB_HOST', 'Specify database host') do |db_host|
+            @options.host = db_host
+          end
+
+          opts.on('-pDB_PORT', '--db-port=DB_PORT', 'Specify database port') do |db_port|
+            @options.port = db_port.to_i
+          end
+
+          opts.on('-dDB_NAME', '--db-name=DB_NAME', 'Specify database name') do |db_name|
+            @options.database = db_name
+          end
+
+          opts.on('-uDB_USER', '--db-user=DB_USER', 'Specify database user') do |db_user|
+            @options.username = db_user
+          end
+
+          opts.on('-PDB_PASSWORD', '--db-password=DB_PASSWORD', 'Specify database password') do |db_password|
+            @options.password = db_password
+          end
+
+          opts.on('-n', '--db-encoding=DB_ENCODING', 'Specify database encoding, default is utf8') do |db_encoding|
+            @options.encoding = db_encoding
+          end
+
+          opts.on('-o', '--db-pool=DB_POOL', 'Specify database pool size, default is 5') do |db_pool|
+            @options.pool = db_pool
+          end
+
+          opts.on('-HSSH_HOST', '--ssh-host=SSH_HOST', 'Specify SSH host') do |ssh_host|
+            @options.ssh[:host] = ssh_host
+          end
+
+          opts.on('-OSSH_PORT', '--ssh-port=SSH_PORT', 'Specify SSH port') do |ssh_port|
+            @options.ssh[:port] = ssh_port.to_i
+          end
+
+          opts.on('-USSH_USER', '--ssh-user=SSH_USER', 'Specify SSH user') do |ssh_user|
+            @options.ssh[:user] = ssh_user
+          end
+
+          opts.on('-WSSH_PASSWORD', '--ssh-password=SSH_PASSWORD', 'Specify SSH password') do |ssh_password|
+            @options.ssh[:password] = ssh_password
+          end
+
+          opts.on('-LSSH_LOCAL_PORT', '--ssh-local-port=SSH_LOCAL_PORT', 'Specify local SSH proxy port') do |local_port|
+            @options.ssh[:local_port] = local_port.to_i
+          end
+
+          opts.on('-ECODE', '--eval=CODE', 'evaluate CODE') do |code|
+            @options.code = code
+          end
+
+          opts.on('-S', '--show-sql', 'Show SQL on STDOUT') do
+            @options.show_sql = true
+          end
+
+          opts.on('-wOUTOUT', '--write-sql=OUTPUT', 'Write SQL to OUTPUT file') do |file|
+            @options.write_sql = file
+          end
+
+          opts.on('-AOUTPUT', '--append-sql=OUTPUT', 'Append SQL to OUTPUT file') do |file|
+            @options.append_sql = file
+          end
+
+          opts.on('-V', '--version', 'Prints version') do
+            puts "ARQL #{Arql::VERSION}"
+            exit
+          end
+
+          opts.on('', '--help', 'Prints this help') do
+            puts opts
+            exit
+          end
+
+        end.parse!
+
+        @options.args = ARGV
+      end
+
+      def default_config_file
+        conf = File.expand_path('~/.arql.yml')
+        return conf if File.file?(conf)
+        conf = File.expand_path('~/.arql.yaml')
+        return conf if File.file?(conf)
+        conf = File.expand_path('~/.arql.d/init.yml')
+        return conf if File.file?(conf)
+        conf = File.expand_path('~/.arql.d/init.yaml')
+        return conf if File.file?(conf)
+      end
+
+      def default_initializer
+        conf = File.expand_path('~/.arql.rb')
+        return conf if File.file?(conf)
+        conf = File.expand_path('~/.arql.d/init.rb')
+        return conf if File.file?(conf)
+      end
+    end
+  end
+end

data/lib/arql/commands.rb

@@ -0,0 +1,9 @@
+require 'arql/commands/info'
+require 'arql/commands/models'
+require 'arql/commands/table'
+require 'arql/commands/reconnect'
+require 'arql/commands/redefine'
+require 'arql/commands/show_sql'
+
+module Arql::Commands
+end

data/lib/arql/commands/info.rb

@@ -0,0 +1,52 @@
+require 'rainbow'
+
+module Arql::Commands
+  module Info
+    class << self
+      def db_info
+        <<~EOF
+
+        Database Connection Information:
+
+            Active:    #{color_boolean(ActiveRecord::Base.connection.active?)}
+            Host:      #{Arql::App.config[:host]}
+            Port:      #{Arql::App.config[:port]}
+            Username:  #{Arql::App.config[:username]}
+            Password:  #{(Arql::App.config[:password] || '').gsub(/./, '*')}
+            Database:  #{Arql::App.config[:database]}
+            Adapter:   #{Arql::App.config[:adapter]}
+            Encoding:  #{Arql::App.config[:encoding]}
+            Pool Size: #{Arql::App.config[:pool]}
+        EOF
+      end
+
+      def ssh_info
+        <<~EOF
+
+        SSH Connection Information:
+
+            Active:     #{color_boolean(Arql::SSHProxy.active?)}
+            Host:       #{Arql::App.config[:ssh][:host]}
+            Port:       #{Arql::App.config[:ssh][:port]}
+            Username:   #{Arql::App.config[:ssh][:user]}
+            Password:   #{(Arql::App.config[:ssh][:password] || '').gsub(/./, '*')}
+            Local Port: #{Arql::SSHProxy.local_ssh_proxy_port}
+        EOF
+      end
+
+      private
+      def color_boolean(bool)
+        if bool
+          Rainbow('TRUE').green
+        else
+          Rainbow('FALSE').red
+        end
+      end
+    end
+
+    Pry.commands.block_command 'info' do
+      puts Info::db_info
+      puts Info::ssh_info if Arql::App.config[:ssh].present?
+    end
+  end
+end

data/lib/arql/commands/models.rb

@@ -0,0 +1,40 @@
+require 'terminal-table'
+
+module Arql::Commands
+  module Models
+    class << self
+      def models
+        t = []
+        t << ['Table Name', 'Model Class', 'Abbr']
+        t << nil
+        Arql::Definition.models.each do |definition|
+          t << [definition[:table], definition[:model].name, definition[:abbr] || '']
+        end
+        t
+      end
+
+      def models_table
+        Terminal::Table.new do |t|
+          models.each { |row| t << (row || :separator) }
+        end
+      end
+    end
+  end
+
+  Pry.commands.block_command 'm' do
+    puts
+    puts Models::models_table
+  end
+
+  Pry.commands.alias_command 'l', 'm'
+end
+
+module Kernel
+  def models
+    Arql::Commands::Models::models
+  end
+
+  def tables
+    models
+  end
+end