mingle-macro-development-toolkit 1.3.2 → 1.3.3

data/History.txt

@@ -1,3 +1,11 @@
+== 1.3.3 January 2011
+
+  * Minor bug fix
+
+== 1.3.2 August 2010
+
+  * Minor bug fix
+
 == 1.3.1 March 2010
 
   * 1 bug fix

data/{README.rdoc → README.txt}

@@ -1,18 +1,20 @@
 = Macro Development Toolkit - supporting development of custom macros for Mingle
 
-This toolkit provides support for developing, testing and deploying custom Mingle macros. 
+http://mingle-macros.rubyforge.org/
+
+This toolkit provides support for developing, testing and deploying custom Mingle macros.
 
 Use the built in generator to create a skeleton of a plugin which you can then deploy to an instance of Mingle running
 version 2.2 or later of the software.
 
-This allows you to take advantage of free charting utilities such as the Google Charts API, to create 
+This allows you to take advantage of free charting utilities such as the Google Charts API, to create
 new visualizations, specific to your project or organization.
 
 == FEATURES:
 
 * A command line tool to generate the skeleton of a custom Mingle macro
 * A unit test helper that uses locally available YAML fixture files to facilitate unit testing of the macros
-* An integration test helper that can 
+* An integration test helper that can
   * obtain data from a remote instance of Mingle
   * test MQL execution against a remote instance of Mingle
 * Rake task to deploy the custom macro as a plugin to a locally deployed Mingle instance
@@ -28,16 +30,16 @@ then use:
 == GETTING STARTED:
 
 To get started with this gem after you install it, use the new_mingle_macro script to generate a skeleton for your
-macro, along with test helpers. Say you wanted to create a new macro called "risk_meter" start out by creating 
+macro, along with test helpers. Say you wanted to create a new macro called "risk_meter" start out by creating
 the macro skeleton as follows
 
   % new_mingle_macro risk_meter
 
-The skeleton project will also contain a file, called "getting_started.txt" that will walk you through the steps 
+The skeleton project will also contain a file, called "getting_started.txt" that will walk you through the steps
 of fleshing out your macro.
 
 == SUPPORT:
- 
+
 For any issues/clarifications/comments with installation or using this gem, contact us at the Mingle forums[http://community.thoughtworks.com/pages/home]. You can also get in touch with the ThoughtWorks Studios support
 team over email at support@thoughtworks.com
 

data/Rakefile

@@ -17,32 +17,24 @@ end
 require File.dirname(__FILE__) + '/lib/macro_development_toolkit'
 
 
-# if ARGV[0] == "repackage"
-
-  %w[newgem rubigen hoe].each { |f| require f }
-  # Hoe.plugin :newgem
-  # Hoe.plugin :website
-  
-  # Generate all the Rake tasks
-  # Run 'rake -T' to see list of generated tasks (from gem root directory)
-  $hoe = Hoe.spec('mingle-macro-development-toolkit') do |p|
-    p.version = MacroDevelopmentToolkit::VERSION
-    p.developer('ThoughtWorks Inc', 'support@thoughtworks.com')
-    p.post_install_message = 'getting_started.txt'
-    p.rubyforge_name       = 'mingle-macros'
-    p.extra_deps         = [
-      ['activesupport','>= 2.0.2'],
-    ]
-    p.summary = "This toolkit provides support for developing, testing and deploying custom Mingle macros."
-    p.extra_rdoc_files = ['README.rdoc']
-    p.clean_globs |= %w[**/.DS_Store tmp *.log]
-    path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
-    p.remote_rdoc_dir = ''
-    p.rsync_args = '-av --delete --ignore-errors'
-  end
-
-  require 'newgem/tasks'
-
-# end
+%w[newgem rubigen hoe].each { |f| require f }
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.spec('mingle-macro-development-toolkit') do |p|
+  p.version = MacroDevelopmentToolkit::VERSION
+  p.developer('ThoughtWorks Inc', 'support@thoughtworks.com')
+  p.post_install_message = 'getting_started.txt'
+  p.rubyforge_name       = 'mingle-macros'
+  p.extra_deps         = [
+    ['activesupport','2.3.5'],
+  ]
+  p.summary = "This toolkit provides support for developing, testing and deploying custom Mingle macros."
+  p.clean_globs |= %w[**/.DS_Store tmp *.log]
+  path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
+  p.remote_rdoc_dir = ''
+  p.rsync_args = '-av --delete --ignore-errors'
+end
+require 'newgem/tasks'
 
 Dir['tasks/**/*.rake'].each { |t| load t }

data/bin/new_mingle_macro

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
-#Copyright 2010 ThoughtWorks, Inc.  All rights reserved.
+#Copyright 2011 ThoughtWorks, Inc.  All rights reserved.
  
 module NewMingleMacro
   module Messages
@@ -23,7 +23,7 @@ underscores (_). Is this OK? [Yes/No]"
 SPECIAL_CHARACTER_REPLACEMENT_MESSAGE
 
   AUTO_GENERATED_CLASS_NAME_MESSAGE = <<-AUTO_GENERATED_CLASS_NAME_MESSAGE
-Warning: You did not provide a class name for your macro. A class name has been generated
+Succeeded with warnings: You did not provide a class name for your macro. A class name has been generated
 for you. This name should be considered a guide and we highly recommend naming your own 
 classes name with appropriate namespaces to avoid collisions with standard libraries
 or Mingle classes. Please run this tool with no command-line arguments to learn
@@ -35,10 +35,16 @@ end
 require 'erb'
 require 'fileutils'
 begin
-  require 'active_support'
+  require 'active_support/all'
 rescue LoadError
   require 'rubygems'
-  require 'active_support'
+  require 'active_support/all'
+end
+
+require 'active_support/version'
+REQUIRED_ACTIVE_SUPPORT_VERSION = '2.3.5'
+unless ActiveSupport::VERSION::STRING == REQUIRED_ACTIVE_SUPPORT_VERSION
+  raise "For guaranteed compatibility with Mingle, you must develop macros using ActiveSupport #{REQUIRED_ACTIVE_SUPPORT_VERSION}.  You are using version #{ActiveSupport::VERSION::STRING}" 
 end
 
 def print_usage

data/example/integration_test_helper.rb

@@ -6,12 +6,13 @@ require File.join(File.dirname(__FILE__), 'rest_loader')
 
 class Test::Unit::TestCase
   
-  def project(name)
-    @project ||= load_project_resource(name)
+  def project(resource)
+    @projects ||= {}
+    @projects[resource] ||= load_project_resource(resource)
   end
   
   def projects(*resources)
-    @projects ||= resources.map{ |resource| load_project_resource(resource) }
+    resources.collect {|resource| project(resource)}
   end
   
   def errors
@@ -25,7 +26,6 @@ class Test::Unit::TestCase
   private
   
   def load_project_resource(resource)
-    RESTfulLoaders::ProjectLoader.new(resource, nil, self).project
+    RESTfulLoaders::ProjectLoader.new(resource, self).project
   end
-  
 end

data/example/unit_test_helper.rb

@@ -6,17 +6,8 @@ require File.join(File.dirname(__FILE__), 'fixture_loader')
 class Test::Unit::TestCase
   
   def project(name)
-    @project ||= load_project_fixture(name)
+    @projects ||= {}
+    @projects[name] ||= FixtureLoaders::ProjectLoader.new(name).project
   end
-  
-  def projects(*names)
-    @projects ||= names.map { |name| load_project_fixture(name) }
-  end
-  
-  private
-  
-  def load_project_fixture(name)
-    FixtureLoaders::ProjectLoader.new(name).project
-  end
-   
-end
+
+end  

data/lib/macro_development_toolkit.rb

@@ -4,7 +4,7 @@ $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
 module MacroDevelopmentToolkit
-  VERSION = '1.3.2'
+  VERSION = '1.3.3'
 end
 
 require 'yaml'

data/lib/macro_development_toolkit/mingle/project.rb

@@ -1,5 +1,5 @@
 module Mingle
-  # Copyright 2009 ThoughtWorks, Inc.  All rights reserved.
+  # Copyright 2010 ThoughtWorks, Inc.  All rights reserved.
   
   # This is a lightweight representation of a project.
   # From an instance of this class you can the name & identifier of the project.
@@ -27,14 +27,14 @@ module Mingle
     end
     
     # *returns*: A list CardTypes as configured for this project.
-    # There will always be atleast one element in this list.
+    # There will always be at least one element in this list.
     def card_types
-      @card_types_loader.load
+      @card_types_loader.load.collect(&:card_type)
     end
     
     # *returns*: An list of PropertyDefinitions as configured for this project, which may be empty
     def property_definitions
-      @property_definitions_loader.load
+      @property_definitions_loader.load.collect(&:property_definition)
     end
 
     # *accepts*: The name of a project variable configured for this project

data/lib/macro_development_toolkit/mingle_model_loader.rb

@@ -9,179 +9,143 @@ module MingleModelLoaders
       @macro_context = macro_context
       @alert_receiver = alert_receiver
     end
-
-    def card_types_property_definitions_by_card_type_id_loader(card_type_id)
-      LoadCardTypesPropertyDefinitionsByCardTypeId.new(card_type_id, @project)
-    end  
-  
-    def card_types_property_definitions_by_property_definition_id_loader(property_definition_id)
-      LoadCardTypesPropertyDefinitionsByPropertyDefinitionId.new(property_definition_id, @project)
-    end
-  
-    def values_by_property_definition_id_loader(property_definition_id)
-      LoadValuesByPropertyDefinitionId.new(property_definition_id, @project)
-    end  
-
-    def card_type_by_id_loader(card_type_id)
-      LoadCardTypeById.new(card_type_id, @project)
-    end
-  
-    def property_definition_by_id_loader(property_definition_id)
-      LoadPropertyDefinitionById.new(property_definition_id, @project)
-    end
-    
-    def card_types_by_project_id_loader
-      LoadCardTypesByProjectId.new(@project)
-    end  
-
-    def property_definitions_by_project_id_loader
-      LoadPropertyDefinitionsByProjectId.new(@project)
-    end  
-    
-    def team_by_project_id_loader
-      LoadTeamByProjectId.new(@project)
-    end
-    
-    def project_variables_by_project_id_loader
-      LoadProjectVariablesByProjectId.new(@project)
-    end    
   end
 
   class ProjectLoader < Base
     def project
+      @proj ||= load
+    end
+    
+    def load
       project = Mingle::Project.new(@project, :content_provider => @macro_context[:content_provider], :alert_receiver => @alert_receiver)
-      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.card_types_loader = CardTypesLoader.new(@project)
+      project.property_definitions_loader = PropertyDefinitionsLoader.new(@project)
+      project.team_loader = TeamLoader.new(@project)
+      project.project_variables_loader = ProjectVariablesLoader.new(@project)
       project
     end
   end
-
-  class LoadCardTypesByProjectId < Base
+  
+  class CardTypesLoader
+    def initialize(project)
+      @project = project
+    end
+    
     def load
       @project.with_active_project do
         @project.card_types.collect do |ct|
-          card_type = Mingle::CardType.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)
+          CardTypeLoader.new(ct)
+        end.sort_by {|loader| loader.card_type.position}
       end
