jse4r 0.2.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9218575b22bb92b6850c899c9bd83a6025e867699a38b9960ee306a032691c05
+  data.tar.gz: 8224a8dd3d968ca693811f5e8a83b8a47a32d2a11ba215e912d4839ef61a7a84
+SHA512:
+  metadata.gz: 9709bef4773fc21221ac5883081bc77715a69a80431f3ff8f823b321c161618cff6e11385dbea5052895521cb413a7b0ad725484c009317163dc74194ba92480
+  data.tar.gz: ffccc8545db69a0a7e547655821f20fd5e07edee8bbf31cbd6cb341086616d4eac97021d5d22e351ca55bb66a7339ae48810a1e7a7d213b5d4604567e4b84464

data/lib/jse/ast/base.rb

@@ -0,0 +1,19 @@
+module JSE
+  module Ast
+    class AstNode
+      def initialize(env)
+        @env = env
+      end
+
+      attr_reader :env
+
+      def apply(call_env)
+        raise NotImplementedError
+      end
+
+      def to_json
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/jse/ast/nodes.rb

@@ -0,0 +1,203 @@
+module JSE
+  module Ast
+    class LiteralNode < AstNode
+      def initialize(value, env)
+        super(env)
+        @value = value
+      end
+
+      attr_reader :value
+
+      def apply(_call_env)
+        @value
+      end
+
+      def to_json
+        @value
+      end
+    end
+
+    class SymbolNode < AstNode
+      def initialize(name, env)
+        super(env)
+        @name = name
+      end
+
+      attr_reader :name
+
+      def apply(call_env)
+        val = call_env.resolve(@name)
+        raise NameError, "Symbol '#{@name}' not found" if val.nil?
+        val
+      end
+
+      def to_json
+        @name
+      end
+    end
+
+    class ArrayNode < AstNode
+      def initialize(elements, env)
+        super(env)
+        @elements = elements
+      end
+
+      attr_reader :elements
+
+      def apply(call_env)
+        return [] if @elements.empty?
+
+        first = @elements.first
+        if first.is_a?(SymbolNode) && JSE::Parser.symbol?(first.name)
+          apply_function_call(call_env, first.name)
+        else
+          @elements.map { |e| call_env.eval(e) }
+        end
+      end
+
+      def to_json
+        @elements.map(&:to_json)
+      end
+
+      private
+
+      def apply_function_call(call_env, symbol)
+        rest = @elements[1..]
+        if symbol == "$quote"
+          # Pass unevaluated
+          args = rest.map(&:to_json)
+          return apply_functor(call_env, symbol, args)
+        end
+        evaluated = rest.map { |e| call_env.eval(e) }
+        apply_functor(call_env, symbol, evaluated)
+      end
+
+      def apply_functor(call_env, symbol, args)
+        functor = call_env.resolve(symbol)
+        raise NameError, "Unknown operator: #{symbol}" if functor.nil?
+        functor.call(call_env, *args)
+      end
+    end
+
+    class ObjectNode < AstNode
+      def initialize(dict, env)
+        super(env)
+        @dict = dict
+      end
+
+      def apply(call_env)
+        @dict.transform_values { |v| call_env.eval(v) }
+      end
+
+      def to_json
+        @dict.transform_values(&:to_json)
+      end
+    end
+
+    class ExpressionNode < AstNode
+      def initialize(operator, value, metadata, env)
+        super(env)
+        @operator = operator
+        @value = value
+        @metadata = metadata
+      end
+
+      attr_reader :operator, :value, :metadata
+
+      def apply(call_env)
+        functor = call_env.resolve(@operator)
+        raise NameError, "Unknown operator: #{@operator}" if functor.nil?
+
+        evaluated_meta = @metadata.transform_values { |v| deep_eval(call_env, v) }
+        call_env.set_meta(evaluated_meta)
+        begin
+          args = case @operator
+          when "$quote"
+            [@value]
+          when "$expr"
+            [call_env.eval(@value)]
+          when "$sql"
+            # $sql receives raw JSON stored in LiteralNode by parser
+            if @value.is_a?(LiteralNode)
+              [@value.value]
+            else
+              [@value]
+            end
+          else
+            if @value.is_a?(ArrayNode)
+              @value.elements.map { |e| deep_eval(call_env, e) }
+            else
+              [call_env.eval(@value)]
+            end
+          end
+
+          functor.call(call_env, *args)
+        ensure
+          call_env.clear_meta
+        end
+      end
+
+      def to_json
+        result = { @operator => @value.to_json }
+        @metadata.each { |k, v| result[k] = v }
+        result
+      end
+
+      private
+
+      def deep_eval(env, value)
+        evaluated = env.eval(value)
+        case evaluated
+        when Array
+          evaluated.map { |item| deep_eval(env, item) }
+        when Hash
+          evaluated.transform_values { |v| deep_eval(env, v) }
+        else
+          evaluated
+        end
+      end
+    end
+
+    class QuoteNode < AstNode
+      def initialize(value, env)
+        super(env)
+        @value = value
+      end
+
+      def apply(_call_env)
+        @value
+      end
+
+      def to_json
+        if @value.respond_to?(:to_json)
+          ["$quote", @value.to_json]
+        else
+          ["$quote", @value]
+        end
+      end
+    end
+
+    class LambdaNode < AstNode
+      def initialize(params, body, closure_env)
+        super(closure_env)
+        @params = params
+        @body = body
+        @closure_env = closure_env
+      end
+
+      def apply(call_env, *args)
+        if args.length != @params.length
+          raise ArgumentError, "Lambda expects #{@params.length} args, got #{args.length}"
+        end
+
+        call_env = JSE::Env.new(parent: @closure_env)
+        @params.zip(args).each { |param, arg| call_env.set(param, arg) }
+        call_env.eval(@body)
+      end
+
+      def to_json
+        "<lambda>"
+      end
+    end
+  end
+end

