capsium 0.1.2 → 0.2.0

data/lib/capsium/cli/convert.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Capsium
+  class Cli
+    class Convert < Thor
+      extend ThorExt::Start
+
+      desc "jekyll PACKAGE_FILE OUTPUT_DIRECTORY",
+           "Convert a Capsium package to a Jekyll site"
+
+      def jekyll(package_file, output_directory)
+        converter = Capsium::Converters::Jekyll.new(package_file,
+                                                    output_directory)
+        converter.convert
+      end
+    end
+  end
+end

data/lib/capsium/cli/package.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Capsium
+  class Cli
+    class Package < Thor
+      extend ThorExt::Start
+
+      desc "info PACKAGE_PATH", "Display information about the package"
+
+      def info(path_to_package)
+        package = Capsium::Package.new(path_to_package)
+        puts "Package Path: #{package.path}"
+        puts "Routes: #{package.routes.to_hash}"
+        puts "Manifest: #{package.manifest.to_hash}"
+      end
+
+      desc "manifest PATH_TO_PACKAGE",
+           "Show the manifest content of the package"
+
+      def manifest(path_to_package)
+        package = Capsium::Package.new(path_to_package)
+        puts JSON.pretty_generate(package.manifest.to_hash)
+      end
+
+      desc "storage PATH_TO_PACKAGE", "Show the storage datasets of the package"
+
+      def storage(path_to_package)
+        package = Capsium::Package.new(path_to_package)
+        puts JSON.pretty_generate(package.storage.to_hash)
+      end
+
+      desc "routes PATH_TO_PACKAGE", "Show the routes of the package"
+
+      def routes(path_to_package)
+        package = Capsium::Package.new(path_to_package)
+        puts JSON.pretty_generate(package.routes.to_hash)
+      end
+
+      desc "metadata PATH_TO_PACKAGE", "Show the metadata of the package"
+
+      def metadata(path_to_package)
+        package = Capsium::Package.new(path_to_package)
+        puts JSON.pretty_generate(package.metadata.to_hash)
+      end
+
+      desc "pack PATH_TO_PACKAGE_FOLDER", "Package the files into the package"
+      option :force, type: :boolean, default: false, aliases: "-f"
+
+      def pack(path_to_package)
+        package = Capsium::Package.new(path_to_package)
+        packager = Capsium::Packager.new
+        packager.pack(package, options)
+      end
+
+      desc "unpack PACKAGE_FILE", "Unpack a .cap package into a directory"
+      option :output, type: :string, aliases: "-o", desc: "Output directory"
+
+      def unpack(path_to_package)
+        destination = options[:output] || File.basename(path_to_package, ".cap")
+        Capsium::Packager.new.unpack(path_to_package, destination)
+        puts "Package unpacked to: #{destination}"
+      end
+
+      desc "validate PACKAGE_PATH", "Validate a package directory or .cap file"
+
+      def validate(path_to_package)
+        results = Capsium::Package::Validator.new(path_to_package).run
+        results.each { |result| puts format_result(result) }
+        return if results.all?(&:ok?)
+
+        raise Thor::Error, "Package validation failed"
+      end
+
+      private
+
+      def format_result(result)
+        line = "#{result.ok? ? 'PASS' : 'FAIL'} #{result.name}"
+        return line if result.messages.empty?
+
+        "#{line}: #{result.messages.join('; ')}"
+      end
+    end
+  end
+end

data/lib/capsium/cli/reactor.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Capsium
+  class Cli
+    class Reactor < Thor
+      extend ThorExt::Start
+
+      desc "serve PACKAGE_PATH",
+           "Start the Capsium reactor to serve the package"
+      option :port, type: :numeric, default: Capsium::Reactor::DEFAULT_PORT
+      option :do_not_listen, type: :boolean, default: false
+
+      def serve(path_to_package)
+        reactor = Capsium::Reactor.new(
+          package: path_to_package,
+          port: options[:port],
+          do_not_listen: options[:do_not_listen]
+        )
+        reactor.serve
+      ensure
+        reactor&.package&.cleanup
+      end
+    end
+  end
+end

data/lib/capsium/cli.rb

