unibuf 0.1.0

data/lib/unibuf/commands/convert.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Unibuf
+  module Commands
+    # Convert command - Convert between Protocol Buffer formats
+    class Convert
+      attr_reader :options
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      def run(file)
+        validate_inputs!(file)
+
+        puts "Converting #{file} to #{target_format}..." if verbose?
+
+        message = load_message(file)
+        converted = convert_message(message)
+        write_output(converted)
+
+        puts "✓ Converted successfully" if verbose?
+      rescue FileNotFoundError => e
+        error "File not found: #{e.message}"
+        exit 1
+      rescue InvalidArgumentError => e
+        error "Invalid argument: #{e.message}"
+        exit 1
+      rescue StandardError => e
+        error "Error: #{e.message}"
+        error e.backtrace.first(5).join("\n") if verbose?
+        exit 1
+      end
+
+      private
+
+      def validate_inputs!(file)
+        raise FileNotFoundError, file unless File.exist?(file)
+
+        unless target_format
+          raise InvalidArgumentError,
+                "Target format required"
+        end
+
+        valid_formats = %w[json yaml textproto]
+        unless valid_formats.include?(target_format)
+          raise InvalidArgumentError,
+                "Invalid format '#{target_format}'. " \
+                "Valid formats: #{valid_formats.join(', ')}"
+        end
+      end
+
+      def load_message(file)
+        # Detect source format and parse appropriately
+        if json_file?(file)
+          load_from_json(file)
+        elsif yaml_file?(file)
+          load_from_yaml(file)
+        else
+          Unibuf.parse_file(file)
+        end
+      end
+
+      def load_from_json(file)
+        require "json"
+        data = JSON.parse(File.read(file))
+        Unibuf::Models::Message.from_hash(data)
+      end
+
+      def load_from_yaml(file)
+        require "yaml"
+        data = YAML.load_file(file)
+        Unibuf::Models::Message.from_hash(data)
+      end
+
+      def convert_message(message)
+        case target_format
+        when "json"
+          message.to_json
+        when "yaml"
+          message.to_yaml
+        when "textproto"
+          message.to_textproto
+        end
+      end
+
+      def write_output(content)
+        if output_file
+          File.write(output_file, content)
+          puts "Output written to #{output_file}" if verbose?
+        else
+          puts content
+        end
+      end
+
+      def json_file?(file)
+        file.end_with?(".json")
+      end
+
+      def yaml_file?(file)
+        file.end_with?(".yaml", ".yml")
+      end
+
+      def target_format
+        options[:to]
+      end
+
+      def output_file
+        options[:output]
+      end
+
+      def verbose?
+        options[:verbose]
+      end
+
+      def error(message)
+        warn "Error: #{message}"
+      end
+    end
+  end
+end

data/lib/unibuf/commands/parse.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Unibuf
+  module Commands
+    # Parse command - Parse Protocol Buffer text format files
+    class Parse
+      attr_reader :options
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      def run(file)
+        validate_file!(file)
+
+        puts "Parsing #{file}..." if verbose?
+
+        message = parse_file(file)
+        output_result(message)
+
+        puts "✓ Successfully parsed #{file}" if verbose?
+      rescue FileNotFoundError => e
+        error "File not found: #{e.message}"
+        exit 1
+      rescue ParseError => e
+        error "Parse error: #{e.message}"
+        exit 1
+      rescue StandardError => e
+        error "Unexpected error: #{e.message}"
+        error e.backtrace.first(5).join("\n") if verbose?
+        exit 1
+      end
+
+      private
+
+      def validate_file!(file)
+        raise FileNotFoundError, file unless File.exist?(file)
+      end
+
+      def parse_file(file)
+        Unibuf.parse_file(file)
+      end
+
+      def output_result(message)
+        content = format_output(message)
+
+        if output_file
+          File.write(output_file, content)
+          puts "Output written to #{output_file}" if verbose?
+        else
+          puts content
+        end
+      end
+
+      def format_output(message)
+        case output_format
+        when "json"
+          message.to_json
+        when "yaml"
+          message.to_yaml
+        when "textproto"
+          message.to_textproto
+        else
+          raise InvalidArgumentError, "Unknown format: #{output_format}"
+        end
+      end
+
+      def output_file
+        options[:output]
+      end
+
+      def output_format
+        options[:format] || "json"
+      end
+
+      def verbose?
+        options[:verbose]
+      end
+
+      def error(message)
+        warn "Error: #{message}"
+      end
+    end
+  end
+end