data/lib/jse/ast/parser.rb

@@ -0,0 +1,97 @@
+module JSE
+  class Parser
+    def self.symbol?(s)
+      return false if s == "$*"
+      s.is_a?(String) && s.start_with?("$") && !s.start_with?("$$")
+    end
+
+    def self.unescape(s)
+      s.is_a?(String) && s.start_with?("$$") ? s[1..] : s
+    end
+
+    def initialize(env)
+      @env = env
+    end
+
+    def parse(expr)
+      case expr
+      when nil, true, false, Integer, Float
+        Ast::LiteralNode.new(expr, @env)
+      when String
+        if self.class.symbol?(expr)
+          Ast::SymbolNode.new(expr, @env)
+        else
+          Ast::LiteralNode.new(self.class.unescape(expr), @env)
+        end
+      when Array
+        parse_list(expr)
+      when Hash
+        parse_dict(expr)
+      else
+        Ast::LiteralNode.new(expr, @env)
+      end
+    end
+
+    private
+
+    def parse_list(lst)
+      return Ast::ArrayNode.new([], @env) if lst.empty?
+
+      first = lst.first
+      if first == "$quote"
+        value = lst.length > 1 ? lst[1] : nil
+        return Ast::QuoteNode.new(value, @env)
+      end
+
+      if first.is_a?(String) && self.class.symbol?(first)
+        elements = lst[1..].map { |e| parse(e) }
+        return Ast::ExpressionNode.new(first, Ast::ArrayNode.new(elements, @env), {}, @env)
+      end
+
+      elements = lst.map { |e| parse(e) }
+      Ast::ArrayNode.new(elements, @env)
+    end
+
+    def parse_dict(dict)
+      symbol_keys = dict.keys.select { |k| self.class.symbol?(k) }
+
+      if symbol_keys.empty?
+        result = {}
+        dict.each do |k, v|
+          parsed_key = self.class.unescape(k)
+          result[parsed_key] = parse(v)
+        end
+        return Ast::ObjectNode.new(result, @env)
+      end
+
+      if symbol_keys.length == 1
+        operator = symbol_keys.first
+
+        if operator == "$quote"
+          return Ast::QuoteNode.new(dict[operator], @env)
+        end
+
+        # $sql: pass raw JSON directly (bypass JSE parsing)
+        if operator == "$sql"
+          raw_value = dict[operator]
+          metadata = {}
+          dict.each do |k, v|
+            next if k == operator
+            metadata[self.class.unescape(k)] = v
+          end
+          return Ast::ExpressionNode.new(operator, Ast::LiteralNode.new(raw_value, @env), metadata, @env)
+        end
+
+        parsed_value = parse(dict[operator])
+        metadata = {}
+        dict.each do |k, v|
+          next if k == operator
+          metadata[self.class.unescape(k)] = parse(v)
+        end
+        return Ast::ExpressionNode.new(operator, parsed_value, metadata, @env)
+      end
+
+      raise "JSE structure error: object cannot have multiple operator keys"
+    end
+  end
+end

data/lib/jse/engine.rb

