capsium 0.1.2 → 0.3.0

data/lib/capsium/package/storage.rb

@@ -1,76 +1,51 @@
 # frozen_string_literal: true
 
-# lib/capsium/package/storage.rb
-require "json"
-require "shale"
-require_relative "dataset"
-require_relative "storage_config"
+require "forwardable"
 
 module Capsium
   class Package
     class Storage
       extend Forwardable
-      attr_reader :config
 
-      def_delegators :@config, :to_json
+      attr_reader :path, :config, :datasets
 
-      attr_reader :datasets
+      def_delegators :@config, :to_json, :to_hash
 
       def initialize(path)
         @path = path
         @dir = File.dirname(path)
-        @datasets_path = File.join(@dir, DATA_DIR)
         @config = if File.exist?(path)
                     StorageConfig.from_json(File.read(path))
                   else
-                    StorageConfig.new(datasets: generate_datasets)
+                    StorageConfig.new
                   end
-        @datasets = load_datasets || generate_datasets
+        @datasets = load_datasets
+      end
+
+      def data_sets
+        @config.data_sets
       end
 
       def load_datasets
-        if File.exist?(@path)
-          storage_data = StorageConfig.from_json(File.read(@path))
-          storage_data.datasets.map do |dataset_config|
-            dataset_config.to_dataset(@datasets_path)
-          end
+        data_sets.map do |name, dataset_config|
+          dataset_config.to_dataset(name, @dir)
         end
       end
 
-      def save_to_file(output_path = @path)
-        storage_config = StorageConfig.new(datasets: @datasets.map do |dataset|
-                                                       DatasetConfig.from_dataset(dataset)
-                                                     end)
-        File.write(output_path, storage_config.to_json)
+      def dataset(name)
+        @datasets.find { |dataset| dataset.name == name }
       end
 
-      def generate_datasets
-        paths = File.join(@datasets_path, "*.{yaml,yml,json,csv,tsv,sqlite,db}")
-        Dir.glob(paths).map do |file_path|
-          Dataset.new(config: DatasetConfig.new(
-            name: File.basename(file_path,
-                                ".*"), source: file_path, format: detect_format(file_path)
-          ))
-        end
+      def dataset_names
+        data_sets.keys.sort
       end
 
-      private
+      def empty?
+        data_sets.empty?
+      end
 
-      def detect_format(file_path)
-        case File.extname(file_path).downcase
-        when ".yaml", ".yml"
-          "yaml"
-        when ".json"
-          "json"
-        when ".csv"
-          "csv"
-        when ".tsv"
-          "tsv"
-        when ".sqlite", ".db"
-          "sqlite"
-        else
-          raise "Unsupported data file type: #{File.extname(file_path)}"
-        end
+      def save_to_file(output_path = @path)
+        File.write(output_path, to_json)
       end
     end
   end

data/lib/capsium/package/storage_config.rb

@@ -1,9 +1,134 @@
-require "shale"
+# frozen_string_literal: true
+
+require "json"
+require "lutaml/model"
 
 module Capsium
   class Package
