rbtoon 0.1.0

data/lib/rbtoon/handler.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RbToon
+  class Handler # :nodoc: all
+    def initialize
+      @stack = [Nodes::Root.new]
+    end
+
+    def output
+      @stack.first
+    end
+
+    def push_object(key)
+      object = Nodes::Object.new(current, key.position)
+      push_value(object)
+
+      @stack << object
+      push_value(key)
+    end
+
+    def push_array(l_bracket_token, size)
+      array = Nodes::Array.new(current, l_bracket_token.position, size)
+      push_value(array)
+
+      @stack << array
+    end
+
+    def push_value(value)
+      current.push_value(value)
+    end
+
+    def push_values(values)
+      values.each { |value| push_value(value) }
+    end
+
+    def push_tabular_fields(fields)
+      current.push_tabular_fields(fields)
+    end
+
+    def push_tabular_row(values)
+      row = Nodes::TabularRow.new(values, values.first.position)
+      push_value(row)
+    end
+
+    def push_blank(token)
+      return unless token
+
+      blank = Nodes::Blank.new(token)
+      push_value(blank)
+    end
+
+    def push_empty_object(position)
+      object = Nodes::EmptyObject.new(position)
+      push_value(object)
+    end
+
+    def pop
+      @stack.pop
+    end
+
+    def quoted_string(token)
+      Nodes::QuotedString.new(token)
+    end
+
+    def unquoted_string(token)
+      Nodes::UnquotedString.new(token)
+    end
+
+    def empty_string(position)
+      Nodes::EmptyString.new(position)
+    end
+
+    def boolean(token)
+      Nodes::Boolean.new(token)
+    end
+
+    def null(token)
+      Nodes::Null.new(token)
+    end
+
+    def number(token)
+      Nodes::Number.new(token)
+    end
+
+    private
+
+    def current
+      @stack.last
+    end
+  end
+end

data/lib/rbtoon/nodes/array.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module RbToon # :nodoc: all
+  module Nodes
+    class Array < StructureBase
+      def initialize(parent, position, size)
+        super(parent, position)
+        @size = size
+      end
+
+      def push_tabular_fields(fields)
+        @fields = fields
+      end
+
+      def validate(strict: true)
+        if @fields
+          validate_tabular_array(strict)
+        else
+          validate_array(strict)
+        end
+      end
+
+      def to_ruby(symbolize_names: false, **optargs)
+        values = non_blank_values
+        result =
+          if tabular?
+            to_ruby_tabular(values, symbolize_names, **optargs)
+          else
+            to_ruby_list(values, symbolize_names, **optargs)
+          end
+        result || []
+      end
+
+      def kind
+        :array
+      end
+
+      private
+
+      def tabular?
+        !@fields.nil?
+      end
+
+      def validate_tabular_array(strict)
+        check_blank(strict, 'tabular rows')
+        validate_array_size('tabular rows')
+        validate_tabular_row_size
+        @valus&.flatten&.each { |value| value.validate(strict:) }
+      end
+
+      def validate_array(strict)
+        check_blank(strict, 'array')
+        validate_array_size('array items')
+        @values&.each { |value| value.validate(strict:) }
+      end
+
+      def validate_array_size(kind)
+        actual = non_blank_values&.size || 0
+        expected = @size.to_ruby
+        return if actual == expected
+
+        raise_parse_error "expected #{expected} #{kind}, but got #{actual}", position
+      end
+
+      def validate_tabular_row_size
+        expected = @fields.size
+        non_blank_values.each do |row|
+          actual = row.size
+          next if actual == expected
+
+          position = row.position
+          raise_parse_error "expected #{expected} tabular row items, but got #{actual}", position
+        end
+      end
+
+      def to_ruby_tabular(rows, symbolize_names, **optargs)
+        return unless rows
+
+        fields = to_ruby_list(@fields, symbolize_names, **optargs)
+        fields.map!(&:to_sym) if symbolize_names
+
+        rows.map do |row|
+          fields
+            .zip(row.to_ruby(symbolize_names:, **optargs))
+            .to_h
+        end
+      end
+
+      def to_ruby_list(values, symbolize_names, **optargs)
+        values&.map { |value| value.to_ruby(symbolize_names:, **optargs) }
+      end
+    end
+
+    class TabularRow < Base
+      def initialize(values, position)
+        super(position)
+        @values = values
+      end
+
+      def size
+        @values.size
+      end
+
+      def to_ruby(**optargs)
+        @values.map { |value| value.to_ruby(**optargs) }
+      end
+
+      def kind
+        :tabular_row
+      end
+    end
+  end
+end

