toon-parser 0.1.0

data/lib/toon-parser/api.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+
+module ToonParser
+  # API helpers for handling TOON-formatted requests and responses
+  class API
+    class APIError < Error; end
+
+    def initialize(base_url, headers: {})
+      @base_url = base_url
+      @default_headers = {
+        "Content-Type" => "application/toon",
+        "Accept" => "application/toon"
+      }.merge(headers)
+    end
+
+    # Make a GET request and parse TOON response
+    #
+    # @param path [String] API endpoint path
+    # @param headers [Hash] Additional headers
+    # @return [Hash, Array] Parsed response data
+    def get(path, headers: {})
+      uri = URI.join(@base_url, path)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+
+      request = Net::HTTP::Get.new(uri.request_uri)
+      merge_headers(request, headers)
+
+      response = http.request(request)
+      handle_response(response)
+    end
+
+    # Make a POST request with TOON body and parse TOON response
+    #
+    # @param path [String] API endpoint path
+    # @param data [Hash, Array] Data to send (will be serialized to TOON)
+    # @param headers [Hash] Additional headers
+    # @return [Hash, Array] Parsed response data
+    def post(path, data: nil, headers: {})
+      uri = URI.join(@base_url, path)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+
+      request = Net::HTTP::Post.new(uri.request_uri)
+      merge_headers(request, headers)
+
+      if data
+        toon_body = Serializer.new.serialize(data)
+        request.body = toon_body
+      end
+
+      response = http.request(request)
+      handle_response(response)
+    end
+
+    # Make a PUT request with TOON body and parse TOON response
+    #
+    # @param path [String] API endpoint path
+    # @param data [Hash, Array] Data to send (will be serialized to TOON)
+    # @param headers [Hash] Additional headers
+    # @return [Hash, Array] Parsed response data
+    def put(path, data: nil, headers: {})
+      uri = URI.join(@base_url, path)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+
+      request = Net::HTTP::Put.new(uri.request_uri)
+      merge_headers(request, headers)
+
+      if data
+        toon_body = Serializer.new.serialize(data)
+        request.body = toon_body
+      end
+
+      response = http.request(request)
+      handle_response(response)
+    end
+
+    # Make a PATCH request with TOON body and parse TOON response
+    #
+    # @param path [String] API endpoint path
+    # @param data [Hash, Array] Data to send (will be serialized to TOON)
+    # @param headers [Hash] Additional headers
+    # @return [Hash, Array] Parsed response data
+    def patch(path, data: nil, headers: {})
+      uri = URI.join(@base_url, path)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+
+      request = Net::HTTP::Patch.new(uri.request_uri)
+      merge_headers(request, headers)
+
+      if data
+        toon_body = Serializer.new.serialize(data)
+        request.body = toon_body
+      end
+
+      response = http.request(request)
+      handle_response(response)
+    end
+
+    # Make a DELETE request and parse TOON response
+    #
+    # @param path [String] API endpoint path
+    # @param headers [Hash] Additional headers
+    # @return [Hash, Array] Parsed response data
+    def delete(path, headers: {})
+      uri = URI.join(@base_url, path)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+
+      request = Net::HTTP::Delete.new(uri.request_uri)
+      merge_headers(request, headers)
+
+      response = http.request(request)
+      handle_response(response)
+    end
+
+    private
+
+    def merge_headers(request, additional_headers)
+      all_headers = @default_headers.merge(additional_headers)
+      all_headers.each do |key, value|
+        request[key] = value
+      end
+    end
+
+    def handle_response(response)
+      unless response.is_a?(Net::HTTPSuccess)
+        raise APIError, "HTTP #{response.code}: #{response.message}"
+      end
+
+      content_type = response["Content-Type"] || ""
+      body = response.body
+
+      # Check if response is TOON format
+      if content_type.include?("application/toon") || content_type.include?("text/toon")
+        Parser.new.parse(body)
+      else
+        # Try to parse anyway if it looks like TOON
+        if body.strip.match?(/^[a-zA-Z_].*\[.*\]\{.*\}:|^\[.*\]\{.*\}:/)
+          Parser.new.parse(body)
+        else
+          body
+        end
+      end
+    end
+  end
+
+  # Convenience method to create an API client
+  #
+  # @param base_url [String] Base URL for the API
+  # @param headers [Hash] Default headers
+  # @return [API] API client instance
+  #
+  # @example
+  #   api = ToonParser.api("https://api.example.com")
+  #   users = api.get("/users")
+  def self.api(base_url, headers: {})
+    API.new(base_url, headers: headers)
+  end
+end
+

