evt-settings 0.2.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0a822d919bc5c170700be5d1868528ce23963e9e
+  data.tar.gz: 76092c54a183f451291916f3463da61e3b43400f
+SHA512:
+  metadata.gz: bdffc312827641c6cc382e7a04a4ec053fd844b3337bf3e8d4d428486c01d33c2e287e5e0169232aff7bf64e97895d803202cb2845ff199a287250c03a2f1c0e
+  data.tar.gz: ccafb6216d297b0898c11c572baf606e590d8a23c80b3c2cdbf08e833734ddc7eebbd6137ad45e8c7d349dc033cc9977c2094a1c76f214ca48342bfc719de791

data/lib/settings/activate.rb

@@ -0,0 +1,11 @@
+class Settings
+  def self.activate(target_class=nil)
+    target_class ||= Object
+
+    macro_module = Settings::Setting::Macro
+
+    return if target_class.is_a? macro_module
+
+    target_class.extend(macro_module)
+  end
+end

data/lib/settings/data_source/build.rb

@@ -0,0 +1,18 @@
+class Settings
+  class DataSource
+    module Build
+      def self.call(input=nil)
+        data_source_type = type(input)
+        data_source_type.build(input)
+      end
+      class << self; alias :! :call; end # TODO: Remove deprecated actuator [Kelsey, Thu Oct 08 2015]
+
+      def self.type(input=nil)
+        return Settings::DataSource::Hash if input.is_a?(::Hash)
+        return Settings::DataSource::File if input.is_a?(String) || input.nil?
+
+        raise Settings::Error, "Input is not supported: #{input}"
+      end
+    end
+  end
+end

data/lib/settings/data_source/data_source.rb

@@ -0,0 +1,11 @@
+class Settings
+  class DataSource
+    include Log::Dependency
+
+    attr_reader :source
+
+    def initialize(source)
+      @source = source
+    end
+  end
+end

data/lib/settings/data_source/file.rb

@@ -0,0 +1,119 @@
+class Settings
+  class DataSource
+    class File < DataSource
+      def self.build(source=nil)
+        canonical = canonical(source)
+        validate(canonical)
+
+        new(canonical)
+      end
+
+      def self.canonical(source)
+        logger.trace { "Canonizing the file source (#{source})" }
+
+        canonize(source).tap do |instance|
+          logger.debug { "Canonized the file source (#{source})" }
+        end
+      end
+
+      def self.canonize(source)
+        return default_filepath if source.nil?
+        return source if full_path?(source)
+
+        dirpath = nil
+        filepath = nil
+
+        if file?(source)
+          dirpath = Pathname.new(Directory::Defaults.pathname)
+        else
+          filepath = Pathname.new(Defaults.filename)
+        end
+
+        dirpath ||= Pathname.new(source)
+        filepath ||= Pathname.new(source)
+
+        pathname(filepath, dirpath)
+      end
+
+      def self.default_filepath
+        dirpath = Pathname.new(Directory::Defaults.pathname)
+        filepath = Pathname.new(Defaults.filename)
+
+        pathname(filepath, dirpath)
+      end
+
+      def self.pathname(filepath, dirpath)
+        (dirpath + filepath).to_s
+      end
+
+      def self.full_path?(source)
+        file?(source) && dir?(source)
+      end
+
+      def self.file?(filepath)
+        ::File.extname(filepath) != ""
+      end
+
+      def self.dir?(dirpath)
+        ::File.dirname(dirpath) != "."
+      end
+
+      def self.validate(pathname)
+        logger.trace { "Validating the pathname (#{pathname})" }
+
+        pathname = Pathname.new(pathname)
+
+        unless pathname.file?
+          msg = "Settings cannot be read from #{pathname}. The file doesn't exist."
+          logger.error { msg }
+          raise Settings::Error, msg
+        end
+
+        logger.trace { "Validated the pathname (#{pathname})" }
+      end
+
+      def self.logger
+        @logger ||= Log.get(self)
+      end
+
+      def get_data
+        logger.trace { "Reading file: #{source}" }
+        file = ::File.open(source)
+        data = JSON.load(file).tap do
+          logger.debug { "Read file: #{source}" }
+        end
+
+        data = Casing::Underscore.(data)
+
+        hash_data_source = Hash.build data
+        hash_data_source.get_data
+      end
+
+      module Defaults
+        def self.logger
+          @logger ||= Log.get(self)
+        end
+
+        def self.filename
+          default_file = 'settings.json'
+          logger.debug { "Using the default settings file name (#{default_file})" }
+          default_file
+        end
+      end
+
+      module Directory
+        module Defaults
+          def self.logger
+            @logger ||= Log.get(self)
+          end
+
+          def self.pathname
+            default_dir = Dir.pwd
+            logger.debug { "Using the working directory default settings directory (#{default_dir})" }
+            default_dir
+          end
+        end
+      end
+    end
+  end
+end

