badline 0.9.0 → 0.10.1

data/lib/badline/frontend/app.rb

@@ -3,12 +3,10 @@
 module Badline
   module Frontend
     # Opens the window, then runs the machine a frame at a time: poll
-    # events, clock the frame's cycles, queue the SID's samples, upload the
+    # events, clock the frame's cycles, queue the sound's samples, upload the
     # changed lines, present and wait. Pacer decides the cycles and the wait.
     class App
-      SCALE = 2
       DROPFILE = 0x1000
-      TITLE = "Badline"
 
       # Takes the frame limit, the pacing, the snapshot path, the sound and
       # the verbosity from Options, and runs the timeline's events.
@@ -16,17 +14,21 @@ module Badline
         @computer = computer
         @frame_limit = options.frames
         @verbose = options.verbose?
-        @pacer = Pacer.new(paced: options.paced?, vsync: options.vsync?, verbose: @verbose, region: computer.region)
+        timing = computer.timing
+        @pacer = Pacer.new(paced: options.paced?, vsync: options.vsync?, verbose: @verbose, timing:)
         @timeline = timeline
         @snapshots = Snapshots.new(computer, options)
-        @screen = Screen.new(computer.vic)
+        @screen = Screen.new(computer.video, timing.crop)
         @led = DriveLed.for(computer)
         @controls = Controls.new(computer)
-        open_window
-        @sound = Sound.new(computer.sid, computer.region.clock_hz, options.sound?, @verbose)
+        @window = MachineWindow.new(@screen, timing.pixel_width, vsync: @pacer.vsync?)
+        @pacer.fit(@window.refresh_rate) if @pacer.vsync?
+        @sound = Sound.new(computer.sound_source, timing.clock_hz, options.sound?, @verbose)
         @gamepads = Gamepads.new(computer, @verbose)
         @frame_report = FrameReport.new(@sound)
-        @menu = PauseMenu.new(Painter.new(@renderer), options, @snapshots)
+        @menu = PauseMenu.new(Painter.new(@window.renderer), options, @snapshots)
+        @menu.center(@window.width, @window.height)
+        @scripted = false
       end
 
       def run
@@ -39,7 +41,7 @@ module Badline
         @computer.drive1541&.flush
         @gamepads.close
         @sound.close
-        close_window
+        @window.close
       end
 
       private
@@ -70,36 +72,20 @@ module Badline
         @running = false if @frames == @frame_limit || @timeline.quit?(@frames)
         @pacer.check(Pacer::EARLY_CHECK, stamps.last - @started, stamps.last) if @frames == Pacer::EARLY_CHECK
         report(stamps.last) if (@frames % 50).zero?
-      end
-
-      def open_window
-        abort "SDL_Init: #{SDL.SDL_GetError}" unless SDL.SDL_Init(SDL::INIT_VIDEO | SDL::INIT_EVENTS).zero?
-
-        SDL.SDL_SetHint("SDL_RENDER_SCALE_QUALITY", "0")
-        SDL.SDL_SetHint("SDL_MOUSE_RELATIVE_SCALING", "0")
-        @window = SDL.SDL_CreateWindow(
-          TITLE, SDL::WINDOWPOS_CENTERED, SDL::WINDOWPOS_CENTERED,
-          Screen::WIDTH * SCALE, Screen::HEIGHT * SCALE, SDL::WINDOW_RESIZABLE
-        )
-        flags = SDL::RENDERER_ACCELERATED
-        flags |= SDL::RENDERER_PRESENTVSYNC if @pacer.vsync?
-        @renderer = SDL.SDL_CreateRenderer(@window, -1, flags)
-        fit_display if @pacer.vsync?
-        SDL.SDL_RenderSetLogicalSize(@renderer, Screen::WIDTH, Screen::HEIGHT)
-        create_texture
-      end
-
-      def create_texture
-        @texture = SDL.SDL_CreateTexture(
-          @renderer, SDL::PIXELFORMAT_RGB888, SDL::TEXTUREACCESS_STREAMING, Screen::WIDTH, Screen::HEIGHT
-        )
-      end
-
-      def close_window
-        SDL.SDL_DestroyTexture(@texture)
-        SDL.SDL_DestroyRenderer(@renderer)
-        SDL.SDL_DestroyWindow(@window)
-        SDL.SDL_Quit
+        menu_events
+      end
+
+      # Opens the menu at a menu event, on the page it names, and closes it
+      # at a resume. While the timeline holds it open, its frames count
+      # towards the events after it and --frames.
+      def menu_events
+        if @timeline.menu?(@frames)
+          @menu.section = @timeline.menu_section(@frames)
+          open_menu
+          @scripted = true
+        elsif @menu.open? && @timeline.resume?(@frames)
+          resume(false)
+        end
       end
 
       def handle_events