data/lib/rbtoon/nodes/base.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RbToon # :nodoc: all
+  module Nodes
+    class Base
+      include RaiseParseError
+
+      def initialize(position)
+        @position = position
+      end
+
+      attr_reader :position
+
+      [
+        :array, :tabular_row, :blank, :object, :empty_object,
+        :root, :quoted_string, :unquoted_string, :empty_string,
+        :boolean, :null, :number
+      ].each do |kind|
+        class_eval(<<~M, __FILE__, __LINE__ + 1)
+          # def array?
+          #   kind == :array
+          # end
+          def #{kind}?
+            kind == :#{kind}
+          end
+        M
+      end
+
+      def validate(strict: true)
+      end
+    end
+
+    class StructureBase < Base
+      def initialize(parent, position)
+        super(position)
+        @parent = parent
+      end
+
+      attr_reader :parent
+
+      def push_value(value)
+        (@values ||= []) << value
+      end
+
+      private
+
+      def non_blank_values
+        @values&.reject(&:blank?)
+      end
+
+      def check_blank(strict, kind)
+        return unless strict && @values && inside_array?
+
+        blank =
+          if parent.avove_array_edge?(self)
+            @values.index(&:blank?)
+          else
+            @values[..-2].index(&:blank?)
+          end
+        return unless blank
+
+        position = @values[blank].position
+        raise_parse_error "blank lines inside #{kind} are not allowed", position
+      end
+
+      protected
+
+      def inside_array?
+        array? || parent&.inside_array? || false
+      end
+
+      def avove_array_edge?(object)
+        return false unless inside_array?
+        return true unless @values.last.equal?(object)
+
+        parent.avove_array_edge?(self)
+      end
+    end
+  end
+end

data/lib/rbtoon/nodes/blank.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RbToon # :nodoc: all
+  module Nodes
+    class Blank < Base
+      def initialize(token)
+        super(token.position)
+      end
+
+      def kind
+        :blank
+      end
+    end
+  end
+end

data/lib/rbtoon/nodes/object.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module RbToon # :nodoc: all
+  module Nodes
+    class Object < StructureBase
+      def validate(strict: true)
+        check_blank(strict, 'array')
+        each_key_value do |key, value|
+          key.validate(strict:)
+          value.validate(strict:)
+        end
+      end
+
+      def to_ruby(symbolize_names: false, strict: true, path_expansion: false)
+        each_key_value.with_object({}) do |(key, value), result|
+          build_result(result, key, value, symbolize_names, strict, path_expansion)
+        end
+      end
+
+      def kind
+        :object
+      end
+
+      private
+
+      def each_key_value(&)
+        if block_given?
+          non_blank_values.each_slice(2, &)
+        else
+          non_blank_values.each_slice(2)
+        end
+      end
+
+      def build_result(
+        result, key, value,
+        symbolize_names, strict, path_expansion
+      )
+        k = key.to_ruby(symbolize_names:, strict:, path_expansion:)
+        v = value.to_ruby(symbolize_names:, strict:, path_expansion:)
+
+        paths = split_path(key, k, symbolize_names, path_expansion)
+        insert_value(result, paths, v, strict, key.position)
+      end
+
+      def split_path(key_node, key, symbolize_names, path_expansion)
+        paths =
+          if path_expansion && expandable_key?(key_node, key)
+            key.split('.')
+          else
+            [key]
+          end
+
+        paths.map!(&:to_sym) if symbolize_names
+        paths
+      end
+
+      def expandable_key?(key_node, key)
+        key_node.unquoted_string? &&
+          /\A[_a-z][_a-z0-9]*(?:\.[_a-z][_a-z0-9]*)*\Z/i.match?(key)
+      end
+
+      def insert_value(result, paths, value, strict, position)
+        check_conflict(result, paths, value, strict, position)
+
+        path = paths.first
+        if paths.size > 1
+          result[path] = {} unless result[path].is_a?(Hash)
+          insert_value(result[path], paths[1..], value, strict, position)
+        elsif [result[path], value] in [Hash, Hash]
+          result[path].merge!(value)
+        else
+          result[path] = value
+        end
+      end
+
+      def check_conflict(result, paths, value, strict, position)
+        return unless conflict?(result, paths, value, strict)
+
+        raise_parse_error "key conflict at \"#{paths.first}\"", position
+      end
+
+      def conflict?(result, paths, value, strict)
+        path = paths.first
+        return false unless strict && result.key?(path)
+
+        if paths.size > 1
+          !result[path].is_a?(Hash)
+        elsif [result[path], value] in [Hash, Hash]
+          !result[path].keys.intersect?(value.keys)
+        else
+          true
+        end
+      end
+    end
+
+    class EmptyObject < Base
+      def to_ruby(**_optargs)
+        {}
+      end
+
+      def kind
+        :empty_object
+      end
+    end
+  end
+end