@@ -0,0 +1,19 @@
+module JSE
+  class Engine
+    def initialize(env)
+      @env = env
+      @parser = Parser.new(env)
+    end
+
+    attr_reader :env
+
+    def execute(expr)
+      ast = @parser.parse(expr)
+      @env.eval(ast)
+    end
+
+    def self.with_env
+      new(Env.new)
+    end
+  end
+end

data/lib/jse/env.rb

@@ -0,0 +1,60 @@
+module JSE
+  class Env
+    def initialize(parent: nil)
+      @parent = parent
+      @bindings = {}
+      @current_meta = {}
+    end
+
+    attr_reader :parent
+
+    def resolve(name)
+      if @bindings.key?(name)
+        @bindings[name]
+      elsif @parent
+        @parent.resolve(name)
+      end
+    end
+
+    def register(name, value)
+      if @bindings.key?(name)
+        raise "Symbol '#{name}' already exists in current scope"
+      end
+      @bindings[name] = value
+    end
+
+    def set(name, value)
+      @bindings[name] = value
+    end
+
+    def exists?(name)
+      return true if @bindings.key?(name)
+      return @parent.exists?(name) if @parent
+      false
+    end
+
+    def load(mod)
+      mod.each { |name, functor| register(name, functor) }
+    end
+
+    def eval(node)
+      if node.respond_to?(:apply)
+        node.apply(self)
+      else
+        node
+      end
+    end
+
+    def set_meta(dict)
+      @current_meta = dict
+    end
+
+    def get_meta
+      @current_meta
+    end
+
+    def clear_meta
+      @current_meta = {}
+    end
+  end
+end

data/lib/jse/functors/builtin.rb

@@ -0,0 +1,67 @@
+module JSE
+  module Functors
+    module Builtin
+      def self.quote(env, *args)
+        args[0]
+      end
+
+      def self.eq(env, *args)
+        a = args[0].respond_to?(:apply) ? env.eval(args[0]) : args[0]
+        b = args[1].respond_to?(:apply) ? env.eval(args[1]) : args[1]
+        a == b
+      end
+
+      def self.cond(env, *args)
+        i = 0
+        while i < args.length - 1
+          test = args[i].respond_to?(:apply) ? env.eval(args[i]) : args[i]
+          if test
+            return args[i + 1].respond_to?(:apply) ? env.eval(args[i + 1]) : args[i + 1]
+          end
+          i += 2
+        end
+        # Odd number of args: last is default
+        if args.length.odd?
+          env.eval(args.last)
+        end
+      end
+
+      def self.head(env, *args)
+        lst = args[0].respond_to?(:apply) ? env.eval(args[0]) : args[0]
+        raise "$head requires a list" unless lst.is_a?(Array)
+        raise "$head: list is empty" if lst.empty?
+        lst.first
+      end
+
+      def self.tail(env, *args)
+        lst = args[0].respond_to?(:apply) ? env.eval(args[0]) : args[0]
+        raise "$tail requires a list" unless lst.is_a?(Array)
+        raise "$tail: list is empty" if lst.empty?
+        lst[1..]
+      end
+
+      def self.atomp(env, *args)
+        val = args[0].respond_to?(:apply) ? env.eval(args[0]) : args[0]
+        val.nil? || val.is_a?(Integer) || val.is_a?(Float) ||
+          val == true || val == false || val.is_a?(String)
+      end
+
+      def self.cons(env, *args)
+        elem = args[0].respond_to?(:apply) ? env.eval(args[0]) : args[0]
+        lst = args[1].respond_to?(:apply) ? env.eval(args[1]) : args[1]
+        raise "$cons second argument must be a list" unless lst.is_a?(Array)
+        [elem] + lst
+      end
+
+      BUILTIN_FUNCTORS = {
+        "$quote" => method(:quote),
+        "$eq"    => method(:eq),
+        "$cond"  => method(:cond),
+        "$head"  => method(:head),
+        "$tail"  => method(:tail),
+        "$atom?" => method(:atomp),
+        "$cons"  => method(:cons),
+      }.freeze
+    end
+  end
+end

data/lib/jse/functors/lisp.rb