@@ -1,107 +1,14 @@
 # frozen_string_literal: true
 
-# lib/capsium/cli.rb
 require "thor"
-require_relative "package"
-require_relative "reactor"
-require_relative "thor_ext"
-require_relative "converters/jekyll"
 
 module Capsium
   class Cli < Thor
     extend ThorExt::Start
 
-    class Package < Thor
-      extend ThorExt::Start
-
-      desc "info PACKAGE_PATH", "Display information about the package"
-
-      def info(path_to_package)
-        package = Capsium::Package.new(path_to_package)
-        puts "Package Path: #{package.path}"
-        puts "Routes: #{package.routes.as_json}"
-        puts "Manifest: #{package.manifest.as_json}"
-      end
-
-      desc "manifest PATH_TO_PACKAGE",
-           "Show the manifest content of the package"
-
-      def manifest(path_to_package)
-        package = Capsium::Package.new(path_to_package)
-        puts JSON.pretty_generate(package.manifest.as_json)
-      end
-
-      desc "storage PATH_TO_PACKAGE", "Show the storage datasets of the package"
-
-      def storage(path_to_package)
-        package = Capsium::Package.new(path_to_package)
-        puts JSON.pretty_generate(package.storage.as_json)
-      end
-
-      desc "routes PATH_TO_PACKAGE", "Show the routes of the package"
-
-      def routes(path_to_package)
-        package = Capsium::Package.new(path_to_package)
-        puts JSON.pretty_generate(package.routes.as_json)
-      end
-
-      desc "metadata PATH_TO_PACKAGE", "Show the metadata of the package"
-
-      def metadata(path_to_package)
-        package = Capsium::Package.new(path_to_package)
-        puts JSON.pretty_generate(package.metadata.as_json)
-      end
-
-      desc "pack PATH_TO_PACKAGE_FOLDER", "Package the files into the package"
-      option :force, type: :boolean, default: false, aliases: "-f"
-
-      def pack(path_to_package)
-        package = Capsium::Package.new(path_to_package)
-        packager = Capsium::Packager.new
-        packager.pack(package, options)
-      rescue StandardError => e
-        puts e
-        puts e.inspect
-        puts e.backtrace
-      end
-    end
-
-    class Reactor < Thor
-      extend ThorExt::Start
-
-      desc "serve PACKAGE_PATH",
-           "Start the Capsium reactor to serve the package"
-      option :port, type: :numeric, default: Capsium::Reactor::DEFAULT_PORT
-      option :do_not_listen, type: :boolean, default: false
-
-      def serve(path_to_package)
-        reactor = Capsium::Reactor.new(
-          package: path_to_package,
-          port: options[:port],
-          do_not_listen: options[:do_not_listen],
-        )
-        reactor.serve
-      rescue StandardError => e
-        puts e
-        puts e.inspect
-        puts e.backtrace
-      ensure
-        reactor.package.cleanup
-      end
-    end
-
-    class Convert < Thor
-      extend ThorExt::Start
-
-      desc "jekyll PACKAGE_FILE OUTPUT_DIRECTORY",
-           "Convert a Capsium package to a Jekyll site"
-
-      def jekyll(package_file, output_directory)
-        converter = Capsium::Converters::Jekyll.new(package_file,
-                                                    output_directory)
-        converter.convert
-      end
-    end
+    autoload :Convert, "capsium/cli/convert"
+    autoload :Package, "capsium/cli/package"
+    autoload :Reactor, "capsium/cli/reactor"
 
     desc "package SUBCOMMAND ...ARGS", "Manage packages"
     subcommand "package", Capsium::Cli::Package

data/lib/capsium/converters/jekyll.rb

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 
-# lib/capsium/converters/jekyll.rb
 require "fileutils"
-require "json"
-require "capsium/package"
+require "pathname"
+require "yaml"
 
 module Capsium
   module Converters
@@ -38,7 +37,7 @@ module Capsium
           "baseurl" => "",
           "url" => "",
           "markdown" => "kramdown",
-          "theme" => "minima",
+          "theme" => "minima"
         }
         write_file("_config.yml", config.to_yaml)
       end
