pry-helper 0.1.0

data/lib/pry-helper/definition.rb

@@ -0,0 +1,246 @@
+require 'pry-helper/concerns'
+require 'pry-helper/vd'
+
+module PryHelper
+  module Extension
+    extend ActiveSupport::Concern
+
+    def t
+      puts Terminal::Table.new { |t|
+        v.each { |row| t << (row || :separator) }
+      }
+    end
+
+    def vd
+      VD.new do |vd|
+        vd << ['Attribute Name', 'Attribute Value', 'SQL Type', 'Comment']
+        self.class.connection.columns(self.class.table_name).each do |column|
+          vd << [column.name, read_attribute(column.name), column.sql_type, column.comment || '']
+        end
+      end
+    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
+
+    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 t
+        table_name = Commands::Table::get_table_name(name)
+        puts "\nTable: #{table_name}"
+        puts Commands::Table::table_info_table(table_name)
+      end
+
+      def vd
+        table_name = Commands::Table::get_table_name(name)
+        Commands::VD::table_info_vd(table_name)
+        nil
+      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
+
+      def dump(filename, no_create_table=false)
+        PryHelper::Mysqldump.new.dump_table(filename, table_name, no_create_table)
+      end
+    end
+  end
+
+  class Definition
+    class << self
+      def models
+        @@models ||= []
+      end
+    end
+
+    def initialize
+      @@models = []
+
+      ActiveRecord::Base.connection.tap do |conn|
+        defined_models = ::ApplicationRecord.descendants
+        tables = conn.tables
+        if conn.adapter_name == 'Mysql2'
+          conn.define_singleton_method(:dump) do |filename, no_create_db=false|
+            PryHelper::Mysqldump.new.dump_database(filename, no_create_db)
+          end
+          require 'pry-helper/ext/active_record/connection_adapters/abstract_mysql_adapter'
+          comments = conn.table_comment_of_tables(tables)
+          primary_keys = conn.primary_keys_of_tables(tables)
+        else
+          comments = tables.map { |t| [t, conn.table_comment(t)] }.to_h
+          primary_keys = tables.map { |t| [t, conn.primary_keys(t)] }.to_h
+        end
+
+        ApplicationRecord.include(PryHelper::Extension)
+
+        tables.each do |table_name|
+          table_comment = comments[table_name]
+          primary_keys[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'
+              if model_class = defined_models.find { |m| m.table_name == table_name }
+                model_class.tap do |clazz|
+                  model_class.name.gsub(/[a-z]*/, '').tap do |bare_abbr|
+                    abbr_const = nil
+                    9.times do |idx|
+                      abbr = idx.zero? ? bare_abbr : "#{bare_abbr}#{idx+1}"
+                      unless Object.const_defined?(abbr)
+                        Object.const_set abbr, model_class
+                        abbr_const = abbr
+                        break
+                      end
+                    end
+
+                    @@models << {
+                      model: model_class,
+                      abbr: abbr_const,
+                      table: table_name,
+                      comment: table_comment
+                    }
+                  end
+                end
+              else
+                Class.new(::ApplicationRecord) do
+                  if pkey.is_a?(Array) && pkey.size > 1
+                    self.primary_keys = pkey
+                  else
+                    self.primary_key = pkey&.first
+                  end
+                  self.table_name = table_name
+                  self.inheritance_column = nil
+                  ActiveRecord.default_timezone = :local
+                end.tap do |clazz|
+                  Object.const_set(const_name, clazz).tap do |const|
+                    const_name.gsub(/[a-z]*/, '').tap do |bare_abbr|
+                      abbr_const = nil
+                      9.times do |idx|
+                        abbr = idx.zero? ? bare_abbr : "#{bare_abbr}#{idx+1}"
+                        unless Object.const_defined?(abbr)
+                          Object.const_set abbr, const
+                          abbr_const = abbr
+                          break
+                        end
+                      end
+
+                      @@models << {
+                        model: const,
+                        abbr: abbr_const,
+                        table: table_name,
+                        comment: table_comment
+                      }
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    ::ActiveRecord::Relation.class_eval do
+      def t(*attrs, **options)
+        records.t(*attrs, **options)
+      end
+
+      def vd(*attrs, **options)
+        records.vd(*attrs, **options)
+      end
+
+      def v
+        records.v
+      end
+
+      def a
+        to_a
+      end
+
+      def write_csv(filename, *fields, **options)
+        records.write_csv(filename, *fields, **options)
+      end
+
+      def write_excel(filename, *fields, **options)
+        records.write_excel(filename, *fields, **options)
+      end
+
+      def dump(filename, batch_size=500)
+        records.dump(filename, batch_size)
+      end
+    end
+
+    ::ActiveRecord::Result.class_eval do
+      def t(*attrs, **options)
+        to_a.t(*attrs, **options)
+      end
+
+      def vd(*attrs, **options)
+        to_a.vd(*attrs, **options)
+      end
+
+      def v
+        to_a.v
+      end
+
+      def a
+        to_a
+      end
+
+      def write_csv(filename, *fields, **options)
+        to_a.write_csv(filename, *fields, **options)
+      end
+
+      def write_excel(filename, *fields, **options)
+        to_a.write_excel(filename, *fields, **options)
+      end
+    end
+  end
+end

data/lib/pry-helper/ext/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -0,0 +1,53 @@
+require 'active_record/connection_adapters/abstract_mysql_adapter'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class AbstractMysqlAdapter
+
+      def extract_schema_qualified_name_of_tables(table_names)
+        table_names.map do |string|
+          schema, name = string.to_s.scan(/[^`.\s]+|`[^`]*`/)
+          schema, name = nil, schema unless name
+          [schema, name]
+        end
+      end
+
+      def quoted_scope_of_tables(names = nil)
+        extract_schema_qualified_name_of_tables(names).map do |(schema, name)|
+          scope = {}
+          scope[:schema] = schema ? quote(schema) : "database()"
+          scope[:name] = quote(name) if name
+          scope
+        end
+      end
+
+      def primary_keys_of_tables(table_names) # :nodoc:
+        raise ArgumentError unless table_names.present?
+
+        scopes = quoted_scope_of_tables(table_names)
+
+        res = query(<<~SQL, "SCHEMA")
+        SELECT table_name, column_name
+        FROM information_schema.statistics
+        WHERE index_name = 'PRIMARY'
+        AND (table_schema, table_name) in
+        (#{scopes.map { |scope| "(#{scope[:schema]}, #{scope[:name]})" }.join(', ')})
+          ORDER BY seq_in_index
+        SQL
+
+        res.group_by(&:first).map { |table, vlaues| [table, vlaues.map(&:last)] }.to_h
+      end
+
+      def table_comment_of_tables(table_names) # :nodoc:
+        scopes = quoted_scope_of_tables(table_names)
+
+        query(<<~SQL, "SCHEMA").presence.try(&:to_h)
+        SELECT table_name, table_comment
+        FROM information_schema.tables
+        WHERE (table_schema, table_name) in
+        (#{scopes.map { |scope| "(#{scope[:schema]}, #{scope[:name]})" }.join(', ')})
+        SQL
+      end
+    end
+  end
+end

data/lib/pry-helper/ext/active_record/connection_adapters/postgresql/schema_statements.rb

@@ -0,0 +1,8 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module SchemaStatements
+      end
+    end
+  end
+end

data/lib/pry-helper/ext/array.rb

@@ -0,0 +1,168 @@
+require 'pry-helper/vd'
+
+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, **options)
+    if (attrs.present? || options.present? && options[:except]) && present? && first.is_a?(ActiveRecord::Base)
+      column_names = first.attribute_names.map(&:to_sym)
+      attrs = attrs.flat_map { |e| e.is_a?(Regexp) ? column_names.grep(e) : e }.uniq
+      if options.present? && options[:except]
+        attrs = column_names if attrs.empty?
+        if options[:except].is_a?(Regexp)
+          attrs.reject! { |e| e =~ options[:except] }
+        else
+          attrs -= [options[:except]].flatten
+        end
+      end
+      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 vd(*attrs, **options)
+    if (attrs.present? || options.present? && options[:except]) && present? && first.is_a?(ActiveRecord::Base)
+      column_names = first.attribute_names.map(&:to_sym)
+      attrs = attrs.flat_map { |e| e.is_a?(Regexp) ? column_names.grep(e) : e }.uniq
+      if options.present? && options[:except]
+        attrs = column_names if attrs.empty?
+        if options[:except].is_a?(Regexp)
+          attrs.reject! { |e| e =~ options[:except] }
+        else
+          attrs -= [options[:except]].flatten
+        end
+      end
+
+      PryHelper::VD.new do |vd|
+        vd << attrs
+        each do |e|
+          vd << e.attributes.values_at(*attrs.map(&:to_s))
+        end
+      end
+    else
+      PryHelper::VD.new do |vd|
+        v.each { |row| vd << row if row }
+      end
+    end
+    nil
+  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
+
+  def write_csv(filename, *fields, **options)
+    generate_csv(filename, **options) do |csv|
+      if size > 0 && first.is_a?(ActiveRecord::Base)
+        if fields.empty?
+          fields = first.attributes.keys
+        else
+          fields = fields.map(&:to_s)
+        end
+        csv << fields
+      end
+      if size > 0 && first.is_a?(Hash)
+        if fields.empty?
+          fields = first.keys
+        end
+        csv << fields
+      end
+      each do |row|
+        if row.is_a?(Array)
+          csv << row.map(&:to_s)
+        else
+          csv << row.slice(*fields).values.map(&:to_s)
+        end
+      end
+    end
+  end
+
+  def write_excel(filename, *fields, **options)
+    sheet_name = options[:sheet_name] || 'Sheet1'
+    generate_excel(filename) do |workbook|
+      workbook.add_worksheet(name: sheet_name) do |sheet|
+        if size > 0 && first.is_a?(ActiveRecord::Base)
+          if fields.empty?
+            fields = first.attributes.keys
+          else
+            fields = fields.map(&:to_s)
+          end
+          sheet.add_row(fields, types: [:string] * fields.size)
+        end
+        if size > 0 && first.is_a?(Hash)
+          if fields.empty?
+            fields = first.keys
+          end
+          sheet.add_row(fields, types: [:string] * fields.size)
+        end
+        each do |row|
+          if row.is_a?(Array)
+            sheet.add_row(row.map(&:to_s), types: [:string] * row.size)
+          else
+            sheet.add_row(row.slice(*fields).values.map(&:to_s), types: [:string] * fields.size)
+          end
+        end
+      end
+    end
+  end
+
+  def dump(filename, batch_size=500)
+    File.open(File.expand_path(filename), 'w') do |file|
+      group_by(&:class).each do |(klass, records)|
+        file.puts(klass.to_upsert_sql(records, batch_size))
+      end
+    end
+    {size: size, file: File.expand_path(filename)}
+  end
+end

data/lib/pry-helper/ext/hash.rb

@@ -0,0 +1,41 @@
+class Hash
+  def write_excel(filename)
+    generate_excel(filename) do |workbook|
+      each do |sheet_name, sheet_data|
+        workbook.add_worksheet(name: sheet_name) do |sheet|
+          if sheet_data.is_a?(Hash)
+            fields = sheet_data[:fields].map(&:to_s)
+            sheet.add_row(fields, types: [:string] * fields.size)
+            sheet_data[:data].each do |row|
+              sheet.add_row(row.slice(*fields).values.map(&:to_s), types: [:string] * fields.size)
+            end
+          end
+
+          if sheet_data.is_a?(Array)
+            if sheet_data.size > 0 && sheet_data.first.is_a?(ActiveModel::Base)
+              fields = sheet_data.first.attributes.keys
+              sheet.add_row(fields, types: [:string] * fields.size)
+              sheet_data.each do |row|
+                sheet.add_row(row.slice(*fields).values.map(&:to_s), types: [:string] * fields.size)
+              end
+            end
+
+            if sheet_data.size > 0 && sheet_data.first.is_a?(Hash)
+              fields = sheet_data.first.keys
+              sheet.add_row(fields, types: [:string] * fields.size)
+              sheet_data.each do |row|
+                sheet.add_row(row.slice(*fields).values.map(&:to_s), types: [:string] * fields.size)
+              end
+            end
+
+            if sheet_data.size > 0 && sheet_data.first.is_a?(Array)
+              sheet_data.each do |row|
+                sheet.add_row(row.map(&:to_s), types: [:string] * fields.size)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pry-helper/ext/kernel.rb

@@ -0,0 +1,111 @@
+require 'pry-helper/concerns'
+module Kernel
+  CSV_BOM = "\xef\xbb\xbf"
+
+  include ::PryHelper::Concerns::GlobalDataDefinition
+
+  def sql(sql)
+    ActiveRecord::Base.connection.exec_query(sql)
+  end
+
+  def print_tables(format = :md)
+
+    tables = ActiveRecord::Base.connection.tables.map do |table_name|
+      {
+        table: table_name,
+        table_comment: ActiveRecord::Base.connection.table_comment(table_name) || '',
+        columns: ::ActiveRecord::Base.connection.columns(table_name)
+      }
+    end
+
+    outputs = tables.map do |table|
+      table_name = table[:table]
+      table_comment = table[:table_comment]
+      case format
+      when :md
+        "# #{table_name} #{table_comment}\n\n" +
+          Terminal::Table.new { |t|
+          t.headings = ['PK', 'Name', 'SQL Type', 'Limit', 'Precision', 'Scale', 'Default', 'Nullable', 'Comment']
+          t.rows = table[:columns].map { |column|
+            pk = if [::ActiveRecord::Base.connection.primary_key(table_name)].flatten.include?(column)
+                   'Y'
+                 else
+                   ''
+                 end
+            [pk, "`#{column.name}`", column.sql_type, column.sql_type_metadata.limit || '', column.sql_type_metadata.precision || '',
+             column.sql_type_metadata.scale || '', column.default || '', column.null, column.comment || '']
+          }
+          t.style = {
+            border_top: false,
+            border_bottom: false,
+            border_i: '|'
+          }
+        }.to_s.lines.map { |l| '  ' + l }.join
+      when :org
+        "* #{table_name} #{table_comment}\n\n" +
+          Terminal::Table.new { |t|
+          t.headings = ['PK', 'Name', 'SQL Type', 'Limit', 'Precision', 'Scale', 'Default', 'Nullable', 'Comment']
+          t.rows = table[:columns].map { |column|
+            pk = if [::ActiveRecord::Base.connection.primary_key(table_name)].flatten.include?(column)
+                   'Y'
+                 else
+                   ''
+                 end
+            [pk, "=#{column.name}=", column.sql_type, column.sql_type_metadata.limit || '', column.sql_type_metadata.precision || '',
+             column.sql_type_metadata.scale || '', column.default || '', column.null, column.comment || '']
+          }
+          t.style = {
+            border_top: false,
+            border_bottom: false,
+          }
+        }.to_s.lines.map { |l| '  ' + l.gsub(/^\+|\+$/, '|') }.join
+      when :sql
+        "-- Table: #{table_name}\n\n" + ActiveRecord::Base.connection.exec_query("show create table `#{table_name}`").rows.last.last + ';'
+      end
+    end
+
+    outputs.each { |out| puts out; puts }
+  end
+
+  def generate_csv(filename, **options, &block)
+    opts = {
+      col_sep: "\t",
+      row_sep: "\r\n"
+    }
+    opts.merge!(options.except(:encoding))
+    encoding = options[:encoding] || 'UTF-16LE'
+    File.open(File.expand_path(filename), "w:#{encoding}") do |file|
+      file.write(CSV_BOM)
+      file.write CSV.generate(**opts, &block)
+    end
+  end
+
+  def parse_csv(filename, **options)
+    encoding = options[:encoding] || 'UTF-16'
+    opts = {
+      headers: false,
+      col_sep: "\t",
+      row_sep: "\r\n"
+    }
+    opts.merge!(options.except(:encoding))
+    CSV.parse(IO.read(File.expand_path(filename), encoding: encoding, binmode: true).encode('UTF-8'), **opts).to_a
+  end
+
+  def generate_excel(filename)
+    Axlsx::Package.new do |package|
+      yield(package.workbook)
+      package.serialize(File.expand_path(filename))
+    end
+  end
+
+  def parse_excel(filename)
+    xlsx = Roo::Excelx.new(File.expand_path(filename))
+    xlsx.sheets.each_with_object({}) do |sheet_name, result|
+      begin
+        result[sheet_name] = xlsx.sheet(sheet_name).to_a
+      rescue
+      end
+    end
+  end
+
+end

data/lib/pry-helper/ext/object.rb

@@ -0,0 +1,22 @@
+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
+
+  def a
+    [self]
+  end
+end

data/lib/pry-helper/ext/string.rb

@@ -0,0 +1,13 @@
+class String
+  def p
+    puts self
+  end
+
+  def expa
+    File.expand_path(self)
+  end
+
+  def f
+    expa
+  end
+end

data/lib/pry-helper/ext/time.rb

@@ -0,0 +1,15 @@
+require 'active_support/core_ext/time/conversions'
+require 'active_support/core_ext/object/json'
+
+class Time
+  DATE_FORMATS ||= {}
+  DATE_FORMATS[:default] = '%Y-%m-%d %H:%M:%S'
+
+  def inspect
+    to_s
+  end
+
+  def as_json(*args)
+    to_s
+  end
+end

data/lib/pry-helper/ext.rb

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