ripxplore 0.0.1

data/lib/HostSystem.rb

@@ -0,0 +1,84 @@
+$:.unshift(File.dirname(__FILE__)) unless
+	$:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+require 'open-uri'
+require 'RipXploreLog'
+require 'SubclassTracking'
+
+class HostSystem
+  def HostSystem.possible_file_systems
+    results=[]
+    FileSystem.all_file_systems.each do |candidate| 
+      results<<candidate if self==candidate.host_system
+    end
+    results
+  end
+  
+  def HostSystem.all_host_systems
+    HostSystem.subclasses
+  end
+
+#each subclass should override to_ascii with a function that converts a character in the native format to an ASCII equivalent
+def HostSystem.to_ascii(byte)
+  byte.chr
+end
+
+def HostSystem.s_to_ascii(s)
+  r=""
+  s.each_byte do |b|
+    r+=to_ascii(b)
+  end
+  r
+end
+
+#given a buffer (e.g a sector or a file), produce a formatted hex dump which includes chars converted to ASCII
+def HostSystem.hex_dump(buffer)
+   	s=""
+		(0..(buffer.length/16)).each {|line_number|
+			 lhs=""
+			 rhs=""
+			 start_byte=line_number*16
+			 line=buffer[start_byte,16]
+			if line.length>0 then
+				 line.each_byte {|byte|
+					  lhs+= sprintf("%02X ", byte)
+					  rhs+= to_ascii(byte).sub(/[\x00-\x1f]/,'.')
+			 	}
+				lhs+=" "*(16-line.length)*3
+				s+=sprintf("%02X\t%s %s\n",start_byte,lhs,rhs)
+			end
+		}
+		s
+end
+
+#does counting of tracks start at track 0 (e.g. Apple 2) or track 1 (e.g. C64)?
+def HostSystem.start_track
+  0
+end
+end
+
+HostSystem.extend SubclassTracking
+  
+# == Author
+# Jonno Downes (jonno@jamtronix.com)
+#
+# == Copyright
+# Copyright (c) 2008 Jonno Downes (jonno@jamtronix.com)
+#
+#Permission is hereby granted, free of charge, to any person obtaining
+#a copy of this software and associated documentation files (the
+#"Software"), to deal in the Software without restriction, including
+#without limitation the rights to use, copy, modify, merge, publish,
+#distribute, sublicense, and/or sell copies of the Software, and to
+#permit persons to whom the Software is furnished to do so, subject to
+#the following conditions:
+
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/ImageFormat.rb

