mingle_events 0.1.3 → 0.1.4

data/Gemfile

@@ -1,4 +1,2 @@
-source 'http://rubygems.org'
-
-gem 'nokogiri'
-gem 'activesupport'
+source :rubygems
+gemspec

data/lib/mingle_events.rb

@@ -6,21 +6,37 @@ require 'logger'
 
 require 'rubygems'
 require 'nokogiri'
+require 'active_support'
+require 'active_support/core_ext'
+require 'archive/tar/minitar'
+require 'api_auth'
+
 
 require File.expand_path(File.join(File.dirname(__FILE__), 'mingle_events', 'feed'))
-require File.expand_path(File.join(File.dirname(__FILE__), 'mingle_events', 'http_error'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'mingle_events', 'xml'))
 require File.expand_path(File.join(File.dirname(__FILE__), 'mingle_events', 'poller'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'mingle_events', 'http_error'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'mingle_events', 'http'))
 require File.expand_path(File.join(File.dirname(__FILE__), 'mingle_events', 'mingle_basic_auth_access'))
 require File.expand_path(File.join(File.dirname(__FILE__), 'mingle_events', 'mingle_oauth_access'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'mingle_events', 'mingle_hmac_auth_access'))
 require File.expand_path(File.join(File.dirname(__FILE__), 'mingle_events', 'processors'))
 require File.expand_path(File.join(File.dirname(__FILE__), 'mingle_events', 'project_custom_properties'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'mingle_events', 'zip_directory'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'mingle_events', 'entry_cache'))
 require File.expand_path(File.join(File.dirname(__FILE__), 'mingle_events', 'project_event_fetcher'))
 
 module MingleEvents
-  
+
   attr_accessor :log
   module_function :log, :log=
   self.log = Logger.new(STDOUT)
   self.log.level = Logger::INFO
 
-end
+
+  URIParser = URI.const_defined?(:Parser) ? URI::Parser.new : URI
+  ATOM_AND_MINGLE_NS = {
+    'atom' => "http://www.w3.org/2005/Atom",
+    'mingle' => "http://www.thoughtworks-studios.com/ns/mingle"
+  }
+end

data/lib/mingle_events/entry_cache.rb

@@ -0,0 +1,129 @@
+module MingleEvents
+  class EntryCache
+    def initialize(root_dir)
+      @dir = ZipDirectory.new(root_dir)
+    end
+        
+    def all_entries
+      current_state = load_current_state
+      Entries.new(@dir, current_state[:first_fetched_entry_info_file], current_state[:last_fetched_entry_info_file])
+    end
+    
+    def entries(from_entry, to_entry)
+      Entries.new(@dir, file_for_entry(from_entry), file_for_entry(to_entry))
+    end
+    
+    def first
+      current_state_entry(:first_fetched_entry_info_file)
+    end
+    
+    def latest
+      current_state_entry(:last_fetched_entry_info_file)
+    end
+    
+    def write(entry, next_entry)
+      file = file_for_entry(entry)
+      file_content = {:entry_xml => entry.raw_xml, :next_entry_file_path => file_for_entry(next_entry)}
+      @dir.write_file(file) {|out| YAML.dump(file_content, out)}
+    end
+    
+    def has_current_state?
+      @dir.exists?(current_state_file)
+    end
+    
+    def set_current_state(latest_entry)
+      return if latest_entry.nil?
+      write(latest_entry, nil)
+      update_current_state(latest_entry, latest_entry)
+    end
+    
+    def update_current_state(oldest_new_entry, most_recent_new_entry)
+      current_state = load_current_state
+      current_state.merge!(:last_fetched_entry_info_file => file_for_entry(most_recent_new_entry))
+      if current_state[:first_fetched_entry_info_file].nil?
+        current_state.merge!(:first_fetched_entry_info_file => file_for_entry(oldest_new_entry))
+      end
+      @dir.write_file(current_state_file) { |out| YAML.dump(current_state, out)  }
+      @dir.reload
+    end
+    
+    def clear
+      @dir.delete
+    end
+    
+    private
+    
+    def load_current_state
+      if has_current_state?
+        @dir.file(current_state_file) { |f| YAML.load(f)}
+      else
+        {:last_fetched_entry_info_file => nil, :first_fetched_entry_info_file => nil}
+      end
+    end
+    
+    def current_state_file
+      'current_state.yml'
+    end
+    
+    def current_state_entry(info_file_key)
+      if info_file = load_current_state[info_file_key]
+        Feed::Entry.from_snippet((@dir.file(info_file) { |f| YAML.load(f) })[:entry_xml])
+      end
+    end
+    
+    def file_for_entry(entry)
+      return nil if entry.nil?
+      entry_id_as_uri = URI.parse(entry.entry_id)
+      relative_path_parts = entry_id_as_uri.path.split('/').reject(&:blank?)
+      entry_id_int = relative_path_parts.last
+      insertions = ["#{entry_id_int.to_i/16384}", "#{entry_id_int.to_i%16384}"]
+      relative_path_parts = relative_path_parts[0..-2] + insertions + ["#{entry_id_int}.yml"]  
+      File.join(*relative_path_parts)
+    end
+
+    class Entries
+      include Enumerable
+
+      class Enumerator
+        def initialize(dir, first, last)
+          @dir, @first, @last = dir, first, last
+          @last_pos = :limbo
+          @current_pos = first
+        end
+
+        def next
+          raise StopIteration.new unless has_next?
+          current_entry_info = @dir.file(@current_pos) {|f| YAML.load(f) }
+          Feed::Entry.from_snippet(current_entry_info[:entry_xml]).tap do
+            @last_pos = @current_pos
+            @current_pos = current_entry_info[:next_entry_file_path]
+          end
+        end
+
+        private
+        def has_next?
+          @current_pos && @last_pos != @last
+        end
+      end
+      
+      def initialize(state_dir, first_info_file, last_info_file)
+        @dir = state_dir
+        @first_info_file = first_info_file
+        @last_info_file = last_info_file
+      end
+          
+      def each(&block)
+        enumerator = Enumerator.new(@dir, @first_info_file, @last_info_file)
+        return enumerator unless block_given?
+        loop do
+          begin
+            yield(enumerator.next)
+          rescue StopIteration
+            break
+          end
+        end
+      end
+    end
+    
+  end  
+end