data/lib/toon-parser/controller_helpers.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+begin
+  require "rails"
+
+  module ToonParser
+  # Controller helpers for TOON format
+  module ControllerHelpers
+    extend ActiveSupport::Concern
+
+    included do
+      # Set default format to TOON for API controllers
+      # Override in your controller if needed:
+      # before_action :set_toon_format
+    end
+
+    # Render TOON response
+    #
+    # @param data [Hash, Array] Data to render as TOON
+    # @param options [Hash] Render options
+    #
+    # @example
+    #   def index
+    #     @users = User.all
+    #     render toon: { users: @users }
+    #   end
+    def render_toon(data, options = {})
+      render options.merge(toon: data)
+    end
+
+    # Parse TOON request body
+    #
+    # @return [Hash, Array] Parsed request body
+    #
+    # @example
+    #   def create
+    #     data = parse_toon_request
+    #     @user = User.create(data)
+    #     render toon: @user
+    #   end
+    def parse_toon_request
+      return {} unless request.content_type&.include?("application/toon")
+
+      ToonParser.parse(request.body.read)
+    end
+
+    # Set default format to TOON
+    #
+    # @example
+    #   class ApiController < ApplicationController
+    #     before_action :set_toon_format
+    #   end
+    def set_toon_format
+      request.format = :toon if request.format == :html || request.format == Mime[:html]
+    end
+
+    # Respond to TOON format
+    #
+    # @example
+    #   respond_to do |format|
+    #     format.toon { render toon: @users }
+    #     format.json { render json: @users }
+    #   end
+    def respond_to_toon(data, options = {})
+      respond_to do |format|
+        format.toon { render options.merge(toon: data) }
+        format.json { render options.merge(json: data) }
+      end
+    end
+  end
+end
+
+  # Auto-include in ActionController::Base if Rails is available
+  if defined?(ActionController::Base)
+    ActionController::Base.include ToonParser::ControllerHelpers
+  end
+rescue LoadError
+  # Rails is not available, skip controller helpers
+end
+

data/lib/toon-parser/parser.rb

@@ -0,0 +1,375 @@
+# frozen_string_literal: true
+
+module ToonParser
+  # Parser for TOON (Token-Oriented Object Notation) format
+  class Parser
+    class ParseError < ToonParser::Error; end
+
+    def initialize
+      @lines = []
+      @index = 0
+    end
+
+    # Parse a TOON string into Ruby objects
+    #
+    # @param toon_string [String] The TOON formatted string
+    # @return [Hash, Array] Parsed Ruby object
+    def parse(toon_string)
+      @lines = toon_string.lines.map(&:chomp).reject(&:empty?)
+      @index = 0
+      parse_value
+    end
+
+    private
+
+    def parse_value
+      return nil if @index >= @lines.size
+
+      line = @lines[@index]
+      indent = get_indent(line)
+      content = line.strip
+
+      # Check for array patterns first (before key-value pairs)
+      if content.match?(/^[a-zA-Z_][a-zA-Z0-9_]*\[.*\]\{.*\}:?$/)
+        # Array declaration with schema: key[size]{schema}:
+        parse_array_with_schema(indent)
+      elsif content.match?(/^\[.*\]\{.*\}:?$/)
+        # Inline array with schema: [size]{schema}:
+        parse_inline_array_with_schema(indent)
+      elsif content.match?(/^[a-zA-Z_][a-zA-Z0-9_]*\[\d+\]:?$/)
+        # Simple array with key: key[size]:
+        parse_simple_array_with_key(indent)
+      elsif content.match?(/^\[\d+\]:?$/)
+        # Simple array: [size]:
+        parse_simple_array(indent)
+      elsif content.start_with?("{") && content.end_with?("}:")
+        # Object schema: {field1,field2}:
+        parse_object_schema(indent)
+      elsif content.include?(":") && !content.start_with?(":")
+        # Key-value pair (object property)
+        parse_object(indent)
+      else
+        # Primitive value or array row
+        parse_primitive_or_row(indent)
+      end
+    end
+
+    def parse_object(base_indent = 0)
+      result = {}
+      current_indent = base_indent
+
+      while @index < @lines.size
+        line = @lines[@index]
+        indent = get_indent(line)
+
+        # Stop if we've gone back to a higher level
+        break if indent < current_indent
+
+        # Skip if not at current level
+        if indent > current_indent
+          @index += 1
+          next
+        end
+
+        content = line.strip
+
+        # Parse key: value
+        if content.include?(":")
+          key, value_part = content.split(":", 2).map(&:strip)
+          @index += 1
+
+          # Check if value is on next line(s)
+          if value_part.empty? && @index < @lines.size
+            next_line = @lines[@index]
+            next_indent = get_indent(next_line)
+
+            if next_indent > indent
+              # Value is indented on next line
+              result[key] = parse_value
+            else
+              # Empty value
+              result[key] = nil
+            end
+          else
+            # Value is inline
+            result[key] = parse_inline_value(value_part)
+          end
+        else
+          @index += 1
+        end
+      end
+
+      result
+    end
+
+    def parse_array_with_schema(base_indent)
+      line = @lines[@index].strip
+      @index += 1
+
+      # Parse: key[size]{schema}:
+      match = line.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\[(\d+)\]\{([^}]+)\}:?$/)
+      raise ParseError, "Invalid array schema format: #{line}" unless match
+
+      key = match[1]
+      size = match[2].to_i
+      schema = match[3].split(",").map(&:strip)
+
+      # Parse array rows
+      array = []
+      current_indent = base_indent
+
+      size.times do
+        break if @index >= @lines.size
+
+        line = @lines[@index]
+        indent = get_indent(line)
+
+        # Skip if not indented properly
+        if indent <= current_indent
+          break
+        end
+
+        content = line.strip
+        values = parse_row(content)
+
+        if values.size == schema.size
+          obj = {}
+          schema.each_with_index do |field, i|
+            obj[field] = parse_primitive_value(values[i])
+          end
+          array << obj
+        end
+
+        @index += 1
+      end
+
+      { key => array }
+    end
+
+    def parse_inline_array_with_schema(base_indent)
+      line = @lines[@index].strip
+      @index += 1
+
+      # Parse: [size]{schema}:
+      match = line.match(/^\[(\d+)\]\{([^}]+)\}:?$/)
+      raise ParseError, "Invalid inline array schema format: #{line}" unless match
+
+      size = match[1].to_i
+      schema = match[2].split(",").map(&:strip)
+
+      array = []
+      current_indent = base_indent
+
+      size.times do
+        break if @index >= @lines.size
+
+        line = @lines[@index]
+        indent = get_indent(line)
+
+        if indent <= current_indent
+          break
+        end
+
+        content = line.strip
+        values = parse_row(content)
+
+        if values.size == schema.size
+          obj = {}
+          schema.each_with_index do |field, i|
+            obj[field] = parse_primitive_value(values[i])
+          end
+          array << obj
+        end
+
+        @index += 1
+      end
+
+      array
+    end
+
+    def parse_simple_array(base_indent)
+      line = @lines[@index].strip
+      @index += 1
+
+      # Parse: [size]:
+      match = line.match(/^\[(\d+)\]:?$/)
+      raise ParseError, "Invalid array format: #{line}" unless match
+
+      size = match[1].to_i
+      array = []
+      current_indent = base_indent
+
+      size.times do
+        break if @index >= @lines.size
+
+        line = @lines[@index]
+        indent = get_indent(line)
+
+        if indent <= current_indent
+          break
+        end
+
+        content = line.strip
+        array << parse_primitive_value(content)
+        @index += 1
+      end
+
+      array
+    end
+
+    def parse_simple_array_with_key(base_indent)
+      line = @lines[@index].strip
+      @index += 1
+
+      # Parse: key[size]:
+      match = line.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\[(\d+)\]:?$/)
+      raise ParseError, "Invalid array format: #{line}" unless match
+
+      key = match[1]
+      size = match[2].to_i
+      array = []
+      current_indent = base_indent
+
+      size.times do
+        break if @index >= @lines.size
+
+        line = @lines[@index]
+        indent = get_indent(line)
+
+        if indent <= current_indent
+          break
+        end
+
+        content = line.strip
+        array << parse_primitive_value(content)
+        @index += 1
+      end
+
+      { key => array }
+    end
+
+    def parse_object_schema(base_indent)
+      line = @lines[@index].strip
+      @index += 1
+
+      # Parse: {field1,field2}:
+      match = line.match(/^\{([^}]+)\}:?$/)
+      raise ParseError, "Invalid object schema format: #{line}" unless match
+
+      schema = match[1].split(",").map(&:strip)
+
+      # Expect one row following
+      if @index < @lines.size
+        line = @lines[@index]
+        indent = get_indent(line)
+
+        if indent > base_indent
+          content = line.strip
+          values = parse_row(content)
+
+          if values.size == schema.size
+            obj = {}
+            schema.each_with_index do |field, i|
+              obj[field] = parse_primitive_value(values[i])
+            end
+            @index += 1
+            return obj
+          end
+        end
+      end
+
+      {}
+    end
+
+    def parse_primitive_or_row(base_indent)
+      line = @lines[@index].strip
+      @index += 1
+
+      # Check if there are more indented lines (array rows)
+      if @index < @lines.size
+        next_line = @lines[@index]
+        next_indent = get_indent(next_line)
+
+        if next_indent > base_indent
+          # This is likely an array of rows
+          array = []
+          array << parse_primitive_value(line)
+
+          while @index < @lines.size
+            line = @lines[@index]
+            indent = get_indent(line)
+
+            break if indent <= base_indent
+
+            content = line.strip
+            array << parse_primitive_value(content)
+            @index += 1
+          end
+
+          return array
+        end
+      end
+
+      parse_primitive_value(line)
+    end
+
+    def parse_row(content)
+      # Split by comma, but handle quoted strings
+      result = []
+      current = ""
+      in_quotes = false
+      quote_char = nil
+
+      content.each_char do |char|
+        if (char == '"' || char == "'") && !in_quotes
+          in_quotes = true
+          quote_char = char
+        elsif char == quote_char && in_quotes
+          in_quotes = false
+          quote_char = nil
+          current += char
+        elsif char == "," && !in_quotes
+          result << current.strip
+          current = ""
+        else
+          current += char
+        end
+      end
+
+      result << current.strip unless current.empty?
+      result
+    end
+
+    def parse_primitive_value(value)
+      return nil if value == "null" || value.empty?
+
+      # Boolean
+      return true if value == "true"
+      return false if value == "false"
+
+      # Number
+      if value.match?(/^-?\d+$/)
+        return value.to_i
+      elsif value.match?(/^-?\d+\.\d+$/)
+        return value.to_f
+      end
+
+      # String (remove quotes if present)
+      if (value.start_with?('"') && value.end_with?('"')) ||
+         (value.start_with?("'") && value.end_with?("'"))
+        return value[1..-2]
+      end
+
+      value
+    end
+
+    def parse_inline_value(value)
+      value.strip.empty? ? nil : parse_primitive_value(value.strip)
+    end
+
+    def get_indent(line)
+      line.size - line.lstrip.size
+    end
+  end
+end
+

data/lib/toon-parser/railtie.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+begin
+  require "rails"
+
+  module ToonParser
+    # Rails integration for TOON format
+    class Railtie < Rails::Railtie
+      initializer "toon_parser.register_mime_type" do |app|
+        # Register TOON MIME type
+        Mime::Type.register "application/toon", :toon
+        Mime::Type.register_alias "application/toon", :toon
+      end
+
+      initializer "toon_parser.register_renderer" do |app|
+        # Register TOON renderer
+        ActionController::Renderers.add :toon do |obj, options|
+          self.content_type ||= Mime[:toon]
+          self.response_body = ToonParser.serialize(obj)
+        end
+      end
+
+      initializer "toon_parser.parameter_parser" do |app|
+        # Register TOON parameter parser for request bodies
+        ActionDispatch::Request.parameter_parsers[:toon] = lambda do |raw_post|
+          ToonParser.parse(raw_post)
+        end
+      end
+    end
+  end
+rescue LoadError
+  # Rails is not available, skip Railtie
+end
+