capsium 0.1.1 → 0.1.2

data/lib/capsium/package/metadata.rb

@@ -3,45 +3,31 @@
 # lib/capsium/package/metadata.rb
 require "shale"
 require "forwardable"
+require_relative "metadata_config"
 
 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_delegator :@config, :to_json
+      def_delegator :@config, :name
+      def_delegator :@config, :version
+      def_delegator :@config, :description # Delegate description method
+      def_delegator :@config, :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,17 @@
+require "shale"
+
+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 :description, Shale::Type::String # Add description attribute
+      attribute :dependencies, Dependency, collection: true
+    end
+  end
+end

data/lib/capsium/package/routes.rb

@@ -3,154 +3,96 @@
 # lib/capsium/package/routes.rb
 require "json"
 require "fileutils"
+require_relative "routes_config"
 
 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
+    class Routes
+      extend Forwardable
+      attr_reader :config
 
-      def remove(route)
-        r = @routes.resolve(route)
-        @routes.remove(r)
-      end
+      def_delegators :@config, :to_json
 
-      def sort!
-        @routes.sort_by!(&:path)
-        self
-      end
-    end
-
-    class Routes
-      attr_reader :path, :data, :index, :manifest
+      attr_reader :path, :config, :index, :manifest, :storage
 
       ROUTES_FILE = "routes.json"
-      DEFAULT_INDEX_TARGET = "index.html"
+      DEFAULT_INDEX_TARGET = "content/index.html"
       INDEX_ROUTE = "/"
 
-      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)
+        @storage = storage
+        @config = if File.exist?(path)
+                    RoutesConfig.from_json(File.read(path))
+                  else
+                    generate_routes
+                  end
+        validate_index_path(@config.resolve(INDEX_ROUTE)&.target&.file)
         validate
       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)
+        @config.remove(route)
       end
 
       def validate
-        @data.routes.each do |route|
-          route.target.validate(@manifest)
+        @config.routes.each do |route|
+          route.target.validate(@manifest, @storage)
         end
       end
 
       def to_json(*_args)
-        @data.sort!.to_json
+        @config.sort!.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
 
-      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
+      def generate_routes
+        r = RoutesConfig.new
+        manifest.config.sort!.content.each_with_object({}) do |data_item, _hash|
+          relative_path = data_item.file.sub(/^#{Package::CONTENT_DIR}/o, "")
+          r.add(relative_path, data_item.file)
 
-          if file_path == DEFAULT_INDEX_TARGET
-            routes.add(INDEX_ROUTE, DEFAULT_INDEX_TARGET)
+          # Ensure the index route is included
+          if File.basename(relative_path, ".*") == "index"
+            r.add("/index", data_item.file)
+            r.add("/", data_item.file)
           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")
+        r
       end
 
-
       def validate_index_path(index_path)
-        target_path = @manifest.path_to_content_file(index_path)
+        return unless index_path
 
+        target_path = @manifest.path_to_content_file(index_path)
         raise "Index file does not exist: #{target_path}" unless File.exist?(target_path)
+        raise "Index file is not an HTML file: #{target_path}" unless File.extname(target_path).downcase == ".html"
+      end
 
-        return if File.extname(target_path).downcase == ".html"
-
-        raise "Index file is not an HTML file: #{target_path}"
+      def validate_route_target(route, target)
+        # Add any necessary validation logic for the route and target
       end
     end
   end

data/lib/capsium/package/routes_config.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "shale"
+
+module Capsium
+  class Package
+    class RouteTarget < Shale::Mapper
+      attribute :file, Shale::Type::String
+      attribute :dataset, Shale::Type::String
+
+      def fs_path(manifest)
+        return unless file
+
+        manifest.path_to_content_file(manifest.lookup(file)&.file)
+      end
+
+      def mime(manifest)
+        manifest.lookup(file)&.mime
+      end
+
+      def validate(manifest, storage)
+        if file
+          target_path = fs_path(manifest)
+          unless target_path && File.exist?(target_path) && target_path.to_s.start_with?(manifest.content_path.to_s)
+            raise "Route target does not exist or is outside of the content directory: #{target_path}"
+          end
+        elsif dataset
+          unless storage.datasets.any? { |ds| ds.config.name == dataset }
+            raise "Dataset target does not exist: #{dataset}"
+          end
+        else
+          raise "Route target must have either a file or a dataset"
+        end
+      end
+    end
+
+    class Route < Shale::Mapper
+      attribute :path, Shale::Type::String
+      attribute :target, RouteTarget
+    end
+
+    class RoutesConfig < Shale::Mapper
+      attribute :routes, Route, collection: true
+
+      def resolve(route)
+        routes.detect { |r| r.path == route }
+      end
+
+      def add(route, target)
+        target = RouteTarget.new(file: target) if target.is_a?(String)
+        r = Route.new(path: route, target: target)
+        @routes << r
+        r
+      end
+
+      def update(route, updated_route, updated_target)
+        r = resolve(route)
+        r.path = updated_route
+        r.target = updated_target
+        r
+      end
+
+      def remove(route)
+        r = resolve(route)
+        @routes.delete(r)
+      end
+
+      def sort!
+        @routes.sort_by!(&:path)
+        self
+      end
+    end
+  end
+end

data/lib/capsium/package/storage.rb

@@ -2,50 +2,75 @@
 
 # lib/capsium/package/storage.rb
 require "json"
+require "shale"
+require_relative "dataset"
+require_relative "storage_config"
 
 module Capsium
   class Package
     class Storage
-      attr_reader :datasets
+      extend Forwardable
+      attr_reader :config
+
+      def_delegators :@config, :to_json
 
-      DATA_DIR = "data"
+      attr_reader :datasets
 
       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)
