mysettingslogic 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5e710432765a4074e290768ced0028a1e2274a52e18d6c84357297efdb6e2a13
-  data.tar.gz: 33f5787dcffd7156d714828d439430f2ce256b56f396e0c340924828d581e961
+  metadata.gz: de00322bc80f8460d6cbe0f788cd7d990b68598c6c507ed85168e34487bb9dec
+  data.tar.gz: 779432a4edcad5b6cdbc585519f000a7912b20de6fb3c86ab0f76b69eb953a17
 SHA512:
-  metadata.gz: 6250d8ac98a9e581ce9534713c06b1eab51d45d81d4a33c7577c6899e801398c3bc84c43ec3ef2f8c6729adfe03a86696aab326ed553aded4a2eb460e8536094
-  data.tar.gz: 0652c46d8eb4ec8d84ab802ad08828353b86a91e68bbbad668904cc9de9b8f3e779b3647cad06e8b7f43345364558007e03287bac5aadffa64fe687bdb7a1a3e
+  metadata.gz: 2f70ec6e332ada01cf3efad8bee20e4299bc6ef9c30e285c851fbd8c3c6bbdcd29ddbd420811d2dce5f4cb63694018f203bd5892bfb80ea51f410cd4b5928886
+  data.tar.gz: f1a5dd630886966efd19eefdada7f06123d3ebd0bf75694c25a2a47bdcaa57aaf8ee856fec71fa15ad1f562fa4fd921d4be9278f5879794598d40cc4922716f7

data/lib/settingslogic.rb

