arql 0.1.31

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

data/lib/arql/commands/reconnect.rb

@@ -0,0 +1,23 @@
+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?
+      end
+
+      def reconnect!
+        Arql::SSHProxy.reconnect! if Arql::App.config[:ssh].present?
+        ActiveRecord::Base.connection.reconnect!
+      end
+    end
+
+    Pry.commands.block_command 'reconnect' do
+      Reconnect.reconnect
+    end
+
+    Pry.commands.block_command 'reconnect!' do
+      Reconnect.reconnect!
+    end
+  end
+end

data/lib/arql/commands/redefine.rb

@@ -0,0 +1,15 @@
+module Arql::Commands
+  module Redefine
+    class << self
+      def redefine
+        Arql::Definition.redefine
+      end
+    end
+
+    Pry.commands.block_command 'redefine' do
+      Redefine.redefine
+    end
+
+    Pry.commands.alias_command 'redef', 'redefine'
+  end
+end

data/lib/arql/commands/show_sql.rb

@@ -0,0 +1,25 @@
+module Arql::Commands
+  module ShowSql
+    class << self
+      def show
+        return if Arql::App.log_io.is_a?(Arql::MultiIO) && Arql::App.log_io.include?(STDOUT)
+        Arql::App.log_io ||= Arql::MultiIO.new
+        ActiveRecord::Base.logger = Logger.new(Arql::App.log_io)
+        Arql::App.log_io << STDOUT
+      end
+
+      def hide
+        return if !Arql::App.log_io.is_a?(Arql::MultiIO) || !Arql::App.log_io.include?(STDOUT)
+        Arql::App.log_io.delete(STDOUT)
+      end
+    end
+
+    Pry.commands.block_command 'show-sql' do
+      ShowSql.show
+    end
+
+    Pry.commands.block_command 'hide-sql' do
+      ShowSql.hide
+    end
+  end
+end

data/lib/arql/commands/table.rb

