mingle-macro-development-toolkit 1.3.2 → 1.3.3

data/test/fixtures/sample/card_types.yml

@@ -3,27 +3,35 @@
   position: 3
   color: 'ff3300'
   id: 339
+  project_id: 78
 - name: Defect
   position: 5
   color: '000599'
   id: 340
+  project_id: 78
 - name: Task
   position: 4
   color: 'ffe066'
   id: 341
+  project_id: 78
 - name: Sprint
   position: 2
   color: 'ff0db6'
   id: 342
+  project_id: 78
 - name: Release
   position: 1
   color: '990024'
   id: 343
+  project_id: 78
 - name: Feature
   position: 6
   color: '296600'
   id: 344
+  project_id: 78
 - name: Epic Story
   position: 7
   color: '00d91d'
-  id: 345
+  id: 345
+  project_id: 78
+  

data/test/fixtures/sample/project_variables.yml

@@ -1,5 +1,7 @@
 --- 
 - name: Current Release
   display_value: 'Release 3'
+  project_id: 78
 - name: Current Sprint
-  display_value: 'Iteration 7'
+  display_value: 'Iteration 7'
+  project_id: 78

data/test/fixtures/sample/property_definitions.yml

@@ -3,39 +3,49 @@
   name: Status
   description: ""
   type_description: Managed text list
+  project_id: 78
 - id: 1141
   name: Priority
   description: ""
   type_description: Managed text list
+  project_id: 78
 - id: 1142
   name: Development Started On
   description: ""
   type_description: Managed text list
+  project_id: 78
 - id: 1143
   description: ""
   name: Development Completed On
   type_description: Date
+  project_id: 78
 - id: 1144
   description: ""
   name: Added On
   type_description: Date
+  project_id: 78
 - id: 1145
   description: ""
   name: Estimate - Planning
-  type_description: Formula  
+  type_description: Formula
+  project_id: 78
 - id: 1146
   description: ""
   name: Risk
-  type_description: Managed text list  
+  type_description: Managed text list
+  project_id: 78
 - id: 1147
   description: ""
   name: Task Estimate
   type_description:  Managed text list
+  project_id: 78
 - id: 1148
   description: 
   name: Estimate - Task
   type_description:  Managed text list
+  project_id: 78
 - id: 1149
   description: Individual assigned to a work item
   name: Owner
-  type_description: User  
+  type_description: User
+  project_id: 78

data/test/integration/integration_test_helper.rb

@@ -2,20 +2,32 @@
 
 require 'delegate'
 require 'test/unit'
+require 'net/http'
 require 'macro_development_toolkit'
 require File.dirname(__FILE__) + '/rest_loader'
 
 class Test::Unit::TestCase
-
-  def project(name)
-    @project ||= RESTfulLoaders::ProjectLoader.new(name, nil, self).project
-  end  
-
+  
+  def project(resource)
+    @projects ||= {}
+    @projects[resource] ||= load_project_resource(resource)
+  end
+  
+  def projects(*resources)
+    resources.collect {|resource| project(resource)}
+  end
+  
   def errors
     @errors ||= []
-  end  
+  end
   
   def alert(message)
     errors << message
-  end  
-end  
+  end
+  
+  private
+  
+  def load_project_resource(resource)
+    RESTfulLoaders::ProjectLoader.new(resource, self).project
+  end
+end

data/test/integration/rest_loader.rb

@@ -1,311 +1,233 @@
 #Copyright 2010 ThoughtWorks, Inc.  All rights reserved.
 
 module RESTfulLoaders
+
   class RemoteError < StandardError
     def self.parse(response_body)
       Hash.from_xml(response_body)['errors'].delete("error")
-    end  
-  end  
-  
-  class Base
-    def initialize(project_name)
-      @xml_model = if (String === project_name)
-        @project_name = project_name
-        OpenStruct.new(Hash.from_xml(get(project_name)))
-      else
-        project_name
-      end    
-      raise "No such project resource available! #{@project_name}" unless (@xml_model && @xml_model.to_s != '')
     end
+  end
 
