capsium 0.1.1 → 0.2.0

data/lib/capsium/package/manifest.rb

@@ -1,60 +1,63 @@
 # frozen_string_literal: true
 
-# lib/capsium/package/manifest.rb
-require "json"
+require "forwardable"
 require "marcel"
-require "shale"
+require "pathname"
 
 module Capsium
   class Package
     class Manifest
-      attr_accessor :path, :content_path, :data
+      extend Forwardable
+
+      attr_reader :path, :content_path, :config
+
+      def_delegators :@config, :to_hash
 
       def initialize(path)
         @path = path
-        # This is {package-name}/content
-        # or
-        # /tmp/../content
-        @content_path = File.join(File.dirname(@path), "content")
-
-        @data = if File.exist?(path)
-                  ManifestData.from_json(File.read(path))
-                else
-                  ManifestData.new(content: generate_manifest)
-                end
+        @content_path = File.join(File.dirname(@path), Package::CONTENT_DIR)
+        @config = if File.exist?(path)
+                    ManifestConfig.from_json(File.read(path))
+                  else
+                    ManifestConfig.new(resources: generate_manifest)
+                  end
       end
 
+      # Auto-generation (ARCHITECTURE.md section 3): scan content/
+      # recursively, detect MIME types, default visibility "exported",
+      # deterministic (sorted) output.
       def generate_manifest
-        files = Dir[File.join(@content_path, "**", "*")].reject do |f|
-          File.directory?(f)
+        content_files.sort.to_h do |file_path|
+          [relative_path(file_path),
+           Resource.new(type: mime_from_path(file_path), visibility: "exported")]
         end
+      end
 
-        files.sort.map do |file_path|
-          ManifestDataItem.new(
-            file: relative_path(file_path),
-            mime: mime_from_path(file_path)
-          )
-        end
+      def resources
+        @config.resources
       end
 
-      def lookup(filename)
-        @data.content.detect do |data_item|
-          data_item.file == filename
-        end
+      def lookup(path)
+        resources[path]
+      end
+
+      def type_for(path)
+        resource = lookup(path)
+        resource&.type
       end
 
       def to_json(*_args)
-        @data.to_json
+        @config.to_json
       end
 
       def save_to_file(output_path = @path)
-        File.open(output_path, "w") do |file|
-          file.write(to_json)
-        end
+        File.write(output_path, to_json)
       end
 
       def path_to_content_file(path)
-        Pathname.new(@content_path).join(path)
+        raise TypeError, "Path cannot be nil" if path.nil?
+
+        Pathname.new(File.dirname(@path)).join(path)
       end
 
       def content_file_exists?(path)
@@ -62,11 +65,17 @@ module Capsium
       end
 
       def relative_path(path)
-        Pathname.new(path).relative_path_from(@content_path).to_s
+        Pathname.new(path).relative_path_from(File.dirname(@path)).to_s
       end
 
       private
 
+      def content_files
+        Dir.glob(File.join(@content_path, "**", "*")).select do |file|
+          File.file?(file)
+        end
+      end
+
       def mime_from_path(path)
         Marcel::MimeType.for(
           Pathname.new(path),
@@ -75,23 +84,5 @@ module Capsium
         )
       end
     end
-
-    class ManifestDataItem < Shale::Mapper
-      attribute :file, Shale::Type::String
-      attribute :mime, Shale::Type::String
-
-      # json do
-      #   map "file", to: :file
-      #   map "mime", to: :mime
-      # end
-    end
-
-    class ManifestData < Shale::Mapper
-      attribute :content, ManifestDataItem, collection: true
-
-      # json do
-      #   map "content", to: :content
-      # end
-    end
   end
 end

