logica_compiler 0.1.0

data/lib/logica_compiler/installer.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require "erb"
+require "fileutils"
+require "pathname"
+require "yaml"
+
+module LogicaCompiler
+  class Installer
+    PINNED_LOGICA_VERSION = "1.3.1415926535897"
+
+    DEFAULT_ENGINE = "postgres"
+    DEFAULT_OUTPUT_DIR = "logica/compiled"
+
+    SAMPLE_PROGRAM_REL = "logica/programs/hello_world.l"
+    SAMPLE_QUERY_NAME = "hello_world"
+    SAMPLE_PREDICATE = "Greet"
+
+    def initialize(root:, force: false, stdout: $stdout, stderr: $stderr)
+      @root = Pathname(root)
+      @force = !!force
+      @stdout = stdout
+      @stderr = stderr
+      @conflicts = []
+    end
+
+    def run!
+      ensure_dir(@root.join("logica/programs"))
+      ensure_dir(@root.join("logica/compiled"))
+
+      ensure_file(@root.join("logica/programs/.keep"), "", mode: nil)
+      ensure_file(@root.join("logica/compiled/.keep"), "", mode: nil)
+
+      ensure_template(@root.join(SAMPLE_PROGRAM_REL), "hello_world.l", mode: nil)
+      ensure_config_yml
+      ensure_requirements
+      ensure_gitignore_block
+      ensure_template(@root.join("bin/logica"), "bin_logica", mode: 0o755)
+      ensure_template(@root.join("config/initializers/logica_compiler.rb"), "initializer.rb", mode: nil)
+
+      if @conflicts.any?
+        @stderr.puts "\nConflicts detected. No files were overwritten."
+        @stderr.puts @conflicts.map { |p| "  - #{p}" }.join("\n")
+        @stderr.puts "\nHow to resolve:"
+        @stderr.puts "  - Re-run with FORCE=1 to overwrite conflicting files"
+        @stderr.puts "  - Or manually merge the templates and re-run"
+        @stderr.puts "Template source: #{template_root}"
+        raise InstallError, "LogicaCompiler install aborted due to conflicts (FORCE=1 to overwrite)."
+      end
+
+      say("done", "Installed LogicaCompiler integration into #{@root}")
+      say("next", "bin/logica install")
+      say("next", "bin/logica compile")
+      true
+    end
+
+    private
+
+    def template_root
+      Pathname(__dir__).join("templates")
+    end
+
+    def template_vars
+      {
+        engine: DEFAULT_ENGINE,
+        output_dir: DEFAULT_OUTPUT_DIR,
+        sample_program_rel: SAMPLE_PROGRAM_REL,
+        sample_query_name: SAMPLE_QUERY_NAME,
+        sample_predicate: SAMPLE_PREDICATE,
+        pinned_logica_version: PINNED_LOGICA_VERSION,
+      }
+    end
+
+    def render_template(name)
+      path = template_root.join("#{name}.erb")
+      ERB.new(path.read, trim_mode: "-").result_with_hash(template_vars)
+    end
+
+    def ensure_dir(path)
+      path = Pathname(path)
+      return say("exist", path.to_s) if path.exist?
+
+      FileUtils.mkdir_p(path)
+      say("create", path.to_s)
+    end
+
+    def ensure_template(dest, template_name, mode:)
+      content = render_template(template_name)
+      ensure_file(dest, content, mode:)
+    end
+
+    def ensure_file(dest, content, mode:)
+      dest = Pathname(dest)
+
+      if dest.exist?
+        existing = dest.read
+        return say("identical", dest.to_s) if existing == content
+
+        if @force
+          write_file(dest, content, mode:)
+          return say("force", dest.to_s)
+        end
+
+        say("conflict", dest.to_s)
+        @conflicts << dest.to_s
+        return :conflict
+      end
+
+      write_file(dest, content, mode:)
+      say("create", dest.to_s)
+      :create
+    end
+
+    def write_file(dest, content, mode:)
+      FileUtils.mkdir_p(dest.dirname)
+      dest.write(content)
+      File.chmod(mode, dest.to_s) if mode
+    end
+
+    def ensure_config_yml
+      path = @root.join("logica/config.yml")
+
+      if !path.exist? || @force
+        return ensure_template(path, "config.yml", mode: nil)
+      end
+
+      begin
+        data = YAML.safe_load(path.read, permitted_classes: [], aliases: false) || {}
+        data = data.to_h
+      rescue StandardError => e
+        say("conflict", path.to_s)
+        @stderr.puts "Could not parse #{path} (#{e.class}: #{e.message}). Please merge manually or re-run with FORCE=1."
+        @conflicts << path.to_s
+        return :conflict
+      end
+
+      changed = false
+      unless data["engine"]
+        data["engine"] = DEFAULT_ENGINE
+        changed = true
+      end
+      unless data["output_dir"]
+        data["output_dir"] = DEFAULT_OUTPUT_DIR
+        changed = true
+      end
+
+      queries = data["queries"]
+      queries = {} unless queries.is_a?(Hash)
+      unless queries.key?(SAMPLE_QUERY_NAME)
+        queries[SAMPLE_QUERY_NAME] = { "program" => SAMPLE_PROGRAM_REL, "predicate" => SAMPLE_PREDICATE }
+        data["queries"] = queries
+        changed = true
+      end
+
+      return say("identical", path.to_s) unless changed
+
+      yaml = YAML.dump(data)
+      yaml = yaml.sub(/\A---\s*\n/, "")
+      yaml << "\n" unless yaml.end_with?("\n")
+      write_file(path, yaml, mode: nil)
+      say("update", path.to_s)
+      :update
+    end
+
+    def ensure_requirements
+      path = @root.join("logica/requirements.txt")
+      desired = render_template("requirements.txt")
+
+      if path.exist? && !@force
+        if path.read.include?("logica==")
+          return say("identical", path.to_s)
+        end
+
+        say("conflict", path.to_s)
+        @stderr.puts "requirements.txt exists but does not pin logica. Add:\n  #{desired.strip}\nOr re-run with FORCE=1."
+        @conflicts << path.to_s
+        return :conflict
+      end
+
+      ensure_file(path, desired, mode: nil)
+    end
+
+    def ensure_gitignore_block
+      path = @root.join(".gitignore")
+      existed = path.exist?
+      existing = existed ? path.read : +""
+
+      block = render_template("gitignore_block")
+      return say("identical", path.to_s) if existing.include?("/logica/compiled/*")
+
+      updated = existing.dup
+      updated << "\n" unless updated.end_with?("\n") || updated.empty?
+      updated << block
+
+      write_file(path, updated, mode: nil)
+      say(existed ? "update" : "create", path.to_s)
+      existed ? :update : :create
+    end
+
+    def say(status, message)
+      @stdout.puts format("%-10s %s", status, message)
+    end
+  end
+end

