AttributeClassShouldBeSealed.cs :  » Development » devAdvantage » AnticipatingMinds » KnowledgePack » Design » C# / CSharp Open Source

using System;
using System.Collections;
using System.Xml;
using AnticipatingMinds.Genesis.KnowledgeManagement;
using AnticipatingMinds.Genesis.CodeDOM;


namespace AnticipatingMinds.KnowledgePack.Design{
  /// <summary>
  /// Summary description for AttributeClassShouldBeSealedRuleTemplate.
  /// </summary>
  public class AttributeClassShouldBeSealedRuleTemplate : RuleTemplate
  {
    public AttributeClassShouldBeSealedRuleTemplate(string templateId, IDictionary templateProperties):base(templateId,templateProperties)
    {
    }
  
    public override string Name
    {
      get
      {
        return ResourceManager.GetLocalizedString("AttributeClassShouldBeSealedRule|Name");
      }
    }
    
    public override string Description
    {
      get
      {
        return ResourceManager.GetLocalizedString("AttributeClassShouldBeSealedRule|Description");
      }
    }


    public override Rule CreateRule(string ruleId, IDictionary ruleProperties)
    {
      return new AttributeClassShouldBeSealedRule(ruleId,Id,ruleProperties);
    }  
  }

  public class AttributeClassShouldBeSealedRule : Rule
  {
    /// <summary>
    /// This is used for declaring all code elements you want to analyze
    /// Note that this started only declares one.
    /// </summary>
    private Type[] targetedCodeElements = {typeof(CodeClassDeclaration)};
    
    internal AttributeClassShouldBeSealedRule(string id, string templateId, IDictionary ruleProperties) : base(id,templateId,ruleProperties)
    {
    }
  
    public override Type[] TargetedCodeElements
    {
      get
      {
        return targetedCodeElements;
      }
    }
  
  
    public override RuleViolation[] Analyze(object codeElement, System.Threading.ManualResetEvent cancelAnalysisEvent)
    {
      CodeClassDeclaration classDeclaration = (CodeClassDeclaration)codeElement;
      if((classDeclaration.Modifiers & CodeClassDeclaration.TypeDeclarationModifiers.Abstract) != 0)
        return emptyViolation;

      if(classDeclaration.GetAssemblyTypeManager().IsTypeSubclassOf(classDeclaration.FullName,"System.Attribute"))
      {
        if ( (classDeclaration.Modifiers & CodeClassDeclaration.TypeDeclarationModifiers.Sealed) == 0 )
        {
          RuleViolationCollection violationsFound = new RuleViolationCollection();
          string violationMessage = string.Format(ResourceManager.GetLocalizedString("AttributeClassShouldBeSealedRule|Violation") , classDeclaration.Name); 
          RuleViolation v = new RuleViolation(this , violationMessage , classDeclaration);
          v.AddCorrection(ResourceManager.GetLocalizedString("AttributeClassShouldBeSealedRule|Correction"),true,false);
          v.Severity = RuleViolation.ViolationSeverity.Warning;
          v.ViolationData["ClassDeclaration"] = classDeclaration;
          violationsFound.Add(v);
          return violationsFound.ToArray();
        }
      }      
      // Convert to an array for return.
      return emptyViolation;
    }  
  
    public override void Correct(RuleViolationCorrection[] requestedCorrections, AnticipatingMinds.Genesis.Effectors.CodeEffector codeEffector, System.Threading.ManualResetEvent cancelCorrectionEvent)
    {
      codeEffector.BeginCodeChanges(ResourceManager.GetLocalizedString("AttributeClassShouldBeSealedRule|CorrectionDescription"));
      foreach(RuleViolationCorrection requestedCorrection in requestedCorrections)
      {
        if(requestedCorrection.Violation.IsFixed)
          continue;

        CodeClassDeclaration classDeclaration = requestedCorrection.Violation.ViolationData["ClassDeclaration"] as CodeClassDeclaration;
        CodeClassDeclaration.TypeDeclarationModifiers modifiers = classDeclaration.Modifiers;
        modifiers |= CodeClassDeclaration.TypeDeclarationModifiers.Sealed;

        codeEffector.ChangeCodeElement(classDeclaration,classDeclaration.GetType().GetProperty("Modifiers"),modifiers);
        requestedCorrection.Violation.IsFixed = true;
      }
      codeEffector.CommitCodeChanges();

    }

    public override Type[] ApplicableApplicabilityScopeTypes
    {
      get
      {
        return applicableApplicabilityScopeTypes;
      }
    }

    private static Type[] applicableApplicabilityScopeTypes = {typeof(ClassApplicabilityScope),typeof(FileApplicabilityScope)};
    private RuleViolation[] emptyViolation = new RuleViolation[0];
  }

}