mingle-macro-development-toolkit 1.3.2 → 1.3.3

data/test/unit/fixture_loader.rb

@@ -1,181 +1,109 @@
 #Copyright 2010 ThoughtWorks, Inc.  All rights reserved.
-require 'erb'
 
 module FixtureLoaders
   class Base
-    def initialize(mingle_file_name, macro_context=nil, alert_receiver=nil)
-      @mingle_file_name = mingle_file_name
-      @expanded_fixture = File.join(File.dirname(__FILE__), '..', 'fixtures', mingle_file_name)
-      raise "No such project fixture! #{mingle_file_name}" unless File.exist?(@expanded_fixture)
+    
+    def initialize(attributes)
+      @attributes = attributes
     end
-  
+    
     def load_fixtures_for(name)
-      YAML::load(ERB.new(File.read("#{@expanded_fixture}/#{name}.yml")).result(binding))
-    end
-  
-    def card_types_property_definitions_by_card_type_id_loader(card_type_id)
-      LoadCardTypesPropertyDefinitionsByCardTypeId.new(card_type_id, @mingle_file_name)
-    end  
-  
-    def card_types_property_definitions_by_property_definition_id_loader(property_definition_id)
-      LoadCardTypesPropertyDefinitionsByPropertyDefinitionId.new(property_definition_id, @mingle_file_name)
-    end
-  
-    def values_by_property_definition_id_loader(property_definition_id)
-      LoadValuesByPropertyDefinitionId.new(property_definition_id, @mingle_file_name)
-    end  
-
-    def card_type_by_id_loader(card_type_id)
-      LoadCardTypeById.new(card_type_id, @mingle_file_name)
+      path = File.join(File.dirname(__FILE__), '..', 'fixtures', "sample", "#{name}.yml")
+      YAML::load(File.read(path))
     end
-  
-    def property_definition_by_id_loader(property_definition_id)
-      LoadPropertyDefinitionById.new(property_definition_id, @mingle_file_name)
-    end  
     
-    def card_types_by_project_id_loader
-      LoadCardTypesByProjectId.new(@mingle_file_name)
-    end  
-
-    def property_definitions_by_project_id_loader
-      LoadPropertyDefinitionsByProjectId.new(@mingle_file_name)
-    end  
-    
-    def team_by_project_id_loader
-      LoadTeamByProjectId.new(@mingle_file_name)
+    def match?(record)
+      @attributes.all? { |key, value| value == record[key] }
     end
-    
-    def project_variables_by_project_id_loader
-      LoadProjectVariablesByProjectId.new(@mingle_file_name)
-    end    
-    
   end
 
   class ProjectLoader < Base
-    def project
-      project_attributes = load_fixtures_for('projects').first
-      project = Mingle::Project.new(OpenStruct.new(project_attributes), nil)
-      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
+    attr_reader :project
+
+    def initialize(identifier)
+      project_attributes = load_fixtures_for('projects').detect {|project| project['identifier'] == identifier }
+      @project = Mingle::Project.new(OpenStruct.new(project_attributes), nil)
+      project.card_types_loader = CardTypesLoader.new('project_id' => project_attributes['id'])
+      project.property_definitions_loader = PropertyDefinitionsLoader.new('project_id' => project_attributes['id'])
+      project.team_loader = TeamLoader.new('project_id' => project_attributes['id'])
+      project.project_variables_loader = ProjectVariablesLoader.new('project_id' => project_attributes['id'])
     end
   end
-
-  class LoadCardTypesByProjectId < Base
+  
+  class CardTypesLoader < Base
     def load
       load_fixtures_for('card_types').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  
+        CardTypeLoader.new('id' => ct['id']) if match?(ct)
+      end.compact.sort_by { |loader| loader.card_type.position }
+    end
   end
-
-  class LoadPropertyDefinitionsByProjectId < Base
+  
+  class CardTypeLoader < Base
+    def card_type
+      @card_type ||= load
+    end
+    
     def load
-      load_fixtures_for('property_definitions').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  
+      record = load_fixtures_for('card_types').find {|ct| match?(ct)}
+      card_type = Mingle::CardType.new(OpenStruct.new(record))
+      card_type.card_types_property_definitions_loader = CardTypesPropertyDefinitionsLoader.new('card_type_id' => record['id'])
+      card_type
+    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 PropertyDefinitionsLoader < Base
     def load