data/lib/logica_compiler/manifest.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "time"
+
+module LogicaCompiler
+  class Manifest
+    VERSION = 1
+
+    def self.build(engine:, logica_version:, queries:, compiled_at: Time.now.utc)
+      {
+        "version" => VERSION,
+        "engine" => engine.to_s,
+        "logica" => { "pypi" => "logica", "version" => logica_version.to_s },
+        "compiled_at" => compiled_at.iso8601,
+        "queries" => queries.transform_keys(&:to_s),
+      }
+    end
+
+    def self.load(path)
+      JSON.parse(File.read(path.to_s))
+    end
+
+    def self.write!(path, manifest)
+      path = path.to_s
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, "#{JSON.pretty_generate(manifest)}\n")
+    end
+  end
+end

data/lib/logica_compiler/railtie.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module LogicaCompiler
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      load File.expand_path("tasks/logica_compiler.rake", __dir__)
+    end
+  end
+end

data/lib/logica_compiler/registry.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "json"
+
+module LogicaCompiler
+  class Registry
+    class MissingManifestError < StandardError; end
+    class InvalidManifestError < StandardError; end
+    class MissingQueryError < KeyError; end
+
+    def self.unavailable(message:)
+      Unavailable.new(message: message.to_s)
+    end
+
+    def self.load(manifest_path:, output_dir:, strict: false)
+      new(manifest_path:, output_dir:).tap { _1.load!(strict:) }
+    rescue Errno::ENOENT, MissingManifestError, InvalidManifestError => e
+      raise if strict
+
+      return unavailable(message: "#{e.message}. Run `bin/logica compile` again.") if e.is_a?(InvalidManifestError)
+
+      MissingManifest.new(manifest_path:)
+    end
+
+    def initialize(manifest_path:, output_dir:)
+      @manifest_path = manifest_path.to_s
+      @output_dir = output_dir.to_s
+      @entries = nil
+      @sql_cache = {}
+    end
+
+    def load!(strict: false)
+      data = JSON.parse(File.read(@manifest_path))
+      queries = data.is_a?(Hash) ? data["queries"] : nil
+
+      unless queries.is_a?(Hash)
+        raise InvalidManifestError, "Invalid Logica manifest #{@manifest_path}: missing or invalid 'queries' key"
+      end
+
+      @entries = queries
+      self
+    rescue Errno::ENOENT
+      raise MissingManifestError, "Missing Logica manifest: #{@manifest_path}" if strict
+
+      raise
+    rescue JSON::ParserError => e
+      raise InvalidManifestError, "Invalid Logica manifest #{@manifest_path}: #{e.message}"
+    end
+
+    def sql(name)
+      name = name.to_s
+      entry = entries.fetch(name) { raise MissingQueryError, "Unknown Logica query: #{name}" }
+      sql_file = entry.fetch("sql")
+      @sql_cache[name] ||= File.read(File.join(@output_dir, sql_file))
+    end
+
+    def entry(name)
+      entries.fetch(name.to_s) { raise MissingQueryError, "Unknown Logica query: #{name}" }
+    end
+
+    private
+
+    def entries
+      @entries || raise(MissingManifestError, "Registry not loaded")
+    end
+
+    class MissingManifest
+      def initialize(manifest_path:)
+        @manifest_path = manifest_path.to_s
+      end
+
+      def sql(_name)
+        raise MissingManifestError,
+              "Missing Logica manifest: #{@manifest_path}. Run `bin/logica compile` first."
+      end
+
+      def entry(_name)
+        raise MissingManifestError,
+              "Missing Logica manifest: #{@manifest_path}. Run `bin/logica compile` first."
+      end
+    end
+
+    class Unavailable
+      def initialize(message:)
+        @message = message.to_s
+      end
+
+      def sql(_name)
+        raise MissingManifestError, @message
+      end
+
+      def entry(_name)
+        raise MissingManifestError, @message
+      end
+    end
+  end
+end

