translatomatic 0.1.3 → 0.2.0

data/lib/translatomatic/config/location_settings.rb

@@ -0,0 +1,133 @@
+module Translatomatic
+  module Config
+    # settings for a specific location
+    # location can be user settings, project settings, or file specific
+    # settings.
+    class LocationSettings
+      class << self
+        # load settings from environment variables
+        def from_environment
+          settings = {}
+          Options.options.each_value do |option|
+            if option.env_name && ENV.include?(option.env_name)
+              settings[option.name] = ENV[option.env_name]
+            end
+          end
+          new(settings, location: :env, path: Dir.pwd)
+        end
+
+        def runtime(data = {})
+          new(data.deep_symbolize_keys, location: :runtime, path: Dir.pwd)
+        end
+      end
+
+      # @return [String] The path to the settings file
+      attr_reader :path
+
+      # @return [Symbol] The location of these settings (:user, :project, :env)
+      attr_reader :location
+
+      def initialize(data = {}, options = {})
+        @data = data
+        @options = options || {}
+        @location = @options[:location]
+        @path = @options[:path]
+        @data[:files] ||= {} unless options[:no_files]
+      end
+
+      # @return [String] Configuration as YAML
+      def to_yaml
+        data_for_save.to_yaml
+      end
+
+      # @return [Hash] Files data
+      def files
+        @data[:files]
+      end
+
+      # Get a configuration setting
+      # @param key [String] configuration key
+      # @return [String] The configuration value
+      def get(key, default = nil)
+        include?(key) ? @data[key.to_sym] : default
+      end
+
+      # Change a configuration setting.
+      # @param key [String] configuration key
+      # @param value [Object] new value for the configuration
+      # @return [Object] the new value
+      def set(key, value)
+        update(key) { |option| @data[option.name] = cast(value, option.type) }
+      end
+
+      # Remove a configuration setting
+      # @param key [String] configuration key to remove
+      # @return [void]
+      def unset(key)
+        update(key) { |option| @data.delete(option.name) }
+      end
+
+      # If key is an array type, adds the value to the existing list.
+      # Raises an error for non array types.
+      # @param key [String] configuration key
+      # @param value [Object] value to add to the list
+      # @return [Object] the new value
+      def add(key, value)
+        update_array(key, value, :add)
+      end
+
+      # If key is an array type, removes the value from the existing list.
+      # Raises an error for non array types.
+      # @param key [String] configuration key
+      # @param value [Object] value to remove from the list
+      # @return [Object] the new value
+      def subtract(key, value)
+        update_array(key, value, :subtract)
+      end
+
+      # Test if configuration includes the given key
+      # @param key [String] configuration key
+      # @return [boolean] true if the configuration key is set
+      def include?(key)
+        Options.check_valid_key(key)
+        @data.include?(key.to_sym)
+      end
+
+      private
+
+      include Translatomatic::Util
+      include Translatomatic::TypeCast
+
+      def data_for_save
+        data = @data.dup
+        files = data.delete(:files)
+        # put files at the bottom
+        data[:files] = files unless files.blank?
+        data
+      end
+
+      def update_array(key, value, add)
+        update(key) do |option|
+          assert_array_type(option)
+          current = @data[option.name] || []
+          casted = cast(value, option.type)
+          new_value = add == :add ? current + casted : current - casted
+          @data[option.name] = new_value
+        end
+      end
+
+      # common functionality for set/unset/add/subtract methods
+      def update(key)
+        key = Options.check_valid_key(key)
+        option = Options.options[key.to_sym]
+        raise t('config.command_line_only') if option.command_line_only
+        yield option
+      end
+
+      def assert_array_type(option)
+        is_array = array_type?(option.type)
+        raise t('config.non_array_key', key: option.name) unless is_array
+      end
+    end
+  end
+end

data/lib/translatomatic/config/options.rb