@@ -0,0 +1,55 @@
+require 'terminal-table'
+
+module Arql::Commands
+  module Table
+    class << self
+      def get_table_name(name)
+        name = name.to_s
+        return name if name =~ /^[a-z]/
+        if Object.const_defined?(name)
+          klass = Object.const_get(name)
+          return klass.table_name if klass < ActiveRecord::Base
+        end
+        name
+      end
+
+      def table_info_table(table_name)
+        Terminal::Table.new do |t|
+          table_info(table_name).each { |row| t << (row || :separator) }
+        end
+      end
+
+      def table_info(table_name)
+        t = []
+        t << ['PK', 'Name', 'SQL Type', 'Ruby Type', 'Limit', 'Precision', 'Scale', 'Default', 'Nullable', 'Comment']
+        t << nil
+        connection = ::ActiveRecord::Base.connection
+        connection.columns(table_name).each do |column|
+          pk = if column.name == connection.primary_key(table_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
+    end
+
+    Pry.commands.block_command 't' do |name|
+      table_name = Table::get_table_name(name)
+      puts
+      puts "Table: #{table_name}"
+      puts Table::table_info_table(table_name)
+    end
+  end
+end
+
+module Kernel
+  def table(name)
+    Arql::Commands::Table::table_info(Arql::Commands::Table::get_table_name(name))
+  end
+end

data/lib/arql/connection.rb

@@ -0,0 +1,10 @@
+module Arql
+  class Connection
+    class << self
+      def open(options)
+        ActiveRecord::Base.establish_connection(options)
+        $C = ActiveRecord::Base.connection
+      end
+    end
+  end
+end

data/lib/arql/definition.rb

@@ -0,0 +1,180 @@
+module Arql
+  module Extension
+    extend ActiveSupport::Concern
+
+    def t
+      puts Terminal::Table.new { |t|
+        v.each { |row| t << (row || :separator) }
+      }
+    end
+
+    def v
+      t = []
+      t << ['Attribute Name', 'Attribute Value', 'SQL Type', 'Comment']
+      t << nil
+      self.class.connection.columns(self.class.table_name).each do |column|
+        t << [column.name, read_attribute(column.name), column.sql_type, column.comment || '']
+      end
+      t
+    end
+
+    def to_insert_sql
+      self.class.to_insert_sql([self])
+    end
+
+    def to_upsert_sql
+      self.class.to_upsert_sql([self])
+    end
+
+    included do
+    end
+
+    class_methods do
+      def t
+        table_name = Commands::Table::get_table_name(name)
+        puts "\nTable: #{table_name}"
+        puts Commands::Table::table_info_table(table_name)
+      end
+
+      def v
+        table_name = Commands::Table::get_table_name(name)
+        Commands::Table::table_info(table_name)
+      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
+        ActiveRecord::Base.connection.exec_query("show create table #{table_name}").rows.last.last
+      end
+    end
+  end
+
+  class Definition
+    class << self
+      def models
+        @@models ||= []
+      end
+
+      def redefine
+        options = @@options
+        @@models.each do |model|
+          Object.send :remove_const, model[:model].name.to_sym if model[:model]
+          Object.send :remove_const, model[:abbr].to_sym if model[:abbr]
+        end
+        @@models = []
+        ActiveRecord::Base.connection.tap do |conn|
+          conn.tables.each do |table_name|
+            conn.primary_key(table_name).tap do |pkey|
+              table_name.camelize.tap do |const_name|
+                const_name = 'Modul' if const_name == 'Module'
+                const_name = 'Clazz' if const_name == 'Class'
+                Class.new(ActiveRecord::Base) do
+                  include Arql::Extension
+                  self.primary_key = pkey
+                  self.table_name = table_name
+                  self.inheritance_column = nil
+                  self.default_timezone = :local
+                  if options[:created_at].present?
+                    define_singleton_method :timestamp_attributes_for_create do
+                      options[:created_at]
+                    end
+                  end
+
+                  if options[:updated_at].present?
+                    define_singleton_method :timestamp_attributes_for_update do
+                      options[:updated_at]
+                    end
+                  end
+                end.tap do |clazz|
+                  Object.const_set(const_name, clazz).tap do |const|
+                    const_name.gsub(/[a-z]*/, '').tap do |abbr|
+                      unless Object.const_defined?(abbr)
+                        Object.const_set abbr, const
+                        abbr_const = abbr
+                      end
+
+                      @@models << {
+                        model: const,
+                        abbr: abbr_const,
+                        table: table_name
+                      }
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def initialize(options)
+      @@options = options
+      @@models = []
+      ActiveRecord::Base.connection.tap do |conn|
+        conn.tables.each do |table_name|
+          conn.primary_key(table_name).tap do |pkey|
+            table_name.camelize.tap do |const_name|
+              const_name = 'Modul' if const_name == 'Module'
+              const_name = 'Clazz' if const_name == 'Class'
+              Class.new(ActiveRecord::Base) do
+                include Arql::Extension
+                self.primary_key = pkey
+                self.table_name = table_name
+                self.inheritance_column = nil
+                self.default_timezone = :local
+                if options[:created_at].present?
+                  define_singleton_method :timestamp_attributes_for_create do
+                    options[:created_at]
+                  end
+                end
+
+                if options[:updated_at].present?
+                  define_singleton_method :timestamp_attributes_for_update do
+                    options[:updated_at]
+                  end
+                end
+              end.tap do |clazz|
+                Object.const_set(const_name, clazz).tap do |const|
+                  const_name.gsub(/[a-z]*/, '').tap do |abbr|
+                    unless Object.const_defined?(abbr)
+                      Object.const_set abbr, const
+                      abbr_const = abbr
+                    end
+
+                    @@models << {
+                      model: const,
+                      abbr: abbr_const,
+                      table: table_name
+                    }
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    ::ActiveRecord::Relation.class_eval do
+      def t
+        records.t
+      end
+
+      def v
+        records.v
+      end
+    end
+  end
+end

data/lib/arql/ext.rb

@@ -0,0 +1,5 @@
+require 'arql/ext/object'
+require 'arql/ext/array'
+require 'arql/ext/time'
+require 'arql/ext/string'
+require 'arql/ext/kernel'

data/lib/arql/ext/array.rb

@@ -0,0 +1,65 @@
+class Array
+  def to_insert_sql(batch_size=500)
+    raise 'All element should be an ActiveRecord instance object' unless all? { |e| e.is_a?(ActiveRecord::Base) }
+    group_by(&:class).map do |(klass, records)|
+      klass.to_insert_sql(records, batch_size)
+    end.join("\n")
+  end
+
+  def to_upsert_sql(batch_size=500)
+    raise 'All element should be an ActiveRecord instance object' unless all? { |e| e.is_a?(ActiveRecord::Base) }
+    group_by(&:class).map do |(klass, records)|
+      klass.to_upsert_sql(records, batch_size)
+    end.join("\n")
+  end
+
+  def t(*attrs)
+    if attrs.present? && present? && first.is_a?(ActiveRecord::Base)
+      puts Terminal::Table.new { |t|
+        t << attrs
+        t << :separator
+        each do |e|
+          t << e.attributes.values_at(*attrs.map(&:to_s))
+        end
+      }
+    else
+      table = Terminal::Table.new { |t|
+        v.each { |row| t << (row || :separator)}
+      }.to_s
+
+      terminal_width = `tput cols`.to_i
+      if table.lines.first.size > terminal_width
+        table = table.lines.map(&:chomp)
+        puts table[0..2].join("\n")
+        puts table[3..-1].join("\n#{'-' * terminal_width}\n")
+      else
+        puts table
+      end
+    end
+  end
+
+  def v
+    return self unless present?
+    t = []
+    if map(&:class).uniq.size == 1
+      if first.is_a?(ActiveRecord::Base)
+        t << first.attribute_names
+        t << nil
+        each do |e|
+          t << e.attributes.values_at(*first.attribute_names).map(&:as_json)
+        end
+      elsif first.is_a?(Array)
+        t = map { |a| a.map(&:as_json) }
+      elsif first.is_a?(Hash) || first.is_a?(ActiveSupport::HashWithIndifferentAccess)
+        t << first.keys
+        t << nil
+        each do |e|
+          t << e.values_at(*first.keys).map(&:as_json)
+        end
+      else
+        return self
+      end
+    end
+    t
+  end
+end

data/lib/arql/ext/kernel.rb

@@ -0,0 +1,5 @@
+module Kernel
+  def sql(sql)
+    ActiveRecord::Base.connection.exec_query(sql)
+  end
+end

data/lib/arql/ext/object.rb

@@ -0,0 +1,18 @@
+class Object
+
+  def j
+    to_json
+  end
+
+  def jj
+    JSON.pretty_generate(JSON.parse(to_json))
+  end
+
+  def jp
+    puts j
+  end
+
+  def jjp
+    puts jj
+  end
+end