arql 0.3.31 → 0.4.0

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
 

data/lib/arql/commands/sandbox.rb

@@ -9,16 +9,18 @@ module Arql::Commands
 
       def enter
         ActiveRecord::ConnectionAdapters::AbstractAdapter.set_callback(:checkout, :after, &@sandbox_callback)
-        ActiveRecord::Base.connection.begin_transaction(joinable: false)
+        Arql::App.instance.definitions.each do |_, definition|
+          definition.connection.begin_transaction(joinable: false)
+        end
         @enabled = true
       end
 
       def quit
         ActiveRecord::ConnectionAdapters::AbstractAdapter.skip_callback(:checkout, :after, &@sandbox_callback)
+        Arql::App.instance.definitions.each do |_, definition|
+          definition.connection.rollback_transaction
+        end
         @enabled = false
-
-        puts "begin_transaction callbacks removed."
-        puts "You still have open %d transactions open, don't forget commit or rollback them." % ActiveRecord::Base.connection.open_transactions if ActiveRecord::Base.connection.open_transactions > 0
       end
     end
 

data/lib/arql/commands.rb

@@ -1,11 +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'
 require 'arql/commands/sandbox'
-require 'arql/commands/vd'
 
 module Arql::Commands
 end

data/lib/arql/concerns/global_data_definition.rb

@@ -159,7 +159,14 @@ module Arql
         #
         # See also TableDefinition#column for details on how to create columns.
         def create_table(table_name, **options, &blk)
-          ActiveRecord::Base.connection.create_table(table_name, **options, &blk)
+          env_name = options[:env]
+          unless env_name
+            raise ArgumentError, ':env option is required' if Arql::App.instance.environments.size > 1
+
+            env_name = Arql::App.instance.environments.first
+          end
+          options = options.except(:env)
+          Arql::App.instance.definitions[env_name].connection.create_table(table_name, **options, &blk)
         end
 
         # Creates a new join table with the name created using the lexical order of the first two
@@ -201,7 +208,14 @@ module Arql
         #   ) ENGINE=InnoDB DEFAULT CHARSET=utf8
         #
         def create_join_table(table_1, table_2, column_options: {}, **options)
-          ActiveRecord::Base.connection.create_join_table(table_1, table_2, column_options, **options)
+          env_name = options[:env]
+          unless env_name
+            raise ArgumentError, ':env option is required' if Arql::App.instance.environments.size > 1
+
+            env_name = Arql::App.instance.environments.first
+          end
+          options = options.except(:env)
+          Arql::App.instance.definitions[env_name].connection.create_join_table(table_1, table_2, column_options, **options)
         end
 
         # Drops a table from the database.
@@ -217,7 +231,14 @@ module Arql
         # it can be helpful to provide these in a migration's +change+ method so it can be reverted.
         # In that case, +options+ and the block will be used by #create_table.
         def drop_table(table_name, **options)
-          ActiveRecord::Base.connection.drop_table(table_name, **options)
+          env_name = options[:env]
+          unless env_name
+            raise ArgumentError, ':env option is required' if Arql::App.instance.environments.size > 1
+
+            env_name = Arql::App.instance.environments.first
+          end
+          options = options.except(:env)
+          Arql::App.instance.definitions[env_name].connection.drop_table(table_name, **options)
         end
 
         # Drops the join table specified by the given arguments.
@@ -227,7 +248,14 @@ module Arql
         # to provide one in a migration's +change+ method so it can be reverted.
         # In that case, the block will be used by #create_join_table.
         def drop_join_table(table_1, table_2, **options)
-          ActiveRecord::Base.connection.drop_join_table(table_1, table_2, **options)
+          env_name = options[:env]
+          unless env_name
+            raise ArgumentError, ':env option is required' if Arql::App.instance.environments.size > 1
+
+            env_name = Arql::App.instance.environments.first
+          end
+          options = options.except(:env)
+          Arql::App.instance.definitions[env_name].connection.drop_join_table(table_1, table_2, **options)
         end
 
         # Renames a table.
@@ -235,9 +263,15 @@ module Arql
         #   rename_table('octopuses', 'octopi')
         #
         def rename_table(table_name, new_name)
-          ActiveRecord::Base.connection.rename_table(table_name, new_name)
-        end
+          env_name = options[:env]
+          unless env_name
+            raise ArgumentError, ':env option is required' if Arql::App.instance.environments.size > 1
 
+            env_name = Arql::App.instance.environments.first
+          end
+          options = options.except(:env)
+          Arql::App.instance.definitions[env_name].connection.rename_table(table_name, new_name)
+        end
       end
     end
   end

data/lib/arql/concerns/model_extension.rb

@@ -0,0 +1,168 @@
+module Arql
+  module Extension
+    extend ActiveSupport::Concern
+
+    def v(compact: false)
+      t = []
+      t << ['Attribute Name', 'Attribute Value', 'SQL Type', 'Comment']
+      t << nil
+      self.class.connection.columns(self.class.table_name).each do |column|
+        value = read_attribute(column.name)
+        if compact && value.blank?
+          next
+        end
+        t << [column.name, value, column.sql_type, column.comment || '']
+      end
+      t
+    end
+
+    def t(compact: false, format: :terminal)
+      puts Terminal::Table.new { |t|
+        t.style = self.class.table_style_for_format(format)
+        v(compact: compact).each { |row| t << (row || :separator) }
+      }.try { |e|
+        case format
+        when :md
+          e.to_s.lines.map { |l| '  ' + l }.join
+        when :org
+          e.to_s.lines.map { |l| '  ' + l.gsub(/^\+|\+$/, '|') }.join
+        else
+          e.to_s
+        end
+      }
+    end
+
+    def vd(compact: false)
+      VD.new do |vd|
+        vd << ['Attribute Name', 'Attribute Value', 'SQL Type', 'Comment']
+        self.class.connection.columns(self.class.table_name).each do |column|
+          value = read_attribute(column.name)
+          next if compact && value.blank?
+
+          vd << [column.name, read_attribute(column.name), column.sql_type, column.comment || '']
+        end
+      end
+    end
+
+    def to_insert_sql
+      self.class.to_insert_sql([self])
+    end
+
+    def to_upsert_sql
+      self.class.to_upsert_sql([self])
+    end
+
+    def write_csv(filename, *fields, **options)
+      [self].write_csv(filename, *fields, **options)
+    end
+
+    def write_excel(filename, *fields, **options)
+      [self].write_excel(filename, *fields, **options)
+    end
+
+    def dump(filename, batch_size=500)
+      [self].dump(filename, batch_size)
+    end
+
+    included do
+    end
+
+    class_methods do
+
+      def v
+        t = [['PK', 'Name', 'SQL Type', 'Ruby Type', 'Limit', 'Precision', 'Scale', 'Default', 'Nullable', 'Comment']]
+        t << nil
+        columns.each do |column|
+          pk = if [connection.primary_key(table_name)].flatten.include?(column.name)
+                 'Y'
+               else
+                 ''
+               end
+          t << [pk, 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, column.comment || '']
+        end
+        t
+      end
+
+      def t(format: :terminal)
+        heading_prefix = case format
+        when :md
+          '# '
+        when :org
+          '* '
+        when :sql
+          '-- '
+        end
+        puts "\n#{heading_prefix}Table: #{table_name}\n\n"
+        if format == :sql
+          puts to_create_sql + ';'
+        else
+          puts(Terminal::Table.new { |t|
+            t.style = self.table_style_for_format(format)
+            v.each { |row| t << (row || :separator) }
+          }.try { |e|
+            case format
+            when :md
+              e.to_s.lines.map { |l| '  ' + l }.join
+            when :org
+              e.to_s.lines.map { |l| '  ' + l.gsub(/^\+|\+$/, '|') }.join
+            else
+              e.to_s
+            end
+          })
+        end
+      end
+
+      def vd
+        VD.new do |vd|
+          v.each do |row|
+            vd << row if row
+          end
+        end
+        nil
+      end
+
+      def to_insert_sql(records, batch_size=1)
+        to_sql(records, :skip, batch_size)
+      end
+
+      def to_upsert_sql(records, batch_size=1)
+        to_sql(records, :update, batch_size)
+      end
+
+      def to_sql(records, on_duplicate, batch_size)
+        records.in_groups_of(batch_size, false).map do |group|
+          ActiveRecord::InsertAll.new(self, group.map(&:attributes), on_duplicate: on_duplicate).send(:to_sql) + ';'
+        end.join("\n")
+      end
+
+      def to_create_sql
+        superclass.definition.connection.exec_query("show create table `#{table_name}`").rows.last.last
+      end
+
+      def dump(filename, no_create_table=false)
+        Arql::Mysqldump.new(superclass.definition.options).dump_table(filename, table_name, no_create_table)
+      end
+
+      def table_style_for_format(format)
+        case format.to_s
+        when 'md'
+          {
+            border_top: false,
+            border_bottom: false,
+            border_i: '|'
+          }
+        when 'org'
+          {
+            border_top: false,
+            border_bottom: false,
+          }
+        else
+          {}
+        end
+      end
+    end
+  end
+end