-    class StorageConfig < Shale::Mapper
-      attribute :datasets, DatasetConfig, collection: true
+    # A single dataset entry (ARCHITECTURE.md section 5). Paths are
+    # package-relative POSIX paths. Kinds: schema-backed file (via
+    # "source") or SQLite ("databaseFile" + "table").
+    class DatasetConfig < Lutaml::Model::Serializable
+      FORMATS = {
+        ".yaml" => "yaml", ".yml" => "yaml", ".json" => "json",
+        ".csv" => "csv", ".tsv" => "tsv",
+        ".sqlite" => "sqlite", ".db" => "sqlite"
+      }.freeze
+      SCHEMA_TYPES = %w[json-schema].freeze
+
+      attribute :source, :string
+      attribute :schema_file, :string
+      attribute :schema_type, :string, values: SCHEMA_TYPES
+      attribute :database_file, :string
+      attribute :table, :string
+
+      json do
+        map :source, to: :source
+        map "schemaFile", to: :schema_file
+        map "schemaType", to: :schema_type
+        map "databaseFile", to: :database_file
+        map :table, to: :table
+      end
+
+      def format
+        FORMATS.fetch(File.extname(backing_file).downcase) do
+          raise Error, "Unsupported data file type: #{File.extname(backing_file)}"
+        end
+      end
+
+      def sqlite?
+        !database_file.nil?
+      end
+
+      def backing_file
+        database_file || source.to_s
+      end
+
+      def to_dataset(name, package_path)
+        Dataset.new(name: name, config: self, package_path: package_path)
+      end
+    end
+
+    # A single storage layer entry (ARCHITECTURE.md section 5a). "path" is
+    # a package-relative directory mirroring the content/ tree; layers are
+    # stacked bottom -> top in declaration order. "visibility: private"
+    # layers are hidden from dependent packages.
+    class LayerConfig < Lutaml::Model::Serializable
+      attribute :path, :string
+      attribute :writable, :boolean, default: false
+      attribute :visibility, :string, values: Resource::VISIBILITIES, default: "exported"
+
+      json do
+        map :path, to: :path
+        map :writable, to: :writable
+        map :visibility, to: :visibility
+      end
+
+      def private?
+        visibility == "private"
+      end
+    end
+
+    # The "storage" object holding the dataSets map and the layers stack.
+    class StorageData < Lutaml::Model::Serializable
+      attribute :data_sets, :hash, default: {}
+      attribute :layers, LayerConfig, collection: true, default: []
+
+      json do
+        map "dataSets", with: { from: :data_sets_from_json, to: :data_sets_to_json }
+        map :layers, to: :layers
+      end
+
+      def data_sets_from_json(model, value)
+        model.data_sets = (value || {}).to_h do |name, attributes|
+          [name, DatasetConfig.from_json(JSON.generate(attributes))]
+        end
+      end
+
+      def data_sets_to_json(model, doc)
+        doc["dataSets"] = model.data_sets.sort.to_h do |name, dataset|
+          [name, JSON.parse(dataset.to_json)]
+        end
+      end
+    end
+
+    # Canonical storage.json model. The legacy gem form
+    # ({"datasets": [{name, source, format, schema}]}) is accepted on read
+    # and normalized; writers emit only the canonical form.
+    class StorageConfig < Lutaml::Model::Serializable
+      attribute :storage, StorageData
+
+      json do
+        map :storage, to: :storage
+      end
+
+      def self.from_json(json)
+        doc = JSON.parse(json)
+        doc["storage"] ||= { "dataSets" => legacy_data_sets(doc.delete("datasets")) }
+        super(JSON.generate(doc))
+      end
+
+      def self.legacy_data_sets(datasets)
+        (datasets || []).to_h do |item|
+          entry = { "source" => item["source"] }
+          if item["schema"]
+            entry["schemaFile"] = item["schema"]
+            entry["schemaType"] = "json-schema"
+          end
+          [item["name"], entry]
+        end
+      end
+      private_class_method :legacy_data_sets
+
+      def data_sets
+        storage ? storage.data_sets : {}
+      end
+
+      # The configured storage layers, bottom -> top (empty when the
+      # package uses the single implicit content/ layer).
+      def layers
+        storage ? storage.layers : []
+      end
     end
   end
 end

data/lib/capsium/package/store.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "json"
+require "zip"
+
+module Capsium
+  class Package
+    # A package store directory (ARCHITECTURE.md section 4a): a directory
+    # of "<name>-<version>.cap" files plus an optional index.json mapping
+    # dependency GUID -> file name. Dependencies resolve to the newest
+    # version satisfying their semver range; an index.json entry pins the
+    # GUID to a specific file (still range-checked).
+    class Store
+      INDEX_FILE = "index.json"
+      CAP_GLOB = "*.cap"
+
+      # One store .cap with its identity per its metadata.json.
+      CatalogEntry = Data.define(:path, :guid, :version)
+
+      attr_reader :dir
+
+      # The store configured via the CAPSIUM_STORE environment variable,
+      # or nil when unset.
+      def self.default
+        dir = ENV.fetch("CAPSIUM_STORE", nil)
+        dir.nil? || dir.empty? ? nil : new(dir)
+      end
+
+      def initialize(dir)
+        unless File.directory?(dir)
+          raise DependencyError, "Package store directory not found: #{dir}"
+        end
+
+        @dir = dir
+      end
+
+      # The newest .cap providing the dependency GUID whose version
+      # satisfies the range string.
+      def find(guid, range_string)
+        range = VersionRange.parse(range_string)
+        indexed = indexed_path(guid)
+        return indexed_satisfying(indexed, guid, range_string, range) if indexed
+
+        candidates = catalog.select { |entry| entry.guid == guid }
+        if candidates.empty?
+          raise DependencyNotFoundError,
+                "no package for dependency #{guid} in store #{@dir}"
+        end
+
+        satisfying = candidates.select { |entry| range.satisfied_by?(entry.version) }
+        return satisfying.max_by(&:version).path unless satisfying.empty?
+
+        versions = candidates.map { |entry| entry.version.to_s }.sort.join(", ")
+        raise UnsatisfiableDependencyError,
+              "no version of #{guid} satisfies '#{range_string}' " \
+              "(store has: #{versions})"
+      end
+
+      # Every .cap in the store with its metadata identity (memoized).
+      def catalog
+        @catalog ||= Dir.glob(File.join(@dir, CAP_GLOB)).map do |path|
+          catalog_entry(path)
+        end
+      end
+
+      private
+
+      def indexed_path(guid)
+        file = load_index[guid]
+        file && File.join(@dir, file)
+      end
+
+      def indexed_satisfying(path, guid, range_string, range)
+        unless File.file?(path)
+          raise DependencyNotFoundError,
+                "#{INDEX_FILE} maps #{guid} to a missing file: #{path}"
+        end
+
+        entry = catalog_entry(path)
+        return entry.path if range.satisfied_by?(entry.version)
+
+        raise UnsatisfiableDependencyError,
+              "indexed #{guid} #{entry.version} does not satisfy '#{range_string}'"
+      end
+
+      def catalog_entry(cap_path)
+        metadata = read_metadata(cap_path)
+        CatalogEntry.new(path: cap_path, guid: metadata["guid"],
+                         version: Version.parse(metadata["version"].to_s))
+      end
+
+      def read_metadata(cap_path)
+        Zip::File.open(cap_path) do |zip|
+          entry = zip.find_entry(Package::METADATA_FILE)
+          raise DependencyError, "no #{Package::METADATA_FILE} in #{cap_path}" unless entry
+
+          JSON.parse(entry.get_input_stream.read)
+        end
+      end
+
+      def load_index
+        @load_index ||= begin
+          path = File.join(@dir, INDEX_FILE)
+          File.file?(path) ? JSON.parse(File.read(path)) : {}
+        end
+      end
+    end
+  end
+end

data/lib/capsium/package/testing/config_test.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+
+module Capsium
+  class Package
+    module Testing
+      # A "config" test (05x-testing): the configuration file must exist
+      # in the package and parse as the declared format (json or yaml).
+      # The known Capsium package configs (metadata.json, manifest.json,
+      # routes.json, storage.json, security.json) are additionally
+      # validated against their canonical models.
+      class ConfigTest < TestCase
+        FORMATS = %w[json yaml].freeze
+
+        attr_reader :format, :config_file
+
+        def initialize(name:, format:, config_file:)
+          super(name: name)
+          @format = format
+          @config_file = config_file
+        end
+
+        def run(context)
+          problems = config_problems(context)
+          Result.new(name: name, ok: problems.empty?, messages: problems)
+        end
+
+        private
+
+        def config_problems(context)
+          return ["unsupported config format: #{format}"] unless FORMATS.include?(format)
+
+          full_path = File.join(context.package_path, config_file.delete_prefix("/"))
+          return ["config file missing in package: #{config_file}"] unless File.file?(full_path)
+
+          parse(full_path)
+          model_problems(full_path)
+        rescue JSON::ParserError, Psych::SyntaxError => e
+          ["cannot parse #{config_file}: #{e.message}"]
+        end
+
+        def parse(full_path)
+          format == "yaml" ? YAML.load_file(full_path) : JSON.parse(File.read(full_path))
+        end
+
+        def model_problems(full_path)
+          case File.basename(config_file)
+          when Package::METADATA_FILE then Metadata.new(full_path).config.format_errors
+          when Package::MANIFEST_FILE then probe { ManifestConfig.from_json(File.read(full_path)) }
+          when Package::ROUTES_FILE then probe { RoutesConfig.from_json(File.read(full_path)) }
+          when Package::STORAGE_FILE then probe { StorageConfig.from_json(File.read(full_path)) }
+          when Package::SECURITY_FILE then probe { SecurityConfig.from_json(File.read(full_path)) }
+          else []
+          end
+        end
+
+        def probe
+          yield
+          []
+        rescue StandardError => e
+          [e.message]
+        end
+      end
+
+      TestCase.register("config", ConfigTest)
+    end
+  end
+end