@@ -137,11 +123,14 @@ module Badline
       # it.
       def swap(computer)
         @computer = computer
-        @screen = Screen.new(computer.vic)
+        timing = computer.timing
+        @screen = Screen.new(computer.video, timing.crop)
+        @window.fit(@screen, timing.pixel_width)
+        @menu.center(@window.width, @window.height)
         @led = DriveLed.for(computer)
         @controls.computer = computer
         @gamepads.computer = computer
-        @sound.switch(computer.sid, computer.region.clock_hz)
+        @sound.switch(computer.sound_source, timing.clock_hz)
         @snapshots.computer = computer
       end
 
@@ -162,6 +151,7 @@ module Badline
       # pressing the cartridge's freeze button if asked.
       def resume(freeze)
         @menu.close
+        @scripted = false
         SDL.SDL_SetRelativeMouseMode(@controls.pot_device? ? 1 : 0)
         @timeline.press_freeze(@computer, @frames) if freeze
         @reported = now
@@ -170,50 +160,58 @@ module Badline
       end
 
       # Runs a frame of the menu, which has the keys and the mouse while the
-      # machine stands still.
+      # machine stands still. A menu the timeline opened counts its frames
+      # and takes their screenshots.
       def paused_frame
-        action = @menu.frame(@renderer, @texture, @controls)
+        scripted = @scripted
+        action = @menu.frame(@window.renderer, @window.texture, @controls)
+        present_menu(scripted)
         if action == :quit
           @running = false
         elsif !action.nil?
           swap(@menu.computer) if action == :swap
           resume(action == :freeze)
         end
+        finish_paused_frame if scripted && @running
       end
 
-      def update_title
-        title = TITLE
-        title += " [#{@controls.tag}]" unless @controls.tag.empty?
-        title += " [MUTED]" if @sound.muted?
-        SDL.SDL_SetWindowTitle(@window, title)
+      def present_menu(scripted)
+        renderer = @window.renderer
+        @timeline.screenshots(@frames + 1).each { |path| Screenshot.write(renderer, path) } if scripted
+        SDL.SDL_RenderPresent(renderer)
+        SDL.SDL_Delay(10)
+      end
+
+      def finish_paused_frame
+        @frames += 1
+        @timeline.run(@computer, @frames)
+        @running = false if @frames == @frame_limit || @timeline.quit?(@frames)
+        menu_events
       end
 
-      def fit_display
-        SDL.SDL_GetWindowDisplayMode(@window, SDL.display_mode)
-        @pacer.fit(SDL.mode_refresh(SDL.display_mode))
+      def update_title
+        tags = []
+        tags << @controls.tag unless @controls.tag.empty?
+        tags << "MUTED" if @sound.muted?
+        @window.title(tags)
       end
 
       def emulate
-        computer = @computer
-        cycles = @pacer.cycles(@sound)
-        i = 0
-        while i < cycles
-          computer.cycle!
-          i += 1
-        end
+        @computer.run_cycles(@pacer.cycles(@sound))
       end
 
       def upload
         @screen.update
-        SDL.SDL_UpdateTexture(@texture, nil, @screen.pixels, Screen::ROW_BYTES)
+        @window.upload(@screen)
       end
 
       def draw
-        SDL.SDL_RenderClear(@renderer)
-        SDL.SDL_RenderCopy(@renderer, @texture, nil, nil)
-        @led&.draw(@renderer)
-        @timeline.screenshots(@frames + 1).each { |path| Screenshot.write(@renderer, path) }
-        SDL.SDL_RenderPresent(@renderer)
+        renderer = @window.renderer
+        SDL.SDL_RenderClear(renderer)
+        SDL.SDL_RenderCopy(renderer, @window.texture, nil, nil)
+        @led&.draw(renderer, @window.width, @window.height)
+        @timeline.screenshots(@frames + 1).each { |path| Screenshot.write(renderer, path) }
+        SDL.SDL_RenderPresent(renderer)
       end
 
       def report(at)