data/lib/rbtoon/nodes/root.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RbToon # :nodoc: all
+  module Nodes
+    class Root < Array
+      def initialize
+        super(nil, nil, nil)
+      end
+
+      def validate(strict: true)
+        @values&.each_with_index do |value, i|
+          i.positive? &&
+            (raise_parse_error 'two or more values at root depth', value.position)
+          value.validate(strict:)
+        end
+      end
+
+      def to_ruby(**optargs)
+        return {} unless @values
+
+        @values.first.to_ruby(**optargs)
+      end
+
+      def kind
+        :root
+      end
+    end
+  end
+end

data/lib/rbtoon/nodes/scalar.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RbToon # :nodoc: all
+  module Nodes
+    class Scalar < Base
+      def initialize(token)
+        super(token.position)
+        @token = token
+      end
+
+      attr_reader :token
+    end
+
+    class QuotedString < Scalar
+      def to_ruby(**_optargs)
+        token.text[1..-2]
+      end
+
+      def kind
+        :quoted_string
+      end
+    end
+
+    class UnquotedString < Scalar
+      def to_ruby(**_optargs)
+        token.text.strip
+      end
+
+      def kind
+        :unquoted_string
+      end
+    end
+
+    class EmptyString < Base
+      def to_ruby(**_optargs)
+        ''
+      end
+
+      def kind
+        :empty_string
+      end
+    end
+
+    class Boolean < Scalar
+      def to_ruby(**_optargs)
+        token.text.strip == 'true'
+      end
+
+      def kind
+        :boolean
+      end
+    end
+
+    class Null < Scalar
+      def to_ruby(**_optargs)
+        nil
+      end
+
+      def kind
+        :null
+      end
+    end
+
+    class Number < Scalar
+      def to_ruby(**_optargs)
+        text = token.text.strip
+        if text.match?(/[.e]/i)
+          value_f = text.to_f
+          value_i = value_f.to_i
+          value_f == value_i ? value_i : value_f
+        else
+          text.to_i
+        end
+      end
+
+      def kind
+        :number
+      end
+    end
+  end
+end

data/lib/rbtoon/parse_error.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RbToon
+  ##
+  # The exception class is raised when the given Toon includes errors.
+  #
+  # Fields:
+  # +error_message+::
+  #   Message string of the detected error.
+  # +position+::
+  #   Position information where the error is detected.
+  class ParseError < StandardError
+    def initialize(error_message, position)
+      super(error_message)
+      @error_message = error_message
+      @position = position
+    end
+
+    ##
+    # Read accessor to +error_message+ field.
+    attr_reader :error_message
+
+    ##
+    # Read accessor to +position+ field.
+    attr_reader :position
+
+    ##
+    # Return the +error_message+ string.
+    # The +position+ information is also included if provided.
+    def to_s
+      (position && "#{super} -- #{position}") || super
+    end
+  end
+
+  module RaiseParseError # :nodoc:
+    private
+
+    def raise_parse_error(message, position = nil)
+      raise ParseError.new(message, position)
+    end
+  end
+end

data/lib/rbtoon/parser.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RbToon
+  class Parser < GeneratedParser # :nodoc:
+    include RaiseParseError
+
+    def initialize(scanner, handler, debug: false)
+      @scanner = scanner
+      @handler = handler
+      @yydebug = debug
+      super()
+    end
+
+    def parse
+      do_parse
+      handler.output
+    end
+
+    private
+
+    attr_reader :scanner
+    attr_reader :handler
+
+    def next_token
+      scanner.next_token
+    end
+
+    def on_error(_token_id, value, _value_stack)
+      message = "syntax error on value '#{value.text}' (#{value.kind})"
+      raise_parse_error message, value.position
+    end
+
+    def to_list(val)
+      [val[0], *val[1]&.map { |_, value| value }]
+    end
+  end
+end