data/lib/unibuf/commands/schema.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Unibuf
+  module Commands
+    # Schema command - Parse and display schema files
+    class Schema
+      attr_reader :options
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      def run(file)
+        validate_file!(file)
+
+        puts "Parsing schema #{file}..." if verbose?
+
+        schema = parse_schema(file)
+        output_result(schema)
+
+        puts "✓ Successfully parsed schema" if verbose?
+      rescue FileNotFoundError => e
+        error "File not found: #{e.message}"
+        exit 1
+      rescue ParseError => e
+        error "Parse error: #{e.message}"
+        exit 1
+      rescue StandardError => e
+        error "Unexpected error: #{e.message}"
+        error e.backtrace.first(5).join("\n") if verbose?
+        exit 1
+      end
+
+      private
+
+      def validate_file!(file)
+        raise FileNotFoundError, file unless File.exist?(file)
+      end
+
+      def parse_schema(file)
+        case File.extname(file)
+        when ".proto"
+          Unibuf.parse_schema(file)
+        when ".fbs"
+          Unibuf.parse_flatbuffers_schema(file)
+        else
+          raise InvalidArgumentError,
+                "Unknown schema format: #{File.extname(file)}"
+        end
+      end
+
+      def output_result(schema)
+        content = format_output(schema)
+
+        if output_file
+          File.write(output_file, content)
+          puts "Output written to #{output_file}" if verbose?
+        else
+          puts content
+        end
+      end
+
+      def format_output(schema)
+        case output_format
+        when "json"
+          require "json"
+          schema.to_h.to_json
+        when "yaml"
+          require "yaml"
+          schema.to_h.to_yaml
+        when "text"
+          format_text(schema)
+        else
+          raise InvalidArgumentError, "Unknown format: #{output_format}"
+        end
+      end
+
+      def format_text(schema)
+        lines = []
+        lines << "Package: #{schema.package}" if schema.package
+        lines << "Syntax: #{schema.syntax}"
+        lines << ""
+        lines << "Messages (#{schema.messages.size}):"
+        schema.messages.each do |msg|
+          lines << "  #{msg.name} (#{msg.fields.size} fields)"
+        end
+        if schema.enums.any?
+          lines << ""
+          lines << "Enums (#{schema.enums.size}):"
+          schema.enums.each do |enum|
+            lines << "  #{enum.name} (#{enum.values.size} values)"
+          end
+        end
+        lines.join("\n")
+      end
+
+      def output_file
+        options[:output]
+      end
+
+      def output_format
+        options[:format] || "text"
+      end
+
+      def verbose?
+        options[:verbose]
+      end
+
+      def error(message)
+        warn "Error: #{message}"
+      end
+    end
+  end
+end

