mingle_events 0.0.4

data/lib/mingle_events/processors/card_type_filter.rb

@@ -0,0 +1,28 @@
+module MingleEvents
+  module Processors
+    
+    # Filters events by card types. As events do not contain the type
+    # of the card, this filter requires a lookup against Mingle to 
+    # determine the type of the card that sourced the event. In the case
+    # of the card's being deleted in the interim between the actual event
+    # and this filtering, the event will be filtered as there is no means
+    # to determine its type. Therefore, it's recommended to also
+    # subscribe a 'CardDeleted' processor to the same project.    
+    class CardTypeFilter
+    
+      def initialize(card_types, card_data)
+        @card_types = card_types
+        @card_data = card_data
+      end
+    
+      def process_events(events)
+        events.select do |event|
+          event.card? && 
+            @card_data.for_card_event(event) &&
+            @card_types.include?(@card_data.for_card_event(event)[:card_type_name])
+        end
+      end
+
+    end
+  end
+end

data/lib/mingle_events/processors/category_filter.rb

@@ -0,0 +1,19 @@
+module MingleEvents
+  module Processors
+    
+    # Removes events from the stream that do not match all of the specified categories
+    class CategoryFilter
+    
+      def initialize(categories)
+        @categories = categories
+      end
+    
+      def process_events(events)
+        events.select do |event|
+          @categories.all?{|c| event.categories.include?(c)}
+        end
+      end
+    
+    end
+  end
+end

data/lib/mingle_events/processors/custom_property_filter.rb

@@ -0,0 +1,30 @@
+module MingleEvents
+  module Processors
+    
+    # Filters events by a single custom property value. 
+    # As events will not necessarily contain this data, 
+    # this filter requires a lookup against Mingle to 
+    # determine the type of the card that sourced the event. In the case
+    # of the card's being deleted in the interim between the actual event
+    # and this filtering, the event will be filtered as there is no means
+    # to determine its type. Therefore, it's recommended to also
+    # subscribe a 'CardDeleted' processor to the same project.    
+    class CustomPropertyFilter
+    
+      def initialize(property_name, property_value, card_data)
+        @property_name = property_name
+        @property_value = property_value
+        @card_data = card_data
+      end
+    
+      def process_events(events)
+        events.select do |event|
+          event.card? && 
+            @card_data.for_card_event(event) &&
+            @property_value == @card_data.for_card_event(event)[:custom_properties][@property_name]
+        end
+      end
+
+    end
+  end
+end

data/lib/mingle_events/processors/http_post_publisher.rb

@@ -0,0 +1,20 @@
+module MingleEvents
+  module Processors
+    
+    class HttpPostPublisher
+
+      def initialize(url)
+        @url = url
+      end
+      
+      def process_events(events)
+        events.map{|e| process_event(e)}
+      end
+
+      def process_event(event) 
+        Net::HTTP.post_form(URI.parse(@url), {'event' => event.raw_xml}).body
+      end
+    
+    end
+  end
+end

data/lib/mingle_events/processors/pipeline.rb

@@ -0,0 +1,20 @@
+module MingleEvents
+  module Processors
+    
+    # Manages the passing of a stream of events through a sequence of processors
+    class Pipeline
+      
+      def initialize(processors)
+        @processors = processors
+      end
+      
+      def process_events(events)
+        processed_events = events
+        @processors.each do |processor|
+          processed_events = processor.process_events(processed_events)
+        end
+        processed_events
+      end
+    end
+  end
+end

data/lib/mingle_events/processors/puts_publisher.rb

@@ -0,0 +1,17 @@
+module MingleEvents
+  module Processors
+    
+    # Writes each event in stream to stdout, mostly for demonstration purposes
+    class PutsPublisher
+      
+      def process_events(events)
+        events.map{|e| process_event(e)}
+      end
+
+      def process_event(event) 
+        puts "Processing event #{event}"
+      end
+    
+    end
+  end
+end

data/lib/mingle_events/project_custom_properties.rb