@@ -51,7 +50,7 @@ module Capsium
 
       def copy_content_files(package)
         package.content_files.each do |file_path|
-          relative_path = Pathname.new(file_path).relative_path_from(Pathname.new(package.instance_variable_get(:@path)))
+          relative_path = Pathname.new(file_path).relative_path_from(Pathname.new(package.path))
           output_path = File.join(@output_directory, relative_path)
           FileUtils.mkdir_p(File.dirname(output_path))
           FileUtils.cp(file_path, output_path)
@@ -63,8 +62,7 @@ module Capsium
           route.path == "/"
         end
         if root_route
-          index_path = File.join(package.instance_variable_get(:@path),
-                                 root_route.target.file)
+          index_path = File.join(package.path, root_route.resource)
           index_content = File.read(index_path)
           write_file("index.html", index_content)
         else

data/lib/capsium/converters.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Capsium
+  module Converters
+    autoload :Jekyll, "capsium/converters/jekyll"
+  end
+end

data/lib/capsium/package/dataset.rb

@@ -1,72 +1,105 @@
 # frozen_string_literal: true
 
-require "json"
-require "yaml"
 require "csv"
-require "sqlite3"
-require "shale"
+require "forwardable"
+require "json"
 require "json-schema"
-require_relative "dataset_config"
+require "sqlite3"
+require "yaml"
 
 module Capsium
   class Package
+    # A loaded dataset. "source"/"schemaFile"/"databaseFile" are
+    # package-relative paths (ARCHITECTURE.md section 5), resolved against
+    # the package directory.
     class Dataset
-      attr_reader :config, :data, :data_path
+      attr_reader :name, :config, :data, :package_path
 
       extend Forwardable
 
       def_delegators :@config, :to_json
 
-      def initialize(config:, data_path: nil)
+      def initialize(name:, config:, package_path:)
+        @name = name
         @config = config
-        @data_path = data_path || config.source
+        @package_path = package_path
         @data = load_data
       end
 
+      def source_path
+        File.join(@package_path, @config.backing_file)
+      end
+
+      def schema_path
+        return unless @config.schema_file
+
+        File.join(@package_path, @config.schema_file)
+      end
+
       def load_data
+        return nil unless File.file?(source_path)
+
         case @config.format
-        when "yaml" then YAML.load_file(@data_path)
-        when "json" then JSON.parse(File.read(@data_path))
-        when "csv" then CSV.read(@data_path, headers: true)
-        when "tsv" then CSV.read(@data_path, col_sep: "\t", headers: true)
+        when "yaml" then YAML.load_file(source_path)
+        when "json" then JSON.parse(File.read(source_path))
+        when "csv" then CSV.read(source_path, headers: true)
+        when "tsv" then CSV.read(source_path, col_sep: "\t", headers: true)
         when "sqlite" then load_sqlite_data
         else
-          raise "Unsupported data file type: #{@config.format}"
+          raise Error, "Unsupported data file type: #{@config.format}"
         end
       end
 
       def validate
-        return unless @config.schema
+        return true unless @config.schema_file && @config.schema_type == "json-schema"
 
-        schema_path = File.join(File.dirname(@data_path), @config.schema)
-        schema = YAML.load_file(schema_path) if @config.format == "yaml"
-        schema = JSON.parse(File.read(schema_path)) if @config.format == "json"
+        JSON::Validator.validate!(load_schema, @data.to_json)
+      end
 
-        case @config.format
-        when "yaml" then YAML.load_file(@data_path)
-        when "json" then JSON.parse(File.read(@data_path))
-        else
-          raise "Validation is only supported for YAML and JSON formats"
+      # File-existence and schema validations for this dataset. Returns a
+      # list of human-readable problems; empty when valid.
+      def validation_errors
+        problems = []
+        unless File.file?(source_path)
+          problems << "dataset source missing on disk: #{@config.backing_file}"
         end
-
-        JSON::Validator.validate!(schema, @data.to_json)
+        problems.concat(schema_validation_errors)
+        problems
       end
 