-      load_fixtures_for('property_type_mappings').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_fixtures_for('property_type_mappings').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  
-
+      load_fixtures_for('property_definitions').collect do |pd|
+        PropertyDefinitionLoader.new('id' => pd['id']) if match?(pd)
+      end.compact
+    end
   end
-
-  class LoadCardTypeById < Base
-    def initialize(card_type_id, fixture_file_name)
-      super(fixture_file_name)
-      @card_type_id = card_type_id
-    end  
-
+  
+  class PropertyDefinitionLoader < Base
+    def property_definition
+      @property_definition ||= load
+    end
+    
     def load
-      yaml = load_fixtures_for('card_types').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
+      record = load_fixtures_for('property_definitions').find { |pd| match?(pd)}
+      property_definition = Mingle::PropertyDefinition.new(OpenStruct.new(record))
+      property_definition.card_types_property_definitions_loader = CardTypesPropertyDefinitionsLoader.new('property_definition_id' => record['id'])
+      property_definition.values_loader = PropertyValuesLoader.new('property_definition_id' => record['id'])
+      property_definition
     end
-
+  end
+  
+  class PropertyValuesLoader < Base
     def load
-      yaml = load_fixtures_for('property_definitions').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  
+      load_fixtures_for('property_values').collect do |pv|
+        Mingle::PropertyValue.new(OpenStruct.new(pv)) if match?(pv)
+      end.compact
+    end
   end
 
-  class LoadValuesByPropertyDefinitionId < Base
-    def initialize(property_definition_id, fixture_file_name)
-      super(fixture_file_name)
-      @property_definition_id = property_definition_id
-    end
-  
+  class CardTypesPropertyDefinitionsLoader < Base
     def load
-      result = load_fixtures_for('property_values').collect do |pv|
-        next unless pv['property_definition_id'] == @property_definition_id
-        property_value = Mingle::PropertyValue.new(OpenStruct.new(pv))
-        property_value.property_definition_loader = property_definition_by_id_loader(pv['property_definition_id'])
-        property_value
+      load_fixtures_for('property_type_mappings').collect do |mapping|
+        pd = PropertyDefinitionLoader.new('id' => mapping['property_definition_id']) if match?(mapping)
+        ct = CardTypeLoader.new('id' => mapping['card_type_id']) if match?(mapping)
+        OpenStruct.new(:card_type => ct.load, :property_definition => pd.load) if ct && pd
       end.compact
-    end  
+    end
   end
   
-  class LoadTeamByProjectId < Base
+  class TeamLoader < Base
     def load
-      load_fixtures_for('users').collect { |user| Mingle::User.new(OpenStruct.new(user)) }
-    end  
+      load_fixtures_for('users').collect do |user|
+        Mingle::User.new(OpenStruct.new(user)) if match?(user)
+      end.compact
+    end
   end
-
-  class LoadProjectVariablesByProjectId < Base
+  
+  class ProjectVariablesLoader < Base
     def load
-      load_fixtures_for('project_variables').collect { |pv| Mingle::ProjectVariable.new(OpenStruct.new(pv)) }
-    end  
+      load_fixtures_for('project_variables').collect do |pv|
+        Mingle::ProjectVariable.new(OpenStruct.new(pv)) if match?(pv)
+      end.compact
+    end
   end
 end

data/test/unit/fixture_loader_test.rb

@@ -1,45 +1,45 @@
-#Copyright 2008 ThoughtWorks, Inc.  All rights reserved.
+#Copyright 2010 ThoughtWorks, Inc.  All rights reserved.
 
 require File.dirname(__FILE__) + '/unit_test_helper.rb'
 
 class FixtureLoaderTest < Test::Unit::TestCase
   
-  TEST_FIXTURE = 'sample'
+  PROJECT = 'scrum_template_2_1'
   
   def test_should_load_direct_project_attributes_from_correct_fixture
-    assert_not_nil project(TEST_FIXTURE)
-    assert_equal 'scrum_template_2_1', project(TEST_FIXTURE).identifier
+    assert_not_nil project(PROJECT)
+    assert_equal 'scrum_template_2_1', project(PROJECT).identifier
   end
   
   def test_should_load_first_level_project_associations_from_correct_fixture
-    assert_equal(['Release', 'Sprint', 'Story', 'Task', 'Defect', 'Feature', 'Epic Story'], project(TEST_FIXTURE).card_types.collect(&:name))
+    assert_equal(['Release', 'Sprint', 'Story', 'Task', 'Defect', 'Feature', 'Epic Story'], project(PROJECT).card_types.collect(&:name))
   end
   
   def test_should_load_second_level_project_associations_for_card_type_from_correct_fixture
