ruby-toon 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7f006a20c57bdd904663ccfd5294101e625934bc5a1df303a6f2cf471f3745df
+  data.tar.gz: 80e3c4cd371b9eca3c47855bc79fdf67102e6c04272c69c3c1f752957c240e5d
+SHA512:
+  metadata.gz: 6c6ef31232a2209e64815eae5f25f9bf195caee071323777eeac4a4217b45ae3937c7a8cb937d5dd60bc46f4b6c3ca0b757b0e61de58d314e67454d03f3a5b9a
+  data.tar.gz: 1f7ee09ca1533d1ac7cb4ce3b7233f27dae0389ddfda99e9771b3087918c47e5528e858d83ddcfe69496973412a846107c80d01e6f3995a9953da8d658788870

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Anil Yanduri
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,260 @@
+````markdown
+# 🎋 Toon — Token-Oriented Object Notation for Ruby
+
+`toon` is a Ruby implementation of **TOON (Token-Oriented Object Notation)** —
+a compact, readable, indentation-based data format designed for humans *and* machines.
+
+This gem provides:
+
+- A **TOON encoder** (Ruby → TOON)
+- A **TOON decoder** (TOON → Ruby)
+- A **CLI** (`bin/toon`) for converting TOON ↔ JSON
+- Optional **ActiveSupport integration** (`Object#to_toon`)
+- Full RSpec test suite
+
+---
+
+## ✨ Features
+
+### ✔ Encode Ruby objects → TOON
+```ruby
+Toon.generate({ "name" => "Alice", "age" => 30 })
+````
+
+Produces:
+
+```
+name:Alice
+age:30
+```
+
+### ✔ Decode TOON → Ruby
+
+```ruby
+Toon.parse("name:Alice\nage:30")
+```
+
+Returns:
+
+```ruby
+{ "name" => "Alice", "age" => 30 }
+```
+
+---
+
+## 🧩 Arrays
+
+### Nested arrays (encoder output)
+
+```
+colors:
+  [3]:
+    red
+    green
+    blue
+```
+
+### Flat arrays (user input)
+
+```
+colors[3]:
+  red
+  green
+  blue
+```
+
+Both decode correctly.
+
+---
+
+## 📊 Tabular Arrays
+
+### Nested tabular (encoder output)
+
+```
+users:
+  [2]{id,name}:
+    1,A
+    2,B
+```
+
+→ numeric fields parsed (`id` becomes integer)
+
+### Flat tabular (user input)
+
+```
+users[2]{id,name}:
+  1,Alice
+  2,Bob
+```
+
+→ fields remain **strings**
+
+---
+
+## ⚙️ ActiveSupport Integration
+
+If ActiveSupport is installed:
+
+```ruby
+require "active_support"
+require "toon"
+
+{a: 1}.to_toon
+# => "a:1\n"
+```
+
+Adds `Object#to_toon` for convenience.
+
+---
+
+## 🚀 Installation
+
+Gem coming soon. For now:
+
+```bash
+git clone <your-repo-url>
+cd toon
+bundle install
+```
+
+Use locally:
+
+```ruby
+require_relative "lib/toon"
+```
+
+---
+
+## 🧰 CLI Usage
+
+### Encode JSON → TOON
+
+```bash
+echo '{"name":"Alice","age":30}' | bin/toon --encode
+```
+
+### Decode TOON → JSON
+
+```bash
+echo "name:Alice\nage:30" | bin/toon --decode
+```
+
+### Read from STDIN automatically
+
+```bash
+bin/toon --encode < input.json
+```
+
+---
+
+## 🧪 Running Tests
+
+Ensure CLI is executable:
+
+```bash
+chmod +x bin/toon
+```
+
+Run all tests:
+
+```bash
+bundle exec rspec
+```
+
+Tests include:
+
+* Encoder specs
+* Decoder specs
+* CLI specs
+* ActiveSupport specs
+
+---
+
+## 📚 Supported TOON Grammar (Current)
+
+### Key-value
+
+```
+key:value
+```
+
+### Nested objects
+
+```
+user:
+  name:Alice
+  age:30
+```
+
+### Primitive arrays
+
+```
+colors:
+  [3]:
+    red
+    green
+    blue
+```
+
+Flat form:
+
+```
+colors[3]:
+  red
+  green
+  blue
+```
+
+### Tabular arrays
+
+```
+users:
+  [2]{id,name}:
+    1,A
+    2,B
+```
+
+Flat form:
+
+```
+users[2]{id,name}:
+  1,A
+  2,B
+```
+
+---
+
+## ⚠️ Error Handling
+
+Malformed input (e.g., missing indentation):
+
+```
+Malformed TOON: array header '[3]:' must be under a key (e.g., 'colors:')
+```
+
+Decoder stops with a friendly `Toon::Error`.
+
+---
+
+## 🗺️ Roadmap
+
+* Multiline values
+* Quoted strings
+* Mixed-type arrays
+* Strict vs non-strict modes
+* Streaming decoder
+* Schema validation
+* Ruby gem release
+
+---
+
+## ❤️ Contributing
+
+PRs and issues welcome!
+
+---
+
+## 📝 License
+
+MIT

