在Sublime文本插件中组织设置的方法

Question

也许这是另一轮“静态vs实例”，但我试图在细节上做魔鬼。 请注意，我对Python和插件开发相当陌生。在

某些插件使用以下代码：

s = sublime.load_settings(__name__ + '.sublime-settings')

class Settings:
  def load(self):
    self.setting1 = s.get('setting1', 'default1')
    self.setting2 = s.get('setting2', 'default2')
    ...

# Global Scope

settings = Settings()
settings.load()
s.add_on_change(__name__ + '-reload', settings.load)

这个例子没有什么特别的错误，除了load_settings和add_on_change方法应该属于Settings：

^{pr2}$

现在，Settings类封装了所有功能。 但是我们真的需要这个类的实例吗？ 我不这么认为。 这就是为什么要使用static：

class Settings:
  settings = sublime.load_settings(__name__ + '.sublime-settings')

  @staticmethod
  def init():
    Settings.settings.add_on_change(__name__ + '-reload', Settings.setup)
    Settings.setup()

  @staticmethod
  def setup():
    Settings.setting1 = Settings.settings.get('setting1', 'default1')
    Settings.setting2 = Settings.settings.get('setting2', 'default2')
    ...

# Global Scope

Settings.init()

上述示例的优点（如果有的话）是：

• 类封装所有与设置相关的功能
• 无需创建实例即可访问设置

有没有其他“体面”的方式来组织设置？在

Answer 1

将插件设置放入包根目录下名为Preferences.sublime-settings的文件中。这些设置将由Sublime文本自动加载并合并到Sublime的默认设置中。然后，您可以通过sublimeapi访问所有插件设置，而不需要任何样板代码。在

考虑以下名为Preferences.sublime-settings的插件设置文件：

{
    "plugin_name_setting1": true,
    "plugin_name_setting2": true
}

这些设置可通过视图对象获得：

^{pr2}$

例如，从TextCommand内部：

class ATextCommand(sublime_plugin.TextCommand):
    def run(self, edit):
        setting1 = self.view.settings().get('plugin_name_setting1')
        setting2 = self.view.settings().get('plugin_name_setting2')

或从传递到函数的视图对象依赖项：

def my_plugin_func(view):
    setting1 = view.settings().get('plugin_name_setting1')
    setting2 = view.settings().get('plugin_name_setting2')

也可以通过直接加载首选项文件来访问它们：

settings = sublime.load_settings('Preferences.sublime-settings')
setting1 = settings.get('plugin_name_setting1')
setting2 = settings.get('plugin_name_setting2')

专业人士

主要的好处是不需要样板代码。您只需创建设置文件并将其放入插件的根文件夹。在

用户可以在每个项目的基础上全局配置插件和。在

要全局设置设置，用户可以使用全局首选项文件，菜单>；首选项>；设置：

{
    "plugin_name_setting1": true,
    "plugin_name_setting2": true
}

要在项目前级别对其进行设置，可以使用项目文件设置，菜单>项目>编辑项目：

{
    "settings": {
        "plugin_name_setting1": true,
        "plugin_name_setting2": true
    }
}

这些设置也可以用于keymap上下文约束：

{ 
    "keys": [",", "a"], 
    "command": "a_plugin_command", 
    "context": [{ "key": "setting.plugin_name_setting2" } ] 
}

缺点

您的用户插件设置不在单独的命名设置文件中。我不认为这是一个大问题，如果你的所有插件设置前缀与你的插件名称，这样它们将在首选项文件中并排排序。我不知道其他的坏蛋是什么。在

Answer 2

第二个例子是最好的方法，所有的东西都封装在类中。@staticmethod方法没有我能想到的优点——一次只创建一个实例的类没有任何问题。在

全局settings = Settings()赋值应该从plugin_loaded()内部调用，以确保stapi已就绪，否则{}可能会失败。在

应该使用回调，以便在用户更改设置时不需要重新启动升华文本来更新设置的值。这些应该在plugin_unloaded()中删除，以防用户卸载插件。在

