arql 0.3.31 → 0.4.1

data/lib/arql/app.rb

@@ -1,114 +1,141 @@
 module Arql
   class App
+    attr_accessor :log_io, :environments, :definitions, :options, :config
 
     class << self
-      attr_accessor :log_io, :env, :prompt, :instance, :connect_options
+      attr_accessor :instance
 
-      def config
-        @@effective_config
+      def log_io
+        instance.log_io
+      end
+
+      def log_io=(io)
+        instance.log_io = io
+      end
+
+      # environment names
+      def environments
+        instance.environments
       end
 
       def prompt
-        if env
-          env
-        else
-          File.basename(@@effective_config[:database])
-        end
+        instance.prompt
+      end
+
+      def config
+        instance.config
+      end
+    end
+
+    def prompt
+      if environments.present?
+        environments.join('+')
+      else
+        File.basename(@options.database)
       end
     end
 
     def initialize(options)
-      require "arql/connection"
       require "arql/definition"
+
+      App.instance = self
+
+      # command line options
       @options = options
-      App.env = @options.env
-      App.connect_options = connect_options
-      Connection.open(App.connect_options)
+
+      # env names
+      @environments = @options.environments
+      @environments ||= ['default']
+
       print "Defining models..."
-      @definition = Definition.new(effective_config)
+      @definitions = config[:environments].each_with_object({}) do |(env_name, env_conf), h|
+        h[env_name] = Definition.new(env_conf)
+      end.with_indifferent_access
+
       print "\u001b[2K"
       puts "\rModels defined"
       print "Running initializers..."
       load_initializer!
       print "\u001b[2K"
       puts "\rInitializers loaded"
-      App.instance = self
-    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])
+      return unless config[:options][:initializer]
+
+      initializer_file = File.expand_path(config[:options][:initializer])
       unless File.exist?(initializer_file)
-        STDERR.puts "Specified initializer file not found, #{effective_config[:initializer]}"
+        warn "Specified initializer file not found, #{config[:options][: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)), aliases: true).with_indifferent_access
+    def config_from_file
+      @config_from_file ||= YAML.safe_load(IO.read(File.expand_path(@options.config_file)), aliases: true).with_indifferent_access
     rescue ArgumentError
-      @config ||= YAML.load(IO.read(File.expand_path(@options.config_file))).with_indifferent_access
+      @config_from_file ||= YAML.safe_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"
+    # Returns the configuration for config file.
+    #  or default configuration (built from CLI options) if no environment specified
+    def environ_config_from_file
+      if @options.enviroments.present? || @options.environments&.any? { |env_names| !config_from_file.key?(env_names) }
+        warn "Specified ENV `#{@options.env}' not exists in config file"
+        exit(1)
       end
-      if env = @options.env
-        config[env]
+      conf = if @options.environments.present?
+        @config_from_file.slice(*@options.environments)
       else
-        {}
+        { default: @options.to_h }.with_indifferent_access
       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'
+      conf.each do |env_name, env_conf|
+        unless env_conf.key?(:namespace)
+          env_conf[:namespace] = env_name.to_s.gsub(/[^a-zA-Z0-9]/, '_').camelize
         end
-        @@effective_config[:database] = File.expand_path(@@effective_config[:database]) if @@effective_config[:adapter] == 'sqlite3'
       end
-      @@effective_config
+    end
+
+    # Returns the effective configuration for the application.
+    # structure like:
+    # {
+    #   options: {show_sql: true,
+    #             write_sql: 'output.sql',
+    #             },
+    #   environments: {
+    #     development: {adapter: 'mysql2',
+    #                   host: 'localhost',
+    #                   port: 3306},
+    #     test: {adapter: 'mysql2',
+    #            host: 'localhost',
+    #            port: 3306},
+    #    }
+    # }
+    def config
+      @config ||= {
+        options: @options,
+        environments: environ_config_from_file.each_with_object({}) { |(env_name, env_conf), h|
+          conf = env_conf.deep_merge(@options.to_h)
+          conf[:adapter] = 'sqlite3' if conf[:adapter].blank?
+          conf[:database] = File.expand_path(conf[:database]) if conf[:adapter] == 'sqlite3'
+          h[env_name] = conf
+          h
+        }.with_indifferent_access
+      }
     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].first.tap { |file| load(file) }