-    task_type = project(TEST_FIXTURE).card_types.detect { |ct| ct.name == 'Task' }
+    task_type = project(PROJECT).card_types.detect { |ct| ct.name == 'Task' }
     assert_equal(['Estimate - Planning', 'Risk', 'Added On', 'Priority', 'Owner',  'Task Estimate'], task_type.property_definitions.collect(&:name))
   end
   
   def test_should_load_second_level_project_associations_for_property_definition_from_correct_fixture
-    priority_definition = project(TEST_FIXTURE).property_definitions.detect { |pd| pd.name == 'Priority' }
+    priority_definition = project(PROJECT).property_definitions.detect { |pd| pd.name == 'Priority' }
     assert_equal(['Story', 'Task', 'Defect'], priority_definition.card_types.collect(&:name))
   end
   
   def test_should_load_correct_values_for_property_definitions
-    priority_definition = project(TEST_FIXTURE).property_definitions.detect { |pd| pd.name == 'Priority' }
+    priority_definition = project(PROJECT).property_definitions.detect { |pd| pd.name == 'Priority' }
     assert_equal ['High', 'Medium', 'Low'], priority_definition.values.collect(&:db_identifier)
   end  
   
   def test_should_load_correct_team_members
-    assert_equal ['groucho', 'harpo', 'karl'], project(TEST_FIXTURE).team.collect(&:login)
+    assert_equal ['groucho', 'harpo', 'karl'], project(PROJECT).team.collect(&:login)
   end  
   
   def test_should_detect_project_variables
-    assert_equal 'Release 3', project(TEST_FIXTURE).value_of_project_variable('Current Release')
+    assert_equal 'Release 3', project(PROJECT).value_of_project_variable('Current Release')
   end  
   
   def test_should_raise_error_on_trying_to_call_values_for_anything_other_than_managed_or_user_properties
-    added_on = project(TEST_FIXTURE).property_definitions.detect { |pd| pd.name == 'Added On' }
+    added_on = project(PROJECT).property_definitions.detect { |pd| pd.name == 'Added On' }
     assert_raise(RuntimeError) { added_on.values }
   end  
 end  

data/test/unit/unit_test_helper.rb

@@ -1,13 +1,14 @@
-#Copyright 2008 ThoughtWorks, Inc.  All rights reserved.
+#Copyright 2010 ThoughtWorks, Inc.  All rights reserved.
 
 require 'test/unit'
 require 'macro_development_toolkit'
 require File.dirname(__FILE__) + '/fixture_loader'
 
 class Test::Unit::TestCase
-  
+
   def project(name)
-    @project ||= FixtureLoaders::ProjectLoader.new(name).project
-  end  
-  
+    @projects ||= {}
+    @projects[name] ||= FixtureLoaders::ProjectLoader.new(name).project
+  end
+
 end  

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 1
   - 3
-  - 2
-  version: 1.3.2
+  - 3
+  version: 1.3.3
 platform: ruby
 authors: 
 - ThoughtWorks Inc
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-13 00:00:00 -07:00
+date: 2011-01-27 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -22,13 +22,13 @@ dependencies:
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
-    - - ">="
+    - - "="
       - !ruby/object:Gem::Version 
         segments: 
         - 2
-        - 0
-        - 2
-        version: 2.0.2
+        - 3
+        - 5
+        version: 2.3.5
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -46,19 +46,33 @@ dependencies:
   type: :development
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: hoe
+  name: gemcutter
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
         segments: 
-        - 2
-        - 6
-        - 1
-        version: 2.6.1
+        - 0
+        - 5
+        - 0
+        version: 0.5.0
   type: :development
   version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 5
+        - 0
+        version: 2.5.0
+  type: :development
+  version_requirements: *id004
 description: ""
 email: 
 - support@thoughtworks.com
@@ -68,12 +82,12 @@ extensions: []
 
 extra_rdoc_files: 
 - getting_started.txt
+- README.txt
 - LICENSE.txt
 - History.txt
-- README.rdoc
 files: 
 - getting_started.txt
-- README.rdoc
+- README.txt
 - LICENSE.txt
 - History.txt
 - Rakefile
@@ -111,7 +125,7 @@ files:
 - example/integration_test.rb
 - example/integration_test_helper.rb
 has_rdoc: true
-homepage: 
+homepage: http://mingle-macros.rubyforge.org/
 licenses: []
 
 post_install_message: getting_started.txt