-      def save_to_file(output_path)
-        File.write(output_path, to_json)
+      private
+
+      def schema_validation_errors
+        return [] unless @config.schema_file
+        unless File.file?(schema_path)
+          return ["dataset schema missing on disk: #{@config.schema_file}"]
+        end
+
+        validate
+        []
+      rescue JSON::Schema::ValidationError => e
+        ["dataset #{@name} fails schema validation: #{e.message}"]
       end
 
-      private
+      def load_schema
+        case File.extname(schema_path).downcase
+        when ".yaml", ".yml" then YAML.load_file(schema_path)
+        else JSON.parse(File.read(schema_path))
+        end
+      end
 
       def load_sqlite_data
-        db = SQLite3::Database.new(@data_path)
-        tables = db.execute("SELECT name FROM sqlite_master WHERE type='table';")
-        data = {}
-        tables.each do |table|
-          table_name = table.first
-          data[table_name] = db.execute("SELECT * FROM #{table_name};")
+        db = SQLite3::Database.new(source_path)
+        tables = @config.table ? [@config.table] : sqlite_tables(db)
+        tables.to_h do |table_name|
+          [table_name, db.execute("SELECT * FROM #{table_name};")]
         end
-        data
+      ensure
+        db&.close
+      end
+
+      def sqlite_tables(db)
+        db.execute("SELECT name FROM sqlite_master WHERE type='table';").map(&:first)
       end
     end
   end

data/lib/capsium/package/manifest.rb

@@ -1,51 +1,56 @@
 # frozen_string_literal: true
 
-# lib/capsium/package/manifest.rb
-require "json"
+require "forwardable"
 require "marcel"
-require "shale"
-require_relative "manifest_config"
+require "pathname"
 
 module Capsium
   class Package
     class Manifest
       extend Forwardable
-      attr_accessor :path, :content_path, :config
 
-      def_delegators :@config, :to_json
+      attr_reader :path, :content_path, :config
+
+      def_delegators :@config, :to_hash
 
       def initialize(path)
         @path = path
         @content_path = File.join(File.dirname(@path), Package::CONTENT_DIR)
-
         @config = if File.exist?(path)
                     ManifestConfig.from_json(File.read(path))
                   else
-                    ManifestConfig.new(content: generate_manifest)
+                    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|
-          ManifestConfigItem.new(
-            file: relative_path(file_path),
-            mime: mime_from_path(file_path),
-          )
-        end
+      def resources
+        @config.resources
       end
 
-      def lookup(filename)
-        @config.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)
+        @config.to_json
       end
 
       def save_to_file(output_path = @path)
-        @config.content.sort_by!(&:file)
         File.write(output_path, to_json)
       end
 
@@ -65,11 +70,17 @@ module Capsium
 
       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),
           name: File.basename(path),
-          extension: File.extname(path),
+          extension: File.extname(path)
         )
       end
     end

data/lib/capsium/package/manifest_config.rb

@@ -1,17 +1,62 @@
-require "shale"
+# frozen_string_literal: true
+
+require "json"
+require "lutaml/model"
 
 module Capsium
   class Package
-    class ManifestConfigItem < Shale::Mapper
-      attribute :file, Shale::Type::String
-      attribute :mime, Shale::Type::String
+    # 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
 
-    class ManifestConfig < Shale::Mapper
-      attribute :content, ManifestConfigItem, collection: true
+    # 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!
-        @content.sort_by!(&:file)
+        self.resources = resources.sort.to_h
         self
       end
     end

data/lib/capsium/package/metadata.rb

@@ -1,9 +1,6 @@
 # frozen_string_literal: true
 
-# lib/capsium/package/metadata.rb
-require "shale"
 require "forwardable"
-require_relative "metadata_config"
 
 module Capsium
   class Package
@@ -11,11 +8,10 @@ module Capsium
       attr_reader :path, :config
 
       extend Forwardable
-      def_delegator :@config, :to_json
-      def_delegator :@config, :name
-      def_delegator :@config, :version
-      def_delegator :@config, :description # Delegate description method
-      def_delegator :@config, :dependencies
+
+      def_delegators :@config, :to_json, :to_hash, :name, :version,
+                     :description, :guid, :uuid, :author, :license,
+                     :repository, :dependencies
 
       def initialize(path)
         @path = path