-      elsif STDIN.isatty
+      if @options.code&.present?
+        eval(@options.code)
+      elsif @options.args.present?
+        @options.args.first.tap { |file| load(file) }
+      elsif $stdin.isatty
         run_repl!
       else
-        eval(STDIN.read)
+        eval($stdin.read)
       end
     end
 
@@ -117,32 +144,32 @@ module Arql
     end
 
     def should_show_sql?
-      effective_config[:show_sql]
+      @options.show_sql
     end
 
     def should_write_sql?
-      effective_config[:write_sql]
+      @options.write_sql
     end
 
     def should_append_sql?
-      effective_config[:append_sql]
+      @options.append_sql
     end
 
     def show_sql
       App.log_io ||= MultiIO.new
       ActiveRecord::Base.logger = Logger.new(App.log_io)
-      App.log_io << STDOUT
+      App.log_io << $stdout
     end
 
     def write_sql
-      write_sql_file = effective_config[:write_sql]
+      write_sql_file = @options.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]
+      write_sql_file = @options.append_sql
       App.log_io ||= MultiIO.new
       ActiveRecord::Base.logger = Logger.new(App.log_io)
       App.log_io << File.new(write_sql_file, 'a')

data/lib/arql/cli.rb

@@ -12,6 +12,7 @@ module Arql
       def parse_options!
         @options = OpenStruct.new(config_file: default_config_file,
                                   initializer: default_initializer,
+                                  babel_compatable: false,
                                   ssh: {})
 
 
@@ -19,7 +20,7 @@ module Arql
           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,
+            If neither [ruby file] nor -e option specified, and STDIN is 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
@@ -32,8 +33,12 @@ module Arql
             @options.initializer = initializer
           end
 
-          opts.on('-eENVIRON', '--env=ENVIRON', 'Specify config environment.') do |env|
-            @options.env = env
+          opts.on('-eENVIRON', '--env=ENVIRON', 'Specify config environment, multiple environments allowed, separated by comma') do |env_names|
+            @options.environments = env_names.split(/[,\+:]/)
+            if @options.environments.any? { |e| e =~ /^default|arql$/i }
+              warn '[default, arql] are reserved environment names, please use another name'
+              exit(1)
+            end
           end
 
           opts.on('-aDB_ADAPTER', '--db-adapter=DB_ADAPTER', 'Specify database Adapter, default is sqlite3') do |db_adapter|
@@ -92,6 +97,11 @@ module Arql
             @options.code = code
           end
 
+          opts.on('-b', '--babel', 'Enable compatibility for Org-Mode Babel') do
+            @options.babel_compatable = true
+          end
+
+
           opts.on('-S', '--show-sql', 'Show SQL on STDOUT') do
             @options.show_sql = true
           end
@@ -117,24 +127,36 @@ module Arql
         end.parse!
 
         @options.args = ARGV
+
+        if @options.environments&.size&.positive? && any_database_options?
+          $stderr.puts "Following options are not allowed when using multiple environments specified: #{database_options.join(', ')}"
+          $stderr.puts "    #{database_options.join(', ')}"
+          exit(1)
+        end
+      end
+
+      def any_database_options?
+        %i[adapter host port database username
+           password encoding pool ssh].reduce(false) do |acc, opt|
+          acc || @options.send(opt).present?
+        end
+      end
+
+      def database_options
+        ['--db-adapter', '--db-host', '--db-port', '--db-name', '--db-user', '--db-password',
+         '--db-encoding', '--db-pool', '--ssh-host', '--ssh-port', '--ssh-user', '--ssh-password', '--ssh-local-port']
       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)
