hayadentaku 3.5.7

data/lib/dentaku/flat_hash.rb

@@ -0,0 +1,161 @@
+module Dentaku
+  class FlatHash
+    # Flattens a nested hash so that each leaf becomes a top-level entry whose
+    # key is the dot-joined path of segments leading to it. Non-Hash values
+    # (including Arrays) are treated as leaves. Empty nested Hashes are dropped,
+    # matching the historical behavior of this method.
+    #
+    # The flattened key preserves the type (Symbol vs String) of the
+    # outermost key in the path: if the top-level key is a Symbol the joined
+    # key is a Symbol, otherwise it stays a String.
+    def self.from_hash(h)
+      return { "" => h } unless h.is_a?(Hash)
+
+      acc = {}
+      h.each do |k, v|
+        if v.is_a?(Hash)
+          unless v.empty?
+            if k.is_a?(Symbol)
+              flatten_leaves_sym(v, k.to_s, acc)
+            else
+              flatten_leaves_str(v, k.to_s, acc)
+            end
+          end
+        else
+          acc[k] = v
+        end
+      end
+      acc
+    end
+
+    # Like {.from_hash}, but additionally retains every intermediate nested Hash
+    # under its dot-joined path key.
+    def self.from_hash_with_intermediates(h)
+      return { "" => h } unless h.is_a?(Hash)
+
+      acc = {}
+      h.each do |k, v|
+        acc[k] = v
+        if v.is_a?(Hash) && !v.empty?
+          if k.is_a?(Symbol)
+            flatten_with_intermediates_sym(v, k.to_s, acc)
+          else
+            flatten_with_intermediates_str(v, k.to_s, acc)
+          end
+        end
+      end
+      acc
+    end
+
+    def self.flatten_keys(hash)
+      result = {}
+      hash.each { |k, v| result[flatten_key(k)] = v }
+      result
+    end
+
+    def self.flatten_key(segments)
+      return segments.first if segments.length == 1
+      key = segments.join('.')
+      segments.first.is_a?(Symbol) ? key.to_sym : key
+    end
+
+    # Inverse of {.from_hash}: re-nests a hash whose keys may contain dots.
+    def self.expand(hash)
+      result = {}
+      hash.each do |k, v|
+        key_str = k.to_s
+        if key_str.include?('.')
+          parts   = key_str.split('.', -1)
+          last    = parts.length - 1
+          current = result
+          if k.is_a?(Symbol)
+            i = 0
+            while i < last
+              current = (current[parts[i].to_sym] ||= {})
+              i += 1
+            end
+            current[parts[last].to_sym] = v
+          else
+            i = 0
+            while i < last
+              current = (current[parts[i]] ||= {})
+              i += 1
+            end
+            current[parts[last]] = v
+          end
+        else
+          result[k] = v
+        end
+      end
+      result
+    end
+
+    # Writes the flattened "intermediates" form of `{identifier => value}`
+    # directly into `target`, without allocating an intermediate Hash. Used by
+    # the iterator AST nodes (map/filter/reduce/all/any/enum) where the result
+    # of `from_hash_with_intermediates` is otherwise immediately discarded after
+    # being merged into the per-iteration context.
+    #
+    # Returns nothing meaningful; mutates `target`.
+    def self.write_pair_with_intermediates!(identifier, value, target)
+      target[identifier] = value
+      return unless value.is_a?(Hash) && !value.empty?
+
+      if identifier.is_a?(Symbol)
+        flatten_with_intermediates_sym(value, identifier.to_s, target)
+      else
+        flatten_with_intermediates_str(value, identifier.to_s, target)
+      end
+    end
+
+    # --- internals ---------------------------------------------------------
+
+    # The four helpers below are duplicated by output-key type (Symbol vs
+    # String) on purpose: hoisting the Symbol/String branch out of the inner
+    # loop is measurably faster than checking it on every leaf.
+
+    def self.flatten_leaves_sym(h, prefix, acc)
+      h.each do |k, v|
+        if v.is_a?(Hash)
+          flatten_leaves_sym(v, "#{prefix}.#{k}", acc) unless v.empty?
+        else
+          acc[:"#{prefix}.#{k}"] = v
+        end
+      end
+    end
+    private_class_method :flatten_leaves_sym
+
+    def self.flatten_leaves_str(h, prefix, acc)
+      h.each do |k, v|
+        if v.is_a?(Hash)
+          flatten_leaves_str(v, "#{prefix}.#{k}", acc) unless v.empty?
+        else
+          acc["#{prefix}.#{k}"] = v
+        end
+      end
+    end
+    private_class_method :flatten_leaves_str
+
+    def self.flatten_with_intermediates_sym(h, prefix, acc)
+      h.each do |k, v|
+        new_prefix = "#{prefix}.#{k}"
+        acc[new_prefix.to_sym] = v
+        if v.is_a?(Hash) && !v.empty?
+          flatten_with_intermediates_sym(v, new_prefix, acc)
+        end
+      end
+    end
+    private_class_method :flatten_with_intermediates_sym
+
+    def self.flatten_with_intermediates_str(h, prefix, acc)
+      h.each do |k, v|
+        new_prefix = "#{prefix}.#{k}"
+        acc[new_prefix] = v
+        if v.is_a?(Hash) && !v.empty?
+          flatten_with_intermediates_str(v, new_prefix, acc)
+        end
+      end
+    end
+    private_class_method :flatten_with_intermediates_str
+  end
+end

