/// <summary>
        ///     Parse commands from plugin.yml
        /// </summary>
        /// <param name="map"></param>
        /// <returns></returns>
        /// <remarks></remarks>
        private static List<PluginCommand> ParseCommands(Mapping map)
        {
            try
            {
                List<PluginCommand> l = new List<PluginCommand>();

                Scalar sc = new Scalar();
                Sequence seq = new Sequence();
                Type typeScalar = sc.GetType();
                Type typeSequence = seq.GetType();
                Type typeMapping = map.GetType();
                if (map.GetType() != typeMapping) return l;

                foreach (MappingEntry entry in map.Enties)
                {
                    PluginCommand pc = new PluginCommand {Name = ((Scalar) entry.Key).Text};

                    if (entry.Value.GetType() == typeMapping)
                    {
                        foreach (MappingEntry secondlevel in ((Mapping) entry.Value).Enties)
                        {
                            if (secondlevel.Key.GetType() != typeScalar) continue;
                            switch (((Scalar) secondlevel.Key).Text)
                            {
                                case "description":
                                    pc.Description = ((Scalar) secondlevel.Value).Text;
                                    break;
                                case "usage":
                                    pc.Usage = ((Scalar) secondlevel.Value).Text;
                                    break;
                                case "alias":
                                    if (entry.Value.GetType() == typeSequence)
                                    {
                                        pc.Aliases = ArrayFromSequence((Sequence) secondlevel.Value);
                                    }
                                    else if (entry.Value.GetType() == typeScalar)
                                    {
                                        pc.Aliases = new string[1];
                                        // ReSharper disable once PossibleInvalidCastException
                                        pc.Aliases[0] = ((Scalar) entry.Value).Text;
                                    }
                                    break;
                                case "aliases":
                                    if (entry.Value.GetType() == typeSequence)
                                    {
                                        pc.Aliases = ArrayFromSequence((Sequence) secondlevel.Value);
                                    }
                                    else if (entry.Value.GetType() == typeScalar)
                                    {
                                        pc.Aliases = new string[1];
            // ReSharper disable once PossibleInvalidCastException
                                        pc.Aliases[0] = ((Scalar) entry.Value).Text;
                                    }
                                    break;
                            }
                        }
                    }

                    l.Add(pc);
                }
                return l;
            }
            catch (Exception ex)
            {
                Logger.Log(LogLevel.Warning, "InstalledPlugin",
                    "An exception occured when trying to load plugin commands", ex.Message);
                return new List<PluginCommand>();
            }
        }
 /// <summary>
 ///     Convert a sequence to an array
 /// </summary>
 /// <param name="seq"></param>
 /// <returns></returns>
 /// <remarks></remarks>
 private static string[] ArrayFromSequence(Sequence seq)
 {
     try
     {
         Scalar sc = new Scalar();
         Type typeScalar = sc.GetType();
         string[] arr = new string[seq.Enties.Count];
         for (int i = 0; i <= seq.Enties.Count - 1; i++)
         {
             if (seq.Enties[i].GetType() == typeScalar)
             {
                 arr[i] = (((Scalar) seq.Enties[i]).Text);
             }
         }
         return arr;
     }
     catch (Exception ex)
     {
         Logger.Log(LogLevel.Severe, "InstalledPlugin",
             "An exception occured when trying to convert array to sequence", ex.Message);
         return new string[1];
     }
 }
