rcv 0.0.1 → 0.0.2

data/Manifest.txt

@@ -1,29 +1,12 @@
 History.txt
 License.txt
 Manifest.txt
-PostInstall.txt
 README.txt
 Rakefile
 bin/rcv
-config/hoe.rb
-config/requirements.rb
 lib/rcv.rb
 lib/rcv/config.rb
 lib/rcv/reader.rb
 lib/rcv/version.rb
-script/console
-script/destroy
-script/generate
-script/manifest.rb
-script/txt2html
-setup.rb
-tasks/deployment.rake
-tasks/environment.rake
-tasks/website.rake
 test/test_helper.rb
 test/test_rcv.rb
-website/index.html
-website/index.txt
-website/javascripts/rounded_corners_lite.inc.js
-website/stylesheets/screen.css
-website/template.html.erb

data/bin/rcv

@@ -33,9 +33,9 @@ module RCV
     def read(file)
       @filename = file
       if file
-        @reader = RCV::ZipReader.new(file)
+        @reader = RCV::Reader.new(file)
         @reader.read
-        print @reader.get_next
+        print @reader.next_image
       end
     end
 
@@ -59,11 +59,11 @@ module RCV
     end
 
     def on_press_right
-      print @reader.get_next if @reader
+      print @reader.next_image if @reader
     end
 
     def on_press_left
-      print @reader.get_prev if @reader
+      print @reader.prev_image if @reader
     end
 
     def on_press_o
@@ -87,8 +87,8 @@ module RCV
     def on_press_b
       state = RCV::Config.bookmark @filename if @filename
       if state && @reader
-        @reader.load state
-        print @reader.get_next
+        @reader.state = state
+        print @reader.current_image
       end
     end
 
@@ -102,9 +102,9 @@ module RCV
       end
     end
 
-    def print io
-      if io
-        get_pixbuf io
+    def print temp
+      if temp
+        get_pixbuf temp
         @drawing_area.signal_emit("expose_event", nil)
       end
     end

data/lib/rcv.rb

@@ -7,7 +7,7 @@ $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
 module RCV
-  VERSION = [0, 0, 1]
+  VERSION = [0, 0, 2]
 
   def self.version
     VERSION.join(".")

data/lib/rcv/reader.rb

@@ -5,247 +5,187 @@ zip archive reader
 require "rubygems"
 require "zip/zip"
 require "tempfile"
-require "fileutils"
 require "kconv"
-require "thread"
 require "logger"
 require "singleton"
 
 module RCV
-  class ZipReader
+  class Reader
     def initialize(file)
-      @logger = RCVLog.instance
-      @zis = Zip::ZipInputStream.new(file)
-      @entries = []
-      @index = 0
+      @file = file
     end
 
+    # todo : other archive
     def read
-      while entry = @zis.get_next_entry
-        case entry.name
-        when /\.zip$/i
-          @entries << ZipEntry.new(entry)
-        when /\.(jpg|jpeg|png)$/i
-          @entries << ImageEntry.new(entry)
-        end
-      end
-      @entries = @entries.sort_by { |e| e.name }
+      @archive = Archive::ZipFileEntry.new(nil, @file)
+      @archive.read
     end
 
-    def close
-      @entries.each { |e| e.close }
-      @zis.close
+    def next_image
+      @archive.next_image
     end
 
-    def get_next
-      entry = current
-      unless entry
-        @index -= 1
-        entry = current
-      end
-      if entry.last?
-        entry.close
-        @index += 1
-        entry = current
-      end
-      return unless entry
-      entry.get_next
+    def prev_image
+      @archive.prev_image
     end
 
-    def get_prev
-      entry = current
-      unless entry
-        @index -= 1
-        entry = current
-      end
-      if @index == 0
-        return if entry.top?
-      end
-      if entry.top?
-        entry.close
-        @index -= 1
-        entry = current
-      end
-      return unless entry
-      entry.get_prev
+    def current_image
+      @archive.current_image
     end
 
     def state
-      state = [@index, current.state].flatten
-      @logger.debug "Get state : #{state.join(",")}"
-      state
-    end
-
-    def load(state)
-      @logger.debug "Set state : #{state.join(",")}"
-      @index = state.shift
-      current.load state
+      @archive.state.flatten
     end
 
-    def current
-      @entries[@index]
+    def state=(state)
+      @archive.state = state
     end
   end
 
-  class Entry
-    attr_reader :name
-    def initialize(entry)
-      @logger = RCVLog.instance
-      @entry = entry
-      @name = entry.name.toutf8
-      @index = -1
-    end
-
-    def top?
-      @index <= 0
-    end
+  module Archive
+    class ZipImageEntry
+      def initialize(entry)
+        super()
+        @entry = entry
+        @name = entry.name.toutf8
+        @logger = Logger.new(STDOUT)
+        @logger.level = Logger::ERROR
+        @readend = false
+        @index = 0
+      end
 
-    def close; end
-  end
+      attr_reader :name, :readend, :index
 
-  # ignore nested too deep
-  class ZipEntry < Entry
-    def initialize(entry)
-      super
-      @entries = []
-    end
+      def read; end
+      def next_image; current; end
+      def prev_image; current; end
+      def state; @index; end
+      def state=(state); end
 