data/lib/dentaku/parser.rb

@@ -0,0 +1,318 @@
+require_relative './ast'
+
+module Dentaku
+  class Parser
+    AST_OPERATIONS = {
+      add:      AST::Addition,
+      subtract: AST::Subtraction,
+      multiply: AST::Multiplication,
+      divide:   AST::Division,
+      pow:      AST::Exponentiation,
+      negate:   AST::Negation,
+      mod:      AST::Modulo,
+
+      bitor:    AST::BitwiseOr,
+      bitand:   AST::BitwiseAnd,
+      bitshiftleft:  AST::BitwiseShiftLeft,
+      bitshiftright: AST::BitwiseShiftRight,
+
+      lt:       AST::LessThan,
+      gt:       AST::GreaterThan,
+      le:       AST::LessThanOrEqual,
+      ge:       AST::GreaterThanOrEqual,
+      ne:       AST::NotEqual,
+      eq:       AST::Equal,
+
+      and:      AST::And,
+      or:       AST::Or,
+      xor:      AST::Xor,
+    }.freeze
+
+    attr_reader :input, :output, :operations, :arities, :case_sensitive
+
+    def initialize(tokens, options = {})
+      @input             = tokens.dup
+      @output            = []
+      @operations        = options.fetch(:operations, [])
+      @arities           = options.fetch(:arities, [])
+      @function_registry = options.fetch(:function_registry, nil)
+      @case_sensitive    = options.fetch(:case_sensitive, false)
+      @skip_indices      = []
+    end
+
+    def consume(count = 2)
+      operator = operations.pop
+      fail! :invalid_statement if operator.nil?
+
+      output_size = output.length
+      args_size = operator.arity || count
+      min_size = operator.arity || operator.min_param_count || count
+      max_size = operator.arity || operator.max_param_count || count
+
+      if output_size < min_size || args_size < min_size
+        expect = min_size == max_size ? min_size : min_size..max_size
+        fail! :too_few_operands, operator: operator, expect: expect, actual: output_size
+      end
+
+      if (output_size > max_size && operations.empty?) || args_size > max_size
+        expect = min_size == max_size ? min_size : min_size..max_size
+        fail! :too_many_operands, operator: operator, expect: expect, actual: output_size
+      end
+
+      args = []
+      if operator == AST::Array && output.empty?
+        # special case: empty array literal '{}'
+        output.push(operator.new)
+      else
+        fail! :invalid_statement if output_size < args_size
+        args = Array.new(args_size) { output.pop }.reverse
+        output.push operator.new(*args)
+      end
+
+      if operator.respond_to?(:callback) && !operator.callback.nil?
+        operator.callback.call(args)
+      end
+    rescue ::ArgumentError => e
+      raise Dentaku::ArgumentError, e.message
+    rescue NodeError => e
+      fail! :node_invalid, operator: operator, child: e.child, expect: e.expect, actual: e.actual
+    end
+
+    def parse
+      return AST::Nil.new if input.empty?
+
+      i = 0
+      while i < input.length
+        if @skip_indices.include?(i)
+          i += 1
+          next
+        end
+
+        token = input[i]
+        lookahead = input[i + 1]
+        process_token(token, lookahead, i)
+        i += 1
+      end
+
+      consume while operations.any?
+
+      fail! :invalid_statement unless output.count == 1
+
+      output.first
+    end
+
+    def operation(token)
+      AST_OPERATIONS.fetch(token.value)
+    end
+
+    def function(token)
+      function_registry.get(token.value)
+    end
+
+    def function_registry
+      @function_registry ||= Dentaku::AST::FunctionRegistry.new
+    end
+
+    private
+
+    def process_token(token, lookahead, index)
+      case token.category
+      when :datetime      then output << AST::DateTime.new(token)
+      when :numeric       then output << AST::Numeric.new(token)
+      when :logical       then output << AST::Logical.new(token)
+      when :string        then output << AST::String.new(token)
+      when :identifier    then output << AST::Identifier.new(token, case_sensitive: case_sensitive)
+      when :operator, :comparator, :combinator
+        handle_operator(token, lookahead)
+      when :null
+        output << AST::Nil.new
+      when :function
+        handle_function(token)
+      when :case
+        handle_case(token)
+      when :access
+        handle_access(token)
+      when :array
+        handle_array(token)
+      when :grouping
+        handle_grouping(token, lookahead, index)
+      else
+        fail! :not_implemented_token_category, token_category: token.category
+      end
+    end
+
+    def handle_operator(token, lookahead)
+      op_class = operation(token).resolve_class(lookahead)
+      if op_class.right_associative?
+        consume while operations.last && operations.last < AST::Operation && op_class.precedence < operations.last.precedence
+      else
+        consume while operations.last && operations.last < AST::Operation && op_class.precedence <= operations.last.precedence
+      end
+      operations.push op_class
+    end
+
+    def handle_function(token)
+      func = function(token)
+      fail! :undefined_function, function_name: token.value if func.nil?
+      arities.push 0
+      operations.push func
+    end
+
+    def handle_case(token)
+      # We always operate on the innermost (most recent) CASE on the stack.
+      case_index = operations.rindex(AST::Case) || -1
+      token_index = case_index + 1
+
+      case token.value
+      when :open
+        # Start a new CASE context.
+        operations.push AST::Case
+        arities.push(0)
+
+      when :close
+        # Finalize any trailing THEN/ELSE expression still on the stack.
+        if operations[token_index] == AST::CaseThen
+          consume_until(AST::Case)
+          operations.push(AST::CaseConditional)
+          consume(2)
+          arities[-1] += 1
+        elsif operations[token_index] == AST::CaseElse
+          consume_until(AST::Case)
+          arities[-1] += 1
+        end
+        fail! :unprocessed_token, token_name: token.value unless operations.last == AST::Case
+        consume(arities.pop.succ)
+
+      when :when
+        if operations[token_index] == AST::CaseThen
+          # Close out previous WHEN/THEN pair.
+          consume_until([AST::CaseWhen, AST::Case])
+          operations.push(AST::CaseConditional)
+          consume(2)
+          arities[-1] += 1
+        elsif operations.last == AST::Case
+          # First WHEN: finalize switch variable expression.
+          operations.push(AST::CaseSwitchVariable)
+          consume
+        end
+        operations.push(AST::CaseWhen)
+
+      when :then
+        if operations[token_index] == AST::CaseWhen
+          consume_until([AST::CaseThen, AST::Case])
+        end
+        operations.push(AST::CaseThen)
+
+      when :else
+        if operations[token_index] == AST::CaseThen
+          consume_until(AST::Case)
+          operations.push(AST::CaseConditional)
+          consume(2)
+          arities[-1] += 1
+        end
+        operations.push(AST::CaseElse)
+
+      else
+        fail! :unknown_case_token, token_name: token.value
+      end
+    end
+
+    def consume_until(target)
+      matcher =
+        case target
+        when Array then ->(op) { target.include?(op) }
+        else ->(op) { op == target }
+        end
+
+      consume while operations.any? && !matcher.call(operations.last)
+    end
+
+    def handle_access(token)
+      case token.value
+      when :lbracket
+        operations.push AST::Access
+
+      when :rbracket
+        consume while operations.any? && operations.last != AST::Access
+        fail! :unbalanced_bracket, token: token unless operations.last == AST::Access
+        consume
+      end
+    end
+
+    def handle_array(token)
+      case token.value
+      when :array_start
+        operations.push AST::Array
+        arities.push 0
+
+      when :array_end
+        consume while operations.any? && operations.last != AST::Array
+        fail! :unbalanced_bracket, token: token unless operations.last == AST::Array
+        consume(arities.pop.succ)
+      end
+    end
+
+    def handle_grouping(token, lookahead, token_index)
+      case token.value
+      when :open
+        if lookahead && lookahead.value == :close
+          # empty grouping (e.g. function with zero arguments) — we trigger consume later
+          # skip to the end
+          @skip_indices << token_index + 1
+          arities.pop
+          consume(0)
+        else
+          operations.push AST::Grouping
+        end
+
+      when :close
+        consume while operations.any? && operations.last != AST::Grouping
+        lparen = operations.pop
+        fail! :unbalanced_parenthesis, token unless lparen == AST::Grouping
+        if operations.last && operations.last < AST::Function
+          consume(arities.pop.succ)
+        end
+
+      when :comma
+        fail! :invalid_statement if arities.empty?
+        arities[-1] += 1
+        consume while operations.any? && operations.last != AST::Grouping && operations.last != AST::Array
+
+      else
+        fail! :unknown_grouping_token, token_name: token.value
+      end
+    end
+
+    def fail!(reason, **meta)
+      message =
+        case reason
+        when :node_invalid
+          "#{meta.fetch(:operator)} requires #{meta.fetch(:expect).join(', ')} operands, but got #{meta.fetch(:actual)}"
+        when :too_few_operands
+          "#{meta.fetch(:operator)} has too few operands (given #{meta.fetch(:actual)}, expected #{meta.fetch(:expect)})"
+        when :too_many_operands
+          "#{meta.fetch(:operator)} has too many operands (given #{meta.fetch(:actual)}, expected #{meta.fetch(:expect)})"
+        when :undefined_function
+          "Undefined function #{meta.fetch(:function_name)}"
+        when :unprocessed_token
+          "Unprocessed token #{meta.fetch(:token_name)}"
+        when :unknown_case_token
+          "Unknown case token #{meta.fetch(:token_name)}"
+        when :unbalanced_bracket
+          "Unbalanced bracket"
+        when :unbalanced_parenthesis
+          "Unbalanced parenthesis"
+        when :unknown_grouping_token
+          "Unknown grouping token #{meta.fetch(:token_name)}"
+        when :not_implemented_token_category
+          "Not implemented for tokens of category #{meta.fetch(:token_category)}"
+        when :invalid_statement
+          "Invalid statement"
+        else
+          raise ::ArgumentError, "Unhandled #{reason}"
+        end
+
+      raise ParseError.for(reason, **meta), message
+    end
+  end
+end