data/lib/mingle_events/feed/author.rb

@@ -1,9 +1,9 @@
-module MingleEvents  
+module MingleEvents
   module Feed
-    
+
     # The user who's Mingle activity triggered this event
     class Author
-      
+
       # The name of the author
       attr_reader :name
       # The email address of the author
@@ -12,29 +12,18 @@ module MingleEvents
       attr_reader :uri
       # The URI for the author's icon
       attr_reader :icon_uri
-  
+
       def initialize(author_element)
-        @name = author_element.at("name").inner_text
-        @email = optional_element_text(author_element, 'email')
-        @uri = optional_element_text(author_element, 'uri')        
-        @icon_uri = optional_element_text(author_element, 'icon')
+        @name = author_element.inner_text("./atom:name")
+        @email = author_element.optional_inner_text("./atom:email")
+        @uri = author_element.optional_inner_text("./atom:uri")
+        @icon_uri = author_element.optional_inner_text("./mingle:icon")
       end
-      
-      def self.from_snippet(entry_xml)
-        self.new(Nokogiri::XML(entry_xml))        
-      end
-      
-      private 
-      
-      def optional_element_text(parent_element, element_name)
-        element = parent_element.at(element_name)
-        element.nil? ? nil : element.inner_text
+
+      def self.from_snippet(author_xml)
+        self.new(Xml.parse(author_xml, ATOM_AND_MINGLE_NS).select("/atom:author"))
       end
-    
     end
-      
+
   end
 end
-
-
-

data/lib/mingle_events/feed/category.rb

@@ -47,6 +47,8 @@ module MingleEvents
       CARD = Category.new('card', MINGLE_SCHEME)
       # Category for any event that is the creation of a new card
       CARD_CREATION = Category.new('card-creation', MINGLE_SCHEME)
+      # Category for any event that is the copy of a card from one project to another
+      CARD_COPIED_FROM = Category.new('card-copied-from', MINGLE_SCHEME)
       # Category for any event that is the deletion of a card
       CARD_DELETION = Category.new('card-deletion', MINGLE_SCHEME)
       # Category for any event that includes the change of a card's property value

data/lib/mingle_events/feed/changes.rb

@@ -1,76 +1,45 @@
-module MingleEvents  
+module MingleEvents
   module Feed
-    
-    # Enumerable detail for each change specified in the entry's content section 
+
+    # Enumerable detail for each change specified in the entry's content section
     class Changes
-      
+
       include Enumerable
-      
+
       def initialize(changes_element)
         @changes_element = changes_element
       end
-      
-      def each        
+
+      def each
         (@changes ||= parse_changes).each{|c| yield c}
       end
-      
+
       private
-      
+
       def parse_changes
         changes = []
-        @changes_element.search("change").map do |change_element|
+        @changes_element.select_all("./mingle:change").map do |change_element|
           category = Category.for_mingle_term(change_element["type"])
           changes <<  Change.new(category).build(change_element)
         end
         changes
       end
-      
+
       class Change
-        
+
         def initialize(category)
           @category = category
         end
-        
-        def build(element)          
-          element_to_hash(element)
-                                    
-          raw_hash_from_xml = element_to_hash(element)
-          
+
+        def build(element)
+          raw_hash_from_xml = element.to_hash
+
           raw_hash_from_xml[:change].merge({
-            :category => @category, 
+            :category => @category,
             :type => @category
           })
         end