-    def get(url)
-      url = URI.parse(url) unless url.respond_to?(:path)
+  module LoaderHelper
+    
+    def extract(key, container)
+      container[key] ? container[key][key.singularize] : []
+    end
+    
+    def get(resource)
+      url = URI.parse(resource)
       get_request = Net::HTTP::Get.new(url.request_uri)
       get_request.basic_auth(url.user, url.password)
       response = Net::HTTP.start(url.host, url.port) { |http| http.request(get_request) }
-      if response.code.to_s != "200" 
+      if response.code.to_s != "200"
         raise RemoteError, RemoteError.parse(response.body)
       end  
-      response.body
-    end  
-  
-    def load_all_card_types_from_xml
-      extract_array_of 'card_types', :from => @xml_model.project
-    end  
-
-    def load_all_property_definitions_from_xml
-      extract_array_of 'property_definitions', :from => @xml_model.project
-    end  
-
-    def load_all_card_types_property_definitions_from_xml
-      load_all_card_types_from_xml.collect do |card_type_xml| 
-        card_types_property_definitions = OpenStruct.new(card_type_xml).card_types_property_definitions
-        [card_types_property_definitions['card_type_property_definition']].flatten if card_types_property_definitions
-      end.compact.flatten.compact
-    end  
-
-    def card_types_property_definitions_by_card_type_id_loader(card_type_id)
-      LoadCardTypesPropertyDefinitionsByCardTypeId.new(card_type_id, @xml_model)
-    end  
-  
-    def card_types_property_definitions_by_property_definition_id_loader(property_definition_id)
-      LoadCardTypesPropertyDefinitionsByPropertyDefinitionId.new(property_definition_id, @xml_model)
+      Hash.from_xml(response.body)
     end
+  end
   
-    def values_by_property_definition_id_loader(property_definition_id)
-      LoadValuesByPropertyDefinitionId.new(property_definition_id, @xml_model)
-    end  
+  class MqlExecutor < SimpleDelegator
+    include LoaderHelper
 
-    def card_type_by_id_loader(card_type_id)
-      LoadCardTypeById.new(card_type_id, @xml_model)
+    def initialize(resource, error_handler, delegator)
+      super(delegator)
+      @uri = URI.parse(resource)
+      @error_handler = error_handler
+      @version = /(\/api\/([^\/]*))\//.match(@uri.request_uri)[2]
     end
-  
-    def property_definition_by_id_loader(property_definition_id)
-      LoadPropertyDefinitionById.new(property_definition_id, @xml_model)
-    end
-    
-    def card_types_by_project_id_loader
-      LoadCardTypesByProjectId.new(@xml_model)
-    end  
 
-    def property_definitions_by_project_id_loader
-      LoadPropertyDefinitionsByProjectId.new(@xml_model)
-    end  
+    def execute_mql(mql)
+      from_xml_data(get(url_for(:action => "execute_mql", :query => "mql=#{mql}")))
+    rescue => e
+      @error_handler.alert(e.message)
+      []
+    end
     
-    def team_by_project_id_loader
-      LoadTeamByProjectId.new(@xml_model)
+    def can_be_cached?(mql)
+      from_xml_data(get(url_for(:action => "can_be_cached", :query => "mql=#{mql}")))
+    rescue => e
+      @error_handler.alert(e.message)
+      []
     end
     
-    def project_variables_by_project_id_loader
-      LoadProjectVariablesByProjectId.new(@xml_model)
+    def format_number_with_project_precision(number)
+      from_xml_data(get(url_for(:action => "format_number_to_project_precision", :query => "number=#{number}")))
+    rescue => e
+      @error_handler.alert(e.message)
+      []
     end
     
-    def extract_array_of(container_key, options)
-      contents_hash = options[:from]
-      container = contents_hash[container_key]
-      container ? [container[container_key.singularize]].flatten.compact : []
-    end      
-  end
+    def format_date_with_project_date_format(date)
+      from_xml_data(get(url_for(:action => "format_string_to_date_format", :query => "date=#{date}")))
+    rescue => e
+      @error_handler.alert(e.message)
+      []
+    end
 