@@ -0,0 +1,33 @@
+module MingleEvents
+  
+  class ProjectCustomProperties
+    
+    def initialize(mingle_access, project_identifier)
+      @mingle_access = mingle_access
+      @project_identifier = project_identifier
+    end
+    
+    def property_name_for_column(column_name)
+      property_names_by_column_name[column_name]
+    end
+    
+    private
+    
+    def property_names_by_column_name
+      @property_names_by_column_name ||= lookup_property_names_by_column_name
+    end
+    
+    def lookup_property_names_by_column_name      
+      as_document.search('/property_definitions/property_definition').inject({}) do |mapping, element|
+        mapping[element.at('column_name').inner_text] = element.at('name').inner_text        
+        mapping
+      end
+    end
+    
+    def as_document
+      @as_document ||= Nokogiri::XML(@mingle_access.fetch_page("/api/v2/projects/#{@project_identifier}/property_definitions.xml"))
+    end  
+    
+  end
+  
+end

data/lib/mingle_events/project_event_fetcher.rb

@@ -0,0 +1,96 @@
+module MingleEvents
+  
+  # fetch all unseen events and write them to disk for future processing
+  class ProjectEventFetcher
+    
+    def initialize(project_identifier, mingle_access, state_dir=nil)
+      @project_identifier = project_identifier
+      @mingle_access = mingle_access
+      base_uri = URI.parse(mingle_access.base_url)
+      @state_dir = File.expand_path(state_dir || File.join('~', '.mingle_events', base_uri.host, base_uri.port.to_s, project_identifier, 'fetched_events'))
+    end
+    
+    def reset
+      FileUtils.rm_rf(@state_dir)
+    end
+    
+    def fetch_latest
+      page = Feed::Page.new("/api/v2/projects/#{@project_identifier}/feeds/events.xml", @mingle_access)
+      most_recent_new_entry = page.entries.first
+      
+      last_fetched_entry = load_last_fetched_entry
+      fetched_previously_seen_event = false      
+      next_entry = nil
+      while !fetched_previously_seen_event && page
+        page.entries.each do |entry|
+                    
+          if last_fetched_entry && entry.entry_id == last_fetched_entry.entry_id
+            fetched_previously_seen_event = true
+            break
+          end
+          
+          write_entry_to_disk(entry, next_entry)
+          next_entry = entry
+        
+        end
+        page = page.next
+      end
+            
+      update_current_state(most_recent_new_entry)
+      
+      file_for_entry(next_entry)
+    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('/')
+      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(@state_dir, *relative_path_parts)
+    end
+    
+    def current_state_file
+      File.expand_path(File.join(@state_dir, 'current_state.yml'))
+    end
+        
+    private 
+    
+    def load_last_fetched_entry
+      current_state = if File.exist?(current_state_file)
+        YAML.load(File.new(current_state_file))
+      else
+        {:last_fetched_entry_info_file => nil}
+      end
+      last_fetched_entry = if current_state[:last_fetched_entry_info_file]
+        last_fetched_entry_info = YAML.load(File.new(current_state[:last_fetched_entry_info_file]))
+        Feed::Entry.new(Nokogiri::XML(last_fetched_entry_info[:entry_xml]).at('/entry'))
+      else 
+        nil
+      end
+    end
+    
+    def update_current_state(most_recent_new_entry)
+      if most_recent_new_entry
+        File.open(current_state_file, 'w') do |out|
+          YAML.dump({:last_fetched_entry_info_file => file_for_entry(most_recent_new_entry)}, out)
+        end
+      end
+    end
+        
+    def write_entry_to_disk(entry, next_entry)
+      file = file_for_entry(entry)
+      FileUtils.mkdir_p(File.dirname(file))
+      file_content = {
+        :entry_xml => entry.raw_xml,
+        :next_entry_file_path => file_for_entry(next_entry)
+      }
+      File.open(file, 'w') do |out|
+        YAML.dump(file_content, out)
+      end
+    end
+    
+  end
+end

data/test/mingle_events/feed/author_test.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
+
+module MingleEvents
+  module Feed
+    
+    class AuthorTest < Test::Unit::TestCase
+  
+      def test_parse_attributes
+        element = Nokogiri.XML(%{
+          <author xmlns:mingle="http://www.thoughtworks-studios.com/ns/mingle">
+            <name>Sammy Soso</name>
+            <email>sammy@example.com</email>
+            <uri>https://mingle.example.com/api/v2/users/233.xml</uri>
+            <mingle:icon>https://mingle.example.com/user/icon/233/profile.jpg</mingle:icon>
+          </author>})
+        
+        author = Author.new(element)
+        assert_equal("Sammy Soso", author.name)
+        assert_equal("sammy@example.com", author.email)
+        assert_equal("https://mingle.example.com/api/v2/users/233.xml", author.uri)
+        assert_equal("https://mingle.example.com/user/icon/233/profile.jpg", author.icon_uri)
+      end
+    
+      def test_parse_attributes_when_no_optional_fields
+        element = Nokogiri.XML(%{
+          <author xmlns:mingle="http://www.thoughtworks-studios.com/ns/mingle">
+            <name>Sammy Soso</name>
+          </author>})
+        author = Author.new(element)
+        assert_equal("Sammy Soso", author.name)
+        assert_nil(author.email)
+        assert_nil(author.uri)
+        assert_nil(author.icon_uri)
+      end
+  
+    end
+  
+  end
+end

data/test/mingle_events/feed/category_test.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
+
+module MingleEvents
+  module Feed
+    
+    class CategoryTest < Test::Unit::TestCase
+    
+      def test_equality        
+        assert_equal(Category::CARD, Category::CARD)
+        assert_equal(Category::CARD, Category.new('card', 'http://www.thoughtworks-studios.com/ns/mingle#categories'))
+        assert_not_equal(Category::CARD, Category::PAGE)
+        assert_not_equal(Category::CARD, nil)
+        assert_not_equal(Category::CARD, Object.new)
+        assert_equal(:foo, {Category::CARD => :foo}[Category.new('card', 'http://www.thoughtworks-studios.com/ns/mingle#categories')])
+      end
+    
+    end
+  
+  end
+end

data/test/mingle_events/feed/entry_test.rb

