bliss 0.0.7 → 0.0.9

data/lib/bliss/parser.rb

@@ -1,12 +1,217 @@
 module Bliss
   class Parser
-    def initialize(path)
+    def initialize(path, filepath=nil)
       @path = path
-      @parser_machine = Bliss::ParserMachine.new(path)
+      
+      @parser_machine = Bliss::ParserMachine.new
+
+      @push_parser = Nokogiri::XML::SAX::PushParser.new(@parser_machine)
+
+      if filepath
+        @file = File.new(filepath, 'w')
+        @file.autoclose = false
+      end
+
+      @root = nil
+      @nodes = nil
+
+      on_root {}
+    end
+
+    def on_root(&block)
+      return false if not block.is_a? Proc
+      @parser_machine.on_root { |root|
+        @root = root
+        block.call(root)
+      }
+    end
+
+    def on_tag_open(element='default', &block)
+      return false if block.arity != 1
+
+      overriden_block = Proc.new { |depth|
+        if not element == 'default'
+          reset_unhandled_bytes
+        end
+        block.call(depth)
+      }
+      @parser_machine.on_tag_open(element, overriden_block)
+    end
+
+    def on_tag_close(element='default', &block)
+      overriden_block = Proc.new { |hash, depth|
+        #if not element == 'default'
+          reset_unhandled_bytes
+        #end
+        block.call(hash, depth)
+      }
+      @parser_machine.on_tag_close(element, overriden_block)
+    end
+
+    def on_max_unhandled_bytes(bytes, &block)
+      @max_unhandled_bytes = bytes
+      @on_max_unhandled_bytes = block
+    end
+
+    def wait_tag_close(element)
+      @wait_tag_close = "</#{element}>"
+    end
+
+    def reset_unhandled_bytes
+      return false if not check_unhandled_bytes?
+      @unhandled_bytes = 0
+    end
+
+    def check_unhandled_bytes
+      if @unhandled_bytes > @max_unhandled_bytes
+        if @on_max_unhandled_bytes
+          @on_max_unhandled_bytes.call
+          @on_max_unhandled_bytes = nil
+        end
+        #self.close
+      end
+    end
+
+    def exceeded?
+      return false if not check_unhandled_bytes?
+      if @unhandled_bytes > @max_unhandled_bytes
+        return true
+      end
+    end
+
+    def check_unhandled_bytes?
+      @max_unhandled_bytes ? true : false
+    end
+
+    def root
+      @root
+    end
+
+    def close
+      @parser_machine.close
     end
 
     def parse
-      @parser_machine.parse
+      reset_unhandled_bytes if check_unhandled_bytes?
+
+      EM.run do
+        http = EM::HttpRequest.new(@path).get
+        
+        @autodetect_compression = true
+        compression = :none
+        if @autodetect_compression
+          http.headers do
+            if (/^attachment.+filename.+\.gz/i === http.response_header['CONTENT_DISPOSITION']) or http.response_header.compressed? or ["application/octet-stream", "application/x-gzip"].include? http.response_header['CONTENT_TYPE']
+              @zstream = Zlib::Inflate.new(Zlib::MAX_WBITS+16)
+              compression = :gzip
+            end
+          end
+        end
+        
+        http.stream { |chunk|
+          if chunk
+            chunk.force_encoding('UTF-8')
+
+            if check_unhandled_bytes?
+              @unhandled_bytes += chunk.length
+              check_unhandled_bytes
+            end
+            if not @parser_machine.is_closed?
+              begin
+                case compression
+                  when :gzip
+                    chunk = @zstream.inflate(chunk)
+                    chunk.force_encoding('UTF-8')
+                end
+                @push_parser << chunk
+                if @file
+                  @file << chunk
+                end
+              rescue Nokogiri::XML::SyntaxError => e
+                #puts 'encoding error'
+                if e.message.include?("encoding")
+                  raise Bliss::EncodingError, "Wrong encoding given"
+                end
+              end
+
+            else
+              if exceeded?
+                #puts 'exceeded'
+                secure_close
+              else
+                if @file
+                  if @wait_tag_close
+                    #puts 'handle wait'
+                    handle_wait_tag_close(chunk) #if @wait_tag_close
+                  else
+                    #puts 'secure close'
+                    secure_close
+                  end
+                end
+              end
+            end
+          end
+        }
+        http.errback {
+          #puts 'errback'
+          secure_close
+        }
+        http.callback {
+          #if @file
+          #  @file.close
+          #end
+          #EM.stop
+          secure_close
+        }
+      end
+      file_close
     end
