capsium 0.1.1 → 0.2.0

data/capsium.gemspec

@@ -1,25 +1,27 @@
 # frozen_string_literal: true
 
-require_relative "lib/capsium/version"
+require File.expand_path("lib/capsium/version", __dir__)
 
 Gem::Specification.new do |spec|
   spec.name = "capsium"
   spec.version = Capsium::VERSION
   spec.authors = ["Ribose Inc."]
-  spec.email = ["open.source@ribose.com'"]
-
-  spec.summary = "Capsium"
-  spec.description = "Capsium"
-  spec.homepage = "https://github.com/metanorma/capsium"
+  spec.email = ["open.source@ribose.com"]
+
+  spec.summary = "Packager and reactor for Capsium packages (.cap)"
+  spec.description = "Capsium facilitates the creation, management and " \
+                     "deployment of content packages with ease. This gem " \
+                     "provides a structured way to handle content, data, " \
+                     "and metadata for various applications: it packages " \
+                     "them into .cap files and serves them over HTTP."
+  spec.homepage = "https://github.com/capsiums/capsium"
   spec.license = "MIT"
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = spec.homepage
-  spec.metadata["changelog_uri"] = "https://github.com/metanorma/capsium/releases"
+  spec.metadata["changelog_uri"] = "https://github.com/capsiums/capsium/releases"
+  spec.metadata["rubygems_mfa_required"] = "true"
 
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem
-  # that have been added into git.
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`
       .split("\x0")
@@ -29,26 +31,17 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = ">= 2.7.0"
+  spec.required_ruby_version = ">= 3.2.0"
 
-  spec.add_dependency "cssminify"
   spec.add_dependency "csv"
-  spec.add_dependency "htmlcompressor"
-  spec.add_dependency "html-proofer"
   spec.add_dependency "json"
+  spec.add_dependency "json-schema"
   spec.add_dependency "listen"
+  spec.add_dependency "lutaml-model", ">= 0.8", "< 1.0"
   spec.add_dependency "marcel"
-  spec.add_dependency "rubyzip", "~>2.3.2"
-  spec.add_dependency "scss_lint"
-  spec.add_dependency "shale"
+  spec.add_dependency "rubyzip", ">= 2.3.2", "< 4.0"
   spec.add_dependency "sqlite3"
   spec.add_dependency "thor"
-  spec.add_dependency "uglifier"
   spec.add_dependency "webrick"
   spec.add_dependency "yaml"
-
-  spec.add_development_dependency "pry", "~> 0.12.2"
-  spec.add_development_dependency "rake", "~> 13.0"
-  spec.add_development_dependency "rspec", "~> 3.11"
-  spec.add_development_dependency "rubocop", "~> 1.58"
 end

data/exe/capsium

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require "capsium/cli"
+require File.expand_path("../lib/capsium", __dir__)
 
 Capsium::Cli.start(ARGV)

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,88 +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"
-      def serve(path_to_package)
-        package = Capsium::Package.new(path_to_package)
-        reactor = Capsium::Reactor.new(package)
-        reactor.serve
-      rescue StandardError => e
-        puts e
-        puts e.inspect
-        puts e.backtrace
-      ensure
-        package.cleanup
-      end
-    end
-
-    class Convert < Thor
-      extend ThorExt::Start
-      desc "jekyll SITE_DIRECTORY OUTPUT_DIRECTORY", "Convert a Jekyll site directory to a Capsium package"
-      def jekyll(site_directory, output_directory)
-        converter = Capsium::Converters::Jekyll.new(site_directory, 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
@@ -90,7 +16,7 @@ module Capsium
     desc "reactor SUBCOMMAND ...ARGS", "Manage the reactor"
     subcommand "reactor", Capsium::Cli::Reactor
 
-    desc "converter SUBCOMMAND ...ARGS", "Convert from another format"
-    subcommand "converter", Capsium::Cli::Convert
+    desc "convert SUBCOMMAND ...ARGS", "Convert from another format"
+    subcommand "convert", Capsium::Cli::Convert
   end
 end

data/lib/capsium/converters/jekyll.rb

@@ -1,58 +1,89 @@
 # frozen_string_literal: true
 
-# lib/capsium/converters/jekyll_to_capsium.rb
 require "fileutils"
-require "json"
-require "capsium/packager"
+require "pathname"
+require "yaml"
 
 module Capsium
   module Converters
     class Jekyll
-      def initialize(site_directory, output_directory)
-        @site_directory = site_directory
+      def initialize(package_file, output_directory)
+        @package_file = package_file
         @output_directory = output_directory
       end
 
       def convert
-        validate_site_directory
-        package_directory = prepare_package_directory
-        packager = Capsium::Packager.new(package_directory)
-        packager.pack
-        cleanup_package_directory(package_directory)
-      end
+        package = Capsium::Package.new(@package_file)
 
-      private
+        prepare_output_directory
 
-      def validate_site_directory
-        return if Dir.exist?(@site_directory) && File.exist?(File.join(@site_directory, "index.html"))
+        write_config_yml(package)
+        copy_content_files(package)
+        generate_index_html(package)
 
-        raise "Invalid Jekyll site directory: #{@site_directory}"
+        puts "Capsium package converted to Jekyll site at #{@output_directory}"
       end
 
-      def prepare_package_directory
-        package_directory = File.join(@output_directory, "capsium_package")
-        FileUtils.mkdir_p(package_directory)
+      private
 
-        FileUtils.cp_r(Dir.glob("#{@site_directory}/*"), package_directory)
+      def prepare_output_directory
+        FileUtils.mkdir_p(@output_directory)
+      end
 
-        create_manifest(package_directory)
+      def write_config_yml(package)
+        config = {
+          "title" => package.metadata.name || "Capsium Jekyll Site",
+          "description" => package.metadata.description || "Generated from Capsium package",
+          "baseurl" => "",
+          "url" => "",
+          "markdown" => "kramdown",
+          "theme" => "minima"
+        }
+        write_file("_config.yml", config.to_yaml)
+      end
 
-        package_directory
+      def write_file(relative_path, content)
+        output_path = File.join(@output_directory, relative_path)
+        FileUtils.mkdir_p(File.dirname(output_path))
+        File.write(output_path, content)
       end
 
-      def create_manifest(package_directory)
-        manifest = {
-          "name" => "jekyll_site",
-          "version" => "1.0.0",
-          "description" => "A Jekyll site converted to a Capsium package",
-          "files" => Dir.glob("#{package_directory}/**/*").map { |file| file.sub("#{package_directory}/", "") }
-        }
+      def copy_content_files(package)
+        package.content_files.each do |file_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)
+        end
+      end
 
-        File.write(File.join(package_directory, "manifest.json"), JSON.pretty_generate(manifest))
+      def generate_index_html(package)
+        root_route = package.routes.config.routes.find do |route|
+          route.path == "/"
+        end
+        if root_route
+          index_path = File.join(package.path, root_route.resource)
+          index_content = File.read(index_path)
+          write_file("index.html", index_content)
+        else
+          write_file("index.html", default_index_html(package))
+        end
       end
 
-      def cleanup_package_directory(package_directory)
-        FileUtils.rm_rf(package_directory)
+      def default_index_html(package)
+        <<~HTML
+          <!DOCTYPE html>
+          <html>
+          <head>
+            <meta charset="utf-8">
+            <title>#{package.metadata.name || 'Capsium Jekyll Site'}</title>
+          </head>
+          <body>
+            <h1>Welcome to #{package.metadata.name || 'Capsium Jekyll Site'}</h1>
+            <p>This site was generated from a Capsium package.</p>
+          </body>
+          </html>
+        HTML
       end
     end
   end

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,85 +1,105 @@
 # frozen_string_literal: true
 
-# lib/capsium/package/dataset.rb
-require "json"
-require "yaml"
 require "csv"
+require "forwardable"
+require "json"
+require "json-schema"
 require "sqlite3"
+require "yaml"
 
 module Capsium
   class Package
-    class Dataset < Shale::Mapper
-      # {
-      #   "datasets": [
-      #     {
-      #       "name": "animals",
-      #       "source": "data/animals.yaml",
-      #       "format": "yaml",
-      #       "schema": "data/animals_schema.yaml"
-      #     }
-      #   ]
-      # }
-      attr_reader :name, :path, :type, :data
-
-      def initialize(path, data_path)
-        @path = path
-        @name = File.basename(@path, ".*")
-        @type = detect_type
-        @data_path = data_path
+    # A loaded dataset. "source"/"schemaFile"/"databaseFile" are
+    # package-relative paths (ARCHITECTURE.md section 5), resolved against
+    # the package directory.
+    class Dataset
+      attr_reader :name, :config, :data, :package_path
+
+      extend Forwardable
+
+      def_delegators :@config, :to_json
+
+      def initialize(name:, config:, package_path:)
+        @name = name
+        @config = config
+        @package_path = package_path
         @data = load_data
       end
 
-      def detect_type
-        case File.extname(@path).downcase
-        when /.ya?ml/ then :yaml
-        when ".json" then :json
-        when ".csv" then :csv
-        when ".tsv" then :tsv
-        when ".sqlite", ".db" then :sqlite
-        else
-          raise "Unsupported data file type: #{File.extname(@path)}"
-        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
-        case @type
-        when :yaml then YAML.load_file(@path)
-        when :json then JSON.parse(File.read(@path))
-        when :csv then CSV.read(@path, headers: true)
-        when :tsv then CSV.read(@path, col_sep: "\t", headers: true)
-        when :sqlite then load_sqlite_data
+        return nil unless File.file?(source_path)
+
+        case @config.format
+        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: #{@type}"
+          raise Error, "Unsupported data file type: #{@config.format}"
         end
       end
 
-      def as_json
-        {
-          name: name,
-          source: relative_path(path),
-          format: type.to_s
-        }
-      end
+      def validate
+        return true unless @config.schema_file && @config.schema_type == "json-schema"
 
-      def to_json(*_args)
-        JSON.pretty_generate(as_json)
+        JSON::Validator.validate!(load_schema, @data.to_json)
       end
 
-      def relative_path(path)
-        Pathname.new(path).relative_path_from(@data_path).to_s
+      # 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
+        problems.concat(schema_validation_errors)
+        problems
       end
 
       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
+
+      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(@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