data/lib/capsium/package/testing/context.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Capsium
+  class Package
+    module Testing
+      # What a test run needs: the extracted package directory and, when
+      # route tests run, the base URL of the reactor serving the package.
+      Context = Data.define(:package_path, :base_url)
+    end
+  end
+end

data/lib/capsium/package/testing/data_validation_test.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "json"
+require "json-schema"
+require "yaml"
+
+module Capsium
+  class Package
+    module Testing
+      # A "data_validation" test (05x-testing): the rows of the data
+      # file (format: json or yaml) must validate against the JSON
+      # schema file. Array data validates row by row; a single document
+      # validates as one row.
+      class DataValidationTest < TestCase
+        FORMATS = %w[json yaml].freeze
+
+        attr_reader :format, :data_file, :schema_file
+
+        def initialize(name:, format:, data_file:, schema_file:)
+          super(name: name)
+          @format = format
+          @data_file = data_file
+          @schema_file = schema_file
+        end
+
+        def run(context)
+          problems = validation_problems(context)
+          Result.new(name: name, ok: problems.empty?, messages: problems)
+        end
+
+        private
+
+        def validation_problems(context)
+          return ["unsupported data format: #{format}"] unless FORMATS.include?(format)
+
+          schema = load_structured(context, schema_file)
+          rows = load_structured(context, data_file)
+          rows = [rows] unless rows.is_a?(Array)
+          rows.each_with_index.flat_map { |row, index| row_problems(schema, row, index) }
+        rescue Errno::ENOENT, JSON::ParserError, Psych::SyntaxError => e
+          ["cannot load data or schema: #{e.message}"]
+        end
+
+        def load_structured(context, relative_path)
+          full_path = File.join(context.package_path, relative_path.delete_prefix("/"))
+          if File.extname(full_path).match?(/\A\.ya?ml\z/i)
+            YAML.load_file(full_path)
+          else
+            JSON.parse(File.read(full_path))
+          end
+        end
+
+        def row_problems(schema, row, index)
+          JSON::Validator.fully_validate(schema, row).map do |message|
+            "row #{index}: #{message}"
+          end
+        end
+      end
+
+      TestCase.register("data_validation", DataValidationTest)
+    end
+  end
+end

data/lib/capsium/package/testing/file_test.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Capsium
+  class Package
+    module Testing
+      # A "file" test (05x-testing): the file must exist in the package;
+      # optionally its content must contain a string.
+      class FileTest < TestCase
+        attr_reader :path, :contains
+
+        def initialize(name:, path:, contains: nil)
+          super(name: name)
+          @path = path
+          @contains = contains
+        end
+
+        def run(context)
+          problems = existence_problems(context) + contains_problems(context)
+          Result.new(name: name, ok: problems.empty?, messages: problems)
+        end
+
+        private
+
+        def full_path(context)
+          File.join(context.package_path, path.delete_prefix("/"))
+        end
+
+        def existence_problems(context)
+          return [] if File.file?(full_path(context))
+
+          ["file missing in package: #{path}"]
+        end
+
+        def contains_problems(context)
+          return [] unless contains && File.file?(full_path(context))
+          return [] if File.read(full_path(context)).include?(contains)
+
+          ["file #{path} does not contain #{contains.inspect}"]
+        end
+      end
+
+      TestCase.register("file", FileTest)
+    end
+  end
+end