+
+    def autodetect_compression(http)
+      #compression = :none
+      puts compression
+      return compression
+    end
+    
+    def handle_wait_tag_close(chunk)
+      begin
+        last_index = chunk.index(@wait_tag_close)
+        if last_index
+          last_index += 4
+          @file << chunk[0..last_index]
+          @file << "</#{self.root}>" # TODO set this by using actual depth, so all tags get closed
+          secure_close
+        else
+          @file << chunk
+        end
+      rescue
+        secure_close
+      end
+    end
+
+    def file_close
+      if @file
+        @file.close
+      end
+    end
+
+    def secure_close
+      begin
+        if @zstream
+          @zstream.close
+        end
+      rescue
+      ensure
+        EM.stop
+        #puts "Closed secure."
+      end
+    end
+
   end
 end
+
+#require 'stringio'
+#str = StringIO.new
+#z = Zlib::GzipWriter.new(str)
+#z.write(txt)
+#z.close

data/lib/bliss/parser_machine.rb

@@ -1,161 +1,131 @@
 module Bliss
-  class ParserMachine
-    attr_writer :max_unhandled_bytes
+  class ParserMachine < Nokogiri::XML::SAX::Document
+    def initialize
+      @depth = []
+      # @settings = {} # downcased
 
-    def initialize(path, filepath=nil)
-      @path = path
-      
-      @sax_parser = Bliss::SaxParser.new
+      @root = nil
+      @nodes = {}
+      @current_node = {}
 
-      @parser = Nokogiri::XML::SAX::PushParser.new(@sax_parser)
+      @on_root = nil
 
-      if filepath
-        @file = File.new(filepath, 'w')
-      end
+      @on_tag_open = {}
+      @on_tag_close = {}
 
-      @root = nil
-      @nodes = nil
+      @closed = false
 
-      on_root {}
     end
 
     def on_root(&block)
-      return false if not block.is_a? Proc
-      @sax_parser.on_root { |root|
-        @root = root
-        block.call(root)
-      }
+      @on_root = block
     end
 
-    def on_tag_open(element, &block)
-      return false if block.arity != 1
-
-      overriden_block = Proc.new { |depth|
-        reset_unhandled_bytes
-        block.call(depth)
-      }
-      @sax_parser.on_tag_open(element, overriden_block)
+    def on_tag_open(element, block)
+      @on_tag_open.merge!({element => block})
     end
 
-    def on_tag_close(element, &block)
-      overriden_block = Proc.new { |hash|
-        reset_unhandled_bytes
-        block.call(hash)
-      }
-      @sax_parser.on_tag_close(element, overriden_block)
+    def on_tag_close(element, block)
+      @on_tag_close.merge!({element => block})
     end
 
-    def wait_tag_close(element)
-      @wait_tag_close = "</#{element}>"
+    def close
+      @closed = true
     end
 
-    def reset_unhandled_bytes
-      return false if not check_unhandled_bytes?
-      @unhandled_bytes = 0
+    def is_closed?
+      @closed
     end
 
-    def check_unhandled_bytes
-      if @unhandled_bytes > @max_unhandled_bytes
-        self.close
+    def start_element(element, attributes)
+      return if is_closed?
+      # element_transformation
+
+      if @root == nil
+        @root = element
+        if @on_root.is_a? Proc
+          @on_root.call(@root)
+        end
       end
-    end
 