data/lib/extensions/active_support.rb

@@ -0,0 +1,12 @@
+# Optional ActiveSupport integration
+begin
+  require 'active_support'
+  require 'active_support/core_ext/object'
+  class Object
+    def to_toon(**opts)
+      Toon.generate(self, **opts)
+    end
+  end
+rescue LoadError
+  # no activesupport available
+end

data/lib/toon/decoder.rb

@@ -0,0 +1,182 @@
+module Toon
+  module Decoder
+    module_function
+
+    def parse(str, **opts)
+      lines = str.gsub("\r\n", "\n").split("\n")
+      parse_lines(lines)
+    end
+
+    def load(io, **opts)
+      parse(io.read, **opts)
+    end
+
+    def parse_lines(lines)
+      root = {}
+      stack = [ { indent: -1, obj: root, parent: nil, key: nil } ]
+
+      i = 0
+      while i < lines.length
+        raw = lines[i].rstrip
+        i += 1
+
+        next if raw.strip.empty? || raw.strip.start_with?('#')
+
+        indent = leading_spaces(raw)
+        content = raw.strip
+
+        # Fix indentation
+        while indent <= stack.last[:indent]
+          stack.pop
+        end
+
+        current = stack.last
+        parent_obj = current[:obj]
+
+        # ============================================================
+        # FLAT TABULAR ARRAY: users[2]{id,name}:
+        # ============================================================
+        if m = content.match(/^(\w+)\[(\d+)\]\{([^}]*)\}:$/)
+          key     = m[1]
+          count   = m[2].to_i
+          fields  = m[3].split(",").map(&:strip)
+
+          rows = []
+          count.times do
+            row = lines[i]&.strip
+            i += 1
+            next unless row
+            values = split_row(row.strip)
+            rows << Hash[fields.zip(values)]
+          end
+
+          parent_obj[key] = rows
+          next
+        end
+
+        # ============================================================
+        # FLAT PRIMITIVE ARRAY: colors[3]:
+        # ============================================================
+        if m = content.match(/^(\w+)\[(\d+)\]:$/)
+          key   = m[1]
+          count = m[2].to_i
+
+          values = []
+          count.times do
+            row = lines[i]&.strip
+            i += 1
+            next unless row
+            values << parse_scalar(row)
+          end
+
+          parent_obj[key] = values
+          next
+        end
+
+        # ============================================================
+        # NESTED OBJECT KEY: key:
+        # ============================================================
+        if m = content.match(/^(\w+):$/)
+          key = m[1]
+          new_obj = {}
+
+          parent_obj[key] = new_obj
+          stack << { indent: indent, obj: new_obj, parent: parent_obj, key: key }
+          next
+        end
+
+        # Refresh frame for nested array parsing
+        frame = stack.last
+        parent = frame[:parent]
+        key    = frame[:key]
+
+        # ============================================================
+        # NESTED TABULAR ARRAY:
+        #   users:
+        #     [2]{id,name}:
+        # ============================================================
+        if m = content.match(/^\[(\d+)\]\{([^}]*)\}:$/)
+          count   = m[1].to_i
+          fields  = m[2].split(',').map(&:strip)
+
+          rows = []
+          count.times do
+            row = lines[i]&.strip
+            i += 1
+            next unless row
+            values = split_row(row).map { |v| parse_scalar(v) }
+            rows << Hash[fields.zip(values)]
+          end
+
+          parent[key] = rows
+          stack.pop
+          next
+        end
+
+        # ============================================================
+        # NESTED PRIMITIVE ARRAY:
+        #   colors:
+        #     [3]:
+        # ============================================================
+        if m = content.match(/^\[(\d+)\]:$/)
+          count = m[1].to_i
+
+          if key.nil?
+            raise Toon::Error, "Malformed TOON: array header '#{content}' must be under a key (e.g., 'colors:')"
+          end
+
+          values = []
+          count.times do
+            row = lines[i]&.strip
+            i += 1
+            next unless row
+            values << parse_scalar(row)
+          end
+
+          parent[key] = values
+          stack.pop
+          next
+        end
+
+        # ============================================================
+        # SIMPLE KEY: VALUE
+        # ============================================================
+        if m = content.match(/^(\w+):\s*(.*)$/)
+          k = m[1]
+          v = parse_scalar(m[2])
+          parent_obj[k] = v
+          next
+        end
+      end
+
+      root
+    end
+
+
+
+    def leading_spaces(line)
+      line[/^ */].length
+    end
+
+    def parse_scalar(str)
+      # strip quotes
+      if str == 'null' then nil
+      elsif str == 'true' then true
+      elsif str == 'false' then false
+      elsif str.match?(/^".*"$/)
+        str[1..-2].gsub('\\"','"')
+      elsif str =~ /^-?\d+$/
+        str.to_i
+      elsif str =~ /^-?\d+\.\d+$/
+        str.to_f
+      else
+        str
+      end
+    end
+
+    def split_row(row)
+      # simplistic split on comma that ignores quoted commas - naive
+      row.scan(/(?:\"([^\"]*)\"|([^,]+))(?:,|$)/).map { |m| (m[0] || m[1]).to_s.strip }
+    end
+  end
+end

data/lib/toon/encoder.rb

@@ -0,0 +1,128 @@
+require 'stringio'
+module Toon
+  module Encoder
+    module_function
+
+    DEFAULT_OPTIONS = {
+      delimiter: ',',
+      indent: 2,
+      compact_arrays: true, # try to use tabular form when possible
+      pretty: false
+    }
+
+    def generate(obj, **opts)
+      options = DEFAULT_OPTIONS.merge(opts)
+      io = StringIO.new
+      write_object(io, obj, 0, options)
+      io.string
+    end
+
+    def pretty_generate(obj, **opts)
+      generate(obj, **opts.merge(pretty: true))
+    end
+
+    def dump(obj, io = STDOUT, **opts)
+      str = generate(obj, **opts)
+      io.write(str)
+      nil
+    end
+
+    private
+
+    def write_object(io, obj, level, options)
+      case obj
+      when Hash
+        obj.each do |k, v|
+          write_key(io, k, level)
+          if simple_value?(v)
+            io.write(format_simple(v))
+            io.write("\n")
+          else
+            io.write("\n")
+            write_object(io, v, level + 1, options)
+          end
+        end
+      when Array
+        # Try to detect uniform objects for tabular style
+        if options[:compact_arrays] && array_uniform_hashes?(obj)
+          write_tabular(io, obj, level, options)
+        else
+          write_list(io, obj, level, options)
+        end
+      else
+        # scalar
+        io.write(indent(level))
+        io.write(format_simple(obj))
+        io.write("\n")
+      end
+    end
+
+    def write_key(io, key, level)
+      io.write(indent(level))
+      io.write("#{key}:")
+    end
+
+    def write_tabular(io, arr, level, options)
+      keys = (arr.map(&:keys).reduce(:|) || []).uniq
+      io.write(indent(level))
+      io.write("[#{arr.length}]{#{keys.join(',')}}:\n")
+      arr.each do |row|
+        io.write(indent(level + 1))
+        vals = keys.map { |k| format_simple(row[k]) }
+        io.write(vals.join(options[:delimiter]))
+        io.write("\n")
+      end
+    end
+
+    def write_list(io, arr, level, options)
+      io.write(indent(level))
+      io.write("[#{arr.length}]:\n")
+      arr.each do |el|
+        io.write(indent(level + 1))
+        if simple_value?(el)
+          io.write(format_simple(el))
+          io.write("\n")
+        else
+          # nested object or array
+          write_object(io, el, level + 1, options)
+        end
+      end
+    end
+
+    def indent(level)
+      ' ' * (level * 2)
+    end
+
+    def simple_value?(v)
+      v.nil? || v.is_a?(Numeric) || v.is_a?(String) || v == true || v == false
+    end
+
+    def format_simple(v)
+      case v
+      when String
+        # naive quoting: quote when contains delimiter or colon or newline
+        if v.empty? || v.match(/[,:\n{}\[\]]/)
+          '"' + v.gsub('"', '\\"') + '"'
+        else
+          v
+        end
+      when nil
+        'null'
+      when true
+        'true'
+      when false
+        'false'
+      else
+        v.to_s
+      end
+    end
+
+    def array_uniform_hashes?(arr)
+      return false if arr.empty?
+      arr.all? { |e| e.is_a?(Hash) } && (arr.map { |h| h.keys.sort } .uniq.length == 1)
+    end
+
+    module_function :write_object, :write_key, :write_tabular, :write_list,
+                :indent, :simple_value?, :format_simple, :array_uniform_hashes?
+  end
+end

data/lib/toon/version.rb

@@ -0,0 +1,3 @@
+module Toon
+  VERSION = '0.1.0'
+end

data/lib/toon.rb

@@ -0,0 +1,28 @@
+require_relative "toon/version"
+require_relative "toon/encoder"
+require_relative "toon/decoder"
+require_relative "extensions/active_support"
+
+module Toon
+  class Error < StandardError; end
+
+  def self.generate(obj, **opts)
+    Toon::Encoder.generate(obj, **opts)
+  end
+
+  def self.pretty_generate(obj, **opts)
+    Toon::Encoder.pretty_generate(obj, **opts)
+  end
+
+  def self.parse(str, **opts)
+    Toon::Decoder.parse(str, **opts)
+  end
+
+  def self.load(io, **opts)
+    Toon::Decoder.load(io, **opts)
+  end
+
+  def self.dump(obj, io = STDOUT, **opts)
+    Toon::Encoder.dump(obj, io, **opts)
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: ruby-toon
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Anil Yanduri
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2025-11-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+description: 'A full-featured TOON encoder/decoder with JSON feature parity: streaming,
+  hooks, pretty generate, strict parsing, schema hints, CLI and ActiveSupport integration.'
+email:
+- anilkumaryln@gamil.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/extensions/active_support.rb
+- lib/toon.rb
+- lib/toon/decoder.rb
+- lib/toon/encoder.rb
+- lib/toon/version.rb
+homepage: https://github.com/anilyanduri/toon
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Token-Oriented Object Notation (TOON) implementation for Ruby
+test_files: []