kolla 0.0.4 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80e3734cb140b8f92406cd59459951b530c430305f7e0c0a16d8ea6c9838df2a
-  data.tar.gz: 798b79b8a32747efb219b8941e8790d7291d7b775d6bbff3c3027df21cb57dd6
+  metadata.gz: 98522a2e33c960997f0f916d48c56aeb29fdade6f153e5b1e6098b769b4cf6a4
+  data.tar.gz: 15ac9b7c46afb68861a8243155a30ac825c5e6071bc4fe567722b42edf0fc963
 SHA512:
-  metadata.gz: 23077c2f3c679ba15337bd1c80564aaf7cf58fc6e063af7cd8bbb9477a1acaa5e12712c0164b79fb31cb519ba41b5f2b5c04f26e10d03ac56a834f0894514722
-  data.tar.gz: 86d20de4ec7f56e55278cc44cca232443684a816e1c59690f6597bf43a29990415b4cd225ecbc7f73afa79ace5878da751b954527fc640b758bb7cebc57ededd
+  metadata.gz: f51517d99c73fdb2748ce884c8ebe7959771f586dcc95e10e4d56434a530ec64b7a9a6504835e2097e5d36064efcdbb6a338119b57e475573e5c29141f5c11db
+  data.tar.gz: 1a632a31c1667b7fad4b37693f4241fd0ed0a77a44958f50ef1dc2f5e7066c10c94dcc4f40548d66ca459561275e30805eaed0ad6b5cbdd4e0d16457f0e60c2d

data/README.md

@@ -0,0 +1,64 @@
+# Kolla
+
+Zero-dependency CLI that parses `db/schema.rb` and answers "what's in this table?" in under a second — without booting Rails.
+
+## Installation
+
+```
+gem install kolla
+```
+
+## Usage
+
+List all tables:
+
+```
+$ kolla
+users
+posts
+comments
+```
+
+Inspect a table:
+
+```
+$ kolla users
+name (string, null: false)
+email (string)
+life_in_seconds (bigint, default: 0)
+admin (boolean, default: false)
+created_at (datetime, null: false)
+index: [email] (unique)
+index: [name]
+```
+
+Use a custom schema path:
+
+```
+$ kolla -f path/to/schema.rb users
+```
+
+### Options
+
+```
+-h, --help       Show help
+-v, --version    Show version
+-f, --file PATH  Path to schema.rb (default: db/schema.rb)
+```
+
+## What gets filtered
+
+Rails internal tables (`action_*`, `active_*`) are excluded from the table list.
+
+## Development
+
+```
+git clone https://github.com/antonysastre/kolla.git
+cd kolla
+bundle install
+rake test
+```
+
+## License
+
+MIT

data/bin/kolla

@@ -1,4 +1,34 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require 'kolla'
-ARGV.empty? ? Kolla.run : Kolla.run(ARGV)
+require "kolla"
+
+file_path = Kolla::Parser::DEFAULT_FILE
+
+args = ARGV.dup
+while args.first&.start_with?("-")
+  case args.shift
+  when "--help", "-h"
+    puts <<~USAGE
+      Usage: kolla [options] [TABLE_NAME]
+
+      Options:
+        -h, --help       Show this help
+        -v, --version    Show version
+        -f, --file PATH  Path to schema.rb (default: db/schema.rb)
+
+      Examples:
+        kolla              List all tables
+        kolla users        Show fields for 'users' table
+        kolla -f path/schema.rb users
+    USAGE
+    exit 0
+  when "--version", "-v"
+    puts "kolla #{Kolla::VERSION}"
+    exit 0
+  when "--file", "-f"
+    file_path = args.shift
+  end
+end
+
+Kolla.run(args, file_path: file_path)

data/lib/kolla/errors.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Kolla
+  class Error < StandardError; end
+  class SchemaNotFound < Error; end
+  class TableNotFound < Error; end
+end

data/lib/kolla/parser.rb

@@ -2,40 +2,88 @@
 
 module Kolla
   class Parser
-    DEFAULT_FILE = File.join('db', 'schema.rb').freeze
+    DEFAULT_FILE = File.join("db", "schema.rb").freeze
+    IGNORED_PREFIXES = %w[action_ active_].freeze
 
-    def initialize(file_path: DEFAULT_FILE, options: {})
+    Field = Struct.new(:name, :type, :constraints, keyword_init: true)
+    Index = Struct.new(:columns, :unique, keyword_init: true)
+
+    def initialize(file_path: DEFAULT_FILE)
       @file_path = File.expand_path(file_path)
-      @options = options
+      @content = File.read(@file_path)
+    rescue Errno::ENOENT
+      raise SchemaNotFound, "Schema file not found at #{@file_path}"
     end
 
-    def run!
-      content = File.read(file_path)
-      if options[:model_name]
-        extract_fields(content, options[:model_name])
-      else
-        extract_tables(content)
-      end
-    rescue Errno::ENOENT
-      Kolla.logger.warn "Schema file_path not found at #{file_path}"
+    def tables
+      matches = @content.scan(/create_table\s+"(\w+)"/)
+      matches.map(&:first).reject { |table| IGNORED_PREFIXES.any? { |prefix| table.start_with?(prefix) } }
     end
 