@@ -0,0 +1,68 @@
+module Translatomatic
+  module Config
+    # A collection of all translatomatic options available
+    module Options
+      class << self
+        # @return [Hash<String,Translatomatic::Option>] options
+        def options
+          @config_options ||= begin
+            # create mapping from option name to option object
+            map = {}
+            config_sources.each do |source|
+              map.merge!(source_options(source))
+            end
+            map
+          end
+        end
+
+        # @param key [Symbol] Option name
+        # @return [Translatomatic::Option] The specified option
+        def option(key)
+          check_valid_key(key)
+          options[key.to_sym]
+        end
+
+        # Test if key is a recognised configuration option name.
+        # Raise an exception if it isn't
+        # @param key [Symbol] Option name
+        def check_valid_key(key)
+          key = key ? key.to_sym : nil
+          raise t('config.invalid_key', key: key) unless valid_key?(key)
+          key
+        end
+
+        # @return [Boolean] True if key is a recognised configuration option
+        def valid_key?(key)
+          options.include?(key.to_sym)
+        end
+
+        private
+
+        include Translatomatic::Util
+
+        def config_sources
+          [
+            Translatomatic::CLI::CommonOptions,
+            Translatomatic::CLI::Translate,
+            Translatomatic::CLI::Config,
+            Translatomatic::Provider.types,
+            Translatomatic::ResourceFile.types,
+            Translatomatic::Database,
+            Translatomatic::Converter,
+            Translatomatic::FileTranslator
+          ].freeze
+        end
+
+        def source_options(source)
+          map = {}
+          source_options = Translatomatic::Option.options_from_object(source)
+          source_options.each do |sopt|
+            optname = sopt.name.to_sym
+            map[optname] = sopt
+          end
+          map
+        end
+      end
+    end
+  end
+end

data/lib/translatomatic/config/selector.rb

@@ -0,0 +1,127 @@
+module Translatomatic
+  module Config
+    # Selects which set of config settings to use
+    class Selector
+      attr_reader :for_file
+      attr_reader :location
+
+      def initialize(settings, default_location, params = {})
+        @settings = settings
+        @for_file = params[:for_file]
+        @location = params[:location]
+        @default_location = default_location
+      end
+
+      # Find a settings object for reading the specified option
+      # @param key [Symbol] Option name
+      # @return [LocationSettings] settings
+      def settings_for_read(key)
+        if location.nil?
+          # no location, find first settings for key according to precedence
+          settings_with_precedence(key)
+        else
+          # location is set
+          check_valid_location
+          location_settings_for_read(key, location)
+        end
+      end
+
+      # Find a settings object for writing the specified option
+      # @param key [Symbol] Option name
+      # @return [LocationSettings] settings
+      def settings_for_write(key)
+        effective = effective_location(key, location)
+        settings = @settings[effective]
+        if for_file
+          path = file(settings)
+          data = settings.files[path.to_s.to_sym] ||= {}
+          file_location_settings(settings, data)
+        else
+          settings
+        end
+      end
+
+      private
+
+      include Translatomatic::TypeCast
+
+      # valid location list in order of precedence
+      LOCATIONS = %i[runtime project user env].freeze
+
+      def settings_with_precedence(key)
+        # find the first setting found by precedence
+        LOCATIONS.each do |loc|
+          settings = location_settings_for_read(key, loc)
+          return settings if settings
+        end
+        nil
+      end
+
+      def location_settings_for_read(key, loc)
+        effective = effective_location(key, loc)
+        settings = @settings[effective]
+        file_settings = for_file_settings(settings)
+        [file_settings, settings].each do |i|
+          return i if i && i.include?(key)
+        end
+        return nil
+      end
+
+      def effective_location(key, loc)
+        effective = loc || @default_location
+        effective = :user if Options.option(key).user_location_only
+        effective
+      end
+
+      def check_valid_location
+        valid = valid_location?
+        raise t('config.invalid_location', location: location) unless valid
+      end
+
+      def valid_location?
+        location.present? && LOCATIONS.include?(location.to_sym)
+      end
+
+      def for_file_settings(settings)
+        return nil unless for_file
+        data = merged_file_data(settings)
+        file_location_settings(settings, data)
+      end
+
+      def file(settings)
+        path = Pathname.new(for_file)
+        unless path.relative?
+          settings_path = Pathname.new(settings.path)
+          path = path.relative_path_from(settings_path)
+        end
+        path
+      end
+
+      # find matching file configurations
+      def merged_file_data(settings)
+        merged_data = {}
+        file = file(settings)
+        paths = settings.files.keys.collect(&:to_s)
+        paths.sort_by(&:length).each do |path|
+          next unless path_match?(file, path)
+          merged_data.merge!(settings.files[path.to_sym])
+        end
+        merged_data
+      end
+
+      # check if file is equal to or a child of the given path
+      def path_match?(file, path)
+        file.to_s == path || file.to_s.start_with?(path.to_s)
+      end
+
+      def file_location_settings(settings, data)
+        options = {
+          path: settings.path,
+          location: settings.location,
+          no_files: true
+        }
+        LocationSettings.new(data, options)
+      end
+    end
+  end
+end