+                  end
         @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)
+        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
+        end
       end
 
       def save_to_file(output_path = @path)
-        File.open(output_path, "w") do |file|
-          file.write(to_json)
-        end
+        storage_config = StorageConfig.new(datasets: @datasets.map do |dataset|
+                                                       DatasetConfig.from_dataset(dataset)
+                                                     end)
+        File.write(output_path, storage_config.to_json)
       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
+        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
+      end
+
+      private
+
+      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
-        datasets
       end
     end
   end

data/lib/capsium/package/storage_config.rb

@@ -0,0 +1,9 @@
+require "shale"
+
+module Capsium
+  class Package
+    class StorageConfig < Shale::Mapper
+      attribute :datasets, DatasetConfig, collection: true
+    end
+  end
+end

data/lib/capsium/package.rb

@@ -16,7 +16,8 @@ require_relative "packager"
 
 module Capsium
   class Package
-    attr_reader :name, :path, :manifest, :metadata, :routes, :datasets, :storage
+    attr_reader :name, :path, :manifest, :metadata, :routes, :datasets,
+                :storage, :load_type
 
     MANIFEST_FILE = "manifest.json"
     METADATA_FILE = "metadata.json"
@@ -28,9 +29,10 @@ module Capsium
     DATA_DIR = "data"
     ENCRYPTED_PACKAGING_FILE = "package.enc"
 
-    def initialize(path)
+    def initialize(path, load_type: nil)
       @original_path = Pathname.new(path).expand_path
       @path = prepare_package(@original_path)
+      @load_type = load_type || determine_load_type(path)
       create_package_structure
       load_package
       @name = metadata.name
@@ -43,7 +45,6 @@ module Capsium
         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}"
@@ -70,7 +71,6 @@ module Capsium
       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)
@@ -92,9 +92,8 @@ module Capsium
 
       # Optional
       @manifest = Manifest.new(manifest_path)
-      @routes = Routes.new(routes_path, @manifest)
       @storage = Storage.new(storage_path)
-      # @datasets = load_datasets
+      @routes = Routes.new(routes_path, @manifest, @storage)
     end
 
     def cleanup
@@ -107,6 +106,19 @@ module Capsium
       @packager.package_files
     end
 
+    def content_files
+      Dir.glob(File.join(content_path, "**", "*")).select do |file|
+        File.file?(file)
+      end
+    end
+
+    def determine_load_type(path)
+      return :directory if File.directory?(path)
+      return :cap_file if File.extname(path) == ".cap"
+
+      :unsaved
+    end
+
     private
 
     def create_package_structure

data/lib/capsium/packager.rb

@@ -11,28 +11,39 @@ module Capsium
     class FileAlreadyExistsError < StandardError; end
 
     def pack(package, options = {})
-      package_name = package.metadata.name
-      package_version = package.metadata.version
-      cap_file_path = File.expand_path(
-        File.join(package.path, "..", "#{package_name}-#{package_version}.cap")
-      )
-
-      if File.exist?(cap_file_path)
-        unless options[:force]
-          raise FileAlreadyExistsError,
-                "Package target already exists, aborting: `#{relative_path_current(cap_file_path)}`"
-        end
-
+      directory = package.path
+      output_file_name = "#{package.metadata.name}-#{package.metadata.version}.cap"
+      output_directory = File.dirname(directory)
+      cap_file_path = File.join(output_directory, output_file_name)
+
+      if File.exist?(cap_file_path) && !options[:force]
+        raise FileAlreadyExistsError,
+              "Package target already exists, aborting: `#{relative_path_current(cap_file_path)}`"
+      elsif File.exist?(cap_file_path)
         puts "Package target already exists, overwriting: `#{relative_path_current(cap_file_path)}`"
         FileUtils.rm_f(cap_file_path)
       end
 
       Dir.mktmpdir do |dir|
-        FileUtils.cp_r("#{package.path}/.", dir)
+        FileUtils.cp_r("#{directory}/.", dir)
         new_package = Package.new(dir)
         new_package.solidify
