mingle-macro-development-toolkit 1.3.3 → 2.0.0

data/lib/macro_development_toolkit/mingle/property_value.rb

@@ -1,67 +0,0 @@
-module Mingle
-  
-  # Copyright 2009 ThoughtWorks, Inc.  All rights reserved.
-  class PropertyValue
-    
-    def initialize(property_value)
-      @property_value = property_value
-    end
-  
-    # *returns*: The display value of this value
-    # Use the result of this method to display this value on the UI
-    # For the various property types, the following are the values you can expect to see
-    # * Managed/Unmanaged text    : The string value of the value
-    # * Managed/Unmanaged numeric : The numeric string representation of the value
-    # * Date                      : The list of values this property has on all cards on the project, formatted using the project date format
-    # * User                      : The name of the user
-    # * Formula                   : Either the date or the numeric value, formatted as above
-    # * Card                      : The number of the card, followed by the name of the card
-    def display_value
-      @property_value.display_value
-    end
-  
-    # *returns*: The identifier that is used to represent this value in the database
-    # You will most likely not have to use this value in your macros
-    # For the various property types, the following are the values you can expect to see
-    # * Managed/Unmanaged text    : The string value of the value
-    # * Managed/Unmanaged numeric : The numeric string representation of the value
-    # * Date                      : The canonical date format, as stored in the database
-    # * User                      : The id of the user in the database
-    # * Formula                   : Either the date or the numeric value, formatted as above
-    # * Card                      : The id of the card in the database
-    def db_identifier
-      @property_value.db_identifier
-    end
-  
-    # *returns*: A representation of this value that is unique and representable in a URL
-    # Use the result of this method if in any links that you want to build to point back into Mingle
-    # For the various property types, the following are the values you can expect to see
-    # * Managed/Unmanaged text    : The string value of the value
-    # * Managed/Unmanaged numeric : The numeric string representation of the value
-    # * Date                      : The list of values this property has on all cards on the project, formatted using the project date format
-    # * User                      : The login of the user
-    # * Formula                   : Either the date or the numeric value, formatted as above
-    # * Card                      : The number of the card, followed by the name of the card
-    def url_identifier
-      @property_value.url_identifier
-    end
-  
-    # *returns*: The hex color code for this PropertyValue
-    def color
-      @property_value.color.gsub('#', '')
-    end
-
-    # *returns*: The PropertyDefinition that this value belongs to
-    def property_definition
-      @property_definition_loader.load
-    end  
-  
-    def to_s
-      "PropertyValue[display_value=#{display_value},db_identifier=#{db_identifier},url_identifier=#{url_identifier}]"
-    end
-
-    attr_writer :property_definition_loader
-    
-  end
-      
-end

data/lib/macro_development_toolkit/mingle/user.rb

@@ -1,33 +0,0 @@
-module Mingle
-    # Copyright 2009 ThoughtWorks, Inc.  All rights reserved.
-
-    # A lightweight model of a user in Mingle.
-    class User
-        
-    def initialize(full_user)
-      @full_user = full_user
-    end
-    
-    # *returns*: The login of the user as configured in Mingle
-    def login
-      @full_user.login
-    end
-    
-    # *returns*: The full name of the user as configured in Mingle
-    def name
-      @full_user.name
-    end
-    
-    # *returns*: The version control user name of the user as configured in Mingle
-    def version_control_user_name
-      @full_user.version_control_user_name
-    end
-    
-    # *returns*: The email address of the user as configured in Mingle
-    def email
-      @full_user.email
-    end
-  
-  end
-  
-end

data/lib/macro_development_toolkit/mingle_model_loader.rb