-        
-        private
-    
-        def element_to_hash(element, hash = {}) 
-          hash_for_element = (hash[element.name.to_sym] ||= {})
-                   
-          element.attribute_nodes.each do |a|
-            hash_for_element[a.name.to_sym] = a.value
-          end
-                   
-          element.children.each do |child|
-            next unless child.is_a?(Nokogiri::XML::Element)
-            
-            if child.children.count{|c| c.is_a?(Nokogiri::XML::Element)} > 0
-              element_to_hash(child, hash_for_element)
-            else
-              hash_for_element[child.name.to_sym] = if child["nil"] && child["nil"] == "true"
-                nil
-              else
-                child.inner_text
-              end
-            end
-          end 
-          
-          hash         
-        end
-                        
-      end      
-      
-
-    end    
+      end
+    end
   end
 end

data/lib/mingle_events/feed/entry.rb

@@ -5,46 +5,46 @@ module MingleEvents
     # representing an event in Mingle.
     class Entry
       
-      # Construct with the wrapped Nokogiri Elem for the entry
+      # Construct with the wrapped Xml Elem for the entry
       def initialize(entry_element)
         @entry_element = entry_element
       end
       
       def self.from_snippet(entry_xml)
-        self.new(Nokogiri::XML(entry_xml).remove_namespaces!)        
+        self.new(Xml.parse(entry_xml, ATOM_AND_MINGLE_NS).select('/atom:entry'))
       end
   
       # The raw entry XML from the Atom feed
       def raw_xml
-        @raw_xml ||= @entry_element.to_s
+        @raw_xml ||= @entry_element.raw_xml
       end
   
       # The Atom entry's id value. This is the one true identifier for the entry,
       # and therefore the event.
       def entry_id
-        @entry_id ||= @entry_element.at("id").inner_text
+        @entry_id ||= @entry_element.inner_text("./atom:id")
       end
       alias :event_id :entry_id
   
       # The Atom entry's title
       def title
-        @title ||= @entry_element.at('title').inner_text
+        @title ||= @entry_element.inner_text('./atom:title')
       end
   
       # The time at which entry was created, i.e., the event was triggered
       def updated
-        @updated ||= Time.parse(@entry_element.at("updated").inner_text)
+        @updated ||= Time.parse(@entry_element.inner_text("./atom:updated"))
       end
   
       # The user who created the entry (triggered the event), i.e., changed project data in Mingle
-      def author 
-        @author ||= Author.new(@entry_element.at("author"))
+      def author
+        @author ||= Author.new(@entry_element.select("./atom:author"))
       end
     
       # The set of Atom categoies describing the entry
       def categories
-        @categories ||= @entry_element.search("category").map do |category_element|
-          Category.new(category_element["term"], category_element["scheme"])
+        @categories ||= @entry_element.select_all("./atom:category").map do |category_element|
+          Category.new(category_element.attr("term"), category_element.attr("scheme"))
         end
       end
       
@@ -55,7 +55,7 @@ module MingleEvents
       # The data in the change hashes reflect only what is in the XML as encriching them would 
       # require potentially many calls to the Mingle server resulting in very slow processing. 
       def changes
-        @changes ||= Changes.new(@entry_element.at("content/changes"))
+        @changes ||= Changes.new(@entry_element.select("./atom:content/mingle:changes"))
       end
   
       # Whether the entry/event was sourced by a Mingle card
@@ -108,21 +108,16 @@ module MingleEvents
       private
   
       def parse_card_number
-        card_number_element = @entry_element.at(
-          "link[@rel='http://www.thoughtworks-studios.com/ns/mingle#event-source'][@type='application/vnd.mingle+xml']"
-        )
+        card_number_element = @entry_element.select("./atom:link[@rel='http://www.thoughtworks-studios.com/ns/mingle#event-source'][@type='application/vnd.mingle+xml']")
         # TODO: improve this bit of parsing :)
-        card_number_element["href"].split('/').last.split('.')[0..-2].join.to_i
+        card_number_element.attr("href").split('/').last.split('.')[0..-2].join.to_i
       end
   
       def parse_card_version_resource_uri
-        card_number_element = @entry_element.at(
-          "link[@rel='http://www.thoughtworks-studios.com/ns/mingle#version'][@type='application/vnd.mingle+xml']"
-        )
-        card_number_element["href"]
+        card_number_element = @entry_element.select("./atom:link[@rel='http://www.thoughtworks-studios.com/ns/mingle#version'][@type='application/vnd.mingle+xml']")
+        card_number_element.attr("href")
       end
-  
     end
     
   end
-end
+end

data/lib/mingle_events/feed/links.rb

@@ -10,8 +10,8 @@ module MingleEvents
       RELATED_REL = "http://www.thoughtworks-studios.com/ns/mingle#related"
       
       def initialize(entry_element)
-        @links ||= entry_element.search("link").map do |category_element|
-          Link.new(category_element["href"], category_element["rel"], category_element["type"], category_element["title"])
+        @links ||= entry_element.select_all("./atom:link").map do |link_element|
+          Link.new(*%w(href rel type title).map { |name| link_element.attr(name) })
         end
       end
       
@@ -39,4 +39,4 @@ module MingleEvents
     
   end
   
-end
+end