@@ -0,0 +1,72 @@
+module JSE
+  module Functors
+    module Lisp
+      def self.eval_fn(env, *args)
+        raise "$eval requires 1 argument" if args.empty?
+        env.eval(args[0])
+      end
+
+      def self.apply_fn(env, *args)
+        raise "$apply requires (functor, arglist)" if args.length < 2
+        functor = args[0].respond_to?(:apply) ? env.eval(args[0]) : args[0]
+        arglist = args[1].respond_to?(:apply) ? env.eval(args[1]) : args[1]
+        raise "$apply second argument must be a list" unless arglist.is_a?(Array)
+        functor.call(env, *arglist)
+      end
+
+      def self.lambda_fn(env, *args)
+        raise "$lambda requires (params, body)" if args.length < 2
+        params_raw = args[0]
+        body = args[1]
+
+        params = if params_raw.is_a?(Ast::ArrayNode)
+          params_raw.elements.map { |e| e.is_a?(Ast::SymbolNode) ? e.name : e }
+        elsif params_raw.is_a?(Ast::SymbolNode)
+          [params_raw.name]
+        elsif params_raw.is_a?(Array)
+          params_raw
+        else
+          [params_raw.to_s]
+        end
+
+        Ast::LambdaNode.new(params, body, env)
+      end
+
+      def self.def_fn(env, *args)
+        raise "$def requires (name, value)" if args.length < 2
+        name_node = args[0]
+        name = if name_node.is_a?(Ast::SymbolNode)
+          name_node.name
+        elsif name_node.is_a?(String)
+          name_node
+        else
+          name_node.to_s
+        end
+        value = args[1].respond_to?(:apply) ? env.eval(args[1]) : args[1]
+        env.register(name, value)
+        value
+      end
+
+      def self.defn(env, *args)
+        raise "$defn requires (name, params, body)" if args.length < 3
+        name_node = args[0]
+        name = if name_node.is_a?(Ast::SymbolNode)
+          name_node.name
+        else
+          name_node.to_s
+        end
+        lambda_result = lambda_fn(env, args[1], args[2])
+        env.register(name, lambda_result)
+        lambda_result
+      end
+
+      LISP_FUNCTORS = {
+        "$eval"   => method(:eval_fn),
+        "$apply"  => method(:apply_fn),
+        "$lambda" => method(:lambda_fn),
+        "$def"    => method(:def_fn),
+        "$defn"   => method(:defn),
+      }.freeze
+    end
+  end
+end

data/lib/jse/functors/sql.rb