-    def exceeded?
-      return false if not check_unhandled_bytes?
-      if @unhandled_bytes > @max_unhandled_bytes
-        return true
+      @depth.push(element) if @depth.last != element
+      
+      if @on_tag_open.has_key? element
+        @on_tag_open[element].call(@depth)
+      elsif @on_tag_open.has_key? 'default'
+        @on_tag_open['default'].call(@depth)
       end
-    end
 
-    def check_unhandled_bytes?
-      @max_unhandled_bytes ? true : false
-    end
+      current = @nodes.pair_at_chain(@depth)
 
-    def root
-      @root
+      value_at = @nodes.value_at_chain(@depth)
+      
+      if current.is_a? Hash
+        if value_at.is_a? NilClass
+          current[element] = {}
+        elsif value_at.is_a? Hash
+          if current[element].is_a? Array
+            current[element].concat [{}]
+          else
+            current[element] = [current[element], {}]
+            #current = @nodes.pair_at_chain(@depth)
+          end
+        elsif value_at.is_a? Array
+          #puts @depth.inspect
+          #puts current[element].inspect
+          #puts current[element].inspect
+        end
+      elsif current.is_a? Array
+      end
+
+      @current_content = ''
     end
 
-    def close
-      @sax_parser.close
+    def characters(string)
+      return if is_closed?
+      concat_content(string)
     end
 
-    def parse
-      reset_unhandled_bytes if check_unhandled_bytes?
-
-      EM.run do
-        http = EM::HttpRequest.new(@path).get
-        http.stream { |chunk|
-          if chunk
-            chunk.force_encoding('UTF-8')
-
-            @parser << chunk
-
-            if check_unhandled_bytes?
-              @unhandled_bytes += chunk.length
-              check_unhandled_bytes
-            end
-            
-            if not @sax_parser.is_closed?
-              if @file
-                @file << chunk
-              end
-            else
-              if exceeded?
-                #puts 'exceeded'
-                secure_close
-              else
-                if @file
-                  if @wait_tag_close
-                    #puts 'handle wait'
-                    handle_wait_tag_close(chunk) #if @wait_tag_close
-                  else
-                    #puts 'secure close'
-                    secure_close
-                  end
-                end
-              end
-            end
-          end
-        }
-        http.callback {
-          if @file
-            @file.close
-          end
-          EM.stop
-        }
-      end
+    def cdata_block(string)
+      return if is_closed?
+      concat_content(string)
     end
-    
-    def handle_wait_tag_close(chunk)
-      begin
-        last_index = chunk.index(@wait_tag_close)
-        if last_index
-          last_index += 4
-          @file << chunk[0..last_index]
-          @file << "</#{self.root}>" # TODO set this by using actual depth, so all tags get closed
-          secure_close
-        else
-          @file << chunk
+
+    def end_element(element, attributes=[])
+      return if is_closed?
+      # element_transformation
+
+      current = @nodes.pair_at_chain(@depth)
+      value_at = @nodes.value_at_chain(@depth)
+
+      if value_at.is_a? Hash
+        current[element] = @current_content if @current_content.size > 0
+      elsif value_at.is_a? NilClass
+        if current.is_a? Array
+          current = current.last
+          current[element] = @current_content if @current_content.size > 0
         end
-      rescue
-        secure_close
       end
+      @current_content = ''
+      
+      if @on_tag_close.has_key? element
+        @on_tag_close[element].call(value_at, @depth)
+      elsif @on_tag_close.has_key? 'default'
+        @on_tag_close['default'].call(value_at, @depth)
+      end
+
+      @depth.pop if @depth.last == element
     end
 
-    def secure_close
-      begin
-        @file.close
-      rescue
-      ensure
-        EM.stop
+    def concat_content(string)
+      string.strip!
+      if string
+        @current_content << string
       end
     end
 
+    def end_document
+      puts @nodes.inspect
+    end
   end
 end
-
-#require 'stringio'
-#str = StringIO.new
-#z = Zlib::GzipWriter.new(str)
-#z.write(txt)
-#z.close