@@ -0,0 +1,140 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
+
+module MingleEvents
+  module Feed
+    
+    class EntryTest < Test::Unit::TestCase
+  
+      def test_parse_basic_attributes
+        element_xml_text = %{
+          <entry xmlns:mingle="http://www.thoughtworks-studios.com/ns/mingle">
+            <id>https://mingle.example.com/projects/mingle/events/index/234443</id>
+            <title>Page Special:HeaderActions changed</title>
+            <updated>2011-02-03T08:12:42Z</updated>
+            <author>
+              <name>Sammy Soso</name>
+              <email>sammy@example.com</email>
+              <uri>https://mingle.example.com/api/v2/users/233.xml</uri>
+            </author>
+          </entry>}
+        element = Nokogiri::XML(element_xml_text)
+      
+        entry = Entry.new(element)
+        # assert_equal(element_xml_text.inspect, entry.raw_xml.inspect) 
+        assert_equal("https://mingle.example.com/projects/mingle/events/index/234443", entry.entry_id)
+        assert_equal("Page Special:HeaderActions changed", entry.title)
+        assert_equal("Thu Feb 03 08:12:42 UTC 2011", entry.updated.to_s)
+        assert_equal("Sammy Soso", entry.author.name)
+      end
+    
+      def test_parse_categories
+        element_xml_text = %{
+          <entry xmlns:mingle="http://www.thoughtworks-studios.com/ns/mingle">
+            <category term="foo" scheme='http://tws.com/ns#mingle' />
+            <category term="bar" scheme="http://tws.com/ns#go" />
+          </entry>}
+        element = Nokogiri::XML(element_xml_text)
+        
+        entry = Entry.new(element)
+        assert_equal(
+          [Category.new('foo', 'http://tws.com/ns#mingle'), Category.new('bar', 'http://tws.com/ns#go')],
+          entry.categories
+        )
+      end
+    
+      def test_parse_card_number_and_version
+      
+        # the links below contain intentionally nonsensical data so as to ensure
+        # that the card number is derived from a single, precise position
+      
+        element_xml_text = %{
+          <entry xmlns:mingle="http://www.thoughtworks-studios.com/ns/mingle">
+            <category term="card" scheme="http://www.thoughtworks-studios.com/ns/mingle#categories"/>
+            <link href="https://mingle.example.com/projects/atlas/cards/102" rel="http://www.thoughtworks-studios.com/ns/mingle#event-source" type="text/html" title="bug #103"/>
+            <link href="https://mingle.example.com/api/v2/projects/atlas/cards/104.xml?version=7" rel="http://www.thoughtworks-studios.com/ns/mingle#version" type="application/vnd.mingle+xml" title="bug #105 (v7)"/>
+            <link href="https://mingle.example.com/api/v2/projects/atlas/cards/106.xml" rel="http://www.thoughtworks-studios.com/ns/mingle#event-source" type="application/vnd.mingle+xml" title="bug #107"/>
+            <link href="https://mingle.example.com/projects/atlas/cards/108?version=17" rel="http://www.thoughtworks-studios.com/ns/mingle#version" type="text/html" title="bug #109 (v7)"/>
+          </entry>}
+        element = Nokogiri::XML(element_xml_text)
+      
+        entry = Entry.new(element)
+        assert_equal(106, entry.card_number)
+        assert_equal(7, entry.version)
+      end
+    
+      def test_card_number_and_version_throws_error_when_event_not_related_to_a_card      
+        element_xml_text = %{
+          <entry xmlns:mingle="http://www.thoughtworks-studios.com/ns/mingle">
+            <category term="page" scheme="http://www.thoughtworks-studios.com/ns/mingle#categories"/>
+          </entry>}
+        element = Nokogiri::XML(element_xml_text)
+      
+        entry = Entry.new(element)
+      
+        begin
+          entry.card_number
+          fail("Should not have been able to retrieve a card number for non card-related event!")
+        rescue Exception => e
+          assert_equal("You cannot get the card number for an event that is not sourced by a card!", e.message)
+        end
+      
+        begin
+          entry.version
+          fail("Should not have been able to retrieve a card version for non card-related event!")
+        rescue Exception => e
+          assert_equal("You cannot get card version data for an event that is not sourced by a card!", e.message)
+        end
+      
+      end
+    
+      def test_parse_card_version_resource_uri
+      
+        # the links below contain intentionally nonsensical data so as to ensure
+        # that the card number is derived from a single, precise position
+      
+        element_xml_text = %{
+          <entry xmlns:mingle="http://www.thoughtworks-studios.com/ns/mingle">
+            <category term="card" scheme="http://www.thoughtworks-studios.com/ns/mingle#categories"/>
+            <link href="https://mingle.example.com/projects/atlas/cards/102" rel="http://www.thoughtworks-studios.com/ns/mingle#event-source" type="text/html" title="bug #103"/>
+            <link href="https://mingle.example.com/api/v2/projects/atlas/cards/104.xml?version=7" rel="http://www.thoughtworks-studios.com/ns/mingle#version" type="application/vnd.mingle+xml" title="bug #105 (v7)"/>
+            <link href="https://mingle.example.com/api/v2/projects/atlas/cards/106.xml" rel="http://www.thoughtworks-studios.com/ns/mingle#event-source" type="application/vnd.mingle+xml" title="bug #107"/>
+            <link href="https://mingle.example.com/projects/atlas/cards/108?version=7" rel="http://www.thoughtworks-studios.com/ns/mingle#version" type="text/html" title="bug #109 (v7)"/>
+          </entry>}
+        element = Nokogiri::XML(element_xml_text)
+      
+        entry = Entry.new(element)
+        assert_equal('https://mingle.example.com/api/v2/projects/atlas/cards/104.xml?version=7', entry.card_version_resource_uri)
+      end
+    
+      def test_card_version_resource_uri_throws_error_when_not_card_event
+        element_xml_text = %{
+          <entry xmlns:mingle="http://www.thoughtworks-studios.com/ns/mingle">
+            <category term="page" scheme="http://www.thoughtworks-studios.com/ns/mingle#categories"/>
+          </entry>}
+        element = Nokogiri::XML(element_xml_text)
+      
+        entry = Entry.new(element)
+        begin
+          entry.card_version_resource_uri
+          fail("Should not have been able to retrieve a card version resource URI for non card-related event!")
+        rescue Exception => e
+          assert_equal("You cannot get card version data for an event that is not sourced by a card!", e.message)
+        end
+      end
+    
+      def test_entry_id_aliased_as_event_id
+        element_xml_text = %{
+          <entry xmlns:mingle="http://www.thoughtworks-studios.com/ns/mingle">
+            <id>https://mingle.example.com/projects/mingle/events/index/234443</id>
+          </entry>}
+        element = Nokogiri::XML(element_xml_text)
+      
+        entry = Entry.new(element)
+        assert_equal('https://mingle.example.com/projects/mingle/events/index/234443', entry.event_id)
+        assert_equal(entry.entry_id, entry.event_id)
+      end
+      
+    end
+  
+  end
+end