-    end  
+    end
   end
-
-  class LoadPropertyDefinitionsByProjectId < Base
+  
+  class CardTypeLoader
+    def initialize(ct)
+      @ct = ct
+    end
+    
+    def card_type
+      @card_type ||= load
+    end
+    
+    def load
+      ct = Mingle::CardType.new(@ct)
+      ct.card_types_property_definitions_loader = CardTypesPropertyDefinitionsLoader.new(@ct)
+      ct
+    end
+  end
+  
+  class PropertyDefinitionsLoader
+    def initialize(project)
+      @project = project
+    end
+    
     def load
       @project.with_active_project do
         (@project.predefined_property_definitions + @project.all_property_definitions).collect do |pd|
-          property_definition = Mingle::PropertyDefinition.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
+          PropertyDefinitionLoader.new(pd)
         end
       end
-    end  
+    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(pd)
+      @pd = pd
+    end
+    
+    def property_definition
+      @property_definition ||= load
+    end
+    
     def load
-      @project.with_active_project do
-        @project.card_types.find(@card_type_id).property_type_mappings.collect do |ctpd|
-          card_type_property_definition = Mingle::CardTypePropertyDefinition.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.sort_by(&:position).compact
-      end
-    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
-      @project.with_active_project do
-        @project.all_property_definitions.detect { |pd| pd.id == @property_definition_id }.property_type_mappings do |ctpd|
-          card_type_property_definition = Mingle::CardTypePropertyDefinition.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  
-
+      pd = Mingle::PropertyDefinition.new(@pd)
+      pd.card_types_property_definitions_loader = CardTypesPropertyDefinitionsLoader.new(@pd)
+      pd.values_loader = PropertyValuesLoader.new(@pd)
+      pd
+    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
-      @project.with_active_project do
-        ct = Mingle::CardType.new(@project.card_types.find(@card_type_id))
-        ct.card_types_property_definitions_loader = card_types_property_definitions_by_card_type_id_loader(@card_type_id)
-        ct
-      end
-    end  
-  end  
-
-  class LoadPropertyDefinitionById < Base
-    def initialize(property_definition_id, fixture_file_name)
-      super(fixture_file_name)
-      @property_definition_id = property_definition_id
+  
+  class CardTypesPropertyDefinitionsLoader
+    def initialize(card_type_or_property_definition)
+      @card_type_or_property_definition = card_type_or_property_definition
     end