Esempio n. 3
0
		private Sequence ParseBlockSequence(out bool success)
		{
			Sequence sequence = new Sequence();

			while (true)
			{
				int seq_start_position1 = position;
				DataItem dataItem = ParseBlockSequenceEntry(out success);
				if (success) { sequence.Enties.Add(dataItem); }
				else
				{
					Error("Failed to parse BlockSequenceEntry of BlockSequence.");
					break;
				}

				while (true)
				{
					while (true)
					{
						int seq_start_position2 = position;
						ParseIndent(out success);
						if (!success)
						{
							Error("Failed to parse Indent of BlockSequence.");
							break;
						}

						dataItem = ParseBlockSequenceEntry(out success);
						if (success) { sequence.Enties.Add(dataItem); }
						else
						{
							Error("Failed to parse BlockSequenceEntry of BlockSequence.");
							position = seq_start_position2;
						}
						break;
					}
					if (!success) { break; }
				}
				success = true;
				break;
			}
			if (!success) { Error("Failed to parse Enties of BlockSequence."); }
			return sequence;
		}
        /// <summary>
        ///     Loads the contents of a plugin.yml file
        /// </summary>
        /// <param name="ymltext">the yml formatted text</param>
        /// <returns>The InstalledPlugin (me)</returns>
        /// <remarks></remarks>
        public InstalledPlugin LoadPluginYml(string ymltext)
        {
            try
            {
                Scalar sc = new Scalar();
                Sequence seq = new Sequence();
                Mapping map = new Mapping();

                //References to check file types later on
                Type typeScalar = sc.GetType();
                Type typeSequence = seq.GetType();
                Type typeMapping = map.GetType();

                if (ymltext == null | string.IsNullOrEmpty(ymltext))
                {
                    return null;
                }

                YamlStream yml = YamlParser.Load(ymltext);

                if (yml == null)
                {
                    return null;
                }

                //if mapping start parsing
                if (yml.Documents[0].Root.GetType() == typeMapping)
                {
                    foreach (MappingEntry item in ((Mapping) yml.Documents[0].Root).Enties)
                    {
                        //Check the type, check for possible keys and load the value
                        if (item.Value.GetType() == typeScalar)
                        {
                            switch (((Scalar) item.Key).Text)
                            {
                                case "name":
                                    Name = ((Scalar) item.Value).Text;
                                    break;
                                case "version":
                                    Version = ((Scalar) item.Value).Text;
                                    break;
                                case "description":
                                    Description = ((Scalar) item.Value).Text;
                                    break;
                                case "main":
                                    Mainspace = ((Scalar) item.Value).Text;
                                    break;
                                case "author":
                                    Authors = new string[1];
                                    Authors[0] = ((Scalar) item.Value).Text;
                                    break;
                                case "authors":
                                    Authors = new string[1];
                                    Authors[0] = ((Scalar) item.Value).Text;
                                    break;
                            }
                        }
                        else if (item.Value.GetType() == typeSequence)
                        {
                            switch (((Scalar) item.Key).Text)
                            {
                                case "author":
                                    Authors = ArrayFromSequence((Sequence) item.Value);
                                    break;
                                case "Authors":
                                    Authors = ArrayFromSequence((Sequence) item.Value);
                                    break;
                                case "softdepend":
                                    Softdepend = ArrayFromSequence((Sequence) item.Value);
                                    break;
                            }
                        }
                        else if (item.Value.GetType() == typeMapping)
                        {
                            switch (((Scalar) item.Key).Text)
                            {
                                case "commands":
                                    if (item.Value.GetType() == typeMapping)
                                        Commands = ParseCommands((Mapping) item.Value);
                                    else
                                        Commands = new List<PluginCommand>();
                                    break;
                                case "permissions":
                                    if (item.Value.GetType() == typeMapping)
                                        Permissions = ParsePermissions((Mapping) item.Value);
                                    else
                                        Permissions = new List<PluginPermission>();
                                    break;
                            }
                        }
                    }
                }
                return this;
            }
            catch (Exception ex)
            {
                Logger.Log(LogLevel.Warning, "InstalledPlugin", "An exception occured when trying to parse yml text",
                    ex.Message);
                return null;
            }
        }
Esempio n. 5
0
		private Sequence ParseFlowSequence(out bool success)
		{
			Sequence sequence = new Sequence();
			int start_position = position;

			MatchTerminal('[', out success);
			if (!success)
			{
				Error("Failed to parse '[' of FlowSequence.");
				position = start_position;
				return sequence;
			}

			ParseSeparationLinesInFlow(out success);
			success = true;

			while (true)
			{
				int seq_start_position1 = position;
				DataItem dataItem = ParseFlowSequenceEntry(out success);
				if (success) { sequence.Enties.Add(dataItem); }
				else
				{
					Error("Failed to parse FlowSequenceEntry of FlowSequence.");
					break;
				}

				while (true)
				{
					while (true)
					{
						int seq_start_position2 = position;
						MatchTerminal(',', out success);
						if (!success)
						{
							Error("Failed to parse ',' of FlowSequence.");
							break;
						}

						ParseSeparationLinesInFlow(out success);
						success = true;

						dataItem = ParseFlowSequenceEntry(out success);
						if (success) { sequence.Enties.Add(dataItem); }
						else
						{
							Error("Failed to parse FlowSequenceEntry of FlowSequence.");
							position = seq_start_position2;
						}
						break;
					}
					if (!success) { break; }
				}
				success = true;
				break;
			}
			if (!success)
			{
				Error("Failed to parse Enties of FlowSequence.");
				position = start_position;
				return sequence;
			}

			MatchTerminal(']', out success);
			if (!success)
			{
				Error("Failed to parse ']' of FlowSequence.");
				position = start_position;
			}

			return sequence;
		}