data/lib/capsium/package/manifest_config.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "json"
+require "lutaml/model"
+
+module Capsium
+  class Package
+    # A single manifest resource entry (ARCHITECTURE.md section 3).
+    class Resource < Lutaml::Model::Serializable
+      VISIBILITIES = %w[exported private].freeze
+
+      attribute :type, :string
+      attribute :visibility, :string, values: VISIBILITIES, default: "exported"
+      attribute :version, :string
+
+      json do
+        map :type, to: :type
+        map :visibility, to: :visibility
+        map :version, to: :version
+      end
+    end
+
+    # Canonical manifest.json model: an object keyed by package-relative
+    # resource path. The legacy gem form ({"content": [{file, mime}]}) is
+    # accepted on read and normalized; writers emit only the object form.
+    class ManifestConfig < Lutaml::Model::Serializable
+      attribute :resources, :hash, default: {}
+
+      json do
+        map :resources, with: { from: :resources_from_json, to: :resources_to_json }
+      end
+
+      def self.from_json(json)
+        doc = JSON.parse(json)
+        doc["resources"] ||= legacy_resources(doc.delete("content")) if doc.key?("content")
+        super(JSON.generate(doc))
+      end
+
+      def self.legacy_resources(content)
+        (content || []).to_h do |item|
+          [item["file"], { "type" => item["mime"], "visibility" => "exported" }]
+        end
+      end
+      private_class_method :legacy_resources
+
+      def resources_from_json(model, value)
+        model.resources = (value || {}).to_h do |path, attributes|
+          [path, Resource.from_json(JSON.generate(attributes))]
+        end
+      end
+
+      def resources_to_json(model, doc)
+        doc["resources"] = model.resources.sort.to_h do |path, resource|
+          [path, JSON.parse(resource.to_json)]
+        end
+      end
+
+      def sort!
+        self.resources = resources.sort.to_h
+        self
+      end
+    end
+  end
+end

data/lib/capsium/package/metadata.rb

@@ -1,47 +1,29 @@
 # frozen_string_literal: true
 
-# lib/capsium/package/metadata.rb
-require "shale"
 require "forwardable"
 
 module Capsium
   class Package
-    class Dependency < Shale::Mapper
-      attribute :name, Shale::Type::String
-      attribute :version, Shale::Type::String
-    end
-
-    class MetadataData < Shale::Mapper
-      attribute :name, Shale::Type::String
-      attribute :version, Shale::Type::String
-      attribute :dependencies, Dependency, collection: true
-    end
-
     class Metadata
-      attr_reader :path, :data
+      attr_reader :path, :config
 
       extend Forwardable
-      def_delegator :@data, :name
-      def_delegator :@data, :version
-      def_delegator :@data, :dependencies
+
+      def_delegators :@config, :to_json, :to_hash, :name, :version,
+                     :description, :guid, :uuid, :author, :license,
+                     :repository, :dependencies
 
       def initialize(path)
         @path = path
-        @data = if File.exist?(path)
-                  MetadataData.from_json(File.read(path))
-                else
-                  MetadataData.new
-                end
-      end
-
-      def to_json(*_args)
-        @data.to_json
+        @config = if File.exist?(path)
+                    MetadataData.from_json(File.read(path))
+                  else
+                    MetadataData.new
+                  end
       end
 
       def save_to_file(output_path = @path)
-        File.open(output_path, "w") do |file|
-          file.write(to_json)
-        end
+        File.write(output_path, to_json)
       end
     end
   end