这是从我的一个插件中提取的一个粗略的模板。它应该是一个很好的起点，从这里可以将设置处理添加到Sublime文本插件中。在

代码也在GitHub Gist中。在

import sublime
import sublime_plugin

# The global scope ensures that the settings can
# be easily accessed from within all the classes.
global settings

def plugin_loaded():
    """ 
    This module level function is called on ST startup when the API is ready. 
    """

    global settings
    settings = Settings()
    settings.load_all()

def plugin_unloaded():
    """
    This module level function is called just before the plugin is unloaded.
    """

    settings.remove_callbacks()

class Settings:
    """
    Handles all the settings. A callback method is added for each setting, it 
    gets called by ST if that setting is changed in the settings file.
    """

    def __init__(self):

        FILENAME = "YourPluginName.sublime-settings"
        self.settings = sublime.load_settings(FILENAME)

        # User configurable settings.
        self.max_display_length = None
        self.monospace_font     = None
        self.ellipsis_symbols   = None
        self.prefix_custom      = None
        self.command_names      = None
        # ...

    def load_all(self):
        self.init_setting("max_display_length", self.set_max_display_length)
        self.init_setting("monospace_font", self.set_monospace_font)
        self.init_setting("ellipsis_symbols", self.set_ellipsis_symbols)
        self.init_setting("prefix_custom", self.set_prefix_custom)
        self.init_setting("command_names", self.set_command_names)
        # ...

    def init_setting(self, setting_name, setting_method):
        """
        Calls the setting_method to set the setting's value and registers the 
        setting_method as a callback so that it will be called by ST if the 
        setting's value is changed by the user.
        """

        setting_method()
        self.settings.add_on_change(setting_name, setting_method)

    def remove_callbacks(self):
        self.settings.clear_on_change("max_display_length")
        self.settings.clear_on_change("monospace_font")
        self.settings.clear_on_change("ellipsis_symbols")
        self.settings.clear_on_change("prefix_custom")
        self.settings.clear_on_change("command_names")
        # ...

    # Methods for the user configurable settings.

    def set_max_display_length(self):
        DEFAULT = 70
        MIN_LENGTH = 50
        value = self.integer_setting("max_display_length", DEFAULT, MIN_LENGTH)
        self.max_display_length = value

    def set_monospace_font(self):
        DEFAULT = True
        value = self.boolean_setting("monospace_font", DEFAULT)
        self.monospace_font = value

    def set_ellipsis_symbols(self):
        DEFAULT = "…"
        value = self.string_setting("ellipsis_symbols", DEFAULT)
        self.ellipsis_symbols = value

    def set_prefix_custom(self):
        DEFAULT = ""
        # This setting may be set to a string or a list of strings;
        # if it is a list then ensure all list elements are strings.
        value = self.list_or_string_setting("prefix_custom", DEFAULT)
        if isinstance(value, list):
            for index, item in enumerate(value):
                if not isinstance(item, str):
                    value[index] = str(item)
        self.prefix_custom = value

    def set_command_names(self):
        DEFAULT = []
        value = self.list_setting("command_names", DEFAULT)
        self.command_names = value

    # Methods for settings retrieval; all will return a
    # setting of the required type or the default value.

    def string_setting(self, setting, default):
        return self.setting_of_type(setting, default, str)

    def list_setting(self, setting, default):
        return self.setting_of_type(setting, default, list)

    def boolean_setting(self, setting, default):
        return self.setting_of_type(setting, default, bool)

    def list_or_string_setting(self, setting, default):
        return self.setting_of_type(setting, default, (str, list))

    def setting_of_type(self, setting, default, required_type):
        value = self.settings.get(setting, None)
        return value if isinstance(value, required_type) else default

    # Special case.

    def integer_setting(self, setting, default, min_value):
        value = self.settings.get(setting, None)
        return value if self.is_integer(value) and value >= min_value else default

    def is_integer(self, value):
        # Bool is a subclass of int; isinstance(False, int) == True.
        return isinstance(value, int) and not isinstance(value, bool)