arql 0.3.30 → 0.4.0

data/lib/arql/commands/models.rb

@@ -3,54 +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] || '']
+      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
+          Terminal::Table.new do |t|
+            t.style = table_style_for_format(format)
+            t << ['Table Name', 'Model Class', 'Abbr', 'Comment']
+            t << :separator
+            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
-        t
+        result
       end
 
-      def models_table(regexp)
+      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|
-          models.each_with_index { |row, idx| t << (row || :separator) if row.nil? ||
-            regexp.nil? ||
-            idx.zero? ||
-            row.any? { |e| e =~ regexp }
+          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
+        }
+        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 |regexp|
-    puts
-    puts Models::models_table(regexp.try { |e| e.start_with?('/') ? eval(e) : Regexp.new(e) })
-  end
+  Pry.commands.create_command 'm' do
+    description 'List models or columns (specified by `-c`): m [-e env_name_regexp] -c [column_regexp] [table_regexp]'
 
-  Pry.commands.alias_command 'l', 'm'
-end
+    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
 
-module Kernel
-  def models
-    Arql::Commands::Models::models
-  end
+    def process
 
-  def tables
-    models
-  end
+      if opts[:format] == 'sql' && opts[:column]
+        output.puts 'SQL format is not supported for column listing'
+        return
+      end
 
-  def model_classes
-    ::ArqlModel.subclasses
-  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 table_names
-    models[2..-1].map(&:first)
-  end
+      Arql::App.instance.definitions.each do |env_name, definition|
+        next unless env_names.any? { |e| env_name =~ e }
+
+        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

data/lib/arql/concerns/table_data_definition.rb

@@ -91,7 +91,7 @@ module Arql
         #  Shape.add_column(:triangle, 'polygon')
         #  # ALTER TABLE "shapes" ADD "triangle" polygon
         def add_column(column_name, type, **options)
-          ActiveRecord::Base.connection.add_column(table_name, column_name, type, **options)
+          connection.add_column(table_name, column_name, type, **options)
         end
 
         # Changes the column's definition according to the new options.
@@ -101,7 +101,7 @@ module Arql
         #   Post.change_column(:description, :text)
         #
         def change_column(column_name, type, options = {})
-          ActiveRecord::Base.connection.change_column(table_name, column_name, type, **options)
+          connection.change_column(table_name, column_name, type, **options)
         end
 
         # Removes the column from the table definition.
@@ -113,7 +113,7 @@ module Arql
         # In that case, +type+ and +options+ will be used by #add_column.
         # Indexes on the column are automatically removed.
         def remove_column(column_name, type = nil, **options)
-          ActiveRecord::Base.connection.remove_column(table_name, column_name, type, **options)
+          connection.remove_column(table_name, column_name, type, **options)
         end
 
         # Adds a new index to the table. +column_name+ can be a single Symbol, or
@@ -229,7 +229,7 @@ module Arql
         #
         # For more information see the {"Transactional Migrations" section}[rdoc-ref:Migration].
         def add_index(column_name, options = {})
-          ActiveRecord::Base.connection.add_index(table_name, column_name, **options)
+          connection.add_index(table_name, column_name, **options)
         end
 
         # Adds a new foreign key.
@@ -277,7 +277,7 @@ module Arql
         # [<tt>:validate</tt>]
         #   (PostgreSQL only) Specify whether or not the constraint should be validated. Defaults to +true+.
         def add_foreign_key(to_table, **options)
-          ActiveRecord::Base.connection.add_foreign_key(table_name, to_table, **options)
+          connection.add_foreign_key(table_name, to_table, **options)
         end
 
         # Adds timestamps (+created_at+ and +updated_at+) columns to this table.
@@ -286,7 +286,7 @@ module Arql
         #   Supplier.add_timestamps(null: true)
         #
         def add_timestamps(**options)
-          ActiveRecord::Base.connection.add_timestamps(table_name, **options)
+          connection.add_timestamps(table_name, **options)
         end
 
         # Changes the comment for a column or removes it if +nil+.
@@ -296,7 +296,7 @@ module Arql
         #
         #   Post.change_column_comment(:state, from: "old_comment", to: "new_comment")
         def change_column_comment(column_name, comment_or_changes)
-          ActiveRecord::Base.connection.change_column_comment(table_name, column_name, comment_or_changes)
+          connection.change_column_comment(table_name, column_name, comment_or_changes)
         end
 
         # Sets a new default value for a column:
@@ -314,7 +314,7 @@ module Arql
         #   Post.change_column_default(:state, from: nil, to: "draft")
         #
         def change_column_default(column_name, default_or_changes)
-          ActiveRecord::Base.connection.change_column_default(table_name, column_name, default_or_changes)
+          connection.change_column_default(table_name, column_name, default_or_changes)
         end
 
         # Sets or removes a <tt>NOT NULL</tt> constraint on a column. The +null+ flag
@@ -334,7 +334,7 @@ module Arql
         #
         # Please note the fourth argument does not set a column's default.
         def change_column_null(column_name, null, default = nil)
-          ActiveRecord::Base.connection.change_column_null(table_name, column_name, null, default)
+          connection.change_column_null(table_name, column_name, null, default)
         end
 
         # Renames a column.
@@ -342,7 +342,7 @@ module Arql
         #   Supplier.rename_column(:description, :name)
         #
         def rename_column(column_name, new_column_name)
-          ActiveRecord::Base.connection.rename_column(table_name, column_name, new_column_name)
+          connection.rename_column(table_name, column_name, new_column_name)
         end
 
         # A block for changing columns in +table+.
@@ -418,7 +418,7 @@ module Arql
         #
         # See also Table for details on all of the various column transformations.
         def change_table(**options)
-          ActiveRecord::Base.connection.change_table(table_name, **options)
+          connection.change_table(table_name, **options)
         end
 
         # Renames a table.
@@ -426,7 +426,7 @@ module Arql
         #   rename_table('octopi')
         #
         def rename_table(new_name)
-          ActiveRecord::Base.connection.rename_table(table_name, new_name)
+          connection.rename_table(table_name, new_name)
         end
 
         # Changes the comment for a table or removes it if +nil+.
@@ -436,7 +436,7 @@ module Arql
         #
         #   Post.change_table_comment(from: "old_comment", to: "new_comment")
         def change_table_comment(comment_or_changes)
-          ActiveRecord::Base.connection.change_table_comment(table_name, comment_or_changes)
+          connection.change_table_comment(table_name, comment_or_changes)
         end
 
         # Drops a table from the database.
@@ -452,13 +452,13 @@ 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(**options)
-          ActiveRecord::Base.connection.drop_table(table_name, **options)
+          connection.drop_table(table_name, **options)
         end
 
         # Returns an array of foreign keys for the given table.
         # The foreign keys are represented as ForeignKeyDefinition objects.
         def foreign_keys
-          ActiveRecord::Base.connection.foreign_keys(table_name)
+          connection.foreign_keys(table_name)
         end
 
         # Removes the given foreign key from the table. Any option parameters provided
@@ -487,7 +487,7 @@ module Arql
         # [<tt>:to_table</tt>]
         #   The name of the table that contains the referenced primary key.
         def remove_foreign_key(to_table = nil, **options)
-          ActiveRecord::Base.connection.remove_foreign_key(table_name, to_table, **options)
+          connection.remove_foreign_key(table_name, to_table, **options)
         end
 
         # Removes the given index from the table.
@@ -518,7 +518,7 @@ module Arql
         #
         # For more information see the {"Transactional Migrations" section}[rdoc-ref:Migration].
         def remove_index(options = {})
-          ActiveRecord::Base.connection.remove_index(table_name, **options)
+          connection.remove_index(table_name, **options)
         end
 
         # Removes the timestamp columns (+created_at+ and +updated_at+) from the table definition.
@@ -526,7 +526,7 @@ module Arql
         #  Supplier.remove_timestamps
         #
         def remove_timestamps(**options)
-          ActiveRecord::Base.connection.remove_timestamps(**options)
+          connection.remove_timestamps(**options)
         end
 
         # Renames an index.
@@ -536,12 +536,12 @@ module Arql
         #   Person.rename_index 'index_people_on_last_name', 'index_users_on_last_name'
         #
         def rename_index(old_name, new_name)
-          ActiveRecord::Base.connection.rename_index(table_name, old_name, new_name)
+          connection.rename_index(table_name, old_name, new_name)
         end
 
         # Returns the table comment that's stored in database metadata.
         def table_comment
-          ActiveRecord::Base.connection.table_comment(table_name)
+          connection.table_comment(table_name)
         end
 
       end

data/lib/arql/concerns.rb

@@ -1,2 +1,3 @@
 require 'arql/concerns/global_data_definition'
 require 'arql/concerns/table_data_definition'
+require 'arql/concerns/model_extension'