@@ -0,0 +1,190 @@
+require "yaml"
+require "erb"
+require 'open-uri'
+
+# A simple settings solution using a YAML file. See README for more information.
+class Settingslogic < Hash
+  class MissingSetting < StandardError; end
+
+  class << self
+    def name # :nodoc:
+      self.superclass != Hash && instance.key?("name") ? instance.name : super
+    end
+    # Enables Settings.get('nested.key.name') for dynamic access
+    def get(key)
+      parts = key.split('.')
+      curs = self
+      while p = parts.shift
+        curs = curs.send(p)
+      end
+      curs
+    end
+
+    def source(value = nil)
+      @source ||= value
+    end
+
+    def namespace(value = nil)
+      @namespace ||= value
+    end
+
+    def suppress_errors(value = nil)
+      @suppress_errors ||= value
+    end
+
+    def [](key)
+      instance.fetch(key.to_s, nil)
+    end
+
+    def []=(key, val)
+      # Setting[:key][:key2] = 'value' for dynamic settings
+      val = new(val, source) if val.is_a? Hash
+      instance.store(key.to_s, val)
+      instance.create_accessor_for(key, val)
+    end
+
+    def load!
+      instance
+      true
+    end
+
+    def reload!
+      @instance = nil
+      load!
+    end
+
+    private
+      def instance
+        return @instance if @instance
+        @instance = new
+        create_accessors!
+        @instance
+      end
+
+      def method_missing(name, *args, &block)
+        instance.send(name, *args, &block)
+      end
+
+      # It would be great to DRY this up somehow, someday, but it's difficult because
+      # of the singleton pattern.  Basically this proxies Setting.foo to Setting.instance.foo
+      def create_accessors!
+        instance.each do |key,val|
+          create_accessor_for(key)
+        end
+      end
+
+      def create_accessor_for(key)
+        return unless key.to_s =~ /^\w+$/  # could have "some-setting:" which blows up eval
+        instance_eval "def #{key}; instance.send(:#{key}); end"
+      end
+
+  end
+
+  # Initializes a new settings object. You can initialize an object in any of the following ways:
+  #
+  #   Settings.new(:application) # will look for config/application.yml
+  #   Settings.new("application.yaml") # will look for application.yaml
+  #   Settings.new("/var/configs/application.yml") # will look for /var/configs/application.yml
+  #   Settings.new(:config1 => 1, :config2 => 2)
+  #
+  # Basically if you pass a symbol it will look for that file in the configs directory of your rails app,
+  # if you are using this in rails. If you pass a string it should be an absolute path to your settings file.
+  # Then you can pass a hash, and it just allows you to access the hash via methods.
+  def initialize(hash_or_file = self.class.source, section = nil)
+    #puts "new! #{hash_or_file}"
+    case hash_or_file
+    when nil
+      raise Errno::ENOENT, "No file specified as Settingslogic source"
+    when Hash
+      self.replace hash_or_file
+    else
+      file_contents = open(hash_or_file).read
+      hash = file_contents.empty? ? {} : YAML.load(ERB.new(file_contents).result, aliases:true).to_hash
+      if self.class.namespace
+        hash = hash[self.class.namespace] or return missing_key("Missing setting '#{self.class.namespace}' in #{hash_or_file}")
+      end
+      self.replace hash
+    end
+    @section = section || self.class.source  # so end of error says "in application.yml"
+    create_accessors!
+  end
+
+  # Called for dynamically-defined keys, and also the first key deferenced at the top-level, if load! is not used.
+  # Otherwise, create_accessors! (called by new) will have created actual methods for each key.
+  def method_missing(name, *args, &block)
+    key = name.to_s
+    return missing_key("Missing setting '#{key}' in #{@section}") unless has_key? key
+    value = fetch(key)
+    create_accessor_for(key)
+    value.is_a?(Hash) ? self.class.new(value, "'#{key}' section in #{@section}") : value
+  end
+
+  def [](key)
+    fetch(key.to_s, nil)
+  end
+
+  def []=(key,val)
+    # Setting[:key][:key2] = 'value' for dynamic settings
+    val = self.class.new(val, @section) if val.is_a? Hash
+    store(key.to_s, val)
+    create_accessor_for(key, val)
+  end
+
+  # Returns an instance of a Hash object
+  def to_hash
+    Hash[self]
+  end
+
+  # This handles naming collisions with Sinatra/Vlad/Capistrano. Since these use a set()
+  # helper that defines methods in Object, ANY method_missing ANYWHERE picks up the Vlad/Sinatra
+  # settings!  So settings.deploy_to title actually calls Object.deploy_to (from set :deploy_to, "host"),
+  # rather than the app_yml['deploy_to'] hash.  Jeezus.
+  def create_accessors!
+    self.each do |key,val|
+      create_accessor_for(key)
+    end
+  end
+
+  # Use instance_eval/class_eval because they're actually more efficient than define_method{}
+  # http://stackoverflow.com/questions/185947/ruby-definemethod-vs-def
+  # http://bmorearty.wordpress.com/2009/01/09/fun-with-rubys-instance_eval-and-class_eval/
+  def create_accessor_for(key, val=nil)
+    return unless key.to_s =~ /^\w+$/  # could have "some-setting:" which blows up eval
+    instance_variable_set("@#{key}", val)
+    self.class.class_eval <<-EndEval
+      def #{key}
+        return @#{key} if @#{key}
+        return missing_key("Missing setting '#{key}' in #{@section}") unless has_key? '#{key}'
+        value = fetch('#{key}')
+        @#{key} = if value.is_a?(Hash)
+          self.class.new(value, "'#{key}' section in #{@section}")
+        elsif value.is_a?(Array) && value.all?{|v| v.is_a? Hash}
+          value.map{|v| self.class.new(v)}
+        else
+          value
+        end
+      end
+    EndEval
+  end
+
+  def symbolize_keys
+
+    inject({}) do |memo, tuple|
+
+      k = (tuple.first.to_sym rescue tuple.first) || tuple.first
+
+      v = k.is_a?(Symbol) ? send(k) : tuple.last # make sure the value is accessed the same way Settings.foo.bar works
+
+      memo[k] = v && v.respond_to?(:symbolize_keys) ? v.symbolize_keys : v #recurse for nested hashes
+
+      memo
+    end
+
+  end
+
+  def missing_key(msg)
+    return nil if self.class.suppress_errors
+
+    raise MissingSetting, msg
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mysettingslogic
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Ben Johnson
@@ -45,7 +45,8 @@ email:
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- lib/settingslogic.rb
 homepage: ''
 licenses: []
 metadata: {}