data/lib/unibuf/commands/validate.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Unibuf
+  module Commands
+    # Validate command - Validate Protocol Buffer text format files
+    class Validate
+      attr_reader :options
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      def run(file)
+        validate_file_exists!(file)
+
+        puts "Validating #{file}..." if verbose?
+
+        # Syntax validation
+        message = parse_and_validate_syntax(file)
+        puts "✓ Syntax valid" if verbose?
+
+        # Schema validation (if schema provided)
+        if schema_file
+          validate_against_schema(message)
+          puts "✓ Schema valid" if verbose?
+        end
+
+        puts "✓ #{file} is valid"
+      rescue FileNotFoundError => e
+        error "File not found: #{e.message}"
+        exit 1
+      rescue ParseError => e
+        error "Syntax error: #{e.message}"
+        exit 1
+      rescue ValidationError => e
+        error "Validation error: #{e.message}"
+        exit 1
+      rescue StandardError => e
+        error "Unexpected error: #{e.message}"
+        error e.backtrace.first(5).join("\n") if verbose?
+        exit 1
+      end
+
+      private
+
+      def validate_file_exists!(file)
+        raise FileNotFoundError, file unless File.exist?(file)
+      end
+
+      def parse_and_validate_syntax(file)
+        Unibuf.parse_file(file)
+      end
+
+      def validate_against_schema(_message)
+        # TODO: Implement schema validation when Proto3 parser is ready
+        puts "Note: Schema validation not yet implemented" if verbose?
+      end
+
+      def schema_file
+        options[:schema]
+      end
+
+      def verbose?
+        options[:verbose]
+      end
+
+      def strict?
+        options[:strict]
+      end
+
+      def error(message)
+        warn "Error: #{message}"
+      end
+    end
+  end
+end

data/lib/unibuf/errors.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Unibuf
+  # Base error class for all Unibuf errors
+  class Error < StandardError; end
+
+  # Parsing errors
+  class ParseError < Error; end
+  class SyntaxError < ParseError; end
+  class UnexpectedTokenError < ParseError; end
+  class UnterminatedStringError < ParseError; end
+
+  # Validation errors
+  class ValidationError < Error; end
+  class TypeValidationError < ValidationError; end
+  class SchemaValidationError < ValidationError; end
+  class ReferenceValidationError < ValidationError; end
+  class RequiredFieldError < ValidationError; end
+
+  # Model errors
+  class ModelError < Error; end
+  class InvalidFieldError < ModelError; end
+  class InvalidValueError < ModelError; end
+  class TypeCoercionError < ModelError; end
+
+  # File errors
+  class FileError < Error; end
+  class FileNotFoundError < FileError; end
+  class FileReadError < FileError; end
+  class FileWriteError < FileError; end
+
+  # CLI errors
+  class CLIError < Error; end
+  class InvalidArgumentError < CLIError; end
+  class CommandExecutionError < CLIError; end
+end

data/lib/unibuf/models/enum_definition.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Unibuf
+  module Models
+    # Represents an enum type definition from a Proto3 schema
+    class EnumDefinition
+      attr_reader :name, :values
+
+      def initialize(attributes = {})
+        @name = attributes[:name] || attributes["name"]
+        @values = attributes[:values] || attributes["values"] || {}
+      end
+
+      # Queries
+      def value_names
+        values.keys
+      end
+
+      def value_numbers
+        values.values
+      end
+
+      def find_value_by_name(name)
+        values[name]
+      end
+
+      def find_name_by_value(number)
+        values.key(number)
+      end
+
+      # Validation
+      def valid?
+        validate!
+        true
+      rescue ValidationError
+        false
+      end
+
+      def validate!
+        raise ValidationError, "Enum name required" unless name
+
+        if values.empty?
+          raise ValidationError,
+                "Enum must have at least one value"
+        end
+
+        # Check for duplicate values
+        nums = value_numbers
+        duplicates = nums.select { |n| nums.count(n) > 1 }.uniq
+        if duplicates.any?
+          raise ValidationError,
+                "Duplicate enum values: #{duplicates.join(', ')}"
+        end
+
+        true
+      end
+
+      def valid_value?(value)
+        case value
+        when String
+          value_names.include?(value)
+        when Integer
+          value_numbers.include?(value)
+        else
+          false
+        end
+      end
+
+      # Transformation
+      def to_h
+        {
+          name: name,
+          values: values,
+        }
+      end
+    end
+  end
+end