data/lib/capsium/package/testing/report.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Capsium
+  class Package
+    module Testing
+      # The outcome of a test suite run: one Result per test case.
+      class Report
+        attr_reader :results
+
+        def initialize(results = [])
+          @results = results
+        end
+
+        def <<(result)
+          @results << result
+          self
+        end
+
+        def ok?
+          @results.all?(&:ok?)
+        end
+
+        def failures
+          @results.reject(&:ok?)
+        end
+
+        def summary
+          "#{@results.size} tests, #{failures.size} failures"
+        end
+      end
+    end
+  end
+end

data/lib/capsium/package/testing/route_test.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+
+module Capsium
+  class Package
+    module Testing
+      # A "route" test (05x-testing): requests the URL path from the
+      # reactor serving the package and checks the expected status, and
+      # optionally the content type and a response body substring.
+      class RouteTest < TestCase
+        attr_reader :url, :expected_status, :response_contains, :expected_content_type
+
+        def initialize(name:, url:, expected_status:, response_contains: nil,
+                       expected_content_type: nil)
+          super(name: name)
+          @url = url
+          @expected_status = expected_status
+          @response_contains = response_contains
+          @expected_content_type = expected_content_type
+        end
+
+        def run(context)
+          response = Net::HTTP.get_response(URI.join(context.base_url, request_path))
+          problems = status_problems(response) + content_type_problems(response) +
+                     body_problems(response)
+          Result.new(name: name, ok: problems.empty?, messages: problems)
+        end
+
+        private
+
+        # The DSL allows absolute URLs; only their path (and query) is
+        # used — the runner always targets its own reactor.
+        def request_path
+          uri = URI.parse(url)
+          uri.host ? uri.request_uri : url
+        end
+
+        def status_problems(response)
+          return [] if response.code.to_i == expected_status
+
+          ["expected status #{expected_status}, got #{response.code}"]
+        end
+
+        def content_type_problems(response)
+          return [] unless expected_content_type
+          return [] if response.content_type == expected_content_type
+
+          ["expected content type #{expected_content_type}, got #{response.content_type}"]
+        end
+
+        def body_problems(response)
+          return [] unless response_contains
+          return [] if response.body.to_s.include?(response_contains)
+
+          ["response does not contain #{response_contains.inspect}"]
+        end
+      end
+
+      TestCase.register("route", RouteTest)
+    end
+  end
+end

data/lib/capsium/package/testing/test_case.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Capsium
+  class Package
+    module Testing
+      # Base class for one test of the Capsium testing YAML DSL
+      # (05x-testing). Subclasses implement a test kind and register
+      # themselves under their DSL type name (open/closed registry).
+      class TestCase
+        # The outcome of running one test.
+        Result = Data.define(:name, :ok, :messages) do
+          def ok? = ok
+        end
+
+        # Raised for invalid test definitions (unknown type,
+        # missing/unknown attributes, non-hash entries).
+        class DefinitionError < Capsium::Error; end
+
+        attr_reader :name
+
+        def initialize(name:)
+          @name = name
+        end
+
+        # Runs the test against the context and returns a Result.
+        def run(context)
+          raise NotImplementedError
+        end
+
+        def self.register(type, klass)
+          types[type] = klass
+        end
+
+        def self.types
+          @types ||= {}
+        end
+
+        # Builds a test case from a YAML definition hash (string keys).
+        def self.build(definition)
+          unless definition.is_a?(Hash)
+            raise DefinitionError, "test definition is not a mapping: #{definition.inspect}"
+          end
+
+          type = definition["type"] ||
+                 raise(DefinitionError, "test #{definition['name'].inspect} has no type")
+          klass = types[type] || raise(DefinitionError, "unknown test type: #{type}")
+          klass.from_h(definition)
+        rescue ArgumentError => e
+          raise DefinitionError, "invalid #{type} test #{definition['name'].inspect}: #{e.message}"
+        end
+
+        def self.from_h(definition)
+          attributes = definition.transform_keys(&:to_sym)
+          attributes.delete(:type)
+          new(**attributes)
+        end
+      end
+    end
+  end
+end