@@ -1,151 +0,0 @@
-# Copyright 2010 ThoughtWorks, Inc.  All rights reserved.
-
-# MingleModelLoaders understand how to load a graph of lightweight objects from
-# the Mingle model objects at runtime, when the custom macro is deployed into production.
-module MingleModelLoaders
-  class Base
-    def initialize(project, macro_context=nil, alert_receiver=nil)
-      @project = project
-      @macro_context = macro_context
-      @alert_receiver = alert_receiver
-    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 = 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 CardTypesLoader
-    def initialize(project)
-      @project = project
-    end
-    
-    def load
-      @project.with_active_project do
-        @project.card_types.collect do |ct|
-          CardTypeLoader.new(ct)
-        end.sort_by {|loader| loader.card_type.position}
-      end
-    end
-  end
-  
-  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|
-          PropertyDefinitionLoader.new(pd)
-        end
-      end
-    end
-  end
-  
-  class PropertyDefinitionLoader
-    def initialize(pd)
-      @pd = pd
-    end
-    
-    def property_definition
-      @property_definition ||= load
-    end
-    
-    def load
-      pd = Mingle::PropertyDefinition.new(@pd)
-      pd.card_types_property_definitions_loader = CardTypesPropertyDefinitionsLoader.new(@pd)
-      pd.values_loader = PropertyValuesLoader.new(@pd)
-      pd
-    end
-  end
-  
-  class CardTypesPropertyDefinitionsLoader
-    def initialize(card_type_or_property_definition)
-      @card_type_or_property_definition = card_type_or_property_definition
-    end
-    
-    def load
-      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 PropertyValuesLoader
-    def initialize(property_definition)
-      @property_definition = property_definition
-    end
-    
-    def load
-      @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 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
-  
-  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

data/tasks/test.rake

@@ -1,16 +0,0 @@
-namespace :test do
-
-  Rake::TestTask.new(:units) do |t|
-    t.libs << "test/unit"
-    t.pattern = 'test/unit/*_test.rb'
-    t.verbose = true
-  end
-
-  Rake::TestTask.new(:integration) do |t|
-    t.libs << "test/integration"
-    t.pattern = 'test/integration/*_test.rb'
-    t.verbose = true
-  end
-  
-end
-

data/test/integration/rest_loader.rb

@@ -1,233 +0,0 @@
-#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
-
-  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"
-        raise RemoteError, RemoteError.parse(response.body)
-      end  
-      Hash.from_xml(response.body)
-    end
-  end
-  
-  class MqlExecutor < SimpleDelegator
-    include LoaderHelper
-
-    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 execute_mql(mql)
-      from_xml_data(get(url_for(:action => "execute_mql", :query => "mql=#{mql}")))
-    rescue => e
-      @error_handler.alert(e.message)
-      []
-    end
-    
-    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 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 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
-
-    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
-
-  class ProjectLoader
-    include LoaderHelper
-    
-    def initialize(resource, error_handler)
-      @resource = resource
-      @error_handler = error_handler
-    end
-    
-    def project
-      @project ||= load
-    end
-    
-    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 initialize(project)
-      @project = project
-    end
-    
-    def load
-      extract('card_types', @project).collect { |ct| CardTypeLoader.new(@project, ct) }.sort_by { |loader| loader.card_type.position }
-    end
-  end
-  
-  class CardTypeLoader
-    
-    def initialize(project, ct)
-      @project = project
-      @ct = ct
-    end
-    
-    def card_type
-      @card_type ||= load
-    end
-    
-    def load
-      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 PropertyDefinitionsLoader
-    include LoaderHelper
-    
-    def initialize(project)
-      @project = project
-    end
-    
-    def load
-      extract('property_definitions', @project).collect { |pd| PropertyDefinitionLoader.new(@project, pd) }
-    end
-  end
-  
-  class PropertyDefinitionLoader
-    def initialize(project, pd)
-      @project = project
-      @pd = pd
-    end
-    
-    def property_definition
-      @property_definition ||= load
-    end
-    
-    def load
-      @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 PropertyValuesLoader
-    include LoaderHelper
-    
-    def initialize(property_definition)
-      @property_definition = property_definition
-    end
-    
-    def load
-      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
-      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
-    
-    private
-    def match?(mapping)
-      @params.all? { |key, value| value == mapping[key] }
-    end
-  end
-  
-  class TeamLoader
-    include LoaderHelper
-    
-    def initialize(project)
-      @project = project
-    end
-    
-    def load
-      (extract('users', @project) || []).collect{ |user| Mingle::User(OpenStruct.new(user))}
-    end
-  end
-  
-  class ProjectVariablesLoader
-    include LoaderHelper
-    
-    def initialize(project)
-      @project = project
-    end
-    
-    def load
-      extract('project_variables', @project).collect {|pv| Mingle::ProjectVariable.new(OpenStruct.new(pv))}
-    end
-  end
-end