-  class ProjectLoader < Base
-    class MqlExecutionDelegate < SimpleDelegator
-      def initialize(delegate, mql_executor)
-        @mql_executor = mql_executor
-        __setobj__(delegate)
-      end
-      
-      def execute_mql(mql)
-        @mql_executor.execute_mql(mql, self)
-      rescue => e
-        __getobj__.send(:add_alert, e.message)
-        []
-      end
-      
-      def can_be_cached?(mql)
-        @mql_executor.can_be_cached?(mql, self)
-      rescue => e
-        __getobj__.send(:add_alert, e.message)
-        []
-      end
-      
-      def format_number_with_project_precision(number)
-        @mql_executor.format_number_with_project_precision(number, self)
-      rescue => e
-        __getobj__.send(:add_alert, e.message)
-      end
-      
-      def format_date_with_project_date_format(date)
-        @mql_executor.format_date_with_project_date_format(date, self)
-      rescue => e
-        __getobj__.send(:add_alert, e.message)
+    def url_for(params)
+      relative_path = URI.escape("/api/#{@version}/projects/#{identifier}/cards/#{params[:action]}.xml?#{params[:query]}")
+      @uri.merge(relative_path).to_s
+    end
+
+    def from_xml_data(data)
+      if data.is_a?(Hash) && data.keys.size == 1
+        from_xml_data(data.values.first)
+      else
+        data
       end
-    end  
+    end
+  end
 
-    def initialize(project_name, macro_context=nil, alert_receiver=nil)
-      super(project_name)
-      project_name =~ /(\/api\/([^\/]*))\//
-      @api_version_name = $1
-      @macro_context = macro_context
-      @alert_receiver = alert_receiver
+  class ProjectLoader
+    include LoaderHelper
+    
+    def initialize(resource, error_handler)
+      @resource = resource
+      @error_handler = error_handler
     end
-      
-    def load_project_from_xml
-      @xml_model.project
-    end  
     
     def project
-      project = MqlExecutionDelegate.new(Mingle::Project.new(OpenStruct.new(load_project_from_xml), :alert_receiver => @alert_receiver), self)
-      project.card_types_loader = card_types_by_project_id_loader
-      project.property_definitions_loader = property_definitions_by_project_id_loader
-      project.team_loader = team_by_project_id_loader
-      project.project_variables_loader = project_variables_by_project_id_loader
-      project
+      @project ||= load
     end
     
-    def execute_mql(mql, project)
-      from_xml_data(
-        Hash.from_xml(
-          get(
-            build_request_url(:path => url_for("execute_mql"), :query => "mql=#{mql}"))))
+    private
+
+    def load
+      proj = OpenStruct.new(get(@resource)).project
+      project = MqlExecutor.new(@resource, @error_handler, Mingle::Project.new(OpenStruct.new(proj), nil))
+      project.card_types_loader = CardTypesLoader.new(proj)
+      project.property_definitions_loader = PropertyDefinitionsLoader.new(proj)
+      project.team_loader = TeamLoader.new(proj)
+      project.project_variables_loader = ProjectVariablesLoader.new(proj)
+      project
     end
+
+  end
+  
+  class CardTypesLoader
+    include LoaderHelper
     
-    def can_be_cached?(mql, project)
-      from_xml_data(
-        Hash.from_xml(
-          get(
-            build_request_url(:path => url_for("can_be_cached"), :query => "mql=#{mql}"))))
+    def initialize(project)
+      @project = project
     end
     
-    def format_number_with_project_precision(number, project)
-      from_xml_data(
-        Hash.from_xml(
-          get(
-            build_request_url(:path => url_for("format_number_to_project_precision"), :query => "number=#{number}"))))
+    def load
+      extract('card_types', @project).collect { |ct| CardTypeLoader.new(@project, ct) }.sort_by { |loader| loader.card_type.position }
     end
+  end
+  
+  class CardTypeLoader
     
-    def format_date_with_project_date_format(date, project)  
-      from_xml_data(
-        Hash.from_xml(
-          get(
-            build_request_url(:path => url_for("format_string_to_date_format"), :query => "date=#{date}"))))
+    def initialize(project, ct)
+      @project = project
+      @ct = ct
     end
     
-    def url_for(action)
-      "#{@api_version_name}/projects/#{project.identifier}/cards/#{action}.xml"
+    def card_type
+      @card_type ||= load
     end
     
-    def build_request_url(params)
-      url = URI.parse(@project_name)
-      request_class = if url.scheme == 'http'
-        URI::HTTP
-      elsif
-        URI::HTTPS
-      else
-        raise "Unknown protocol used to access project resource #{@project_name}. Supported protocols are HTTP & HTTPS"
-      end  
-      default_params = {:userinfo => "#{url.user}:#{url.password}", :host => url.host, :port => url.port.to_s}      
-      request_class.build2(default_params.merge(params))
-    end  
-    
-    def from_xml_data(data)
-      if data.is_a?(Hash) && data.keys.size == 1
-        from_xml_data(data.values.first)
-      else
-        data
-      end
-    end
-  end
-
-  class LoadCardTypesByProjectId < Base
     def load
-      load_all_card_types_from_xml.collect do |ct|
-        card_type = Mingle::CardType.new(OpenStruct.new(ct))
-        card_type.card_types_property_definitions_loader = card_types_property_definitions_by_card_type_id_loader(ct['id'])
-        card_type
-      end.sort_by(&:position)
-    end  
+      card_type = Mingle::CardType.new(OpenStruct.new(@ct))
+      card_type.card_types_property_definitions_loader = CardTypesPropertyDefinitionsLoader.new(@project, 'card_type_id' => @ct['id'])
+      card_type
+    end
   end
 
-  class LoadPropertyDefinitionsByProjectId < Base
+  class PropertyDefinitionsLoader
+    include LoaderHelper
+    
+    def initialize(project)
+      @project = project
+    end
+    
     def load
-      load_all_property_definitions_from_xml.collect do |pd|
-        property_definition = Mingle::PropertyDefinition.new(OpenStruct.new(pd))
-        property_definition.card_types_property_definitions_loader = card_types_property_definitions_by_property_definition_id_loader(pd['id'])
-        property_definition.values_loader = values_by_property_definition_id_loader(pd['id'])
-        property_definition
-      end
-    end  
+      extract('property_definitions', @project).collect { |pd| PropertyDefinitionLoader.new(@project, pd) }
+    end
   end
-
-  class LoadCardTypesPropertyDefinitionsByCardTypeId < Base
-    def initialize(card_type_id, fixture_file_name)
-      super(fixture_file_name)
-      @card_type_id = card_type_id
-    end  
   
+  class PropertyDefinitionLoader
+    def initialize(project, pd)
+      @project = project
+      @pd = pd
+    end
+    
+    def property_definition
+      @property_definition ||= load
+    end
+    
     def load
-      load_all_card_types_property_definitions_from_xml.collect do |ctpd|
-        next unless ctpd['card_type_id'] == @card_type_id
-        card_type_property_definition = Mingle::CardTypePropertyDefinition.new(OpenStruct.new(ctpd))
-        card_type_property_definition.card_type_loader = card_type_by_id_loader(ctpd['card_type_id'])
-        card_type_property_definition.property_definition_loader = property_definition_by_id_loader(ctpd['property_definition_id'])
-        card_type_property_definition
-      end.compact.sort_by(&:position).compact
-    end  
-  end  
-
-  class LoadCardTypesPropertyDefinitionsByPropertyDefinitionId < Base
-    def initialize(property_definition_id, fixture_file_name)
-      super(fixture_file_name)
-      @property_definition_id = property_definition_id
-    end  
-
-    def load
-      load_all_card_types_property_definitions_from_xml.collect do |ctpd|
-        next unless ctpd['property_definition_id'] == @property_definition_id
-        card_type_property_definition = Mingle::CardTypePropertyDefinition.new(OpenStruct.new(ctpd))
-        card_type_property_definition.card_type_loader = card_type_by_id_loader(ctpd['card_type_id'])
-        card_type_property_definition.property_definition_loader = property_definition_by_id_loader(ctpd['property_definition_id'])
-        card_type_property_definition
-      end.compact.sort_by(&:position).compact
-    end  
+      @property_definition = Mingle::PropertyDefinition.new(OpenStruct.new(@pd))
+      @property_definition.card_types_property_definitions_loader = CardTypesPropertyDefinitionsLoader.new(@project, 'property_definition_id' => @pd['id'])
+      @property_definition.values_loader = PropertyValuesLoader.new(@pd)
+      @property_definition
+    end
   end