+        ['~/.arql.yml', '~/.arql.yaml', '~/.arql.d/init.yml', '~/.arql.d/init.yaml'].find { |f|
+          File.file?(File.expand_path(f))
+        }.try { |f| File.expand_path(f) }
       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)
+        ['~/.arql.rb', '~/.arql.d/init.rb',].find { |f|
+          File.file?(File.expand_path(f))
+        }.try { |f| File.expand_path(f) }
       end
     end
   end

data/lib/arql/commands/info.rb

@@ -3,38 +3,49 @@ 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
+      def db_info(env_name_regexp)
+
+        Arql::App.instance.definitions.map do |env_name, definition|
+          next unless env_name =~ env_name_regexp
+          config = Arql::App.config[:environments][env_name]
+          <<~DB_INFO
+
+          #{env_name} Database Connection Information:
+
+              Active:    #{color_boolean(definition.connection.active?)}
+              Host:      #{config[:host]}
+              Port:      #{config[:port]}
+              Username:  #{config[:username]}
+              Password:  #{(config[:password] || '').gsub(/./, '*')}
+              Database:  #{config[:database]}
+              Adapter:   #{config[:adapter]}
+              Encoding:  #{config[:encoding]}
+              Pool Size: #{config[:pool]}
+          DB_INFO
+        end
       end
 
-      def ssh_info
-        <<~EOF
+      def ssh_info(env_name_regexp)
+        Arql::App.instance.definitions.map do |env_name, definition|
+          next unless env_name =~ env_name_regexp
+          config = Arql::App.config[:environments][env_name]
+          next unless config[:ssh].present?
+          <<~SSH_INFO
 
-        SSH Connection Information:
+          #{env_name} 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
+              Active:     #{color_boolean(definition.ssh_proxy.active?)}
+              Host:       #{config[:ssh][:host]}
+              Port:       #{config[:ssh][:port]}
+              Username:   #{config[:ssh][:user]}
+              Password:   #{(config[:ssh][:password] || '').gsub(/./, '*')}
+              Local Port: #{definition.ssh_proxy.local_ssh_proxy_port}
+          SSH_INFO
+        end
       end
 
       private
+
       def color_boolean(bool)
         if bool
           Rainbow('TRUE').green
@@ -44,9 +55,11 @@ module Arql::Commands
       end
     end
 
-    Pry.commands.block_command 'info' do
-      puts Info::db_info
-      puts Info::ssh_info if Arql::App.config[:ssh].present?
+    Pry.commands.block_command 'info' do |env_name_regexp|
+      env_name_regexp ||= '.*'
+      env_name_regexp = Regexp.new(env_name_regexp, Regexp::IGNORECASE)
+      output.puts Info::db_info(env_name_regexp)
+      output.puts Info::ssh_info(env_name_regexp)
     end
   end
 end

data/lib/arql/commands/models.rb

@@ -3,84 +3,129 @@ require 'terminal-table'
 module Arql::Commands
   module Models
     class << self
-      def models
-        t = []
-        t << ['Table Name', 'Model Class', 'Abbr', 'Comment']
-        t << nil
-        Arql::Definition.models.each do |definition|
-          t << [definition[:table], definition[:model].name, definition[:abbr] || '', definition[:comment] || '']
-        end
-        t
-      end
-
-      def models_table(table_regexp=nil, column_regexp=nil)
-        if column_regexp.nil?
-          Terminal::Table.new do |t|
-            models.each_with_index { |row, idx| t << (row || :separator) if row.nil? ||
-              table_regexp.nil? ||
-              idx.zero? ||
-              row.any? { |e| e =~ table_regexp }
-            }
+      def filter_tables(env_name, definition, format, table_regexp=nil)
+        result = ''
+        result << '-- ' if format == 'sql'
+        result << "Environment: #{env_name}\n"
+        result << "------------------------------\n\n"
+        if format == 'sql'
+          definition.models.each do |model|
+            if table_regexp? || ( model[:table] =~ table_regexp || model[:comment] =~ table_regexp )
+              result << "-- Table: #{table_name}\n\n"
+              result << definition.connection.exec_query("show create table `#{table_name}`").rows.last.last + ';'
+            end
           end
         else