-    private
+    def fields_for(name)
+      escaped = Regexp.escape(name)
+      table_regex = /create_table "#{escaped}".*?do \|t\|(.*?)end/m
+      match = @content.match(table_regex)
+      raise TableNotFound, "Table '#{name}' not found in schema" unless match
 
-    def extract_tables(schema)
-      matches = schema.scan(/create_table\s+"(\w+)"/)
-      matches.map(&:first).reject { |table| table.start_with?('action_', 'active_') }
+      block = match[1]
+      fields = parse_fields(block)
+      indexes = parse_indexes(block)
+
+      format_output(name, fields, indexes)
     end
 
-    def extract_fields(schema, table_name)
-      table_regex = /create_table "#{table_name}".*?do \|t\|(.*?)end/m
-      match = schema.match(table_regex)
-      return [] unless match
+    private
+
+    def parse_fields(block)
+      field_regex = /t\.(\w+)\s+"(\w+)"(.*)/
+      block.scan(field_regex).filter_map do |type, name, rest|
+        next if type == "index"
+
+        constraints = []
+        constraints << "null: false" if rest.include?("null: false")
+        if (default_match = rest.match(/default:\s*("(?:[^"\\]|\\.)*"|[\w.]+)/))
+          constraints << "default: #{default_match[1]}"
+        end
+        Field.new(name: name, type: type, constraints: constraints)
+      end
+    end
 
-      field_regex = /t\.(\w+)\s+"(\w+)"/
-      match[1].scan(field_regex).map { |type, name| "#{name} (#{type})" }
+    def parse_indexes(block)
+      index_regex = /t\.index\s+\[([^\]]+)\](.*)$/
+      block.scan(index_regex).map do |columns, rest|
+        cols = columns.scan(/"(\w+)"/).flatten
+        Index.new(columns: cols, unique: rest.include?("unique: true"))
+      end
     end
 
-    attr_reader :file_path, :options
+    def format_output(table_name, fields, indexes)
+      return [] if fields.empty? && indexes.empty?
+
+      name_width = fields.map { |f| f.name.length }.max
+      type_width = fields.map { |f| f.type.length }.max
+
+      lines = []
+      lines << table_name
+      lines << "\u2500" * [name_width + type_width + 5, table_name.length].max
+
+      fields.each do |f|
+        line = "  #{f.name.ljust(name_width)}  #{f.type.ljust(type_width)}"
+        line << "  #{f.constraints.join(', ')}" unless f.constraints.empty?
+        lines << line
+      end
+
+      unless indexes.empty?
+        lines << ""
+        lines << "  Indexes:"
+        indexes.each do |idx|
+          line = "    [#{idx.columns.join(', ')}]"
+          line << " (unique)" if idx.unique
+          lines << line
+        end
+      end
+
+      lines
+    end
   end
 end

data/lib/kolla/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Kolla
+  VERSION = "0.1.1"
+end

data/lib/kolla.rb

@@ -1,23 +1,24 @@
 # frozen_string_literal: true
 
-require 'logger'
+if RUBY_VERSION < "3.0"
+  abort "kolla requires Ruby 3.0 or later (you have #{RUBY_VERSION})"
+end
 
-# Kolla parses a file and reports matching results.
-module Kolla
-  class << self
-    attr_accessor :logger
-  end
+require_relative "kolla/version"
+require_relative "kolla/errors"
+require_relative "kolla/parser"
 
-  self.logger = Logger.new($stdout)
+module Kolla
+  def self.run(args = [], file_path: Parser::DEFAULT_FILE)
+    parser = Parser.new(file_path: file_path)
 
-  def self.run(args = [])
-    if !args[0].nil?
-      model_name = args[0]
-      puts Parser.new(options:{model_name:}).run!
+    if args.empty?
+      puts parser.tables
     else
-      puts Parser.new.run!
+      puts parser.fields_for(args[0])
     end
+  rescue Kolla::Error => e
+    warn e.message
+    exit 1
   end
 end
-
-require 'kolla/parser'

metadata

@@ -1,27 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: kolla
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.1
 platform: ruby
 authors:
 - Antony Sastre
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-02-15 00:00:00.000000000 Z
+date: 2026-03-20 00:00:00.000000000 Z
 dependencies: []
+description: Zero-dependency CLI that parses db/schema.rb and answers 'what's in this
+  table?' in under a second — without booting Rails.
 email: antony.sastre@gmail.com
 executables:
 - kolla
 extensions: []
 extra_rdoc_files: []
 files:
+- README.md
 - bin/kolla
 - lib/kolla.rb
+- lib/kolla/errors.rb
 - lib/kolla/parser.rb
+- lib/kolla/version.rb
 homepage: https://rubygems.org/gems/kolla
 licenses:
 - MIT
-metadata: {}
+metadata:
+  source_code_uri: https://github.com/antonysastre/kolla
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -36,7 +44,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.3
+rubygems_version: 3.0.3.1
+signing_key: 
 specification_version: 4
-summary: Simple CLI utility tool to parse domain specific files and return reports.
+summary: Simple CLI tool to parse Rails schema file and list its details.
 test_files: []