data/lib/settings/data_source/hash.rb

@@ -0,0 +1,20 @@
+class Settings
+  class DataSource
+    class Hash < DataSource
+      def self.logger
+        @logger ||= Log.get(self)
+      end
+
+      def self.build(source)
+        new(source)
+      end
+
+      def get_data
+        logger.trace { "Converting the raw source data to Confstruct" }
+        Confstruct::Configuration.new(source).tap do |instance|
+          logger.debug { "Converted the raw source data to Confstruct" }
+        end
+      end
+    end
+  end
+end

data/lib/settings/log.rb

@@ -0,0 +1,9 @@
+class Settings
+  class Log < ::Log
+    def tag!(tags)
+      tags << :settings
+      tags << :library
+      tags << :verbose
+    end
+  end
+end

data/lib/settings/registry.rb

@@ -0,0 +1,38 @@
+class Settings
+  class Registry
+    def data
+      @data ||= {}
+    end
+    attr_writer :data
+
+    def register(cls, attribute)
+      unless setting?(cls, attribute)
+        registered?(cls) ? @data[cls].push(attribute) : @data[cls] = [attribute]
+      end
+
+      data[cls]
+    end
+
+    def setting?(cls, attribute)
+      registered?(cls) ? data[cls].include?(attribute) : false
+    end
+
+    def registered?(cls)
+      !!data[cls]
+    end
+
+    class << self
+      def instance
+        @instance ||= new
+      end
+
+      def register(cls, attribute)
+        instance.register(cls, attribute)
+      end
+
+      def setting?(cls, attribute)
+        instance.setting?(cls, attribute)
+      end
+    end
+  end
+end

data/lib/settings/setting/assignment.rb