data/lib/translatomatic/config/settings.rb

@@ -0,0 +1,148 @@
+module Translatomatic
+  module Config
+    # Translatomatic configuration settings.
+    # get and set methods accept a params hash, which recognises the
+    # following keys:
+    # * location: [Symbol] configuration location (:user or :project)
+    # * for_file: [String] file path for per-file configuration
+    class Settings
+      # @return [String] The path to the user home
+      attr_reader :user_path
+
+      # @return [String] The path to the project home
+      attr_reader :project_path
+
+      def initialize(options = {})
+        @runtime = options[:runtime] || {}
+        @user_path = File.realpath(options[:user_path] || Dir.home)
+        @project_path = options[:project_path]
+        @project_path ||= Files.find_project(@user_path)
+        load
+      end
+
+      # Get a configuration setting
+      # @param key [String] configuration key
+      # @param params [Hash] options
+      # @return [String] The configuration value. If location is nil, returns the
+      #   effective value by precedence, otherwise it returns the setting for
+      #   the given configuration file location.
+      def get(key, params = {})
+        option = Options.option(key)
+        settings = settings_read(key, params)
+        value = settings ? settings.get(key, option.default) : option.default
+
+        # cast value to expected type.
+        base_path = config_base_path(settings.location) if settings
+        cast(value, option.type, base_path: base_path)
+      end
+
+      # Change a configuration setting.  By default the project configuration
+      #   file is changed if a project configuration file exists,
+      #   otherwise the user configuration file is changed.
+      # @param key [String] configuration key
+      # @param params [Hash] options
+      # @return [void]
+      def set(key, value, params = {})
+        settings_write(key, params).set(key, value)
+        save
+      end
+
+      # Remove a configuration setting
+      # @param key [String] configuration key to remove
+      # @param params [Hash] options
+      # @return [void]
+      def unset(key, params = {})
+        settings_write(key, params).unset(key)
+        save
+      end
+
+      # If key is an array type, adds the value to the existing list.
+      # Raises an error for non array types.
+      # @param key [String] configuration key
+      # @param value [Object] value to add to the list
+      # @param params [Hash] options
+      # @return [void]
+      def add(key, value, params = {})
+        settings_write(key, params).add(key, value)
+        save
+      end
+
+      # If key is an array type, removes the value from the existing list.
+      # Raises an error for non array types.
+      # @param key [String] configuration key
+      # @param value [Object] value to remove from the list
+      # @param params [Hash] options
+      # @return [void]
+      def subtract(key, value, params = {})
+        settings_write(key, params).subtract(key, value)
+        save
+      end
+
+      # Get all configuration settings
+      # @param params [Hash] options
+      def all(params = {})
+        settings = {}
+        Options.options.each_value do |option|
+          settings[option.name] = get(option.name, params)
+        end
+        settings
+      end
+
+      # Test if configuration includes the given key
+      # @param key [String] configuration key
+      # @param params [Hash] options
+      # @return [boolean] true if the configuration key is set
+      def include?(key, params = {})
+        settings = settings_read(key, params)
+        settings && settings.include?(key)
+      end
+
+      private
+
+      include Translatomatic::Util
+      include Translatomatic::TypeCast
+
+      # Save configuration settings
+      def save
+        Files.save(@settings[:user])
+        Files.save(@settings[:project])
+      end
+
+      # Load configuration from the config file(s)
+      def load
+        @settings = {}
+        @settings[:env] = LocationSettings.from_environment
+        @settings[:user] = Files.load(@user_path, location: :user)
+        @settings[:project] = Files.load(@project_path, location: :project)
+        @settings[:runtime] = LocationSettings.runtime(@runtime)
+      end
+
+      def settings_write(key, params = {})
+        selector = Selector.new(@settings, default_location, params)
+        selector.settings_for_write(key)
+      end
+
+      def settings_read(key, params = {})
+        selector = Selector.new(@settings, nil, params)
+        selector.settings_for_read(key)
+      end
+
+      def default_location
+        # use project location if we have project configuration
+        @project_path ? :project : :user
+      end
+
+      # return base path for the config file at the given location
+      def config_base_path(location)
+        case location
+        when :user
+          user_path
+        when :project
+          project_path
+        when :runtime, :env
+          Dir.pwd
+        end
+      end
+    end
+  end
+end