-        compress_package(new_package, cap_file_path)
+        new_cap_file_path = File.join(dir, output_file_name)
+        compress_package(new_package, new_cap_file_path)
+        puts "Package built at: #{new_cap_file_path}"
+        FileUtils.mv(new_cap_file_path, cap_file_path)
         puts "Package created: #{relative_path_current(cap_file_path)}"
+        return cap_file_path
+      end
+    end
+
+    def unpack(cap_file_path, destination)
+      Zip::File.open(cap_file_path) do |zip_file|
+        zip_file.each do |entry|
+          entry_path = File.join(destination, entry.name)
+          FileUtils.mkdir_p(File.dirname(entry_path))
+          entry.extract(entry_path)
+        end
       end
     end
 
@@ -44,55 +55,6 @@ module Capsium
       end
     end
 
-    # def package_files
-    #   create_metadata_file
-    #   create_manifest_file
-    #   create_packaging_file
-
-    #   compressor = Compressor.new(@package, @package.metadata[:compression])
-    #   compressor.compress
-
-    #   protector = Protector.new(@package, @package.metadata[:encryption], @package.metadata[:signature])
-    #   protector.apply_encryption_and_sign
-    # end
-
-    # private
-
-    # def create_metadata_file
-    #   metadata_path = File.join(@package.path, Package::METADATA_FILE)
-    #   metadata_content = @package.metadata.to_h
-    #   write_json_file(metadata_path, metadata_content)
-    # end
-
-    # def create_manifest_file
-    #   manifest_path = File.join(@package.path, Package::MANIFEST_FILE)
-    #   manifest_content = {
-    #     files: Dir[File.join(@package.path, '**', '*')].reject { |f| File.directory?(f) }
-    #   }
-    #   write_json_file(manifest_path, manifest_content)
-    # end
-
-    def create_packaging_file
-      packaging_path = File.join(@package.path, Package::PACKAGING_FILE)
-      packaging_content = {
-        name: @package.name,
-        content_path: relative_path_package(@package.content_path),
-        data_path: relative_path_package(@package.data_path),
-        datasets: @package.datasets.map(&:to_h)
-      }
-      write_json_file(packaging_path, packaging_content)
-    end
-
-    def write_json_file(path, content)
-      File.open(path, "w") do |file|
-        file.write(JSON.pretty_generate(content))
-      end
-    end
-
-    def relative_path_package(absolute_path)
-      Pathname.new(absolute_path).relative_path_from(Pathname.new(@package.path)).to_s
-    end
-
     def relative_path_current(absolute_path)
       Pathname.new(absolute_path).relative_path_from(Dir.pwd).to_s
     end

data/lib/capsium/protector.rb

@@ -7,7 +7,8 @@ require "json"
 
 module Capsium
   class Protector
-    def initialize(package, encryption_metadata = nil, digital_signature_metadata = nil)
+    def initialize(package, encryption_metadata = nil,
+digital_signature_metadata = nil)
       @package = package
       @encryption_metadata = encryption_metadata
       @digital_signature_metadata = digital_signature_metadata
@@ -32,7 +33,8 @@ module Capsium
 
     def apply_encryption
       encryption = @encryption_metadata
-      data = File.read(File.join(@package.path, Package::ENCRYPTED_PACKAGING_FILE))
+      data = File.read(File.join(@package.path,
+                                 Package::ENCRYPTED_PACKAGING_FILE))
       cipher = OpenSSL::Cipher.new(encryption[:algorithm])
       cipher.encrypt
       key = cipher.random_key
@@ -54,7 +56,8 @@ module Capsium
       case key_management
       when "secure"
         # Implement secure key storage mechanism
-        File.write(File.join(@package.path, "encryption_key.secure"), Base64.encode64(key))
+        File.write(File.join(@package.path, "encryption_key.secure"),
+                   Base64.encode64(key))
       else
         raise "Unknown key management strategy: #{key_management}"
       end
@@ -69,7 +72,7 @@ module Capsium
       signature_json = {
         algorithm: @digital_signature_metadata[:algorithm],
         certificateType: @digital_signature_metadata[:certificateType],
-        signature: Base64.encode64(signature_data)
+        signature: Base64.encode64(signature_data),
       }
 
       File.write(signature_file_path, JSON.pretty_generate(signature_json))
@@ -77,9 +80,14 @@ module Capsium
     end
 
     def combined_data(encrypted_file = nil)
-      metadata_content = File.read(File.join(@package.path, Package::METADATA_FILE))
-      signature_content = File.read(signature_file_path).sub(/"signature": ".*"/, '"signature": ""')
-      package_enc_content = File.read(encrypted_file || File.join(@package.path, "#{@package.name}.enc"))
+      metadata_content = File.read(File.join(@package.path,
+                                             Package::METADATA_FILE))
+      signature_content = File.read(signature_file_path).sub(
+        /"signature": ".*"/, '"signature": ""'
+      )
+      package_enc_content = File.read(encrypted_file || File.join(
+        @package.path, "#{@package.name}.enc"
+      ))
 
       metadata_content + signature_content + package_enc_content
     end