data/lib/unibuf/models/field.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Unibuf
+  module Models
+    # Represents a field in a Protocol Buffer message
+    # Rich domain model with behavior, not just data
+    # Using plain Ruby class for polymorphic value support
+    class Field
+      attr_reader :name, :value, :is_map
+
+      def initialize(attributes = {})
+        @name = attributes["name"] || attributes[:name]
+        @value = attributes["value"] || attributes[:value]
+        @is_map = attributes["is_map"] || attributes[:is_map] || false
+      end
+
+      # Type queries - MECE classification
+      def message_field?
+        value.is_a?(Hash) && value.key?("fields")
+      end
+
+      def scalar_field?
+        !message_field? && !map_field? && !list_field?
+      end
+
+      def map_field?
+        is_map == true || (value.is_a?(Hash) && value.key?("key") && value.key?("value"))
+      end
+
+      def list_field?
+        value.is_a?(Array)
+      end
+
+      # Value type detection
+      def string_value?
+        value.is_a?(String)
+      end
+
+      def integer_value?
+        value.is_a?(Integer)
+      end
+
+      def float_value?
+        value.is_a?(Float)
+      end
+
+      def boolean_value?
+        value.is_a?(TrueClass) || value.is_a?(FalseClass)
+      end
+
+      # Value accessors with type coercion
+      def as_string
+        return value.to_s if scalar_field?
+
+        raise TypeCoercionError, "Cannot convert #{value.class} to String"
+      end
+
+      def as_integer
+        return value if integer_value?
+        return value.to_i if string_value? && value.match?(/^\d+$/)
+
+        raise TypeCoercionError, "Cannot convert #{value.class} to Integer"
+      end
+
+      def as_float
+        return value if float_value?
+        return value.to_f if string_value? && value.match?(/^\d+\.?\d*$/)
+
+        raise TypeCoercionError, "Cannot convert #{value.class} to Float"
+      end
+
+      def as_boolean
+        return value if boolean_value?
+        return true if string_value? && value == "true"
+        return false if string_value? && value == "false"
+
+        raise TypeCoercionError, "Cannot convert #{value.class} to Boolean"
+      end
+
+      def as_message
+        return Models::Message.new(value) if message_field?
+
+        raise TypeCoercionError, "Field is not a message type"
+      end
+
+      def as_list
+        return value if list_field?
+
+        raise TypeCoercionError, "Field is not a list type"
+      end
+
+      # Serialize to textproto format
+      def to_textproto(indent: 0)
+        indent_str = "  " * indent
+
+        if message_field?
+          # Nested message: name { fields }
+          nested_msg = as_message
+          nested_content = nested_msg.to_textproto(indent: indent + 1)
+          "#{indent_str}#{name} {\n#{nested_content}\n#{indent_str}}"
+        elsif map_field?
+          # Map entry: name { key: "k" value: "v" }
+          key_str = format_value(value["key"])
+          val_str = format_value(value["value"])
+          "#{indent_str}#{name} {\n#{indent_str}  key: #{key_str}\n#{indent_str}  value: #{val_str}\n#{indent_str}}"
+        elsif list_field?
+          # List values: each item on separate line with same field name
+          value.map do |item|
+            "#{indent_str}#{name}: #{format_value(item)}"
+          end.join("\n")
+        else
+          # Scalar field: name: value
+          "#{indent_str}#{name}: #{format_value(value)}"
+        end
+      end
+
+      # Comparison
+      def ==(other)
+        return false unless other.is_a?(Field)
+
+        name == other.name && value == other.value
+      end
+
+      def hash
+        [name, value].hash
+      end
+
+      private
+
+      # Format a value for textproto output
+      def format_value(val)
+        case val
+        when String
+          escape_string(val)
+        when Integer, Float
+          val.to_s
+        when TrueClass, FalseClass
+          val.to_s
+        when Hash
+          # Nested message
+          msg = Models::Message.new(val)
+          "{\n#{msg.to_textproto(indent: 1)}\n}"
+        else
+          val.to_s
+        end
+      end
+
+      # Escape and quote a string for textproto
+      def escape_string(str)
+        escaped = str.gsub("\\", "\\\\")
+          .gsub('"', '\"')
+          .gsub("\n", '\\n')
+          .gsub("\t", '\\t')
+          .gsub("\r", '\\r')
+        "\"#{escaped}\""
+      end
+    end
+  end
+end