data/lib/dentaku/print_visitor.rb

@@ -0,0 +1,112 @@
+module Dentaku
+  class PrintVisitor
+    def initialize(node)
+      @output = ''
+      node.accept(self)
+    end
+
+    def visit_operation(node)
+      if node.left
+        visit_operand(node.left, node.class.precedence, suffix: node.operator_spacing, dir: :left)
+      end
+
+      @output << node.display_operator
+
+      if node.right
+        visit_operand(node.right, node.class.precedence, prefix: node.operator_spacing, dir: :right)
+      end
+    end
+
+    def visit_operand(node, precedence, prefix: "", suffix: "", dir: :none)
+      @output << prefix
+      @output << "(" if should_output?(node, precedence, dir == :right)
+      node.accept(self)
+      @output << ")" if should_output?(node, precedence, dir == :right)
+      @output << suffix
+    end
+
+    def should_output?(node, precedence, output_on_equal)
+      return false unless node.is_a?(Dentaku::AST::Operation)
+
+      target_precedence = node.class.precedence
+      target_precedence < precedence || (output_on_equal && target_precedence == precedence)
+    end
+
+    def visit_function(node)
+      @output << node.name
+      @output << "("
+      arg_count = node.args.length
+      node.args.each_with_index do |a, index|
+        a.accept(self)
+        @output << ", " unless index >= arg_count - 1
+      end
+      @output << ")"
+    end
+
+    def visit_case(node)
+      @output << "CASE "
+      node.switch.accept(self)
+      node.conditions.each { |c| c.accept(self) }
+      node.else && node.else.accept(self)
+      @output << " END"
+    end
+
+    def visit_switch(node)
+      node.node.accept(self)
+    end
+
+    def visit_case_conditional(node)
+      node.when.accept(self)
+      node.then.accept(self)
+    end
+
+    def visit_when(node)
+      @output << " WHEN "
+      node.node.accept(self)
+    end
+
+    def visit_then(node)
+      @output << " THEN "
+      node.node.accept(self)
+    end
+
+    def visit_else(node)
+      @output << " ELSE "
+      node.node.accept(self)
+    end
+
+    def visit_negation(node)
+      @output << "-"
+      @output << "(" unless node.node.is_a? Dentaku::AST::Literal
+      node.node.accept(self)
+      @output << ")" unless node.node.is_a? Dentaku::AST::Literal
+    end
+
+    def visit_access(node)
+      node.structure.accept(self)
+      @output << "["
+      node.index.accept(self)
+      @output << "]"
+    end
+
+    def visit_literal(node)
+      @output << node.quoted
+    end
+
+    def visit_identifier(node)
+      @output << node.identifier
+    end
+
+    def visit_nil(node)
+      @output << "NULL"
+    end
+
+    def visit_array(node)
+      @output << node.value.to_s
+    end
+
+    def to_s
+      @output
+    end
+  end
+end

data/lib/dentaku/string_casing.rb

@@ -0,0 +1,7 @@
+module Dentaku
+  module StringCasing
+    def standardize_case(value)
+      case_sensitive ? value : value.downcase
+    end
+  end
+end

data/lib/dentaku/token.rb

@@ -0,0 +1,48 @@
+module Dentaku
+  class Token
+    attr_reader :category, :raw_value, :value
+
+    def initialize(category, value, raw_value = nil)
+      @category  = category
+      @value     = value
+      @raw_value = raw_value
+    end
+
+    def to_s
+      raw_value || value
+    end
+
+    def length
+      raw_value.to_s.length
+    end
+
+    def empty?
+      length.zero?
+    end
+
+    def operator?
+      is?(:operator)
+    end
+
+    def grouping?
+      is?(:grouping)
+    end
+
+    def open?
+      grouping? && value == :open
+    end
+
+    def close?
+      grouping? && value == :close
+    end
+
+    def is?(c)
+      category == c
+    end
+
+    def ==(other)
+      (category.nil? || other.category.nil? || category == other.category) &&
+      (value.nil?    || other.value.nil?    || value    == other.value)
+    end
+  end
+end