@@ -0,0 +1,127 @@
+$:.unshift(File.dirname(__FILE__)) unless
+	$:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+require 'open-uri'
+require 'RipXploreLog'
+require 'SubclassTracking'
+require 'proc_source' 
+class ImageFormat
+
+def self.possible_extensions
+    []
+end  
+
+def to_s
+  self.class.name
+end
+def self.host_system
+  nil
+end  
+
+def host_system
+  self.class.host_system
+end
+def self.all_image_formats
+    ImageFormat.subclasses
+end  
+
+def self.possible_file_systems
+    results=[]
+    FileSystem.all_file_systems.each do |candidate| 
+      results<<candidate if (host_system==candidate.host_system) || (candidate.host_system==HostSystem)
+    end
+    results
+end  
+
+@@all_possible_extensions=nil
+def self.all_possible_extensions  
+  @@all_possible_extensions= ImageFormat.all_image_formats.collect{|format| format.possible_extensions}.flatten.uniq.collect{|ext| ext.downcase} if @@all_possible_extensions.nil?
+  @@all_possible_extensions
+end  
+
+#return an array containing a list of numbers of valid tracks on this image
+ def track_list
+    (start_track..end_track).collect
+end
+
+#for a given byte stream, how many tracks could be interpreted by this image format?
+def track_count
+  0  
+end
+
+#given a track number, a sector number, and an array of bytes, return an array of bytes representing the contents of that track/sector, or nil if specified track/sector not available
+#needs to be overriden in each ImageFormat
+def get_sector(track,sector)
+    nil 
+end
+
+#given a track number, how many sectors should be in this track for this ImageFormat?
+def sectors_in_track(track)
+   [0]
+end
+
+
+#is the first track called track 0 or track 1?
+def start_track  
+  host_system.respond_to?(:start_track) ? host_system.start_track : 0
+end
+  #what track does counting end at?
+def end_track
+  track_count-1+start_track
+end
+
+@@code_for_tests={}
+def self.code_for_tests
+  @@code_for_tests[self] || []
+end
+
+def self.is_valid_image_if(code_for_test)
+  RipXploreLog.debug  "adding test for #{self}: #{code_for_test.source}"
+  @@code_for_tests[self] ||=[]
+  @@code_for_tests[self]<<code_for_test.source
+end
+
+def compatability_score(file_system_image)
+  final_score=1
+   self.class.code_for_tests.each do |code_for_test|
+    RipXploreLog.debug "test for #{file_system_image.filename}#{self} : #{code_for_test} "
+    result = eval code_for_test,binding
+    RipXploreLog.debug "result : #{result}"     
+    final_score+=1
+    return 0  unless (result)
+  end
+  return final_score
+end
+
+
+attr_accessor :file_bytes
+def initialize(file_bytes)
+  @file_bytes=file_bytes
+end
+end
+
+ImageFormat.extend SubclassTracking
+  
+# == Author
+# Jonno Downes (jonno@jamtronix.com)
+#
+# == Copyright
+# Copyright (c) 2008 Jonno Downes (jonno@jamtronix.com)
+#
+#Permission is hereby granted, free of charge, to any person obtaining
+#a copy of this software and associated documentation files (the
+#"Software"), to deal in the Software without restriction, including
+#without limitation the rights to use, copy, modify, merge, publish,
+#distribute, sublicense, and/or sell copies of the Software, and to
+#permit persons to whom the Software is furnished to do so, subject to
+#the following conditions:
+
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/NativeFileType.rb