-
+    
     def load
-      @project.with_active_project do
-        pd = Mingle::PropertyDefinition.new(@project.all_property_definitions.detect { |pd| pd.id == @property_definition_id })
-        pd.card_types_property_definitions_loader = card_types_property_definitions_by_property_definition_id_loader(@property_definition_id)
-        pd.values_loader = values_by_property_definition_id_loader(@property_definition_id)
-        pd
+      if @card_type_or_property_definition.respond_to?(:property_type_mappings)
+        @card_type_or_property_definition.property_type_mappings.collect do |mapping|
+          ct = CardTypeLoader.new(mapping.card_type)
+          pd = PropertyDefinitionLoader.new(mapping.property_definition)
+          OpenStruct.new(:card_type => ct.load, :property_definition => pd.load)
+        end
+      else #pre_defined_property
+        @card_type_or_property_definition.project.with_active_project do |project|
+          project.card_types.collect do |card_type|
+            ct = CardTypeLoader.new(card_type)
+            pd = PropertyDefinitionLoader.new(@card_type_or_property_definition)
+            OpenStruct.new(:card_type => ct.load, :property_definition => pd.load)
+          end
+        end
       end
-    end  
-  end
-
-  class LoadValuesByPropertyDefinitionId < Base
-    def initialize(property_definition_id, fixture_file_name)
-      super(fixture_file_name)
-      @property_definition_id = property_definition_id
     end
+  end
   
+  class PropertyValuesLoader
+    def initialize(property_definition)
+      @property_definition = property_definition
+    end
+    
     def load
-      @project.with_active_project do
-        @project.all_property_definitions.detect { |pd| pd.id == @property_definition_id }.light_property_values.collect do |pv|
-          property_value = Mingle::PropertyValue.new(pv) 
-          property_value.property_definition_loader = property_definition_by_id_loader(@property_definition_id)
-          property_value
-        end.compact
-      end
-    end  
+      @property_definition.light_property_values.collect do |pv|
+        property_value = Mingle::PropertyValue.new(pv)
+        property_value.property_definition_loader = PropertyDefinitionLoader.new(@property_definition)
+        property_value
+      end.compact
+    end
   end
   
-  class LoadTeamByProjectId < Base
+  class TeamLoader
+    def initialize(project)
+      @project = project
+    end
+    
     def load
       @project.with_active_project do
         @project.users.collect { |user| Mingle::User.new(user) }
       end
-    end  
+    end
   end
-
-  class LoadProjectVariablesByProjectId < Base
+  
+  class ProjectVariablesLoader
+    def initialize(project)
+      @project = project
+    end
+    
     def load
       @project.with_active_project do
         @project.project_variables.collect { |plv| Mingle::ProjectVariable.new(plv) }
       end
-    end  
+    end
   end
-end
+end