data/lib/logica_compiler/sql_dialect/postgres.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module LogicaCompiler
+  module SqlDialect
+    class Postgres
+      def placeholder(index) = "$#{index}"
+
+      def statement_timeout_sql(connection, timeout)
+        "SET LOCAL statement_timeout = #{connection.quote(timeout)}"
+      end
+    end
+  end
+end

data/lib/logica_compiler/sql_dialect/sqlite.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module LogicaCompiler
+  module SqlDialect
+    class Sqlite
+      def placeholder(_index) = "?"
+
+      def statement_timeout_sql(_connection, _timeout)
+        nil
+      end
+    end
+  end
+end

data/lib/logica_compiler/sql_safety.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module LogicaCompiler
+  class UnsafeSqlError < StandardError; end
+
+  module SqlSafety
+    PROHIBITED_KEYWORDS = %w[
+      INSERT UPDATE DELETE MERGE
+      CREATE ALTER DROP TRUNCATE
+      GRANT REVOKE
+    ].freeze
+
+    module_function
+
+    def validate!(sql)
+      stripped = strip_leading_comments(sql.to_s).lstrip
+      raise UnsafeSqlError, "SQL is empty" if stripped.empty?
+
+      raise UnsafeSqlError, "Unsafe SQL: must start with SELECT/WITH" unless stripped.match?(/\A(?:WITH|SELECT)\b/i)
+
+      sanitized = strip_strings_and_comments(stripped)
+
+      raise UnsafeSqlError, "Unsafe SQL: contains semicolon (multi-statement risk)" if sanitized.include?(";")
+
+      if sanitized.match?(/\b(?:#{PROHIBITED_KEYWORDS.join("|")})\b/i)
+        raise UnsafeSqlError, "Unsafe SQL: contains prohibited keyword"
+      end
+
+      if sanitized.match?(/\bFOR\s+(?:UPDATE|SHARE|NO\s+KEY\s+UPDATE|KEY\s+SHARE)\b/i)
+        raise UnsafeSqlError, "Unsafe SQL: contains row locking clause"
+      end
+
+      true
+    end
+
+    def strip_leading_comments(sql)
+      s = sql.lstrip
+
+      loop do
+        if s.start_with?("--")
+          s = s.sub(/\A--.*(?:\n|\z)/, "").lstrip
+          next
+        end
+
+        if s.start_with?("/*")
+          s = s.sub(%r{\A/\*.*?\*/}m, "").lstrip
+          next
+        end
+
+        break
+      end
+
+      s
+    end
+
+    def strip_strings_and_comments(sql)
+      s = sql.to_s
+      out = +""
+
+      i = 0
+      state = :normal
+      dollar_delim = nil
+
+      while i < s.length
+        ch = s[i]
+
+        case state
+        when :normal
+          if ch == "-" && s[i + 1] == "-"
+            state = :line_comment
+            out << "  "
+            i += 2
+          elsif ch == "/" && s[i + 1] == "*"
+            state = :block_comment
+            out << "  "
+            i += 2
+          elsif ch == "'"
+            state = :single_quote
+            out << " "
+            i += 1
+          elsif ch == "\""
+            state = :double_quote
+            out << " "
+            i += 1
+          elsif ch == "$"
+            delim = parse_dollar_delimiter(s, i)
+            if delim
+              dollar_delim = delim
+              state = :dollar_quote
+              out << (" " * delim.length)
+              i += delim.length
+            else
+              out << ch
+              i += 1
+            end
+          else
+            out << ch
+            i += 1
+          end
+        when :line_comment
+          if ch == "\n"
+            state = :normal
+            out << "\n"
+          else
+            out << " "
+          end
+          i += 1
+        when :block_comment
+          if ch == "*" && s[i + 1] == "/"
+            state = :normal
+            out << "  "
+            i += 2
+          else
+            out << " "
+            i += 1
+          end
+        when :single_quote
+          if ch == "'"
+            if s[i + 1] == "'"
+              out << "  "
+              i += 2
+            else
+              state = :normal
+              out << " "
+              i += 1
+            end
+          else
+            out << " "
+            i += 1
+          end
+        when :double_quote
+          if ch == "\""
+            if s[i + 1] == "\""
+              out << "  "
+              i += 2
+            else
+              state = :normal
+              out << " "
+              i += 1
+            end
+          else
+            out << " "
+            i += 1
+          end
+        when :dollar_quote
+          if dollar_delim && s[i, dollar_delim.length] == dollar_delim
+            out << (" " * dollar_delim.length)
+            i += dollar_delim.length
+            dollar_delim = nil
+            state = :normal
+          else
+            out << " "
+            i += 1
+          end
+        end
+      end
+
+      out
+    end
+
+    def parse_dollar_delimiter(s, start_index)
+      return nil unless s[start_index] == "$"
+
+      j = start_index + 1
+      while j < s.length && s[j] != "$"
+        return nil unless s[j].match?(/[A-Za-z0-9_]/)
+
+        j += 1
+      end
+
+      return nil unless j < s.length && s[j] == "$"
+
+      s[start_index..j]
+    end
+  end
+end

data/lib/logica_compiler/tasks/logica_compiler.rake

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+namespace :logica_compiler do
+  desc "Install LogicaCompiler integration into the current Rails app"
+  task install: :environment do
+    require "pathname"
+    require "logica_compiler/installer"
+
+    root =
+      if defined?(Rails) && Rails.respond_to?(:root)
+        Pathname(Rails.root)
+      else
+        Pathname(Dir.pwd)
+      end
+
+    force = ENV["FORCE"] == "1"
+
+    LogicaCompiler::Installer.new(root:, force:).run!
+  end
+end

data/lib/logica_compiler/templates/bin_logica.erb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require_relative "../config/environment"
+require "logica_compiler/cli"
+
+LogicaCompiler::CLI.start(ARGV)

data/lib/logica_compiler/templates/config.yml.erb

@@ -0,0 +1,7 @@
+engine: <%= engine %>
+output_dir: <%= output_dir %>
+
+queries:
+  <%= sample_query_name %>:
+    program: <%= sample_program_rel %>
+    predicate: <%= sample_predicate %>

data/lib/logica_compiler/templates/gitignore_block.erb

@@ -0,0 +1,3 @@
+# Logica (precompiled SQL artifacts)
+/logica/compiled/*
+!/logica/compiled/.keep

data/lib/logica_compiler/templates/hello_world.l.erb

@@ -0,0 +1,9 @@
+# Demo program for LogicaCompiler.
+# Run:
+#   bin/logica install
+#   bin/logica compile <%= sample_query_name %>
+#
+# Then execute via Rails:
+#   Rails.application.config.x.logica.runner.exec(:<%= sample_query_name %>)
+#
+<%= sample_predicate %>(greeting: "Hello from LogicaCompiler!");

data/lib/logica_compiler/templates/initializer.rb.erb

@@ -0,0 +1,28 @@
+strict = Rails.env.production?
+
+config =
+  begin
+    LogicaCompiler::Config.load!(root: Rails.root)
+  rescue Errno::ENOENT, Psych::SyntaxError => e
+    raise if strict
+
+    Rails.logger&.warn("[logica_compiler] config load failed (#{e.class}): #{e.message}")
+    LogicaCompiler::Config.new(config_path: "logica/config.yml", root: Rails.root)
+  end
+
+registry =
+  if !strict && !Rails.root.join("logica/config.yml").exist?
+    LogicaCompiler::Registry.unavailable(
+      message: "Missing logica/config.yml. Run `bundle exec rake logica_compiler:install` and then `bin/logica compile`."
+    )
+  else
+    LogicaCompiler::Registry.load(
+      manifest_path: config.manifest_path,
+      output_dir: config.output_dir_path,
+      strict:,
+    )
+  end
+
+Rails.application.config.x.logica ||= ActiveSupport::OrderedOptions.new
+Rails.application.config.x.logica.registry = registry
+Rails.application.config.x.logica.runner = LogicaCompiler::ActiveRecord::Runner.new(registry:)

data/lib/logica_compiler/templates/requirements.txt.erb

@@ -0,0 +1 @@
+logica==<%= pinned_logica_version %>

data/lib/logica_compiler/util.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module LogicaCompiler
+  module Util
+    module_function
+
+    def path_like?(value)
+      s = value.to_s
+      return false if s.empty?
+      return true if s.start_with?(".", "/", "~")
+
+      separators = [File::SEPARATOR, File::ALT_SEPARATOR].compact.uniq
+      separators.any? { |sep| s.include?(sep) }
+    end
+
+    def venv_bin_dir
+      Gem.win_platform? ? "Scripts" : "bin"
+    end
+
+    def command_candidates(cmd)
+      cmd = cmd.to_s
+      candidates = [cmd]
+      return candidates unless Gem.win_platform? && File.extname(cmd).empty?
+
+      pathext = ENV.fetch("PATHEXT", "").split(";").reject(&:empty?)
+      pathext = %w[.exe .bat .cmd] if pathext.empty?
+      pathext.map { |ext| "#{cmd}#{ext}" }
+    end
+
+    def executable_file?(path)
+      File.file?(path) && File.executable?(path)
+    end
+
+    def find_executable_in_dir(dir, cmd)
+      dir = dir.to_s
+      command_candidates(cmd).each do |candidate|
+        path = File.join(dir, candidate)
+        return path if executable_file?(path)
+      end
+      nil
+    end
+
+    def which(cmd)
+      ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).each do |dir|
+        path = find_executable_in_dir(dir, cmd)
+        return path if path
+      end
+      nil
+    end
+  end
+end

data/lib/logica_compiler/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module LogicaCompiler
+  VERSION = "0.1.0"
+end