@@ -0,0 +1,108 @@
+class Settings
+  module Setting
+    module Assignment
+      extend self
+
+      def logger
+        @logger ||= Log.get(self)
+      end
+
+      def assign(receiver, attribute, value, strict=false)
+        settable = assure_settable(receiver, attribute, strict)
+        if settable
+          assign_value(receiver, attribute, value)
+        end
+
+        receiver
+      end
+
+      def assign_value(receiver, attribute, value)
+        logger.trace { "Assigning to #{attribute}" }
+        receiver.public_send("#{attribute}=", value).tap do
+          logger.debug { "Assigned to #{attribute}" }
+          logger.debug(tag: :data) { "#{attribute}: #{value}" }
+        end
+      end
+
+      def setting?(receiver, attribute)
+        receiver_class = receiver.class
+        Settings::Registry.instance.setting? receiver_class, attribute
+      end
+
+      def assignable?(receiver, attribute)
+        receiver.respond_to? setter_name(attribute)
+      end
+
+      def setter_name(attribute)
+        :"#{attribute.to_s}=" unless attribute.to_s.end_with? '='
+      end
+
+      def digest(receiver, attribute, strict)
+        content = []
+        content << "Attribute: #{attribute}" if attribute
+        content << "Receiver: #{receiver}"
+        strict = "<not set>" if strict.nil?
+        content << "Strict: #{strict}"
+        content.join ', '
+      end
+
+      module Object
+        extend Assignment
+
+        def logger
+          @logger ||= Log.get(self)
+        end
+
+        def self.assure_settable(receiver, attribute, strict=true)
+          logger.trace { "Approving attribute (#{digest(receiver, attribute, strict)})" }
+
+          if strict
+            setting = setting?(receiver, attribute)
+            unless setting
+              logger.warn { "Can't set \"#{attribute}\". It isn't a setting of #{receiver}." }
+              return false
+            end
+          end
+
+          assignable = assignable? receiver, attribute
+          unless assignable
+            logger.warn { "Can't set \"#{attribute}\". It isn't assignable to #{receiver}." }
+            return false
+          end
+
+          logger.debug { "\"#{attribute}\" can be set" }
+          true
+        end
+      end
+
+      module Attribute
+        extend Assignment
+
+        def logger
+          @logger ||= Log.get(self)
+        end
+
+        def self.assure_settable(receiver, attribute, strict=true)
+          if strict
+            setting = setting? receiver, attribute
+            unless setting
+              msg = "Can't set \"#{attribute}\". It isn't a setting of #{receiver}."
+              logger.error { msg }
+              raise msg
+            end
+          end
+
+          assignable = assignable? receiver, attribute
+          unless assignable
+            msg = "Can't set \"#{attribute}\". It isn't assignable to #{receiver}."
+            logger.error { msg }
+            raise msg
+          end
+
+          logger.debug { "\"#{attribute}\" can be set" }
+          true
+        end
+      end
+    end
+  end
+end

data/lib/settings/setting/macro.rb

@@ -0,0 +1,16 @@
+class Settings
+  module Setting
+    module Macro
+      def setting_macro(attribute)
+        logger = Log.get(self)
+
+        logger.trace { "Defining setting attribute: #{attribute}" }
+        Attribute::Define.(self, attribute, :accessor)
+        Settings::Registry.register(self, attribute).tap do
+          logger.debug { "Defined setting attribute: #{attribute}" }
+        end
+      end
+      alias :setting :setting_macro
+    end
+  end
+end

data/lib/settings/settings.rb

