smp_tool 0.1.0

data/lib/smp_tool/virtual_volume/utils/converter_from_volume_io.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module SMPTool
+  module VirtualVolume
+    module Utils
+      #
+      # Converts volume IO to the virtual volume.
+      #
+      module ConverterFromVolumeIO
+        class << self
+          private
+
+          def _volume_data(entries, data, extra_word)
+            VolumeData.new(
+              _data_entries(entries, data),
+              extra_word
+            )
+          end
+
+          def _data_entries(entries, data)
+            entries.each_with_index.map do |e, i|
+              DataEntry.new(
+                header: DataEntryHeader.new(e.snapshot.to_h),
+                data: data[i]
+              )
+            end
+          end
+
+          # Extra word value is defined by the target BASIC version,
+          # and the target BASIC version can be identified by the
+          # number of extra bytes per entry (and vice versa).
+          def _choose_extra_word(n_extra_bytes_per_entry)
+            case n_extra_bytes_per_entry
+            when 0
+              Basic10::ENTRY_EXTRA_WORD
+            else
+              Basic20::ENTRY_EXTRA_WORD
+            end
+          end
+
+          def _build_volume_params(volume_io)
+            VirtualVolume::VolumeParams.new(
+              n_clusters_allocated: volume_io.n_clusters_allocated.to_i,
+              n_extra_bytes_per_entry: volume_io.n_extra_bytes_per_entry.to_i,
+              n_dir_segs: volume_io.n_dir_segs.to_i,
+              n_clusters_per_dir_seg: volume_io.n_clusters_per_dir_seg.to_i,
+              extra_word: _choose_extra_word(volume_io.n_extra_bytes_per_entry)
+            )
+          end
+
+          def _read_entries(volume_io)
+            volume_io.directory.segments.to_ary.flat_map(&:dir_seg_entries)
+                     .reject { |e| e.status == DIR_SEG_FOOTER }
+          end
+        end
+
+        def self.read_io(io)
+          read_volume_io(
+            SMPTool::VolumeIO::VolumeIO.read(io)
+          )
+        end
+
+        def self.read_volume_io(volume_io)
+          entries = _read_entries(volume_io)
+          data = volume_io.data.to_ary
+
+          raise ArgumentError, "entries => data lengths mismatch" unless entries.length == data.length
+
+          volume_params = _build_volume_params(volume_io)
+
+          VirtualVolume::Volume.new(
+            bootloader: volume_io.bootloader.bytes.to_ary,
+            home_block: volume_io.home_block.bytes.to_ary,
+            volume_params: volume_params,
+            volume_data: _volume_data(entries, data, volume_params.extra_word)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/smp_tool/virtual_volume/utils/converter_to_volume_io.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module SMPTool
+  module VirtualVolume
+    module Utils
+      #
+      # Converts virtual volume to the volume IO.
+      #
+      class ConverterToVolumeIO
+        def initialize(volume)
+          @bootloader = volume.bootloader
+          @home_block = volume.home_block
+          @n_clusters_allocated = volume.n_clusters_allocated
+          @n_extra_bytes_per_entry = volume.n_extra_bytes_per_entry
+          @n_clusters_per_dir_seg = volume.n_clusters_per_dir_seg
+          @n_max_entries_per_dir_seg = volume.n_max_entries_per_dir_seg
+          @n_dir_segs = volume.n_dir_segs
+
+          @data = _group_entries(volume.data)
+
+          @data_offset = N_SYS_CLUSTERS + @n_dir_segs * @n_clusters_per_dir_seg
+        end
+
+        def call
+          VolumeIO::VolumeIO.new(
+            bootloader: _build_bootloader,
+            home_block: _build_home_block,
+            directory: _build_directory,
+            data: _build_data,
+            n_clusters_allocated: @n_clusters_allocated
+          )
+        end
+
+        private
+
+        def _build_data
+          @data.flatten.map do |e|
+            VolumeIO::FileContent.new(
+              e.data
+            )
+          end
+        end
+
+        def _group_entries(arr)
+          result = arr.each_slice(@n_max_entries_per_dir_seg).to_a
+          diff = @n_dir_segs - result.length
+          diff.times { result << [] }
+          result
+        end
+
+        def _build_bootloader
+          VolumeIO::Bootloader.new(bytes: @bootloader)
+        end
+
+        def _build_home_block
+          VolumeIO::HomeBlock.new(bytes: @home_block)
+        end
+
+        def _build_directory
+          segments = (1..@n_dir_segs).map do |i_dir_seg|
+            _build_dir_seg(i_dir_seg, _build_dir_seg_entries(i_dir_seg))
+          end
+
+          VolumeIO::Directory.new(
+            segments: segments
+          )
+        end
+
+        def _build_dir_seg_entries(i_dir_seg)
+          @data[i_dir_seg - 1]
+            .map { |e| _build_dir_entry(e) }
+            .push(_build_dir_seg_footer)
+        end
+
+        def _build_dir_entry(v_entry)
+          VolumeIO::DirEntry.new(
+            status: v_entry.status,
+            filename: v_entry.filename,
+            n_clusters: v_entry.n_clusters,
+            ch_job: v_entry.ch_job,
+            date: v_entry.date,
+            extra_word: v_entry.extra_word
+          )
+        end
+
+        def _build_dir_seg(i_dir_seg, dir_seg_entries)
+          i_next_seg = i_dir_seg == @n_dir_segs ? 0 : i_dir_seg + 1
+
+          dir_seg = VolumeIO::DirSeg.new(
+            header: _build_header(
+              i_next_seg: i_next_seg,
+              data_offset: @data_offset
+            ),
+            dir_seg_entries: dir_seg_entries
+          )
+
+          _upd_data_offset(i_dir_seg)
+
+          dir_seg
+        end
+
+        def _upd_data_offset(i_dir_seg)
+          n_clustes_in_files = @data[i_dir_seg - 1].sum(&:n_clusters)
+
+          @data_offset += n_clustes_in_files
+        end
+
+        def _build_header(i_next_seg:, data_offset:)
+          VolumeIO::DirSegHeader.new(
+            n_dir_segs: @n_dir_segs,
+            i_next_seg: i_next_seg,
+            n_extra_bytes_per_entry: @n_extra_bytes_per_entry,
+            data_offset: data_offset
+          )
+        end
+
+        def _build_dir_seg_footer
+          VolumeIO::DirEntry.new(
+            status: DIR_SEG_FOOTER
+          )
+        end
+      end
+    end
+  end
+end

data/lib/smp_tool/virtual_volume/utils/empty_vol_data_initializer.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module SMPTool
+  module VirtualVolume
+    module Utils
+      #
+      # Initializes empty data for a volume with the given params.
+      #
+      module EmptyVolDataInitializer
+        #
+        # Initialize empty data.
+        #
+        # @param [Hash{ Symbol => Object }] volume_params
+        #
+        # @return [VolumeData]
+        #
+        def self.call(volume_params)
+          n_data_clusters = volume_params.n_clusters_allocated -
+                            N_SYS_CLUSTERS -
+                            (volume_params.n_dir_segs * volume_params.n_clusters_per_dir_seg)
+
+          data = VolumeData.new(
+            [],
+            volume_params.extra_word
+          )
+
+          data.push_empty_entry(n_data_clusters)
+        end
+      end
+    end
+  end
+end

data/lib/smp_tool/virtual_volume/utils/file_converter.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module SMPTool
+  module VirtualVolume
+    module Utils
+      #
+      # Converts hashes to data entry objects.
+      #
+      class FileConverter
+        def initialize(f_hash, extra_word, &block)
+          str = _process_data(f_hash[:data], &block)
+          @n_clusters = _calc_n_clusters(str)
+          @data = str.ljust(@n_clusters * CLUSTER_SIZE, PAD_CHR)
+
+          @filename = f_hash[:filename]
+          @extra_word = extra_word
+        end
+
+        def call
+          DataEntry.new(
+            header: _make_header,
+            data: @data
+          )
+        end
+
+        private
+
+        def _make_header
+          DataEntryHeader.new(
+            status: PERM_ENTRY,
+            filename: Filename.new(ascii: @filename).radix50,
+            n_clusters: @n_clusters,
+            ch_job: DEF_CH_JOB,
+            date: DEF_DATE,
+            extra_word: @extra_word
+          )
+        end
+
+        def _process_data(arr, &block)
+          arr.map(&block)
+             .join("\r\n")
+             .prepend(0x0A.chr)
+             .prepend(0x0D.chr)
+             .concat(0x0D.chr)
+             .concat(0x0A.chr)
+             .concat(0x00.chr)
+        end
+
+        def _calc_n_clusters(str)
+          (str.length.to_f / CLUSTER_SIZE).ceil
+        end
+      end
+    end
+  end
+end

data/lib/smp_tool/virtual_volume/utils/file_extracter.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module SMPTool
+  module VirtualVolume
+    module Utils
+      #
+      # Extracts files.
+      #
+      class FileExtracter
+        def initialize(data)
+          @data = data.reject { |e| e.status == EMPTY_ENTRY }
+        end
+
+        #
+        # Extract file as is.
+        #
+        # @param [Filename] file_id
+        #
+        # @return [FileInterface]
+        #
+        def f_extract_raw(file_id)
+          FileInterface.new(
+            filename: file_id.print_ascii,
+            data: _extract_raw_data(file_id)
+          )
+        end
+
+        #
+        # Extract file as array of strings.
+        #
+        # @param [Filename] file_id
+        #
+        # @yield [str]
+        #
+        # @return [FileInterface]
+        #
+        def f_extract_txt(file_id, &block)
+          FileInterface.new(
+            filename: file_id.print_ascii,
+            data: _text_data(file_id, &block)
+          )
+        end
+
+        private
+
+        #
+        # Extract file content as an array of strings.
+        #
+        # @param [Filename] id
+        #
+        # @yield [str]
+        #
+        # @return [Array<Strings>]
+        #   Line by line content of the file.
+        #
+        def _text_data(id, &block)
+          _payload(id).split("\r\n")
+                      .reject(&:empty?)
+                      .map(&block)
+        end
+
+        #
+        # Return payload of a file.
+        #
+        # @param [Filename] id
+        #
+        # @return [String]
+        #
+        def _payload(id)
+          _extract_raw_data(id).split(/\x00/).first
+        end
+
+        #
+        # Extract raw data of a file.
+        #
+        # @param [Filename]
+        #
+        # @return [String]
+        #
+        def _extract_raw_data(id)
+          index = @data.find_index { |e| e.filename == id.radix50 }
+
+          raise ArgumentError, "File '#{id.ascii}' not found in the volume" unless index
+
+          @data[index].data
+        end
+      end
+    end
+  end
+end

data/lib/smp_tool/virtual_volume/utils/volume_params_validator.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module SMPTool
+  module VirtualVolume
+    module Utils
+      #
+      # Validates virtual volume params.
+      #
+      module VolumeParamsValidator
+        def self.call(params)
+          result = VolumeParamsContract.new.call(params)
+
+          raise ArgumentError, result.errors.to_h.to_a.join(": ") unless result.success?
+
+          result.schema_result.output
+        end
+      end
+    end
+  end
+end

data/lib/smp_tool/virtual_volume/utils.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module SMPTool
+  module VirtualVolume
+    #
+    # Namespace for utils to manipulate the virtual volume.
+    #
+    module Utils; end
+  end
+end

data/lib/smp_tool/virtual_volume/volume.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+module SMPTool
+  module VirtualVolume
+    #
+    # Ruby representation of the volume.
+    #
+    class Volume
+      extend Forwardable
+
+      def_delegators :@volume_params, :n_clusters_allocated, :n_extra_bytes_per_entry, :n_dir_segs,
+                     :n_clusters_per_dir_seg, :extra_word, :n_max_entries_per_dir_seg, :n_max_entries
+
+      attr_reader :bootloader, :home_block, :volume_params, :data
+
+      def self.read_volume_io(volume_io)
+        Utils::ConverterFromVolumeIO.read_volume_io(volume_io)
+      end
+
+      def self.read_io(volume_io)
+        Utils::ConverterFromVolumeIO.read_io(volume_io)
+      end
+
+      #
+      # Create new virtual volume.
+      #
+      # @param [Array<Integer>] bootloader
+      # @param [Array<Integer>] home_block
+      # @param [VolumeParams] volume_params
+      # @param [VolumeData, nil] volume_data
+      #   Existing volume data (parsed from an existing VolumeIO obj) or nil.
+      #   Nil indicates that an empty volume should be created, and empty data
+      #   must be initialized.
+      #
+      def initialize(bootloader:, home_block:, volume_params:, volume_data: nil)
+        @bootloader = bootloader
+        @home_block = home_block
+
+        @volume_params = volume_params
+        @data = volume_data || Utils::EmptyVolDataInitializer.call(@volume_params)
+      end
+
+      def snapshot
+        {
+          volume_params: @volume_params.snapshot,
+          volume_data: @data.snapshot,
+          n_free_clusters: @data.calc_n_free_clusters
+        }
+      end
+
+      #
+      # Convert `self` to a VolumeIO object.
+      #
+      # @return [VolumeIO]
+      #
+      def to_volume_io
+        Utils::ConverterToVolumeIO.new(self).call
+      end
+
+      #
+      # Convert `self` to a binary string. Write this string to a binary file
+      # to get a MK90 volume that works on an emulator or on a real machine.
+      #
+      # @return [String]
+      #
+      def to_binary_s
+        to_volume_io.to_binary_s
+      end
+
+      #
+      # Allocate more clusters to the volume or trim free clusters.
+      #
+      # @param [Integer] n_clusters
+      #   Number of clusters to add (pos. int.) or to trim (neg. int.).
+      #
+      # @return [Integer]
+      #   Number of clusters that were added/trimmed.
+      #
+      def resize(n_clusters)
+        if n_clusters.positive?
+          _resize_validate_pos_input(n_clusters)
+        elsif n_clusters.negative?
+          _resize_validate_neg_input(n_clusters)
+        else
+          return n_clusters
+        end
+
+        _resize(n_clusters)
+      end
+
+      #
+      # Push a file to the volume.
+      #
+      # @param [FileInterface, Hash{ Symbol => Object }] file_obj
+      #
+      # @yield [str]
+      #   Each line of a file gets passed through this block. The default block encodes
+      #   a string from the UTF-8 to the KOI-7, but a custom block allows to alter this
+      #   behavior (e.g. when the file is already in the KOI-7 encoding).
+      #
+      # @return [String]
+      #   ASCII filename of the pushed file.
+      #
+      def f_push(file_obj, &block)
+        block = ->(str) { InjalidDejice.utf_to_koi(str, forced_latin: "\"") } unless block_given?
+
+        _f_push(file_obj, &block)
+      end
+
+      #
+      # Extract content of a file as an array of strings.
+      #
+      # @param [<String>] filename
+      #   ASCII filename of the file to extract.
+      #
+      # @yield [str]
+      #   Each line of a file gets passed through this block. The default block decodes
+      #   a string from the KOI-7 to the UTF-8, but a custom block allows to alter this
+      #   behavior.
+      #
+      # @return [FileInterface]
+      #
+      def f_extract_txt(filename, &block)
+        block = ->(str) { InjalidDejice.koi_to_utf(str) } unless block_given?
+
+        Utils::FileExtracter.new(@data).f_extract_txt(
+          Filename.new(ascii: filename),
+          &block
+        )
+      end
+
+      #
+      # Extract all files as arrays of strings.
+      #
+      # @return [Array<FileInterface>]
+      #
+      def f_extract_txt_all
+        _all_filenames.map { |fn| f_extract_txt(fn) }
+      end
+
+      #
+      # Extract content of a file as a 'raw' string (as is).
+      #
+      # @param [<String>] filename
+      #   ASCII filename of the file to extract.
+      #
+      # @return [FileInterface]
+      #
+      def f_extract_raw(filename)
+        Utils::FileExtracter.new(@data).f_extract_raw(
+          Filename.new(ascii: filename)
+        )
+      end
+
+      #
+      # Extract all files as 'raw' strings.
+      #
+      # @return [Array<FileInterface>]
+      #
+      def f_extract_raw_all
+        _all_filenames.map { |fn| f_extract_raw(fn) }
+      end
+
+      #
+      # Rename a file.
+      #
+      # @param [<String>] old_filename
+      # @param [<String>] new_filename
+      #
+      # @return [Array<String>]
+      #   Old and new ASCII filenames of a renamed file.
+      #
+      def f_rename(old_filename, new_filename)
+        @data.f_rename(
+          Filename.new(ascii: old_filename),
+          Filename.new(ascii: new_filename)
+        )
+      end
+
+      #
+      # Delete a file.
+      #
+      # @param [<String>] filename
+      #
+      # @return [String]
+      #   ASCII filename of a deleted file.
+      #
+      def f_delete(filename)
+        @data.f_delete(Filename.new(ascii: filename))
+      end
+
+      #
+      # Consolidate all free space at the end ot the volume.
+      #
+      # @return [Integer]
+      #   Number of free clusters that were joined.
+      #
+      def squeeze
+        @data.squeeze
+      end
+
+      private
+
+      def _all_filenames
+        @data.reject { |e| e.status == EMPTY_ENTRY }
+             .map { |e| e.header.print_ascii_filename }
+      end
+
+      def _resize_validate_pos_input(n_delta_clusters)
+        _check_dir_overflow
+
+        return if n_delta_clusters + @volume_params.n_clusters_allocated <= N_CLUSTERS_MAX
+
+        raise ArgumentError, "Volume size can't be more than #{N_CLUSTERS_MAX} clusters"
+      end
+
+      def _resize_validate_neg_input(n_delta_clusters)
+        n_free_clusters = @data.calc_n_free_clusters
+
+        return if n_delta_clusters.abs <= n_free_clusters
+
+        raise ArgumentError, "Can't trim more than #{n_free_clusters} clusters"
+      end
+
+      def _resize(n_clusters)
+        @volume_params.n_clusters_allocated += n_clusters
+        @data.resize(n_clusters)
+      end
+
+      def _check_dir_overflow
+        raise ArgumentError, "Directory table is full" if @data.length >= @volume_params.n_max_entries
+      end
+
+      def _f_push(f_hash, &block)
+        @data.squeeze
+
+        _check_dir_overflow
+
+        file = SMPTool::VirtualVolume::Utils::FileConverter.new(
+          f_hash,
+          @volume_params.extra_word,
+          &block
+        ).call
+
+        @data.f_push(file)
+      end
+    end
+  end
+end