-    # No goodness?
-    # tempfile or memory ? best ?
-    def get_next
-      unless @zis
-        create_temp
-      end
-      if @temp.closed?
-        @temp.open
-      end
-      @entries[@index].close if @entries[@index]
-      @index += 1
-      @entries[@index].get_next
-    end
-
-    def get_prev
-      unless @zis
-        create_temp
-      end
-      if @temp.closed?
-        @index = @entries.size
-        @temp.open
+      def current
+        @readend = true
+        @logger.debug "load : #{@name}"
+        @temp = Tempfile.new("rcv")
+        @temp.binmode
+        @temp.write @entry.get_input_stream.read
+        @temp.flush
+        @temp.path
       end
-      @entries[@index].close if @entries[@index]
-      @index -= 1
-      @entries[@index].get_prev
-    end
 
-    def create_temp
-      @index = -1
-      @temp = Tempfile.new("rcv")
-      @temp.binmode
-      @temp.write @entry.get_input_stream.read
-      @temp.flush
-      @logger.debug "Create temp : #{@name} to #{@temp.path}"
-      @zis = Zip::ZipInputStream.new(@temp.path)
-      while entry = @zis.get_next_entry
-        @entries << ImageEntry.new(entry) if entry.name =~ /\.(jpg|jpeg|png)$/i
+      def close
+        @readend = false
+        @logger.debug "close : #{@name}"
+        @temp.close(true) if @temp
       end
-      @entries = @entries.sort_by { |e| e.name }
     end
 
-    def close
-      @temp.close
-      @entries[@index].close
-#       @zis.close
-#       @zis = nil
-#       @temp.close(true)
-    end
-
-    def last?
-      create_temp unless @zis
-      @index + 1 >= @entries.size
-    end
+    class ZipFileEntry
+      PATTERN = {
+        /\.zip$/i => ZipFileEntry,
+        /\.(jpg|jpeg|png)$/i => ZipImageEntry
+      }
 
-    def state
-      [@index - 1, @entries[@index].state]
-    end
-
-    def current
-      @entries[@index]
-    end
-
-    def load(state)
-      @index = state.shift
-      current.load state
-    end
-  end
-
-  class ImageEntry < Entry
-    def initialize(entry)
-      super
-    end
-
-    def get_next
-      current
-    end
-
-    def get_prev
-      current
-    end
+      def initialize(entry = nil, file = nil)
+        super()
+        @zipfile = file
+        @entry = entry
+        @index = -1
+        @name = entry ? entry.name : nil
+        @readend = false
+      end
 
-    def current
-      @index = 0
-      @logger.debug "Read file : #{@name}"
+      attr_reader :name, :readend, :index
+
+      def read
+        create_temp unless @zipfile
+        unless @entries
+          @entries = []
+          file = @zipfile || @tempfile
+          @zis = Zip::ZipInputStream.new(file)
+          while entry = @zis.get_next_entry
+            PATTERN.each do |k, v|
+              @entries << v.new(entry) if k =~ entry.name
+            end
+          end
+          @entries = @entries.sort_by { |e| e.name }
+        end
+      end
 
-      unless @temp
-        @temp = Tempfile.new("rcv")
-        @temp.binmode
-        @temp.write(@entry.get_input_stream.read)
-        @temp.flush
-        @logger.debug "Create temp : #{@temp.path}"
+      def create_temp
+        unless @temp
+          @temp = Tempfile.new("rcv")
+          @temp.binmode
+          @temp.write @entry.get_input_stream.read
+          @temp.flush
+          @tempfile = @temp.path
+        end
+        if @temp.closed?
+          @temp.open
+        end
       end
-      if @temp.closed?
-        @temp.open
+
+      def next_image
+        return get_next if @index < 0
+        return unless current
+        return get_next if current.readend
+        image = current.next_image
+        return get_next unless image
+        image
       end
 
-      @temp.path
-    end
+      def prev_image
+        return get_prev unless current
+        return get_prev if current.readend
+        image = current.prev_image
+        return get_prev unless image
+        image
+      end
 
-    def last?
-      @index == 0
-    end
+      def get_next
+        if @index >= @entries.size - 1
+          return nil
+        end
+        current.close if @index > -1 && current
+        @index += 1
+        current.read if current
+        return current.next_image if current
+      end
 
-    def close
-      @logger.debug "close #{name}"
-      @temp.close(true) if @temp
-      @temp = nil
-    end
+      def get_prev
+        if @index <= 0
+          return nil
+        end
+        current.close if current
+        @index -= 1
+        current.read if current
+        return current.prev_image if current
+      end
 
-    def state
-      @index - 1
-    end
+      def state
+        [@index, current.state]
+      end
 
-    def load(state)
-      @index = state.shift
-    end
-  end
+      def state=(state)
+        @index = state.shift
+        current.state = state if state.size > 0
+      end
 
-  class RCVLog
-    include Singleton
-    def initialize
-      @logger = Logger.new(STDOUT)
-      @logger.level = Logger::ERROR
-      @m = Mutex.new
-    end
+      def current
+        @entries[@index]
+      end
 
-    def debug str
-      @m.synchronize do
-        @logger.debug str
+      def current_image
+        current.current
       end
-    end
 
-    def error str
-      @m.synchronize do
-        @logger.error str
+      def close
+        @temp.close if @temp
+        @index = @entries.size - 1
       end
     end
+
+    # todo
+    class RarFileEntry; end
+    class RarImageEntry; end
   end
 end