-
-  class LoadCardTypeById < Base
-    def initialize(card_type_id, fixture_file_name)
-      super(fixture_file_name)
-      @card_type_id = card_type_id
-    end  
-
-    def load
-      yaml = load_all_card_types_from_xml.detect { |ct| ct['id'] == @card_type_id }
-      ct = Mingle::CardType.new(OpenStruct.new(yaml))
-      ct.card_types_property_definitions_loader = card_types_property_definitions_by_card_type_id_loader(yaml['id'])
-      ct
-    end  
-  end  
-
-  class LoadPropertyDefinitionById < Base
-    def initialize(property_definition_id, fixture_file_name)
-      super(fixture_file_name)
-      @property_definition_id = property_definition_id
+  
+  class PropertyValuesLoader
+    include LoaderHelper
+    
+    def initialize(property_definition)
+      @property_definition = property_definition
     end
-
+    
     def load
-      yaml = load_all_property_definitions_from_xml.detect { |pd| pd['id'] == @property_definition_id }
-      pd = Mingle::PropertyDefinition.new(OpenStruct.new(yaml))
-      pd.card_types_property_definitions_loader = card_types_property_definitions_by_property_definition_id_loader(yaml['id'])
-      pd.values_loader = values_by_property_definition_id_loader(yaml['id'])
-      pd
-    end  
-  end
-
-  class LoadValuesByPropertyDefinitionId < Base
-    def initialize(property_definition_id, fixture_file_name)
-      super(fixture_file_name)
-      @property_definition_id = property_definition_id
+      extract('values', @property_definition).collect {|value| Mingle::PropertyValue.new(OpenStruct.new(value))}
     end
+    
+  end
   
+  class CardTypesPropertyDefinitionsLoader
+    include LoaderHelper
+    
+    def initialize(project, params)
+      @project = project
+      @params = params
+    end
+    
     def load
-      property_definition = load_all_property_definitions_from_xml.detect { |property_definition_xml| property_definition_xml['id'] == @property_definition_id }
-      return unless property_definition
-      extract_array_of('values', :from => property_definition).collect do |property_value_xml| 
-        property_value = Mingle::PropertyValue.new(OpenStruct.new(property_value_xml)) 
-        property_value.property_definition_loader = property_definition_by_id_loader(property_value_xml['property_definition_id'])
-        property_value
+      mappings = extract('card_types', @project).collect do |card_type|
+        mapping = card_type['card_types_property_definitions'].values
+      end.flatten
+      
+      pds = extract('property_definitions', @project)
+      cts = extract('card_types', @project)
+      mappings.collect do |mapping|
+        if (match?(mapping))
+          pd = pds.find { |pd| pd['id'] && pd['id'] == mapping['property_definition_id'] }
+          ct = cts.find { |ct| ct['id'] == mapping['card_type_id'] }
+          OpenStruct.new(:card_type => CardTypeLoader.new(@project, ct).load, :property_definition => PropertyDefinitionLoader.new(@project, pd).load)
+        end
       end.compact
-    end  
+    end
+    
+    private
+    def match?(mapping)
+      @params.all? { |key, value| value == mapping[key] }
+    end
   end
   
-  class LoadTeamByProjectId < Base
+  class TeamLoader
+    include LoaderHelper
+    
+    def initialize(project)
+      @project = project
+    end
+    
     def load
-      extract_array_of('users', :from => @xml_model.project).collect { |user| Mingle::User.new(OpenStruct.new(user)) }
-    end  
+      (extract('users', @project) || []).collect{ |user| Mingle::User(OpenStruct.new(user))}
+    end
   end
-
-  class LoadProjectVariablesByProjectId < Base
+  
+  class ProjectVariablesLoader
+    include LoaderHelper
+    
+    def initialize(project)
+      @project = project
+    end
+    
     def load
-      extract_array_of('project_variables', :from => @xml_model.project).collect { |pv| Mingle::ProjectVariable.new(OpenStruct.new(pv)) }
-    end  
+      extract('project_variables', @project).collect {|pv| Mingle::ProjectVariable.new(OpenStruct.new(pv))}
+    end
   end
-end
+end