crudboy 0.1.0

data/lib/crudboy/connection.rb

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

data/lib/crudboy/definition.rb

@@ -0,0 +1,123 @@
+require 'crudboy/concerns'
+module Crudboy
+  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
+
+    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
+
+    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
+    end
+  end
+
+  class Definition
+
+    attr_accessor :table_name, :model, :model_name
+
+    def initialize(options)
+      @@options = options
+      @table_name = @@options[:table_name]
+      @model_name = @@options[:model_name]
+      ActiveRecord::Base.connection.tap do |conn|
+        Object.const_set('CrudboyModel', Class.new(ActiveRecord::Base) do
+          include ::Crudboy::Concerns::TableDataDefinition
+          self.abstract_class = true
+        end)
+
+        raise "Table not exist: #{@table_name}" unless conn.tables.include?(@table_name)
+
+        table_comment = conn.table_comment(@table_name)
+        conn.primary_key(@table_name).tap do |pkey|
+          Class.new(::CrudboyModel) do
+            include Crudboy::Extension
+            self.table_name = options[:table_name]
+            if pkey.is_a?(Array)
+              self.primary_keys = pkey
+            else
+              self.primary_key = pkey
+            end
+            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(@model_name, clazz).tap do |const|
+              @model = Model.new(const, @table_name, table_comment)
+            end
+          end
+        end
+      end
+    end
+
+    ::ActiveRecord::Relation.class_eval do
+      def t(*attrs, **options)
+        records.t(*attrs, **options)
+      end
+
+      def v
+        records.v
+      end
+
+      def a
+        to_a
+      end
+
+    end
+  end
+end

data/lib/crudboy/ext.rb

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

data/lib/crudboy/ext/array.rb

@@ -0,0 +1,139 @@
+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 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/crudboy/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/crudboy/ext/kernel.rb

@@ -0,0 +1,112 @@
+require 'crudboy/concerns'
+module Kernel
+  CSV_BOM = "\xef\xbb\xbf"
+
+  include ::Crudboy::Concerns::GlobalDataDefinition
+
+  def sql(sql)
+    ActiveRecord::Base.connection.exec_query(sql)
+  end
+
+  def print_tables(format = :md)
+    require 'terminal-table'
+
+    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/crudboy/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