@@ -0,0 +1,168 @@
+$:.unshift(File.dirname(__FILE__)) unless
+	$:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+require 'open-uri'
+require 'RipXploreLog'
+require 'SubclassTracking'
+require 'proc_source' 
+
+class NativeFileType
+  attr_accessor(:file_system_image,:filename,:contents,:file_type,:aux_code) 
+	def initialize(file_system_image,filename,contents,file_type,aux_code)
+    @file_system_image=file_system_image
+		@filename=filename
+		@contents=contents
+    @file_type=file_type
+    @aux_code=aux_code
+	end
+  
+  def NativeFileType.matching_score
+    ancestors.length
+  end
+
+  def NativeFileType.non_matching_score
+    0
+  end
+  
+
+  def NativeFileType.all_native_file_types
+    NativeFileType.subclasses
+  end
+
+  #how should this file be described in a catalog list?
+  def type_description
+    self.class
+  end
+    
+  def load_address
+    self.class.load_address(contents)    
+  end
+  
+  def NativeFileType.load_address(filebytes)
+    0
+  end
+  
+  def <=>(o)
+    return -1 unless o.respond_to?(:filename)
+    if filename==o.filename then
+      return self.to_s<=>o.to_s
+    else
+      return (filename<=>o.filename)
+    end
+  end
+  
+  def to_hex_dump
+    file_system_image.file_system.host_system.hex_dump(contents)
+  end
+  #some filesystems  differentiate between full and partial filenames.
+  #e.g. in ProDOS the 'full' filename includes the full path
+  #by default, full_filename is the same as filename, but can be overridden
+  #for those filesystems that need this
+  def full_filename
+    @filename
+  end
+  
+  def ==(other_object)
+    if  !other_object.kind_of? NativeFileType then
+      return false
+    end
+     if self.filename!=other_object.filename then
+       return false
+     end
+    return self.to_s==other_object.to_s
+  end
+  
+  
+  #given metadata and contents of a file from a file system image, return an instance of the NativeFileType subclass that is the closest match
+  def NativeFileType.best_fit(file_system_image,filename,contents,file_type=nil,aux_code=nil)
+  candidates={}
+  NativeFileType.all_native_file_types.each do |native_file_type|
+    if !native_file_type.file_system_file_types.keys.include?(file_system_image.file_system) then
+      RipXploreLog.debug("skipping #{native_file_type} - can't reside on #{file_system_image.file_system}")
+    else
+      RipXploreLog.debug("checking native file type #{native_file_type}")
+      candidate_score=native_file_type.compatability_score(file_system_image,filename,contents,file_type,aux_code)
+      RipXploreLog.debug("score - #{candidate_score}")
+      candidates[native_file_type]=candidate_score
+    end    
+  end
+  if candidates.length==0 then
+    RipXploreLog.debug( 'no valid combination of file system and native file types found')
+    return nil
+  end
+  best_candidate=candidates.keys.sort{|a,b| candidates[b]<=>candidates[a]}[0]
+  RipXploreLog.debug("best candidate for #{filename} = #{best_candidate} score: #{candidates[best_candidate]}")
+  best_candidate.new(file_system_image,filename,contents,file_type,aux_code)
+end
+
+
+def NativeFileType.file_type_matches?(file_system_image,file_type)
+  result=false
+  [file_system_file_types[file_system_image.file_system]].flatten.each do |target_file_type|
+    result=true if target_file_type==:any
+    result=true if(file_type.to_s==target_file_type.to_s)     
+    RipXploreLog.debug "test for #{file_type} == #{target_file_type} : #{result}"
+  end
+  result
+end
+
+#how many bytes should be skipped to get to the file data?
+def header_length
+  0
+end  
+
+def data_without_header
+  @contents[header_length,@contents.length-header_length]
+end
+
+@@code_for_tests={}
+def self.code_for_tests
+  @@code_for_tests[self] || []
+end
+
+def self.is_valid_file_if(code_for_test)
+  #puts "adding test for #{self}: #{code_for_test.source}"
+  @@code_for_tests[self] ||=[]
+  @@code_for_tests[self]<<code_for_test.source
+end
+
+def self.compatability_score(file_system_image,filename,contents,file_type,aux_code)
+  return non_matching_score  unless (file_type_matches?(file_system_image,file_type))
+    load_address=self.load_address(contents)
+    passed_tests=0
+   code_for_tests.each do |code_for_test|
+     result = eval code_for_test,binding
+     RipXploreLog.debug "test for #{self} : #{code_for_test} : #{result}"     
+    return non_matching_score  unless (result)
+    passed_tests+=1
+  end
+  return matching_score+passed_tests
+end
+
+end
+
+NativeFileType.extend SubclassTracking
+  
+# == Author
+# Jonno Downes (jonno@jamtronix.com)
+#
+# == Copyright
+# Copyright (c) 2008 Jonno Downes (jonno@jamtronix.com)
+#
+#Permission is hereby granted, free of charge, to any person obtaining
+#a copy of this software and associated documentation files (the
+#"Software"), to deal in the Software without restriction, including
+#without limitation the rights to use, copy, modify, merge, publish,
+#distribute, sublicense, and/or sell copies of the Software, and to
+#permit persons to whom the Software is furnished to do so, subject to
+#the following conditions:
+
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/PatchedPNG.rb

