6517266969

Committed 14 Oct 2023 11:05AM UTC coverage: 12.469% (+0.2%) from 12.308%

Build # 6517266969

Build Type

push

github

Committed by

web-flow

Commit Message

Implementing plugins for better separation (#39)

* Start implementing plugins for better separation
* massive refactor in attempt to split appdomains for plugins
* (breaks old mapping profiles)
* Fix error when switching from mouse button trigger to keyboard trigger and clicking in the combobox where the mouse button capture textbox is.
* Simplify code by removing legacy
* SImplify grouping actions
* Fix profile and add helpful opposite mapping generator tool
* Change solution hierarchy
* Restrict AppDomain plugins went from Zone.MyComputer -> .Internet
* create keypair in ci
* Install the .NET framework tools
* Run command in workflow
* Plugin permissions. Plugins disabled by default
* update readme (icon is no longer used)
* Plugin action runs in seperated process
* Remove unused dependencies.
* Fix action name display for mapping
* Fix Lua plugin script calls (NOTE: laggy when using MessageBox)
* convert project to sdk style
* Add editorconfig and start cleaning up
* Fix documentation. Update namespaces to match files (breaks profiles)
* Include all projects in tests, disable building docs on debug
* Add messagebox script action
* Add tests for pluginhost
* Remove administrator from window title test
* add some icons to ui
* Add enabling/disabling plugins
* Close plugins when Key2Joy shuts down
* Fix appcommand failing
* Fix plugin permission form crashing. Fix plugin load exception not showing warning
* Handle plugin host closing better when app has crashed
* Seperate host and client logic in remote event subscriber
* Ensure the PluginHost shuts down if the app crashes
* Better error output for plugins
* Fix cmd interop not working, add some tests
* also generate docs on plugins
* Fix build order with docs
* Fix enum script parameters and ensure actions share environment scopes
* Fix _wpftmp folders being created dotnet/wpf#2930
* Fix sequence action. Add disabled trigger/action for unloaded plugins on start... (continued)

Run Details

180 of 1703 branches covered (0.0%)

Branch coverage included in aggregate %.

6419 of 6419 new or added lines in 207 files covered. (100.0%)

1035 of 8041 relevant lines covered (12.87%)

8445.05 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

32.47

/Core/Key2Joy.Core/Mapping/Actions/ActionsRepository.cs

﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using Key2Joy.Contracts.Mapping;
using Key2Joy.Contracts.Mapping.Actions;
using Key2Joy.Plugins;

namespace Key2Joy.Mapping.Actions;

public static class ActionsRepository
{
    private static Dictionary<string, MappingTypeFactory<AbstractAction>> actions;

    /// <summary>
    /// Loads all actions in the assembly, optionally merging it with additional action types.
    /// </summary>
    /// <param name="additionalActionTypeFactories"></param>
    public static void Buffer(IReadOnlyList<MappingTypeFactory<AbstractAction>> additionalActionTypeFactories = null)
    {
        static TypeExposedMethod MethodInfoToTypeExposed(MethodInfo m, ExposesScriptingMethodAttribute a)
        {
            return new TypeExposedMethod(a.FunctionName, m.Name, m.DeclaringType);
        }

        actions = Assembly.GetExecutingAssembly()
            .GetTypes()
            .Where(t => t.GetCustomAttribute(typeof(ActionAttribute), false) != null)
            .ToDictionary(
                t => t.FullName,
                t => new MappingTypeFactory<AbstractAction>(
                    t.FullName,
                    t.GetCustomAttribute<ActionAttribute>(),
                    t.GetMethods()
                        .Where(m => m.GetCustomAttributes(typeof(ExposesScriptingMethodAttribute), false).Length > 0)
                        .SelectMany(m => m.GetCustomAttributes<ExposesScriptingMethodAttribute>()
                            .Select(a => MethodInfoToTypeExposed(m, a))
                        )
                )
            );

        if (additionalActionTypeFactories == null)
        {
            return;
        }

        foreach (var actionFactory in additionalActionTypeFactories)
        {
            if (actions.ContainsKey(actionFactory.FullTypeName))
            {
                Console.WriteLine("Action {0} already exists in the action buffer. Overwriting.", actionFactory.FullTypeName);
            }

            actions.Add(actionFactory.FullTypeName, actionFactory);
        }
    }

    /// <summary>
    /// Gets all action type factories
    /// </summary>
    /// <returns></returns>
    public static IDictionary<string, MappingTypeFactory<AbstractAction>> GetAllActions() => actions;

    /// <summary>
    /// Gets all action attributes
    /// </summary>
    /// <returns></returns>
    public static IList<ActionAttribute> GetAllActionAttributes() => actions.Values.Select(x => x.Attribute as ActionAttribute).ToList();

    /// <summary>
    /// Gets the attribute for the provided action
    /// </summary>
    /// <param name="action"></param>
    /// <returns></returns>
    public static ActionAttribute GetAttributeForAction(AbstractAction action)
    {
        var realTypeName = MappingTypeHelper.GetTypeFullName(actions, action);
        realTypeName = MappingTypeHelper.EnsureSimpleTypeName(realTypeName);
        return actions[realTypeName].Attribute as ActionAttribute;
    }

    /// <summary>
    /// Gets a specific action factory by its type
    /// </summary>
    /// <param name="type"></param>
    /// <returns></returns>
    internal static MappingTypeFactory<AbstractAction> GetAction(Type type) => actions[type.FullName];

    /// <summary>
    /// Gets all action types and their attribute annotations depending on the specified visibility
    /// </summary>
    /// <param name="forTopLevel"></param>
    /// <returns></returns>
    public static SortedDictionary<ActionAttribute, MappingTypeFactory<AbstractAction>> GetAllActions(bool forTopLevel) => new SortedDictionary<ActionAttribute, MappingTypeFactory<AbstractAction>>(
            actions
                .Where(kvp =>
                {
                    if (kvp.Value.Attribute is not ActionAttribute actionAttribute
                    || actionAttribute.Visibility == MappingMenuVisibility.Never)
                    {
                        return false;
                    }

                    if (forTopLevel)
                    {
                        return actionAttribute.Visibility is MappingMenuVisibility.Always
                            or MappingMenuVisibility.OnlyTopLevel;
                    }

                    return actionAttribute.Visibility is MappingMenuVisibility.Always or MappingMenuVisibility.UnlessTopLevel;
                })
                .ToDictionary(t => t.Value.Attribute as ActionAttribute, t => t.Value)
            );
}

1	using System;
2	using System.Collections.Generic;
3	using System.Linq;
4	using System.Reflection;
5	using Key2Joy.Contracts.Mapping;
6	using Key2Joy.Contracts.Mapping.Actions;
7	using Key2Joy.Plugins;
8
9	namespace Key2Joy.Mapping.Actions;
10
11	public static class ActionsRepository
12	{
13	private static Dictionary<string, MappingTypeFactory<AbstractAction>> actions;
14
15	/// <summary>
16	/// Loads all actions in the assembly, optionally merging it with additional action types.
17	/// </summary>
18	/// <param name="additionalActionTypeFactories"></param>
19	public static void Buffer(IReadOnlyList<MappingTypeFactory<AbstractAction>> additionalActionTypeFactories = null)
20	{	1✔
21	static TypeExposedMethod MethodInfoToTypeExposed(MethodInfo m, ExposesScriptingMethodAttribute a)
22	{	29✔
23	return new TypeExposedMethod(a.FunctionName, m.Name, m.DeclaringType);	29✔
24	}	29✔
25
26	actions = Assembly.GetExecutingAssembly()	1✔
27	.GetTypes()	1✔
28	.Where(t => t.GetCustomAttribute(typeof(ActionAttribute), false) != null)	222✔
29	.ToDictionary(	1✔
30	t => t.FullName,	30✔
31	t => new MappingTypeFactory<AbstractAction>(	30✔
32	t.FullName,	30✔
33	t.GetCustomAttribute<ActionAttribute>(),	30✔
34	t.GetMethods()	30✔
35	.Where(m => m.GetCustomAttributes(typeof(ExposesScriptingMethodAttribute), false).Length > 0)	790✔
36	.SelectMany(m => m.GetCustomAttributes<ExposesScriptingMethodAttribute>()	25✔
37	.Select(a => MethodInfoToTypeExposed(m, a))	54✔
38	)	30✔
39	)	30✔
40	);	1✔
41
42	if (additionalActionTypeFactories == null)	1!
43	{	1✔
44	return;	1✔
45	}
46
47	foreach (var actionFactory in additionalActionTypeFactories)	×
48	{	×
49	if (actions.ContainsKey(actionFactory.FullTypeName))	×
50	{	×
51	Console.WriteLine("Action {0} already exists in the action buffer. Overwriting.", actionFactory.FullTypeName);	×
52	}	×
53
54	actions.Add(actionFactory.FullTypeName, actionFactory);	×
55	}	×
56	}	1✔
57
58	/// <summary>
59	/// Gets all action type factories
60	/// </summary>
61	/// <returns></returns>
62	public static IDictionary<string, MappingTypeFactory<AbstractAction>> GetAllActions() => actions;	1✔
63
64	/// <summary>
65	/// Gets all action attributes
66	/// </summary>
67	/// <returns></returns>
68	public static IList<ActionAttribute> GetAllActionAttributes() => actions.Values.Select(x => x.Attribute as ActionAttribute).ToList();	×
69
70	/// <summary>
71	/// Gets the attribute for the provided action
72	/// </summary>
73	/// <param name="action"></param>
74	/// <returns></returns>
75	public static ActionAttribute GetAttributeForAction(AbstractAction action)
76	{	×
77	var realTypeName = MappingTypeHelper.GetTypeFullName(actions, action);	×
78	realTypeName = MappingTypeHelper.EnsureSimpleTypeName(realTypeName);	×
79	return actions[realTypeName].Attribute as ActionAttribute;	×
80	}	×
81
82	/// <summary>
83	/// Gets a specific action factory by its type
84	/// </summary>
85	/// <param name="type"></param>
86	/// <returns></returns>
87	internal static MappingTypeFactory<AbstractAction> GetAction(Type type) => actions[type.FullName];	×
88
89	/// <summary>
90	/// Gets all action types and their attribute annotations depending on the specified visibility
91	/// </summary>
92	/// <param name="forTopLevel"></param>
93	/// <returns></returns>
94	public static SortedDictionary<ActionAttribute, MappingTypeFactory<AbstractAction>> GetAllActions(bool forTopLevel) => new SortedDictionary<ActionAttribute, MappingTypeFactory<AbstractAction>>(	×
95	actions	×
96	.Where(kvp =>	×
97	{	×
98	if (kvp.Value.Attribute is not ActionAttribute actionAttribute	×
99	\|\| actionAttribute.Visibility == MappingMenuVisibility.Never)	×
100	{	×
101	return false;	×
102	}	×
103		×
104	if (forTopLevel)	×
105	{	×
106	return actionAttribute.Visibility is MappingMenuVisibility.Always	×
107	or MappingMenuVisibility.OnlyTopLevel;	×
108	}	×
109		×
110	return actionAttribute.Visibility is MappingMenuVisibility.Always or MappingMenuVisibility.UnlessTopLevel;	×
111	})	×
112	.ToDictionary(t => t.Value.Attribute as ActionAttribute, t => t.Value)	×
113	);	×
114	}

luttje / Key2Joy / 6517266969

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous