logica_compiler 0.1.0

data/lib/logica_compiler/compiler.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+require "digest"
+require "fileutils"
+require "json"
+require "open3"
+require "time"
+require "timeout"
+
+require_relative "sql_safety"
+require_relative "util"
+
+module LogicaCompiler
+  class Compiler
+    DEFAULT_TIMEOUT = 30
+
+    # User-friendly aliases → Logica CLI engine names.
+    # Python Logica uses "psql" as the PostgreSQL engine name (not "postgres").
+    ENGINE_ALIASES = {
+      "postgres" => "psql",
+      "postgresql" => "psql",
+      "pg" => "psql",
+    }.freeze
+
+    def initialize(config:)
+      @config = config
+      @logica_version = nil
+    end
+
+    def compile_all!(force: false, prune: true)
+      version = logica_version
+      out_dir = @config.output_dir_path
+      FileUtils.mkdir_p(out_dir)
+
+      entries = {}
+      @config.queries.each do |name, query|
+        entries[name.to_s] = compile_one!(name:, query:, force:, prune:, logica_version: version)
+      end
+
+      manifest = Manifest.build(
+        engine: @config.engine,
+        logica_version: version,
+        queries: entries
+      )
+      Manifest.write!(@config.manifest_path, manifest)
+      manifest
+    end
+
+    def compile_one!(name:, query:, force: false, prune: true, logica_version: self.logica_version)
+      out_dir = @config.output_dir_path
+      FileUtils.mkdir_p(out_dir)
+
+      program_path = @config.absolute_path(query.program)
+      program_source = File.read(program_path)
+      validate_program_engine!(program_source)
+
+      digest_hex = compute_digest(program_source:, predicate: query.predicate, engine: @config.engine, logica_version:)
+      digest = "sha256:#{digest_hex}"
+
+      sql_filename = "#{name}-#{digest_hex}.sql"
+      meta_filename = "#{name}-#{digest_hex}.meta.json"
+      sql_path = out_dir.join(sql_filename)
+      meta_path = out_dir.join(meta_filename)
+
+      return existing_entry_for(name:) if !force && entry_exists?(name:, digest_hex:)
+
+      prune_old_artifacts!(name:, keep_digest_hex: digest_hex) if prune
+
+      compiled_sql = compile_via_cli!(program_source:, predicate: query.predicate, timeout: compile_timeout)
+      compiled_sql = normalize_sql(compiled_sql)
+
+      sql_with_header = add_sql_header(
+        sql: compiled_sql,
+        name: name.to_s,
+        program: query.program,
+        predicate: query.predicate,
+        engine: @config.engine,
+        digest:
+      )
+      SqlSafety.validate!(sql_with_header)
+
+      File.write(sql_path, sql_with_header)
+
+      meta = {
+        name: name.to_s,
+        program: query.program,
+        predicate: query.predicate,
+        engine: @config.engine,
+        compiled_at: Time.now.utc.iso8601,
+        compiler: { bin: @config.logica_bin, version: logica_version },
+        digest: digest,
+      }
+      File.write(meta_path, "#{JSON.pretty_generate(meta)}\n")
+
+      { "digest" => digest, "sql" => sql_filename, "meta" => meta_filename }
+    end
+
+    def logica_version
+      return @logica_version if @logica_version
+
+      pinned = @config.pinned_logica_version
+      return (@logica_version = pinned) if pinned && !pinned.to_s.strip.empty?
+
+      # If LOGICA_BIN points to a venv-installed executable, infer the venv python and ask pip metadata.
+      bin = @config.logica_bin.to_s
+      if Util.path_like?(bin)
+        venv_dir = File.expand_path("..", File.dirname(bin))
+        python = File.join(venv_dir, Util.venv_bin_dir, "python")
+        if File.executable?(python)
+          stdout, _stderr, status =
+            run_cmd_with_timeout!(
+              [python, "-c", "import importlib.metadata as m; print(m.version('logica'))"],
+              stdin_data: nil,
+              timeout: 5
+            )
+          version = stdout.to_s.strip
+          return (@logica_version = version) if status.success? && !version.empty?
+        end
+      end
+
+      @logica_version = "unknown"
+    rescue StandardError
+      @logica_version = @config.pinned_logica_version || "unknown"
+    end
+
+    private
+
+    def compile_timeout
+      Integer(ENV.fetch("LOGICA_COMPILE_TIMEOUT", DEFAULT_TIMEOUT))
+    rescue ArgumentError
+      DEFAULT_TIMEOUT
+    end
+
+    def entry_exists?(name:, digest_hex:)
+      entry = existing_entry_for(name:)
+      return false unless entry
+      return false unless entry["digest"].to_s == "sha256:#{digest_hex}"
+
+      out_dir = @config.output_dir_path
+      sql_file = entry["sql"].to_s
+      meta_file = entry["meta"].to_s
+      return false if sql_file.empty? || meta_file.empty?
+
+      out_dir.join(sql_file).exist? && out_dir.join(meta_file).exist?
+    end
+
+    def existing_entry_for(name:)
+      manifest = Manifest.load(@config.manifest_path)
+      manifest.fetch("queries", {}).fetch(name.to_s)
+    rescue Errno::ENOENT, KeyError, JSON::ParserError
+      nil
+    end
+
+    def compute_digest(program_source:, predicate:, engine:, logica_version:)
+      Digest::SHA256.hexdigest([program_source, predicate, engine, logica_version].join("\n"))
+    end
+
+    def normalize_sql(sql)
+      sql = sql.to_s
+      sql = extract_main_query_from_psql_script(sql) if logica_engine == "psql"
+      sql.strip.sub(/;\s*\z/, "")
+    end
+
+    def validate_program_engine!(program_source)
+      declared = program_source.match(/@Engine\(\s*["']([^"']+)["']\s*\)\s*;/i)&.captures&.first
+      return if declared.nil?
+
+      return if canonical_engine(declared) == logica_engine
+
+      raise ArgumentError, "Program @Engine(#{declared.inspect}) does not match config engine #{@config.engine.inspect}"
+    end
+
+    def compile_via_cli!(program_source:, predicate:, timeout:)
+      effective_source = ensure_engine_directive(program_source)
+      cmd = [@config.logica_bin, "-", "print", predicate.to_s]
+      stdout, stderr, status = run_cmd_with_timeout!(cmd, stdin_data: effective_source, timeout:)
+      raise CompileError, "Logica compile failed: #{stderr}" unless status.success?
+
+      stdout
+    end
+
+    def ensure_engine_directive(program_source)
+      engine = logica_engine
+
+      # If present, normalize to the canonical Logica engine name (e.g., postgres -> psql).
+      if program_source.match?(/@Engine\(\s*["'][^"']+["']\s*\)\s*;/i)
+        return program_source.sub(/@Engine\(\s*(["'])([^"']+)\1\s*\)\s*;/i) do
+          quote = Regexp.last_match(1)
+          "@Engine(#{quote}#{engine}#{quote});"
+        end
+      end
+
+      "@Engine(\"#{engine}\");\n#{program_source}"
+    end
+
+    def canonical_engine(engine)
+      value = engine.to_s.strip
+      return "" if value.empty?
+
+      down = value.downcase
+      ENGINE_ALIASES.fetch(down, down)
+    end
+
+    def logica_engine
+      canonical_engine(@config.engine)
+    end
+
+    def extract_main_query_from_psql_script(sql)
+      # Logica's psql engine prints a multi-statement script (preamble + final query).
+      # Our runner expects a single SELECT/WITH statement, so keep only the last statement
+      # that starts with SELECT/WITH, ignoring semicolons inside strings/comments/dollar-quotes.
+      sanitized = SqlSafety.strip_strings_and_comments(sql)
+
+      statement_starts = [0]
+      sanitized.to_enum(:scan, /;/).each do
+        statement_starts << Regexp.last_match.end(0)
+      end
+
+      last = nil
+      statement_starts.each do |start|
+        i = start
+        i += 1 while i < sanitized.length && sanitized[i].match?(/\s/)
+        next if i >= sanitized.length
+
+        last = i if sanitized[i..].match?(/\A(?:WITH|SELECT)\b/i)
+      end
+
+      last ? sql[last..] : sql
+    end
+
+    def add_sql_header(sql:, name:, program:, predicate:, engine:, digest:)
+      header = <<~SQL
+        -- LogicaCompiler
+        -- name: #{name}
+        -- program: #{program}
+        -- predicate: #{predicate}
+        -- engine: #{engine}
+        -- digest: #{digest}
+        -- compiled_at: #{Time.now.utc.iso8601}
+      SQL
+
+      "#{header}\n#{sql.strip}\n"
+    end
+
+    def prune_old_artifacts!(name:, keep_digest_hex:)
+      out_dir = @config.output_dir_path
+
+      Dir.glob(out_dir.join("#{name}-*.sql").to_s).each do |path|
+        next if path.end_with?("-#{keep_digest_hex}.sql")
+
+        FileUtils.rm_f(path)
+      end
+
+      Dir.glob(out_dir.join("#{name}-*.meta.json").to_s).each do |path|
+        next if path.end_with?("-#{keep_digest_hex}.meta.json")
+
+        FileUtils.rm_f(path)
+      end
+    end
+
+    def run_cmd_with_timeout!(cmd, stdin_data:, timeout:)
+      stdout_str = +""
+      stderr_str = +""
+
+      Open3.popen3(*cmd) do |stdin, stdout, stderr, wait_thr|
+        stdin.binmode
+        stdout.binmode
+        stderr.binmode
+
+        stdin.write(stdin_data) if stdin_data
+        stdin.close
+
+        out_reader = Thread.new { stdout_str << stdout.read.to_s }
+        err_reader = Thread.new { stderr_str << stderr.read.to_s }
+
+        status = nil
+        begin
+          status = Timeout.timeout(timeout) { wait_thr.value }
+        rescue Timeout::Error
+          terminate_process(wait_thr.pid)
+          raise
+        ensure
+          out_reader.join
+          err_reader.join
+        end
+
+        [stdout_str, stderr_str, status]
+      end
+    rescue Timeout::Error
+      raise Timeout::Error, "Command timed out after #{timeout}s: #{cmd.join(" ")}"
+    end
+
+    def terminate_process(pid)
+      Process.kill("TERM", pid)
+      Timeout.timeout(2) { Process.wait(pid) }
+    rescue Errno::ESRCH, Errno::ECHILD, Timeout::Error
+      begin
+        Process.kill("KILL", pid)
+      rescue Errno::ESRCH
+        nil
+      end
+    end
+  end
+end

data/lib/logica_compiler/config.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "yaml"
+
+require_relative "util"
+
+module LogicaCompiler
+  class Config
+    Query = Struct.new(:program, :predicate, keyword_init: true) do
+      def initialize(program:, predicate:)
+        super(program: program.to_s, predicate: predicate.to_s)
+      end
+    end
+
+    DEFAULT_ENGINE = "postgres"
+    DEFAULT_OUTPUT_DIR = "logica/compiled"
+
+    attr_reader :config_path, :root, :engine, :output_dir, :queries, :logica_bin
+
+    def self.load!(config_path = "logica/config.yml", root: default_root)
+      new(config_path:, root:).tap(&:load!)
+    end
+
+    def self.default_root
+      if defined?(Rails) && Rails.respond_to?(:root)
+        Rails.root
+      else
+        Pathname.new(Dir.pwd)
+      end
+    end
+
+    def initialize(config_path:, root:)
+      @config_path = config_path.to_s
+      @root = Pathname(root)
+      @engine = DEFAULT_ENGINE
+      @output_dir = DEFAULT_OUTPUT_DIR
+      @queries = {}
+      @logica_bin = env_logica_bin
+    end
+
+    def load!
+      data = YAML.safe_load(File.read(absolute_path(config_path)), permitted_classes: [], aliases: false) || {}
+
+      @engine = (data["engine"] || DEFAULT_ENGINE).to_s
+      @output_dir = (data["output_dir"] || DEFAULT_OUTPUT_DIR).to_s
+      @logica_bin ||= (data["logica_bin"] || default_logica_bin).to_s
+
+      queries = (data["queries"] || {}).to_h
+      @queries = queries.each_with_object({}) do |(name, attrs), h|
+        attrs = attrs.to_h
+        h[name.to_sym] = Query.new(
+          program: attrs.fetch("program"),
+          predicate: attrs.fetch("predicate")
+        )
+      end
+
+      self
+    end
+
+    def output_dir_path = root.join(output_dir)
+    def manifest_path = output_dir_path.join("manifest.json")
+    def requirements_path = root.join("logica/requirements.txt")
+    def absolute_path(rel_path) = root.join(rel_path).to_s
+
+    def pinned_logica_version
+      req = requirements_path
+      return nil unless req.exist?
+
+      line = req.read.lines.map(&:strip).find { _1.start_with?("logica==") }
+      return nil unless line
+
+      line.split("==", 2).last&.strip
+    end
+
+    private
+
+    def env_logica_bin
+      value = ENV["LOGICA_BIN"]
+      value = nil if value.to_s.strip.empty?
+      value
+    end
+
+    def default_logica_bin
+      # Default lookup order (when LOGICA_BIN / config.yml logica_bin is not set):
+      # 1) Project python venv: .venv/bin/logica (or .venv/Scripts/logica.exe on Windows)
+      # 2) System-installed logica on PATH
+      # 3) Gem-managed venv: tmp/logica_venv/.../logica (installed via `bin/logica install`)
+      project_venv_dir = root.join(".venv", Util.venv_bin_dir)
+      if (path = Util.find_executable_in_dir(project_venv_dir, "logica"))
+        return path
+      end
+
+      return "logica" if Util.which("logica")
+
+      root.join("tmp/logica_venv", Util.venv_bin_dir, "logica")
+    end
+  end
+end

data/lib/logica_compiler/deps/clock.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module LogicaCompiler
+  module Deps
+    class Clock
+      def now = Time.now
+      def now_utc = Time.now.utc
+    end
+  end
+end

data/lib/logica_compiler/deps/env.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module LogicaCompiler
+  module Deps
+    class Env
+      MISSING = :__missing__
+
+      def [](key) = ENV[key]
+      def fetch(key, *args, &block) = ENV.fetch(key, *args, &block)
+      def key?(key) = ENV.key?(key)
+
+      def set(key, value)
+        ENV[key] = value
+      end
+
+      def delete(key)
+        ENV.delete(key)
+      end
+
+      def with_temp(updates)
+        previous = {}
+        updates.each do |k, v|
+          previous[k] = key?(k) ? ENV[k] : MISSING
+          v.nil? ? delete(k) : set(k, v)
+        end
+
+        yield
+      ensure
+        previous.each do |k, v|
+          v == MISSING ? delete(k) : set(k, v)
+        end
+      end
+    end
+  end
+end

data/lib/logica_compiler/deps/shell.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module LogicaCompiler
+  module Deps
+    class Shell
+      def system(*args)
+        Kernel.system(*args)
+      end
+
+      def system!(*args)
+        ok = system(*args)
+        raise CommandFailedError.new("Command failed: #{args.join(" ")}", command: args.join(" ")) unless ok
+
+        true
+      end
+
+      def capture3(*args)
+        Open3.capture3(*args)
+      end
+
+      def capture!(*args)
+        out, err, status = capture3(*args)
+        raise CommandFailedError.new(err.to_s, command: args.join(" ")) unless status.success?
+
+        out
+      end
+    end
+  end
+end

data/lib/logica_compiler/deps/sleeper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module LogicaCompiler
+  module Deps
+    class Sleeper
+      def sleep(duration = nil)
+        duration.nil? ? Kernel.sleep : Kernel.sleep(duration)
+      end
+    end
+  end
+end

data/lib/logica_compiler/errors.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module LogicaCompiler
+  class Error < StandardError; end
+
+  class CommandFailedError < Error
+    attr_reader :command
+
+    def initialize(message = nil, command: nil)
+      @command = command
+      super(message)
+    end
+  end
+
+  class ConfigurationError < Error; end
+  class UnknownQueryError < ConfigurationError; end
+
+  class InstallError < Error; end
+  class CompileError < Error; end
+  class LogicaError < Error; end
+  class WatcherError < Error; end
+end