@@ -0,0 +1,455 @@
+require "json"
+
+module JSE
+  module Functors
+    module SQL
+      QUERY_FIELDS = "subject, predicate, object, meta"
+
+      # ============================================================
+      # Subquery detection
+      # ============================================================
+
+      def self.subquery?(value)
+        return false unless value.is_a?(Array) && !value.empty?
+        value.all? { |item| item.is_a?(Array) && !item.empty? && item[0].is_a?(String) && item[0].start_with?("$") }
+      end
+
+      # ============================================================
+      # String utilities
+      # ============================================================
+
+      def self.symbol_str?(s)
+        return false if s == "$*"
+        s.is_a?(String) && s.start_with?("$") && !s.start_with?("$$")
+      end
+
+      def self.escaped_str?(s)
+        s.is_a?(String) && s.start_with?("$$")
+      end
+
+      def self.sql_quote(s)
+        "'#{s.gsub("'", "''")}'"
+      end
+
+      def self.parenthesized?(s)
+        return false unless s.start_with?("(")
+        depth = 0
+        s.each_char.with_index do |c, i|
+          depth += 1 if c == "("
+          depth -= 1 if c == ")"
+          return i == s.length - 1 if depth == 0
+        end
+        false
+      end
+
+      # ============================================================
+      # Expression renderer
+      # ============================================================
+
+      def self.render_expr(value)
+        case value
+        when nil then "null"
+        when true then "true"
+        when false then "false"
+        when Integer, Float then value.to_s
+        when String
+          if escaped_str?(value)
+            sql_quote("$#{value[2..]}")
+          elsif symbol_str?(value)
+            value[1..]
+          else
+            sql_quote(value)
+          end
+        when Array
+          return "" if value.empty?
+          if subquery?(value)
+            render_subquery(value)
+          elsif value[0].is_a?(String) && value[0].start_with?("$") && !value[0].start_with?("$$")
+            render_list_expr(value)
+          else
+            value.map { |v| render_expr(v) }.join(", ")
+          end
+        when Hash
+          render_dict(value)
+        else
+          value.to_s
+        end
+      end
+
+      def self.render_dict(dict)
+        return "" if dict.empty?
+        op_keys = dict.keys.select { |k| symbol_str?(k) }
+        if op_keys.empty? || op_keys.length > 1
+          return dict.map { |k, v| "#{render_key(k)} = #{render_expr(v)}" }.join(", ")
+        end
+        op = op_keys.first
+        return %("#{dict[op]}") if op == "$symbol"
+        render_expr(dict[op])
+      end
+
+      def self.render_key(key)
+        if escaped_str?(key)
+          "$#{key[2..]}"
+        elsif symbol_str?(key)
+          key[1..]
+        else
+          key.to_s
+        end
+      end
+
+      def self.render_list_expr(lst)
+        return "" if lst.empty?
+        op = lst[0]
+        return lst.map { |v| render_expr(v) }.join(", ") unless op.is_a?(String)
+        return lst.map { |v| render_expr(v) }.join(", ") if op.start_with?("$$")
+        render_func(op, lst[1..])
+      end
+
+      # ============================================================
+      # Function dispatch
+      # ============================================================
+
+      def self.render_func(op, args)
+        case op
+        when "$as"   then render_as(args)
+        when "$count" then render_count(args)
+        when "$sum"   then render_agg("sum", args)
+        when "$avg"   then render_agg("avg", args)
+        when "$max"   then render_agg("max", args)
+        when "$min"   then render_agg("min", args)
+        when "$eq"    then render_binary("=", args)
+        when "$ne"    then render_binary("!=", args)
+        when "$gt"    then render_binary(">", args)
+        when "$gte"   then render_binary(">=", args)
+        when "$lt"    then render_binary("<", args)
+        when "$lte"   then render_binary("<=", args)
+        when "$like"  then render_binary("like", args)
+        when "$is"    then render_is(args)
+        when "$is-not" then render_is_not(args)
+        when "$and"   then render_logical("and", args)
+        when "$or"    then render_logical("or", args)
+        when "$in"    then render_in(args)
+        when "$case"  then render_case(args)
+        when "$excluded" then render_excluded(args)
+        else
+          "#{op[1..]}(#{args.map { |a| render_expr(a) }.join(", ")})"
+        end
+      end
+
+      def self.render_as(args)
+        return "" if args.length < 2
+        expr = render_expr(args[0])
+        als = render_expr(args[1])
+        if args[0].is_a?(Array)
+          "(#{expr}) as #{als}"
+        elsif args[0].is_a?(String) && symbol_str?(args[0])
+          "#{args[0][1..]} as #{als}"
+        else
+          "#{expr} as #{als}"
+        end
+      end
+
+      def self.render_count(args)
+        return "count(*)" if args.empty?
+        return "count(*)" if args[0].is_a?(String) && args[0] == "$*"
+        "count(#{render_expr(args[0])})"
+      end
+
+      def self.render_agg(fn, args)
+        return "#{fn}(*)" if args.empty?
+        "#{fn}(#{render_expr(args[0])})"
+      end
+
+      def self.render_binary(op, args)
+        return "" if args.length < 2
+        "#{render_expr(args[0])} #{op} #{render_expr(args[1])}"
+      end
+
+      def self.render_is(args)
+        return "" if args.length < 2
+        left = render_expr(args[0])
+        return "#{left} is null" if args[1].nil?
+        "#{left} is #{render_expr(args[1])}"
+      end
+
+      def self.render_is_not(args)
+        return "" if args.length < 2
+        left = render_expr(args[0])
+        return "#{left} is not null" if args[1].nil?
+        "#{left} is not #{render_expr(args[1])}"
+      end
+
+      def self.render_logical(op, args)
+        return op == "and" ? "true" : "false" if args.empty?
+        parts = args.map do |a|
+          r = render_expr(a)
+          parenthesized?(r) ? r : "(#{r})"
+        end
+        "(#{parts.join(" #{op} ")})"
+      end
+
+      def self.render_in(args)
+        return "" if args.length < 2
+        col = render_expr(args[0])
+        val = args[1]
+        if val.is_a?(Array)
+          if subquery?(val)
+            "#{col} in (#{render_subquery(val)})"
+          else
+            "#{col} in (#{val.map { |v| render_expr(v) }.join(", ")})"
+          end
+        else
+          "#{col} in (#{render_expr(val)})"
+        end
+      end
+
+      def self.render_case(args)
+        parts = ["case"]
+        else_val = nil
+        args.each do |arg|
+          if arg.is_a?(Array) && !arg.empty? && arg[0].is_a?(String)
+            if arg[0] == "$when" && arg.length >= 3
+              parts << "when #{render_expr(arg[1])} then #{render_expr(arg[2])}"
+            elsif arg[0] == "$else" && arg.length >= 2
+              else_val = render_expr(arg[1])
+            end
+          end
+        end
+        parts << "else #{else_val}" if else_val
+        parts << "end"
+        parts.join(" ")
+      end
+
+      def self.render_excluded(args)
+        return "excluded" if args.empty?
+        "excluded.#{render_expr(args[0])}"
+      end
+
+      # ============================================================
+      # Subquery rendering
+      # ============================================================
+
+      def self.render_subquery(clauses)
+        clauses.select { |c| c.is_a?(Array) }
+               .map { |c| render_clause(c) }
+               .reject(&:empty?)
+               .join(" ")
+      end
+
+      # ============================================================
+      # Clause renderer
+      # ============================================================
+
+      def self.render_clause(clause)
+        return "" if clause.empty?
+        kw = clause[0]
+        return "" unless kw.is_a?(String) && kw.start_with?("$")
+        args = clause[1..]
+
+        case kw
+        when "$select"
+          "select #{args.map { |a| render_expr(a) }.join(", ")}"
+        when "$from"
+          "from #{render_table(args)}"
+        when "$join"
+          "join #{render_join(args)}"
+        when "$left-join"
+          "left join #{render_join(args)}"
+        when "$right-join"
+          "right join #{render_join(args)}"
+        when "$full-join"
+          "full join #{render_join(args)}"
+        when "$cross-join"
+          "cross join #{render_table(args)}"
+        when "$where"
+          args.empty? ? "" : "where #{render_expr(args[0])}"
+        when "$group-by"
+          args.empty? ? "" : "group by #{render_expr(args[0])}"
+        when "$having"
+          args.empty? ? "" : "having #{render_expr(args[0])}"
+        when "$order-by"
+          render_order_by(args)
+        when "$limit"
+          args.empty? ? "" : "limit #{render_expr(args[0])}"
+        when "$offset"
+          args.empty? ? "" : "offset #{render_expr(args[0])}"
+        when "$with"
+          render_with(args)
+        when "$insert-into"
+          render_insert_into(args)
+        when "$values"
+          "values (#{args.map { |a| render_expr(a) }.join(", ")})"
+        when "$update"
+          "update #{render_table(args)}"
+        when "$set"
+          render_set(args)
+        when "$delete-from"
+          "delete from #{render_table(args)}"
+        when "$on-conflict"
+          args.empty? ? "" : "on conflict (#{render_expr(args[0])})"
+        when "$do-update"
+          render_do_update(args)
+        else
+          kw[1..]
+        end
+      end
+
+      def self.render_table(args)
+        return "" if args.empty?
+        first = args[0]
+        if first.is_a?(Array) && !first.empty? && first[0] == "$as"
+          render_list_expr(first)
+        else
+          render_expr(first)
+        end
+      end
+
+      def self.render_join(args)
+        return "" if args.empty?
+        table = render_expr(args[0])
+        return "#{table} on #{render_expr(args[1])}" if args.length >= 2
+        table
+      end
+
+      def self.render_order_by(args)
+        return "" if args.empty?
+        col = render_expr(args[0])
+        if args.length >= 2 && args[1].is_a?(String) && symbol_str?(args[1])
+          dir = args[1][1..]
+          return "order by #{col} #{dir}" if %w[desc asc].include?(dir)
+        end
+        return "order by #{col} #{render_expr(args[1])}" if args.length >= 2
+        "order by #{col}"
+      end
+
+      def self.render_with(args)
+        return "" if args.empty? || !args[0].is_a?(Hash)
+        cte_defs = args[0]
+        cte_parts = cte_defs.map do |cte_name_key, cte_clauses|
+          cte_name = symbol_str?(cte_name_key) ? cte_name_key[1..] : cte_name_key
+          next unless cte_clauses.is_a?(Array) && !cte_clauses.empty?
+          inner = cte_clauses.map { |c| c.is_a?(Array) ? render_clause(c) : "" }.reject(&:empty?).join(" ")
+          "#{cte_name} as (#{inner})"
+        end.compact
+        return "" if cte_parts.empty?
+        "with #{cte_parts.join(",\n")}"
+      end
+
+      def self.render_insert_into(args)
+        return "insert into" if args.empty?
+        table = render_expr(args[0])
+        if args.length > 1
+          cols = args[1..].map { |a| render_expr(a) }.join(", ")
+          "insert into #{table} (#{cols})"
+        else
+          "insert into #{table}"
+        end
+      end
+
+      def self.render_set(args)
+        return "" if args.empty? || !args[0].is_a?(Hash)
+        parts = args[0].map { |col, val| "#{render_key(col)} = #{render_expr(val)}" }
+        "set #{parts.join(", ")}"
+      end
+
+      def self.render_do_update(args)
+        return "" if args.empty? || !args[0].is_a?(Hash)
+        parts = args[0].map { |col, val| "#{render_key(col)} = #{render_expr(val)}" }
+        "do update set #{parts.join(", ")}"
+      end
+
+      # ============================================================
+      # $sql functor
+      # ============================================================
+
+      def self.sql_fn(env, *args)
+        return "" if args.empty?
+        data = args[0]
+        return "" unless data.is_a?(Array) && !data.empty?
+
+        parts = []
+        pending_values = []
+
+        flush_values = -> {
+          unless pending_values.empty?
+            rows = pending_values.map { |vlist|
+              "(#{vlist.map { |v| render_expr(v) }.join(", ")})"
+            }
+            parts << "values #{rows.join(", ")}"
+            pending_values.clear
+          end
+        }
+
+        data.each do |item|
+          next unless item.is_a?(Array) && !item.empty?
+          if item[0] == "$values"
+            pending_values << item[1..]
+            next
+          end
+          flush_values.call
+          rendered = render_clause(item)
+          parts << rendered unless rendered.empty?
+        end
+        flush_values.call
+
+        parts.join("\n")
+      end
+
+      # ============================================================
+      # Legacy $query / $pattern (backward compatibility)
+      # ============================================================
+
+      def self.pattern_to_triple(subject, predicate, object)
+        if subject == "$*" && object == "$*"
+          [predicate]
+        else
+          [subject, predicate, object]
+        end
+      end
+
+      def self.triple_to_sql_condition(triple)
+        inner = triple.map { |s| %("#{s}") }.join(",")
+        json = %({"triple":[#{inner}]})
+        escaped = json.gsub("'", "''")
+        "meta @> '#{escaped}'"
+      end
+
+      def self.pattern_fn(env, *args)
+        raise "$pattern requires (subject, predicate, object)" if args.length < 3
+        subj, pred, obj = args[0..2].map { |a| env.eval(a) }
+        triple = pattern_to_triple(subj, pred, obj)
+        triple_to_sql_condition(triple)
+      end
+
+      def self.legacy_and(env, *args)
+        args.map { |a| env.eval(a).to_s }.join(" and ")
+      end
+
+      def self.wildcard_fn(_env, *_args)
+        "*"
+      end
+
+      LOCAL_SQL_FUNCTORS = {
+        "$pattern" => method(:pattern_fn),
+        "$and"     => method(:legacy_and),
+        "$*"       => method(:wildcard_fn),
+      }.freeze
+
+      def self.query_fn(env, *args)
+        raise "$query expects a condition expression" if args.empty?
+        local = Env.new(parent: env)
+        local.load(LOCAL_SQL_FUNCTORS)
+        parser = Parser.new(local)
+        condition = parser.parse(args)
+        where = condition.apply(local)
+        where = where.is_a?(Array) ? where.first.to_s : where.to_s
+        "select #{QUERY_FIELDS} \nfrom statement \nwhere \n    #{where} \noffset 0\nlimit 100 \n"
+      end
+
+      SQL_FUNCTORS = {
+        "$sql"   => method(:sql_fn),
+        "$query" => method(:query_fn),
+      }.freeze
+    end
+  end
+end

data/lib/jse/functors/utils.rb

@@ -0,0 +1,123 @@
+module JSE
+  module Functors
+    module Utils
+      def self.eval_arg(env, arg)
+        arg.respond_to?(:apply) ? env.eval(arg) : arg
+      end
+
+      def self.not_fn(env, *args)
+        return true if args.empty?
+        !eval_arg(env, args[0])
+      end
+
+      def self.and_fn(env, *args)
+        return true if args.empty?
+        args.each do |arg|
+          return false unless eval_arg(env, arg)
+        end
+        true
+      end
+
+      def self.or_fn(env, *args)
+        return false if args.empty?
+        args.each do |arg|
+          val = eval_arg(env, arg)
+          return val if val
+        end
+        false
+      end
+
+      def self.listp(env, *args)
+        return false if args.empty?
+        eval_arg(env, args[0]).is_a?(Array)
+      end
+
+      def self.mapp(env, *args)
+        return false if args.empty?
+        eval_arg(env, args[0]).is_a?(Hash)
+      end
+
+      def self.nullp(env, *args)
+        return true if args.empty?
+        eval_arg(env, args[0]).nil?
+      end
+
+      def self.get_fn(env, *args)
+        raise "$get requires (collection, key)" if args.length < 2
+        coll = eval_arg(env, args[0])
+        key = eval_arg(env, args[1])
+        if coll.is_a?(Hash)
+          coll[key]
+        elsif coll.is_a?(Array)
+          raise "$get on list requires integer index" unless key.is_a?(Integer)
+          raise IndexError, "Index #{key} out of range" if key < 0 || key >= coll.length
+          coll[key]
+        else
+          raise "$get first argument must be map or list"
+        end
+      end
+
+      def self.set_fn(env, *args)
+        raise "$set requires (collection, key, value)" if args.length < 3
+        coll = eval_arg(env, args[0])
+        key = eval_arg(env, args[1])
+        val = eval_arg(env, args[2])
+        if coll.is_a?(Hash)
+          coll[key] = val
+        elsif coll.is_a?(Array)
+          raise "$set on list requires integer index" unless key.is_a?(Integer)
+          coll[key] = val
+        else
+          raise "$set first argument must be map or list"
+        end
+        coll
+      end
+
+      def self.del_fn(env, *args)
+        raise "$del requires (collection, key)" if args.length < 2
+        coll = eval_arg(env, args[0])
+        key = eval_arg(env, args[1])
+        if coll.is_a?(Hash)
+          coll.delete(key) { raise KeyError, "Key '#{key}' not found" }
+        elsif coll.is_a?(Array)
+          raise "$del on list requires integer index" unless key.is_a?(Integer)
+          coll.delete_at(key)
+        else
+          raise "$del first argument must be map or list"
+        end
+        coll
+      end
+
+      def self.conj(env, *args)
+        raise "$conj requires exactly 2 arguments" unless args.length == 2
+        elem = eval_arg(env, args[0])
+        lst = eval_arg(env, args[1])
+        raise "$conj second argument must be a list" unless lst.is_a?(Array)
+        lst + [elem]
+      end
+
+      def self.eq2(env, *args)
+        evaluated = args.map { |a| eval_arg(env, a) }
+        case evaluated.length
+        when 1 then true
+        when 2 then evaluated[0] == evaluated[1]
+        else
+          evaluated.each_cons(2).all? { |a, b| a == b }
+        end
+      end
+
+      UTILS_FUNCTORS = {
+        "$not"   => method(:not_fn),
+        "$list?" => method(:listp),
+        "$map?"  => method(:mapp),
+        "$null?" => method(:nullp),
+        "$get"   => method(:get_fn),
+        "$set"   => method(:set_fn),
+        "$del"   => method(:del_fn),
+        "$conj"  => method(:conj),
+        "$and"   => method(:and_fn),
+        "$or"    => method(:or_fn),
+      }.freeze
+    end
+  end
+end

data/lib/jse/version.rb

@@ -0,0 +1,3 @@
+module JSE
+  VERSION = "0.2.4"
+end

data/lib/jse.rb

@@ -0,0 +1,13 @@
+require_relative "jse/version"
+require_relative "jse/env"
+require_relative "jse/ast/base"
+require_relative "jse/ast/nodes"
+require_relative "jse/ast/parser"
+require_relative "jse/engine"
+require_relative "jse/functors/builtin"
+require_relative "jse/functors/utils"
+require_relative "jse/functors/lisp"
+require_relative "jse/functors/sql"
+
+module JSE
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: jse4r
+version: !ruby/object:Gem::Version
+  version: 0.2.4
+platform: ruby
+authors:
+- Mars Liu
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-04-30 00:00:00.000000000 Z
+dependencies: []
+description: JSE is a JSON-based structural expression specification. It extends JSON
+  from a data carrier into a medium that can express structured intent and computational
+  logic.
+email: mars.liu@outlook.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/jse.rb
+- lib/jse/ast/base.rb
+- lib/jse/ast/nodes.rb
+- lib/jse/ast/parser.rb
+- lib/jse/engine.rb
+- lib/jse/env.rb
+- lib/jse/functors/builtin.rb
+- lib/jse/functors/lisp.rb
+- lib/jse/functors/sql.rb
+- lib/jse/functors/utils.rb
+- lib/jse/version.rb
+homepage: https://github.com/MarchLiu/jse
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key:
+specification_version: 4
+summary: JSON Structural Expression (JSE) runtime for Ruby
+test_files: []