@@ -0,0 +1,143 @@
+class Settings
+  class Error < RuntimeError; end
+
+  include Log::Dependency
+
+  attr_reader :data
+  attr_reader :pathname
+
+  def initialize(data, pathname=nil)
+    @data = data
+    @pathname = pathname
+  end
+
+  def self.logger
+    @logger ||= Log.get(self)
+  end
+
+  def self.build(source=nil)
+    source ||= implementer_source
+
+    data_source = DataSource::Build.(source)
+
+    data = data_source.get_data
+
+    instance = new data
+
+    instance
+  end
+
+  def self.implementer_source
+    logger.trace { "Getting data source from the implementer" }
+
+    unless self.respond_to? :data_source
+      logger.trace { "Implementer doesn't provide a data_source" }
+      return nil
+    end
+
+    self.data_source.tap do |data_source|
+      logger.trace { "Got data source from the implementer (#{data_source})" }
+    end
+  end
+
+  def override(override_data)
+    logger.trace { "Overriding settings data" }
+    res = data.push!(override_data)
+    logger.debug { "Overrode settings data" }
+    logger.debug(tag: :data) { "Override data #{override_data}" }
+    res
+  end
+
+  def reset
+    logger.trace { "Resetting overridden settings data" }
+    res = data.pop!
+    logger.debug { "Reset overridden settings data" }
+    res
+  end
+
+  def set(receiver, *namespace, attribute: nil, strict: true)
+    logger.trace { "Setting #{receiver} (#{digest(namespace, attribute, strict)})" }
+    unless attribute.nil?
+      value = set_attribute(receiver, attribute, namespace, strict)
+    else
+      receiver = set_object(receiver, namespace, strict)
+    end
+    value || receiver
+  end
+
+  def set_attribute(receiver, attribute, namespace, strict)
+    logger.trace { "Setting #{receiver} attribute (#{digest(namespace, attribute, strict)})" }
+
+    attribute = attribute.to_s if attribute.is_a? Symbol
+
+    attribute_namespace = namespace.dup
+    attribute_namespace << attribute
+
+    value = get(attribute_namespace)
+
+    if value.nil?
+      msg = "#{attribute_namespace} not found in the data"
+      logger.error { msg }
+      raise Settings::Error, msg
+    end
+
+    Settings::Setting::Assignment::Attribute.assign(receiver, attribute.to_sym, value, strict)
+
+    log_value = value
+    log_value = log_value.to_h if log_value.respond_to? :to_h
+
+    logger.debug { "Set #{receiver} #{attribute} to #{log_value}" }
+
+    value
+  end
+
+  def set_object(receiver, namespace, strict)
+    logger.trace { "Setting #{receiver} object (#{digest(namespace, nil, strict)})" }
+
+    data = get(namespace)
+
+    if data.nil?
+      msg = "#{namespace} not found in the data"
+      logger.error { msg }
+      raise Settings::Error, msg
+    end
+
+    data.each do |attribute, value|
+      Settings::Setting::Assignment::Object.assign(receiver, attribute.to_sym, value, strict)
+    end
+
+    logger.debug { "Set #{receiver} object (#{digest(namespace, nil, strict)})" }
+
+    receiver
+  end
+
+  def assign_value(receiver, attribute, value, strict=false)
+    Settings::Setting::Assignment.assign(receiver, attribute, value, strict)
+  end
+
+  def get(*namespace)
+    namespace.flatten!
+    logger.trace { "Getting #{namespace}" }
+
+    string_keys = namespace.map { |n| n.is_a?(String) ? n : n.to_s }
+
+    value = string_keys.inject(data) {|memo, k| memo ? memo[k] : nil }
+
+    log_data = value
+    log_data = log_data.to_h if log_data.respond_to? :to_h
+
+    logger.debug { "Got #{namespace}" }
+    logger.debug(tag: :data) { "#{namespace}: #{log_data}" }
+
+    value
+  end
+
+  def digest(namespace, attribute, strict)
+    content = []
+    content << "Namespace: #{namespace.join ', '}" unless namespace.empty?
+    content << "Attribute: #{attribute}" if attribute
+    strict = "<not set>" if strict.nil?
+    content << "Strict: #{strict}"
+    content.join ', '
+  end
+end

data/lib/settings.rb

@@ -0,0 +1,19 @@
+require 'pathname'
+require 'json'
+
+require 'log'
+require 'casing'
+require 'attribute'
+require 'dependency'; Dependency.activate
+require 'confstruct'
+
+require 'settings/log'
+require 'settings/data_source/data_source'
+require 'settings/data_source/hash'
+require 'settings/data_source/file'
+require 'settings/data_source/build'
+require 'settings/registry'
+require 'settings/settings'
+require 'settings/activate'
+require 'settings/setting/assignment'
+require 'settings/setting/macro'

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: evt-settings
+version: !ruby/object:Gem::Version
+  version: 0.2.0.3
+platform: ruby
+authors:
+- The Eventide Project
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: evt-log
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: evt-casing
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: confstruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ntl-test_bench
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: " "
+email: opensource@eventide-project.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/settings.rb
+- lib/settings/activate.rb
+- lib/settings/data_source/build.rb
+- lib/settings/data_source/data_source.rb
+- lib/settings/data_source/file.rb
+- lib/settings/data_source/hash.rb
+- lib/settings/log.rb
+- lib/settings/registry.rb
+- lib/settings/setting/assignment.rb
+- lib/settings/setting/macro.rb
+- lib/settings/settings.rb
+homepage: https://github.com/eventide-project/settings
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Settings data access and assignment
+test_files: []