-          connection = ::ActiveRecord::Base.connection
-          table = Terminal::Table.new do |t|
-            t << ['PK', 'Table', 'Model', 'Name', 'SQL Type', 'Ruby Type', 'Limit', 'Precision', 'Scale', 'Default', 'Nullable', 'Comment']
+          Terminal::Table.new do |t|
+            t.style = table_style_for_format(format)
+            t << ['Table Name', 'Model Class', 'Abbr', 'Comment']
             t << :separator
-            Arql::Definition.models.each do |definition|
-              model_class = definition[:model]
-              matched_columns = model_class.columns.select { |column| column.name =~ column_regexp || column.comment =~ column_regexp }
-              next if matched_columns.empty?
-              matched_columns.each do |column|
-                pk = if [connection.primary_key(definition[:table])].flatten.include?(column.name)
-                       'Y'
-                     else
-                       ''
-                     end
-                t << [pk, definition[:table], model_class.name, column.name, column.sql_type,
-                      column.sql_type_metadata.type, column.sql_type_metadata.limit || '',
-                      column.sql_type_metadata.precision || '', column.sql_type_metadata.scale || '', column.default || '',
-                      column.null, "#{definition[:comment]} - #{column.comment}"]
+            definition.models.each do |model|
+              if table_regexp.nil? || ( model[:table] =~ table_regexp || model[:comment] =~ table_regexp )
+                t << [model[:table], model[:model].name, model[:abbr] || '', model[:comment] || '']
               end
             end
+          end.try { |e|
+            case format
+            when 'md'
+              result << e.to_s.lines.map { |l| '  ' + l }.join
+            when 'org'
+              result << e.to_s.lines.map { |l| '  ' + l.gsub(/^\+|\+$/, '|') }.join
+            else
+              result << e.to_s
+            end
+          }
+        end
+        result
+      end
+
+      def filter_columns(env_name, definition, format, column_regexp=nil)
+        result = ''
+        result << '-- ' if format == 'sql'
+        result << "Environment: #{env_name}\n"
+        result << "------------------------------\n\n"
+        Terminal::Table.new do |t|
+          t.style = table_style_for_format(format)
+          t << ['Table', 'Model', 'Name', 'SQL Type', 'Ruby Type', 'Limit', 'Precision', 'Scale', 'Default', 'Nullable', 'Comment']
+          t << :separator
+          definition.models.each do |model_def|
+            model_class = model_def[:model]
+            matched_columns = model_class.columns.select { |column| column.name =~ column_regexp || column.comment =~ column_regexp }
+            next if matched_columns.empty?
+            matched_columns.each do |column|
+              t << [model_def[:table], model_class.name, column.name, column.sql_type,
+                    column.sql_type_metadata.type, column.sql_type_metadata.limit || '',
+                    column.sql_type_metadata.precision || '', column.sql_type_metadata.scale || '', column.default || '',
+                    column.null, "#{model_def[:comment]} - #{column.comment}"]
+            end
+          end
+        end.try { |e|
+          case format
+          when 'md'
+            result << e.to_s.lines.map { |l| '  ' + l }.join
+          when 'org'
+            result << e.to_s.lines.map { |l| '  ' + l.gsub(/^\+|\+$/, '|') }.join
+          else
+            result << e.to_s
           end
-          puts table
+        }
+        result
+      end
+
+      def table_style_for_format(format)
+        case format
+        when 'md'
+          {
+            border_top: false,
+            border_bottom: false,
+            border_i: '|'
+          }
+        when 'org'
+          {
+            border_top: false,
+            border_bottom: false,
+          }
+        else
+          {}
         end
       end
     end
   end
 
