capsium 0.1.1

data/lib/capsium/converters/jekyll.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# lib/capsium/converters/jekyll_to_capsium.rb
+require "fileutils"
+require "json"
+require "capsium/packager"
+
+module Capsium
+  module Converters
+    class Jekyll
+      def initialize(site_directory, output_directory)
+        @site_directory = site_directory
+        @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
+
+      private
+
+      def validate_site_directory
+        return if Dir.exist?(@site_directory) && File.exist?(File.join(@site_directory, "index.html"))
+
+        raise "Invalid Jekyll site directory: #{@site_directory}"
+      end
+
+      def prepare_package_directory
+        package_directory = File.join(@output_directory, "capsium_package")
+        FileUtils.mkdir_p(package_directory)
+
+        FileUtils.cp_r(Dir.glob("#{@site_directory}/*"), package_directory)
+
+        create_manifest(package_directory)
+
+        package_directory
+      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}/", "") }
+        }
+
+        File.write(File.join(package_directory, "manifest.json"), JSON.pretty_generate(manifest))
+      end
+
+      def cleanup_package_directory(package_directory)
+        FileUtils.rm_rf(package_directory)
+      end
+    end
+  end
+end

data/lib/capsium/package/dataset.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+# lib/capsium/package/dataset.rb
+require "json"
+require "yaml"
+require "csv"
+require "sqlite3"
+
+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
+        @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
+      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
+        else
+          raise "Unsupported data file type: #{@type}"
+        end
+      end
+
+      def as_json
+        {
+          name: name,
+          source: relative_path(path),
+          format: type.to_s
+        }
+      end
+
+      def to_json(*_args)
+        JSON.pretty_generate(as_json)
+      end
+
+      def relative_path(path)
+        Pathname.new(path).relative_path_from(@data_path).to_s
+      end
+
+      private
+
+      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};")
+        end
+        data
+      end
+    end
+  end
+end

data/lib/capsium/package/manifest.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+# lib/capsium/package/manifest.rb
+require "json"
+require "marcel"
+require "shale"
+
+module Capsium
+  class Package
+    class Manifest
+      attr_accessor :path, :content_path, :data
+
+      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
+      end
+
+      def generate_manifest
+        files = Dir[File.join(@content_path, "**", "*")].reject do |f|
+          File.directory?(f)
+        end
+
+        files.sort.map do |file_path|
+          ManifestDataItem.new(
+            file: relative_path(file_path),
+            mime: mime_from_path(file_path)
+          )
+        end
+      end
+
+      def lookup(filename)
+        @data.content.detect do |data_item|
+          data_item.file == filename
+        end
+      end
+
+      def to_json(*_args)
+        @data.to_json
+      end
+
+      def save_to_file(output_path = @path)
+        File.open(output_path, "w") do |file|
+          file.write(to_json)
+        end
+      end
+
+      def path_to_content_file(path)
+        Pathname.new(@content_path).join(path)
+      end
+
+      def content_file_exists?(path)
+        File.exist?(path_to_content_file(path))
+      end
+
+      def relative_path(path)
+        Pathname.new(path).relative_path_from(@content_path).to_s
+      end
+
+      private
+
+      def mime_from_path(path)
+        Marcel::MimeType.for(
+          Pathname.new(path),
+          name: File.basename(path),
+          extension: File.extname(path)
+        )
+      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/metadata.rb

@@ -0,0 +1,48 @@
+# 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
+
+      extend Forwardable
+      def_delegator :@data, :name
+      def_delegator :@data, :version
+      def_delegator :@data, :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
+      end
+
+      def save_to_file(output_path = @path)
+        File.open(output_path, "w") do |file|
+          file.write(to_json)
+        end
+      end
+    end
+  end
+end

data/lib/capsium/package/routes.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+# lib/capsium/package/routes.rb
+require "json"
+require "fileutils"
+
+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
+
+      def sort!
+        @routes.sort_by!(&:path)
+        self
+      end
+    end
+
+    class Routes
+      attr_reader :path, :data, :index, :manifest
+
+      ROUTES_FILE = "routes.json"
+      DEFAULT_INDEX_TARGET = "index.html"
+      INDEX_ROUTE = "/"
+
+      def initialize(path, manifest)
+        @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
+      end
+
+      def resolve(url_path)
+        @data.resolve(url_path)
+      end
+
+      def add_route(route, target)
+        validate_route_target(route, target)
+        @data.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)
+      end
+
+      def remove_route(route)
+        @data._removed(route)
+      end
+
+      def validate
+        @data.routes.each do |route|
+          route.target.validate(@manifest)
+        end
+      end
+
+      def to_json(*_args)
+        @data.sort!.to_json
+      end
+
+      def save_to_file(output_path = @path)
+        File.open(output_path, "w") do |file|
+          file.write(to_json)
+        end
+      end
+
+      private
+
+      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
+
+          if file_path == DEFAULT_INDEX_TARGET
+            routes.add(INDEX_ROUTE, DEFAULT_INDEX_TARGET)
+          end
+
+          routes.add("/#{clean_target_html_path(file_path)}", file_path) if file_path =~ /\.html$/
+
+          routes.add("/#{file_path}", file_path)
+        end
+
+        routes
+      end
+
+      def clean_target_html_path(path)
+        File.dirname(path) + File.basename(path, ".html")
+      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}"
+      end
+    end
+  end
+end