data/lib/capsium/package/metadata_config.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "json"
+require "lutaml/model"
+require "uri"
+
+module Capsium
+  class Package
+    class Repository < Lutaml::Model::Serializable
+      attribute :type, :string
+      attribute :url, :string
+
+      json do
+        map :type, to: :type
+        map :url, to: :url
+      end
+    end
+
+    # Canonical metadata.json model (ARCHITECTURE.md section 2).
+    #
+    # The legacy gem form of "dependencies" (an array of {name, version}
+    # objects) is accepted on read and normalized to the canonical object
+    # form; writers emit only the object form.
+    class MetadataData < Lutaml::Model::Serializable
+      KEBAB_CASE_PATTERN = /\A[a-z0-9]+(-[a-z0-9]+)*\z/
+      SEMVER_PATTERN = /\A\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?\z/
+      UUID_PATTERN = /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i
+
+      attribute :name, :string
+      attribute :version, :string
+      attribute :description, :string
+      attribute :guid, :string
+      attribute :uuid, :string
+      attribute :author, :string
+      attribute :license, :string
+      attribute :repository, Repository
+      attribute :dependencies, :hash, default: {}
+      attribute :read_only, :boolean
+
+      json do
+        map :name, to: :name
+        map :version, to: :version
+        map :description, to: :description
+        map :guid, to: :guid
+        map :uuid, to: :uuid
+        map :author, to: :author
+        map :license, to: :license
+        map :repository, to: :repository
+        map :dependencies, to: :dependencies
+        map "readOnly", to: :read_only
+      end
+
+      def self.from_json(json)
+        doc = JSON.parse(json)
+        doc["dependencies"] = normalize_dependencies(doc["dependencies"])
+        super(JSON.generate(doc))
+      end
+
+      def self.normalize_dependencies(dependencies)
+        return {} if dependencies.nil?
+        return dependencies unless dependencies.is_a?(Array)
+
+        dependencies.to_h { |dep| [dep["name"], dep["version"]] }
+      end
+      private_class_method :normalize_dependencies
+
+      # Field-level format validations (ARCHITECTURE.md section 2).
+      # Returns a list of human-readable problems; empty when valid.
+      def format_errors
+        presence_errors + format_field_errors
+      end
+
+      private
+
+      def presence_errors
+        problems = []
+        problems << "name is missing" if name.to_s.empty?
+        problems << "version is missing" if version.to_s.empty?
+        problems << "description is missing" if description.to_s.empty?
+        problems << "guid is missing" if guid.to_s.empty?
+        problems << "uuid is missing" if uuid.to_s.empty?
+        problems
+      end
+
+      def format_field_errors
+        problems = []
+        problems << "name must be kebab-case" if invalid?(name, KEBAB_CASE_PATTERN)
+        problems << "version must be semver" if invalid?(version, SEMVER_PATTERN)
+        problems << "guid must be a URI" if guid && !uri?(guid)
+        problems << "uuid is not a valid UUID" if invalid?(uuid, UUID_PATTERN)
+        problems
+      end
+
+      def invalid?(value, pattern)
+        !value.nil? && !value.match?(pattern)
+      end
+
+      def uri?(value)
+        URI.parse(value).is_a?(URI::Generic)
+      rescue URI::InvalidURIError
+        false
+      end
+    end
+  end
+end

data/lib/capsium/package/routes.rb

@@ -1,156 +1,96 @@
 # frozen_string_literal: true
 
-# lib/capsium/package/routes.rb
-require "json"
-require "fileutils"
+require "forwardable"
 
 module Capsium
   class Package
-    class RouteTarget < Shale::Mapper
-      attribute :file, Shale::Type::String
-
-      def fs_path(manifest)
-        manifest.path_to_content_file(manifest.lookup(file).file)
-      end
-
-      def mime(manifest)
-        manifest.lookup(file).mime
-      end
-
-      def validate(manifest)
-        target_path = fs_path(manifest)
-        return if File.exist?(target_path)
-
-        raise "Route target does not exist: #{target_path}"
-      end
-    end
-
-    class Route < Shale::Mapper
-      attribute :path, Shale::Type::String
-      attribute :target, RouteTarget
-    end
-
-    class RoutesData < Shale::Mapper
-      attribute :routes, Route, collection: true
-
-      def resolve(route)
-        routes.detect do |r|
-          r.path == route
-        end
-      end
-
-      def add(route, target)
-        target = RouteTarget.new(file: target) if target.is_a?(String)
-
-        @routes << Route.new(path: route, target: target)
-      end
-
-      def update(route, updated_route, _updated_target)
-        r = @routes.resolve(route)
-        r.path = updated_route
-        r.target = target
-        r
-      end
-
-      def remove(route)
-        r = @routes.resolve(route)
-        @routes.remove(r)
-      end
+    class Routes
+      extend Forwardable
 
-      def sort!
-        @routes.sort_by!(&:path)
-        self
-      end
-    end
+      attr_reader :path, :config, :manifest, :storage
 
-    class Routes
-      attr_reader :path, :data, :index, :manifest
+      def_delegators :@config, :to_hash
 
-      ROUTES_FILE = "routes.json"
-      DEFAULT_INDEX_TARGET = "index.html"
       INDEX_ROUTE = "/"
+      INDEX_RESOURCE = "content/index.html"
+      DATASET_ROUTE_PREFIX = "/api/v1/data/"
 