-  Pry.commands.block_command 'm' do |arg|
-    puts
-    if arg.start_with?('c=') or arg.start_with?('column=')
-      column_regexp = arg.sub(/^c(olumn)?=/, '')
-      Models::models_table(nil, column_regexp.try { |e| e.start_with?('/') ? eval(e) : Regexp.new(e) })
-    else
-      puts Models::models_table(arg.try { |e| e.start_with?('/') ? eval(e) : Regexp.new(e) }, nil)
+  Pry.commands.create_command 'm' do
+    description 'List models or columns (specified by `-c`): m [-e env_name_regexp] -c [column_regexp] [table_regexp]'
+
+    def options(opt)
+      opt.on '-e', '--env', 'Environment name regexp', argument: true, as: String, required: false, default: nil
+      opt.on '-f', '--format', 'Table format, available: terminal(default), md, org, sql', argument: true, as: String, required: false, default: 'terminal'
+      opt.on '-c', '--column', 'Column name regexp', argument: true, as: String, required: false, default: nil
     end
-  end
 
-  Pry.commands.alias_command 'l', 'm'
-end
+    def process
 
-module Kernel
-  def models
-    Arql::Commands::Models::models
-  end
+      if opts[:format] == 'sql' && opts[:column]
+        output.puts 'SQL format is not supported for column listing'
+        return
+      end
 
-  def tables
-    models
-  end
+      env_names = opts[:env].try {|e| [e]}.presence || Arql::App.environments
+      env_names = env_names.map { |e| e.start_with?('/') ? eval(e) : Regexp.new(e) }
 
-  def model_classes
-    ::ArqlModel.subclasses
-  end
+      Arql::App.instance.definitions.each do |env_name, definition|
+        next unless env_names.any? { |e| env_name =~ e }
 
-  def table_names
-    models[2..-1].map(&:first)
-  end
+        output.puts
+        if opts[:column]
+          column_regexp = opts[:column]
+          output.puts Models::filter_columns(env_name, definition, opts[:format], column_regexp.try { |e| e.start_with?('/') ? eval(e) : Regexp.new(e) })
+        else
+          table_regexp = args&.first
+          output.puts Models::filter_tables(env_name, definition, opts[:format], table_regexp.try { |e| e.start_with?('/') ? eval(e) : Regexp.new(e) })
+        end
+      end
+    end
 
-  def model_names
-    models[2..-1].map(&:second)
   end
+
+  Pry.commands.alias_command 'l', 'm'
 end

data/lib/arql/commands/reconnect.rb

@@ -2,13 +2,17 @@ module Arql::Commands
   module Reconnect
     class << self
       def reconnect
-        Arql::SSHProxy.reconnect if Arql::App.config[:ssh].present?
-        ActiveRecord::Base.connection.reconnect! unless ActiveRecord::Base.connection.active?
+        Arql::App.instance.definitions.each do |_, definition|
+          definition.ssh_proxy.reconnect if definition.options[:ssh].present?
+          definition.connection.reconnect! unless definition.connection.active?
+        end
       end
 
       def reconnect!
-        Arql::SSHProxy.reconnect! if Arql::App.config[:ssh].present?
-        ActiveRecord::Base.connection.reconnect!
+        Arql::App.instance.definitions.each do |_, definition|
+          definition.ssh_proxy.reconnect if definition.options[:ssh].present?
+          definition.connection.reconnect!
+        end
       end
     end
 

data/lib/arql/commands/redefine.rb

@@ -2,7 +2,9 @@ module Arql::Commands
   module Redefine
     class << self
       def redefine
-        Arql::Definition.redefine
+        Arql::App.instance.definitions.each do |_, definition|
+          definition.redefine
+        end
       end
     end