data/lib/badline/frontend/boot.rb

@@ -21,7 +21,7 @@ module Badline
       rescue Media::TrueDrive::Error, Storage::SIDFile::FormatError, Storage::T64::FormatError,
              Storage::TAP::FormatError, Storage::CRTFile::FormatError, Storage::G64Image::FormatError,
              Cartridge::UnsupportedTypeError, Snapshot::FormatError, Media::DiskList::Error,
-             Datasette::Missing => e
+             Datasette::Missing, Unsupported => e
         warn "#{options.program}: #{options.media_path}: #{e.message}"
         return 1
       end
@@ -45,14 +45,11 @@ module Badline
 
     # A new machine built from the options, with `media`, if not nil,
     # attached and started as the command line does, its disk writable if
-    # `writable`. The model gives the chips, and a .sid tune or --sid the
-    # SID.
+    # `writable`. The family and model give the machine, and a .sid tune
+    # or --sid the SID. The VIC-20 raises Unsupported for a .sid
+    # tune.
     def self.start(options, media, writable)
-      model = Model.named(options.model)
-      computer = Computer.new(vic_model: model.vic_model, cia_model: model.cia_model,
-                              sid_model: options.sid_model || Media.sid_model(media, otherwise: model.sid_model),
-                              region: model.region, reu: options.reu, kernal: model.kernal,
-                              datasette: model.datasette)
+      computer = options.family == :vic20 ? vic20(options, media) : c64(options, media)
       Media::TrueDrive.plug(computer) if options.true_drive?
       unless media.nil?
         puts Media.attach(computer, media, autostart: options.autostart?, subtune: options.subtune,
@@ -60,5 +57,33 @@ module Badline
       end
       computer
     end
+
+    def self.c64(options, media)
+      sid_model = options.sid_model || Media.sid_model(media, otherwise: nil)
+      Machine.build(:c64, model: options.model, sid_model:, reu: options.reu)
+    end
+
+    # A VIC-20 with the RAM --ram names, or else the RAM `media` needs
+    # (Media::Vic20Media.ram_for), which it says. Raises Unsupported for
+    # media a VIC-20 doesn't take.
+    def self.vic20(options, media)
+      ram = options.ram
+      unless media.nil?
+        unsupported = Media::Vic20Media::UNSUPPORTED.include?(File.extname(media).downcase)
+        raise Unsupported, "doesn't go in a VIC-20" if unsupported
+
+        ram ||= vic20_ram(media)
+      end
+      Machine.build(:vic20, model: options.model, ram:)
+    end
+
+    def self.vic20_ram(media)
+      ram = Media::Vic20Media.ram_for(media)
+      puts "RAM expansion: #{ram}"
+      ram
+    end
+
+    # Media the machine the options name doesn't take.
+    class Unsupported < ArgumentError; end
   end
 end

data/lib/badline/frontend/controls.rb

@@ -4,11 +4,11 @@ module Badline
   module Frontend
     # Routes host input to the machine. Two settings decide where it goes:
     #
-    # - The keys: every host key goes to the C64 keyboard, or, as Tab
+    # - The keys: every host key goes to the machine's keyboard, or, as Tab
     #   switches, the arrow cluster and space drive one joystick and WASD
     #   and left shift the other. The arrows start on joystick 2, and
-    #   #swap_ports swaps them.
-    # - A pot device the pause menu plugs into a control port: a 1351
+    #   #swap_ports swaps them. The VIC-20's one joystick takes both.
+    # - A pot device the pause menu plugs into a C64 control port: a 1351
     #   mouse or a pair of paddles, which the host mouse drives. Motion
     #   turns the paddles or moves the mouse, and the host's left and right
     #   buttons go to whichever lines the device puts them on.
@@ -65,7 +65,7 @@ module Badline
       # The title bar's tag for the settings, empty for the keyboard alone.
       def tag
         tags = []
-        tags << "JOY #{@arrows_port}" if @joystick
+        tags << (@computer.family == :vic20 ? "JOY" : "JOY #{@arrows_port}") if @joystick
         tags << TAGS[POTS.index(@pot)] if pot_device?
         tags.join(", ")
       end
@@ -105,7 +105,7 @@ module Badline
       # RESTORE isn't in the key matrix, so it goes to the machine instead.
       def c64_key(key, down)
         if key == :restore
-          @computer.press_restore if down
+          down ? @computer.press_restore : @computer.release_restore
         else
           down ? @computer.keyboard.press(key) : @computer.keyboard.release(key)
         end
@@ -113,9 +113,15 @@ module Badline
 
       def paddles? = POTS.index(@pot) >= 3
 
-      # A fresh pot device on its port, and none on the other.
+      # A fresh pot device on its port, and none on the other. A machine
+      # without the ports takes none.
       def attach_pot_device
         ports = @computer.control_ports
+        if ports.nil?
+          @pot = :none
+          return
+        end
+
         ports.device1 = nil
         ports.device2 = nil
         return unless pot_device?

data/lib/badline/frontend/drive_led.rb

@@ -8,8 +8,6 @@ module Badline
     class DriveLed
       WIDTH = 12
       HEIGHT = 4
-      LEFT = Screen::WIDTH - WIDTH - 8
-      TOP = Screen::HEIGHT - HEIGHT - 6
 
       LIT = [0xff, 0x20, 0x20].freeze
       DARK = [0x40, 0x00, 0x00].freeze
@@ -20,11 +18,12 @@ module Badline
         drive ? new(drive) : nil
       end
 
-      # Sets SDL.led_rect to where the LED goes.
-      def self.place
+      # Sets SDL.led_rect to where the LED goes on a screen `width` by
+      # `height`.
+      def self.place(width, height)
         rect = SDL.led_rect
-        SDL.rect_x(rect, LEFT)
-        SDL.rect_y(rect, TOP)
+        SDL.rect_x(rect, width - WIDTH - 8)
+        SDL.rect_y(rect, height - HEIGHT - 6)
         SDL.rect_w(rect, WIDTH)
         SDL.rect_h(rect, HEIGHT)
       end
@@ -37,10 +36,10 @@ module Badline
 
       def color = lit? ? LIT : DARK
 
-      # Fills the LED's rectangle in its colour, then puts back the black
-      # that RenderClear clears with.
-      def draw(renderer)
-        DriveLed.place
+      # Fills the LED's rectangle on a screen `width` by `height` in its
+      # colour, then puts back the black that RenderClear clears with.
+      def draw(renderer, width, height)
+        DriveLed.place(width, height)
         rgb = color
         SDL.SDL_SetRenderDrawColor(renderer, rgb[0], rgb[1], rgb[2], 255)
         SDL.SDL_RenderFillRect(renderer, SDL.led_rect)

data/lib/badline/frontend/frame_rate.rb

@@ -31,10 +31,10 @@ module Badline
 
       attr_reader :base_cycles, :seconds, :refresh, :trim
 
-      # One frame of the region's raster.
-      def self.machine(region)
-        cycles = region.cycles_per_line * region.lines_per_frame
-        new(cycles, cycles.to_f / region.clock_hz, 0, region.clock_hz)
+      # One frame of the machine's raster, from its Timing.
+      def self.machine(timing)
+        cycles = timing.cycles_per_line * timing.lines_per_frame
+        new(cycles, cycles.to_f / timing.clock_hz, 0, timing.clock_hz)
       end
 
       def self.display(refresh, clock_hz)

data/lib/badline/frontend/machine_window.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The emulator's SDL window, its renderer and the streaming texture a
+    # Screen's pixels go into. The renderer's logical size is the screen's,
+    # with each of its pixels `pixel_width` square pixels wide, so the
+    # picture keeps the machine's aspect while the menu and the drive LED
+    # draw in square pixels over it. The window opens at SCALE times that.
+    class MachineWindow
+      SCALE = 2
+      TITLE = "Badline"
+
+      # The logical size, in square pixels.
+      attr_reader :width, :height
+
+      attr_reader :renderer, :texture
+
+      # Opens the window for `screen`, presenting in step with the display
+      # when `vsync`.
+      def initialize(screen, pixel_width, vsync:)
+        abort "SDL_Init: #{SDL.SDL_GetError}" unless SDL.SDL_Init(SDL::INIT_VIDEO | SDL::INIT_EVENTS).zero?
+
+        SDL.SDL_SetHint("SDL_RENDER_SCALE_QUALITY", "0")
+        SDL.SDL_SetHint("SDL_MOUSE_RELATIVE_SCALING", "0")
+        measure(screen, pixel_width)
+        @window = SDL.SDL_CreateWindow(
+          TITLE, SDL::WINDOWPOS_CENTERED, SDL::WINDOWPOS_CENTERED, @width * SCALE, @height * SCALE,
+          SDL::WINDOW_RESIZABLE
+        )
+        flags = SDL::RENDERER_ACCELERATED
+        flags |= SDL::RENDERER_PRESENTVSYNC if vsync
+        @renderer = SDL.SDL_CreateRenderer(@window, -1, flags)
+        create_texture
+      end
+
+      # The refresh rate of the display the window is on, in Hz.
+      def refresh_rate
+        SDL.SDL_GetWindowDisplayMode(@window, SDL.display_mode)
+        SDL.mode_refresh(SDL.display_mode)
+      end
+
+      # Fits the texture, the logical size and the window to another
+      # machine's screen, unless it measures the same.
+      def fit(screen, pixel_width)
+        before = [@width, @height, @texture_width]
+        measure(screen, pixel_width)
+        return if before == [@width, @height, @texture_width]
+
+        SDL.SDL_DestroyTexture(@texture)
+        create_texture
+        SDL.SDL_SetWindowSize(@window, @width * SCALE, @height * SCALE)
+      end
+
+      def upload(screen)
+        SDL.SDL_UpdateTexture(@texture, nil, screen.pixels, screen.row_bytes)
+      end
+
+      # Titles the window, TITLE followed by `tags` in brackets.
+      def title(tags)
+        SDL.SDL_SetWindowTitle(@window, ([TITLE] + tags.map { |tag| "[#{tag}]" }).join(" "))
+      end
+
+      def close
+        SDL.SDL_DestroyTexture(@texture)
+        SDL.SDL_DestroyRenderer(@renderer)
+        SDL.SDL_DestroyWindow(@window)
+        SDL.SDL_Quit
+      end
+
+      private
+
+      def measure(screen, pixel_width)
+        @texture_width = screen.width
+        @width = screen.width * pixel_width
+        @height = screen.height
+      end
+
+      def create_texture
+        SDL.SDL_RenderSetLogicalSize(@renderer, @width, @height)
+        @texture = SDL.SDL_CreateTexture(
+          @renderer, SDL::PIXELFORMAT_RGB888, SDL::TEXTUREACCESS_STREAMING, @texture_width, @height
+        )
+      end
+    end
+  end
+end

data/lib/badline/frontend/menu_media.rb

@@ -4,17 +4,17 @@ module Badline
   module Frontend
     # What the pause menu puts in the machine and takes out: disks, tapes
     # and cartridges, whether disks are writable, which carries over from
-    # one disk to the next, and the disk's set, which PREVIOUS and NEXT step
-    # through: the .m3u or .vfl list it came from, while that lists it, or
-    # the set DiskSet finds. It keeps what last went wrong for the page to
-    # show.
+    # one disk to the next, and the set of the disk in device 8, which
+    # PREVIOUS and NEXT step through: the .m3u or .vfl list it came from,
+    # while that lists it, or the set DiskSet finds. It keeps what last went
+    # wrong for the page to show.
     class MenuMedia
-      attr_reader :disk_path, :problem
+      attr_reader :problem
       attr_writer :computer
 
-      # Starts on the disk the command line's `media_path` put in.
+      # Takes the disk set from the command line's `media_path` when it's a
+      # list.
       def initialize(media_path, writable)
-        @disk_path = PauseMenu.disk_path(media_path)
         @list = Media::DiskList.list?(media_path) ? media_path : ""
         @writable = writable
         @set_path = ""
@@ -25,26 +25,40 @@ module Badline
 
       def writable? = @writable
 
+      # The expanded path of the disk in device 8, however it went in, or
+      # an empty one.
+      def disk_path
+        drive = @computer.drive1541
+        unless drive.nil?
+          disk = drive.disk
+          return disk.nil? ? "" : disk.path.to_s
+        end
+
+        path = @computer.mounted_path
+        path.empty? ? path : File.expand_path(path)
+      end
+
       def inserted?
         drive = @computer.drive1541
         drive.nil? ? @computer.mounted? : !drive.disk.nil?
       end
 
       # Puts a disk in device 8 or a tape in the datasette, `kind` :disk or
-      # :tape. A list puts its first disk in.
+      # :tape, and says whether it went in. A list puts its first disk in.
       def insert(kind, path)
         @problem = ""
         if kind == :disk
           disk = Media::DiskList.disk(path)
           Media.insert_disk(@computer, disk, read_only: !@writable)
           list(path)
-          @disk_path = disk
         else
           @computer.datasette.insert(Storage::TAP.new(path))
         end
+        true
       rescue ArgumentError, SystemCallError, Storage::TAP::FormatError, Storage::T64::FormatError,
              Storage::G64Image::FormatError => e
         @problem = e.message
+        false
       end
 
       # Does what the Drive page's :eject_disk, :previous_disk, :next_disk,
@@ -61,24 +75,25 @@ module Badline
       def eject_disk
         drive = @computer.drive1541
         drive.nil? ? @computer.unmount : drive.insert(nil)
-        @disk_path = ""
       end
 
       # Sets whether disks are writable, for the disk in the drive too,
       # which goes in again as the notch now says.
       def writable(writable)
         @writable = writable
-        insert(:disk, @disk_path) if inserted? && !@disk_path.empty?
+        path = disk_path
+        insert(:disk, path) if inserted? && !path.empty?
       end
 
       # The disks of the set the disk in the drive belongs to.
       def disk_set
-        return [] if @disk_path.empty?
+        path = disk_path
+        return [] if path.empty?
 
-        unless @set_path == @disk_path
-          listed = @list.empty? ? [] : Media::DiskList.disks(@list)
-          @set = listed.include?(@disk_path) ? listed : Media::DiskSet.around(@disk_path)
-          @set_path = @disk_path
+        unless @set_path == path
+          listed = @list.empty? ? [] : expanded(Media::DiskList.disks(@list))
+          @set = listed.include?(path) ? listed : expanded(Media::DiskSet.around(path))
+          @set_path = path
         end
         @set
       end
@@ -87,7 +102,7 @@ module Badline
       # drive, if there is one.
       def step_disk(step)
         set = disk_set
-        index = set.index(@disk_path)
+        index = set.index(disk_path)
         return if index.nil? || !(index + step).between?(0, set.size - 1)
 
         insert(:disk, set[index + step])
@@ -105,14 +120,23 @@ module Badline
       end
 
       # What a save of the machine is named after: the cartridge, the disk,
-      # the tape, or BASIC, without the bracketed parts of a file's name.
+      # the tape, or BASIC, without the bracketed parts of a file's name. A
+      # VIC-20's are named after its disk, or else the machine.
       def game_name
-        name = cartridge_name
-        name = File.basename(@disk_path, File.extname(@disk_path)) if name.empty? && !@disk_path.empty?
-        tape = @computer.datasette.tape
-        name = File.basename(tape.path, File.extname(tape.path)) if name.empty? && !tape.nil?
+        vic20 = @computer.family == :vic20
+        name = vic20 ? "" : cartridge_name
+        disk = disk_path
+        name = File.basename(disk, File.extname(disk)) if name.empty? && !disk.empty?
+        name = tape_name if name.empty? && !vic20
         name = name.sub(/\s*[(\[].*\z/, "").strip
-        name.empty? ? "BASIC" : name
+        return name unless name.empty?
+
+        vic20 ? "VIC-20" : "BASIC"
+      end
+
+      def tape_name
+        tape = @computer.datasette.tape
+        tape.nil? ? "" : File.basename(tape.path, File.extname(tape.path))
       end
 
       # The name the cartridge in the expansion port gives itself, or an
@@ -133,7 +157,6 @@ module Badline
       def start(options, path)
         @problem = ""
         computer = Frontend.start(options, path, @writable)
-        @disk_path = PauseMenu.disk_path(path)
         list(path)
         computer
       rescue ArgumentError, SystemCallError, Media::TrueDrive::Error, Storage::SIDFile::FormatError,
@@ -152,6 +175,8 @@ module Badline
         @list = path
         @set_path = ""
       end
+
+      def expanded(paths) = paths.map { |path| File.expand_path(path) }
     end
   end
 end