-      def initialize(path, manifest)
+      def initialize(path, manifest, storage)
         @path = path
-        @dir = File.dirname(path)
         @manifest = manifest
-        @data = if File.exist?(path)
-                  RoutesData.from_json(File.read(path))
-                else
-                  generate_routes_from_manifest
-                end
-        validate_index_path(@data.resolve(INDEX_ROUTE).target.file)
-        validate
+        @storage = storage
+        @config = if File.exist?(path)
+                    RoutesConfig.from_json(File.read(path))
+                  else
+                    generate_routes
+                  end
       end
 
       def resolve(url_path)
-        @data.resolve(url_path)
+        @config.resolve(url_path)
       end
 
       def add_route(route, target)
-        validate_route_target(route, target)
-        @data.add(route, target)
+        @config.add(route, target)
       end
 
       def update_route(route, updated_route, updated_target)
-        validate_route_target(updated_route, updated_target)
-        @data.update(route, updated_route, updated_target)
+        @config.update(route, updated_route, updated_target)
       end
 
       def remove_route(route)
-        @data._removed(route)
-      end
-
-      def validate
-        @data.routes.each do |route|
-          route.target.validate(@manifest)
-        end
+        @config.remove(route)
       end
 
       def to_json(*_args)
-        @data.sort!.to_json
+        @config.to_json
       end
 
       def save_to_file(output_path = @path)
-        File.open(output_path, "w") do |file|
-          file.write(to_json)
-        end
+        File.write(output_path, to_json)
       end
 
-      private
+      # Auto-generation (ARCHITECTURE.md section 4): every manifest
+      # resource gets a route at its path relative to content/; HTML files
+      # get two routes (basename without extension and full filename); the
+      # index HTML additionally gets "/"; every dataset in storage gets
+      # /api/v1/data/<id>. Output is deterministic (sorted by path).
+      def generate_routes
+        routes = resource_routes + dataset_routes
+        RoutesConfig.new(index: index_resource, routes: routes.sort_by(&:path))
+      end
 
-      def generate_routes_from_manifest
-        routes = RoutesData.new
-        @manifest.data.content.each do |data_item|
-          file_path = data_item.file
-          # mime_type = data_item.mime
-          content_path = @manifest.path_to_content_file(file_path).to_s
+      private
 
-          if file_path == DEFAULT_INDEX_TARGET
-            routes.add(INDEX_ROUTE, DEFAULT_INDEX_TARGET)
-          end
+      def index_resource
+        INDEX_RESOURCE if @manifest.resources.key?(INDEX_RESOURCE)
+      end
 
-          routes.add("/#{clean_target_html_path(file_path)}", file_path) if file_path =~ /\.html$/
+      def resource_routes
+        @manifest.resources.keys.flat_map do |resource_path|
+          routes_for_resource(resource_path)
+        end.uniq(&:path)
+      end
 
-          routes.add("/#{file_path}", file_path)
-        end
+      def routes_for_resource(resource_path)
+        url_path = resource_path.sub(%r{\A#{Package::CONTENT_DIR}/}o, "")
+        routes = [Route.new(path: "/#{url_path}", resource: resource_path)]
+        return routes unless File.extname(resource_path) == ".html"
 
+        basename = File.basename(url_path, ".html")
+        routes << Route.new(path: "/#{basename}", resource: resource_path)
+        routes << Route.new(path: INDEX_ROUTE, resource: resource_path) if index?(resource_path)
         routes
       end
 
-      def clean_target_html_path(path)
-        File.dirname(path) + File.basename(path, ".html")
+      def index?(resource_path)
+        resource_path == INDEX_RESOURCE
       end
 
-
-      def validate_index_path(index_path)
-        target_path = @manifest.path_to_content_file(index_path)
-
-        raise "Index file does not exist: #{target_path}" unless File.exist?(target_path)
-
-        return if File.extname(target_path).downcase == ".html"
-
-        raise "Index file is not an HTML file: #{target_path}"
+      def dataset_routes
+        @storage.dataset_names.map do |name|
+          Route.new(path: "#{DATASET_ROUTE_PREFIX}#{name}", dataset: name)
+        end
       end
     end
   end