data/lib/capsium/package/storage.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# lib/capsium/package/storage.rb
+require "json"
+
+module Capsium
+  class Package
+    class Storage
+      attr_reader :datasets
+
+      DATA_DIR = "data"
+
+      def initialize(path)
+        @path = path
+        @dir = File.dirname(path)
+        @datasets_path = File.join(@dir, DATA_DIR)
+        @datasets = load_datasets || generate_datasets
+      end
+
+      def load_datasets
+        return unless File.exist?(@path)
+
+        storage_data = JSON.parse(File.read(@path))
+        @datasets = storage_data["storage"]
+      end
+
+      def as_json
+        { datasets: datasets.map(&:as_json) }
+      end
+
+      def to_json(*_args)
+        JSON.pretty_generate(as_json)
+      end
+
+      def save_to_file(output_path = @path)
+        File.open(output_path, "w") do |file|
+          file.write(to_json)
+        end
+      end
+
+      def generate_datasets
+        datasets = []
+        paths = File.join(@datasets_path, "*.{yaml,yml,json,csv,tsv,sqlite,db}")
+        Dir.glob(paths).each do |file_path|
+          datasets << Dataset.new(file_path, @datasets_path)
+          # dataset_info[:table] = dataset.table_name if dataset.type == :sqlite
+        end
+        datasets
+      end
+    end
+  end
+end

data/lib/capsium/package.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+# lib/capsium/package.rb
+require "fileutils"
+require "json"
+require "yaml"
+require "csv"
+require "sqlite3"
+require "zip"
+require_relative "package/manifest"
+require_relative "package/metadata"
+require_relative "package/routes"
+require_relative "package/dataset"
+require_relative "package/storage"
+require_relative "packager"
+
+module Capsium
+  class Package
+    attr_reader :name, :path, :manifest, :metadata, :routes, :datasets, :storage
+
+    MANIFEST_FILE = "manifest.json"
+    METADATA_FILE = "metadata.json"
+    PACKAGING_FILE = "packaging.json"
+    SIGNATURE_FILE = "signature.json"
+    STORAGE_FILE = "storage.json"
+    ROUTES_FILE = "routes.json"
+    CONTENT_DIR = "content"
+    DATA_DIR = "data"
+    ENCRYPTED_PACKAGING_FILE = "package.enc"
+
+    def initialize(path)
+      @original_path = Pathname.new(path).expand_path
+      @path = prepare_package(@original_path)
+      create_package_structure
+      load_package
+      @name = metadata.name
+    end
+
+    def prepare_package(path)
+      return path if File.directory?(path)
+
+      if File.file?(path)
+        return decompress_cap_file(path) if File.extname(path) == ".cap"
+
+        raise "Error: The package must have a .cap extension"
+
+      end
+
+      raise "Invalid package path: #{path}"
+    end
+
+    def solidify
+      @manifest.save_to_file
+      @metadata.save_to_file
+      @routes.save_to_file
+      @storage.save_to_file
+    end
+
+    def decompress_cap_file(file_path)
+      temp_dir = Dir.mktmpdir
+      metadata_path = File.join(temp_dir, METADATA_FILE)
+
+      # Extract metadata.json first
+      Zip::File.open(file_path) do |zip_file|
+        if entry = zip_file.find_entry(METADATA_FILE)
+          entry.extract(metadata_path)
+        end
+      end
+
+      metadata = Metadata.new(metadata_path)
+      package_name = metadata.name
+      package_version = metadata.version
+      package_dependencies = metadata.dependencies
+
+      package_path = File.join(temp_dir, "#{package_name}-#{package_version}")
+      FileUtils.mkdir_p(package_path)
+
+      Zip::File.open(file_path) do |zip_file|
+        zip_file.each do |entry|
+          entry_path = File.join(package_path, entry.name)
+          FileUtils.mkdir_p(File.dirname(entry_path))
+          entry.extract(entry_path)
+        end
+      end
+
+      package_path
+    end
+
+    def load_package
+      # Mandatory
+      @metadata = Metadata.new(metadata_path)
+
+      # Optional
+      @manifest = Manifest.new(manifest_path)
+      @routes = Routes.new(routes_path, @manifest)
+      @storage = Storage.new(storage_path)
+      # @datasets = load_datasets
+    end
+
+    def cleanup
+      return unless @path != @original_path && File.directory?(@path)
+
+      FileUtils.remove_entry(@path)
+    end
+
+    def package_files
+      @packager.package_files
+    end
+
+    private
+
+    def create_package_structure
+      FileUtils.mkdir_p(@path)
+      FileUtils.mkdir_p(content_path)
+      FileUtils.mkdir_p(data_path)
+    end
+
+    def content_path
+      File.join(@path, CONTENT_DIR)
+    end
+
+    def data_path
+      File.join(@path, DATA_DIR)
+    end
+
+    def routes_path
+      File.join(@path, ROUTES_FILE)
+    end
+
+    def storage_path
+      File.join(@path, STORAGE_FILE)
+    end
+
+    def metadata_path
+      File.join(@path, METADATA_FILE)
+    end
+
+    def manifest_path
+      File.join(@path, MANIFEST_FILE)
+    end
+  end
+end