@@ -0,0 +1,303 @@
+#code ripped from the Pure Ruby PNG library by Ryan Davis. (http://blog.zenspider.com/)
+
+require 'zlib'
+
+
+class String # :nodoc:
+
+  ##
+  # Calculates a CRC using the algorithm in the PNG specification.
+
+  def png_crc
+    unless defined? @@crc then
+      @@crc = Array.new(256)
+      256.times do |n|
+        c = n
+        8.times do
+          c = (c & 1 == 1) ? 0xedb88320 ^ (c >> 1) : c >> 1
+        end
+        @@crc[n] = c
+      end
+    end
+
+    c = 0xffffffff
+    each_byte do |b|
+      c = @@crc[(c^b) & 0xff] ^ (c >> 8)
+    end
+    return c ^ 0xffffffff
+  end
+
+end
+
+##
+# A pure Ruby Portable Network Graphics (PNG) writer.
+#
+# http://www.libpng.org/pub/png/spec/1.2/
+#
+# PNG supports:
+# + 8 bit truecolor PNGs
+#
+# PNG does not support:
+# + any other color depth
+# + extra data chunks
+# + filters
+#
+# = Example
+#
+#   require 'png'
+#   
+#   canvas = PNG::Canvas.new 200, 200
+#   canvas[100, 100] = PNG::Color::Black
+#   canvas.line 50, 50, 100, 50, PNG::Color::Blue
+#   png = PNG.new canvas
+#   png.save 'blah.png'
+
+class PNG
+
+  ##
+  # Creates a PNG chunk of type +type+ that contains +data+.
+
+  def self.chunk(type, data="")
+    [data.size, type, data, (type + data).png_crc].pack("Na*a*N")
+  end
+
+  ##
+  # Creates a new PNG object using +canvas+
+
+  def initialize(canvas)
+    @height = canvas.height
+    @width = canvas.width
+    @bits = 8
+    @data = canvas.data
+  end
+
+  ##
+  # Writes the PNG to +path+.
+
+  def save(path)
+    File.open(path, "w") do |f|
+      f.write [137, 80, 78, 71, 13, 10, 26, 10].pack("C*") # PNG signature
+      f.write PNG.chunk('IHDR',
+                        [ @height, @width, @bits, 6, 0, 0, 0 ].pack("N2C5"))
+      # 0 == filter type code "none"
+      data = @data.map { |row| [0] + row.map { |p| p.values } }.flatten
+      f.write PNG.chunk('IDAT', Zlib::Deflate.deflate(data.pack("C*"), 9))
+      f.write PNG.chunk('IEND', '')
+    end
+  end
+
+def raw_bytes
+		bytes=""
+		bytes<< [137, 80, 78, 71, 13, 10, 26, 10].pack("C*") # PNG signature
+		bytes<< PNG.chunk('IHDR',
+			[ @height, @width, @bits, 6, 0, 0, 0 ].pack("N2C5"))
+		# 0 == filter type code "none"
+		data = @data.map { |row| [0] + row.map { |p| p.values } }.flatten
+		bytes<< PNG.chunk('IDAT', Zlib::Deflate.deflate(data.pack("C*"), 9))
+		bytes<< PNG.chunk('IEND', '')
+		bytes
+	end
+
+  ##
+  # RGBA colors
+
+  class Color
+
+    attr_reader :values
+
+    ##
+    # Creates a new color with values +red+, +green+, +blue+, and +alpha+.
+
+    def initialize(red, green, blue, alpha)
+      @values = [red, green, blue, alpha]
+    end
+
+    ##
+    # Transparent white
+
+    Background = Color.new 0xFF, 0xFF, 0xFF, 0x00
+ 
+    White      = Color.new 0xFF, 0xFF, 0xFF, 0xFF
+    Black      = Color.new 0x00, 0x00, 0x00, 0xFF
+    Gray       = Color.new 0x7F, 0x7F, 0x7F, 0xFF
+
+    Red        = Color.new 0xFF, 0x00, 0x00, 0xFF
+    Orange     = Color.new 0xFF, 0xA5, 0x00, 0xFF
+    Yellow     = Color.new 0xFF, 0xFF, 0x00, 0xFF
+    Green      = Color.new 0x00, 0xFF, 0x00, 0xFF
+    Blue       = Color.new 0x00, 0x00, 0xFF, 0xFF
+    Purple     = Color.new 0XFF, 0x00, 0xFF, 0xFF
+
+    ##
+    # Red component
+
+    def r; @values[0]; end
+
+    ##
+    # Green component
+
+    def g; @values[1]; end
+
+    ##
+    # Blue component
+
+    def b; @values[2]; end
+
+    ##
+    # Alpha transparency component
+
+    def a; @values[3]; end
+
+    ##
+    # Blends +color+ into this color returning a new blended color.
+
+    def blend(color)
+      return Color.new((r * (0xFF - color.a) + color.r * color.a) >> 8,
+                       (g * (0xFF - color.a) + color.g * color.a) >> 8,
+                       (b * (0xFF - color.a) + color.b * color.a) >> 8,
+                       (a * (0xFF - color.a) + color.a * color.a) >> 8)
+    end
+
+    ##
+    # Returns a new color with an alpha value adjusted by +i+.
+
+    def intensity(i)
+      return Color.new(r,b,g,(a*i) >> 8)
+    end
+
+    def inspect # :nodoc:
+      "#<%s %02x %02x %02x %02x>" % [self.class, *@values]
+    end
+
+  end
+
+  ##
+  # PNG canvas
+
+  class Canvas
+
+    ##
+    # Height of the canvas
+
+    attr_reader :height
+
+    ##
+    # Width of the canvas
+
+    attr_reader :width
+
+    ##
+    # Raw data
+
+    attr_reader :data
+
+    def initialize(height, width, background = Color::White)
+      @height = height
+      @width = width
+      @data = Array.new(@width) { |x| Array.new(@height) { background } }
+    end
+
+    ##
+    # Retrieves the color of the pixel at (+x+, +y+).
+
+    def [](x, y)
+      raise "bad x value #{x} >= #{@height}" if x >= @height
+      raise "bad y value #{y} >= #{@width}" if y >= @width
+      @data[y][x]
+    end
+
+    ##
+    # Sets the color of the pixel at (+x+, +y+) to +color+.
+
+    def []=(x, y, color)
+      raise "bad x value #{x} >= #{@height}" if x >= @height
+      raise "bad y value #{y} >= #{@width}"  if y >= @width
+      @data[y][x] = color
+    end
+
+    ##
+    # Iterates over each pixel in the canvas.
+
+    def each
+      @data.each_with_index do |row, y|
+        row.each_with_index do |pixel, x|
+          yield x, y, color
+        end
+      end
+    end
+
+    ##
+    # Blends +color+ onto the color at point (+x+, +y+).
+
+    def point(x, y, color)
+      self[x,y] = self[x,y].blend(color)
+    end
+
+    ##
+    # Draws a line using Xiaolin Wu's antialiasing technique.
+    #
+    # http://en.wikipedia.org/wiki/Xiaolin_Wu's_line_algorithm
+
+    def line(x0, y0, x1, y1, color)
+      dx = x1 - x0
+      sx = dx < 0 ? -1 : 1
+      dx *= sx # TODO: abs?
+      dy = y1 - y0
+
+      # 'easy' cases
+      if dy == 0 then
+        Range.new(*[x0,x1].sort).each do |x|
+          point(x, y0, color)
+        end
+        return
+      end
+
+      if dx == 0 then
+        (y0..y1).each do |y|
+          point(x0, y, color)
+        end
+        return
+      end
+
+      if dx == dy then
+        Range.new(*[x0,x1].sort).each do |x|
+          point(x, y0, color)
+          y0 += 1
+        end
+        return
+      end
+
+      # main loop
+      point(x0, y0, color)
+      e_acc = 0
+      if dy > dx then # vertical displacement
+        e = (dx << 16) / dy
+        (y0...y1-1).each do |i|
+          e_acc_temp, e_acc = e_acc, (e_acc + e) & 0xFFFF
+          x0 = x0 + sx if (e_acc <= e_acc_temp) 
+          w = 0xFF-(e_acc >> 8)
+          point(x0, y0, color.intensity(w))
+          y0 = y0 + 1
+          point(x0 + sx, y0, color.intensity(0xFF-w))
+        end
+        point(x1, y1, color)
+        return
+      end
+
+      # horizontal displacement
+      e = (dy << 16) / dx
+      (x0...(x1-sx)).each do |i|
+        e_acc_temp, e_acc = e_acc, (e_acc + e) & 0xFFFF
+        y0 += 1 if (e_acc <= e_acc_temp)
+        w = 0xFF-(e_acc >> 8)
+        point(x0, y0, color.intensity(w))
+        x0 += sx
+        point(x0, y0 + 1, color.intensity(0xFF-w))
+      end
+      point(x1, y1, color)
+    end
+
+  end
+
+end
+