cushion_defaults 0.0.3 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6be31769619d31078b95f3ce90c4dbe1e23948d0
-  data.tar.gz: 0f883a5d3b1721e29abc6588ee4fc5be86d9a7a2
+  metadata.gz: 5ee8cdd20d451d7e48d28f67f87161138e5b4c87
+  data.tar.gz: beccbd9d7f439691d120f23e74512be56d480b96
 SHA512:
-  metadata.gz: f71ace7a7cd19e962f49333ad57192acf18fa82752e93bab345ce5f89321091e4df00cb8c7778d4da650b19632e238d57a2bd38364fe5acf299fbbee043ca92d
-  data.tar.gz: f65b07dfb5c5d58e8220c16c0d47fa1968b19269d9fdcf923d94ccc7f0d988afae8fe426452c2dd6132d4e7d8e3fe4516c8179f215a1b2bb2545682f8443b4f1
+  metadata.gz: 240abcc508735adc2eec294ccb1851609b2925e6f90d280b9108d6860c50cf50d064a37cc7df5dea5f269e690e7ec84dea9cee7d8c5117c566958139c624053a
+  data.tar.gz: 0f12017c5d6b9aa2076fff84c69cb343bc3466102f275e13f5077c70df6236d74f132c36c6bc80eb2437de91dd3f60bdc49ecd3c0e3d0da0da6cf4b9e2bddba6

data/lib/cushion_defaults/class_methods.rb

@@ -7,10 +7,9 @@ module CushionDefaults
 
     # Either set up or wipe @defaults. Should not usually be called directly.
     def initialize_defaults_hash
-
       if @defaults
         # We need to maintain the identity of the hash, as child classes may have stored a reference to it
-        @defaults.delete_if { true }
+        @defaults.clear
       else
         @defaults = DefaultsHash.new(self)
       end
@@ -25,7 +24,9 @@ module CushionDefaults
     def defaults=(replacement_hash)
       # Need to copy over keys/vals to ensure @defaults remains a DefaultsHash and retains identity
 
+      CushionDefaults.log("Old defaults deleted for #{self}:#{@defaults.reduce(''){|s,(k,v)| s+"\n\t\t#{k}: #{v}"}}", :info) unless @defaults.empty?
       @defaults.replace(replacement_hash)
+      CushionDefaults.log("New defaults added for #{self}:#{@defaults.reduce(''){|s,(k,v)| s+"\n\t\t#{k}: #{v}"}}", :info)
       @defaults.keys.each do |key|
         unless key.is_a? Symbol
           @defaults[key.to_sym] = @defaults[key].delete!
@@ -54,15 +55,18 @@ module CushionDefaults
 
       yaml = YAML::load(File.open(yaml_path)) rescue {}
 
-      if yaml.empty? && CushionDefaults::configuration.whiny_yaml
-        warn "No YAML configuration for class #{self} found at #{yaml_path}"
+      if yaml.empty?
+        CushionDefaults.log("No YAML configuration for class #{self} found at #{yaml_path}", CushionDefaults.conf.whiny_yaml ? :warn : :debug)
       end
 
       initialize_defaults_hash
+      log_str = "New defaults added for #{self}:"
       # If automatic readers and writers are enabled, this will set them up as a consequence.
       yaml.each do |key, val|
+        log_str << "\n\t\t#{key}: #{val}"
         @defaults[key.to_sym] = val
       end
+      CushionDefaults.log(log_str, :info)
     end
 
     # Sets up a conditional getter method for each :sym in +syms+.
@@ -77,16 +81,17 @@ module CushionDefaults
         sym = sym.to_sym
         sym_str = sym.to_s
         if self_or_parent_instance_method?(sym)
-          warn "#{self} or a parent class already has what looks like a getter method for #{sym_str}"
+          CushionDefaults.log("#{self} or a parent class already has what looks like a getter method for #{sym_str}", :warn)
         end
         instance_variable_string = "@#{sym_str}"
         define_method(sym) do
-          if defaults.not_pushy?(sym) && instance_variable_defined?(instance_variable_string)
+          if instance_variable_defined?(instance_variable_string) && (CushionDefaults.conf.no_pushies? || defaults.not_pushy?(sym))
             instance_variable_get(instance_variable_string)
           else
             defaults[sym]
           end
         end
+        CushionDefaults.log("cushion_reader #{sym} established for #{self}")
       end
     end
 
@@ -94,7 +99,7 @@ module CushionDefaults
       syms.each do |sym|
         method_name = "#{sym}="
         if self_or_parent_instance_method?(method_name)
-          warn "#{self} or a parent class already has what looks like a setter method for #{sym}"
+          CushionDefaults.log("#{self} or a parent class already has what looks like a setter method for #{sym}", :warn)
         end
 
         instance_variable_string = "@#{sym}"
@@ -102,26 +107,33 @@ module CushionDefaults
         define_method(method_name) do |y|
           if CushionDefaults.nilish? y
             if CushionDefaults.conf.whiny_ignores
-              warn "You are attempting to set a nilish value for #{sym}. This will not be recorded, and any value set will be deleted."
+              CushionDefaults.log("You are attempting to set a nilish value for #{sym}. This will not be recorded, and any value set will be deleted.", :warn)
             end
             remove_instance_variable(instance_variable_string) if instance_variable_defined?(instance_variable_string)
           else
-            if defaults.pushy?(sym)
-              warn "You are setting a value for #{sym}, but this is a pushy default and this value will not be returned by any cushion_readers."
+            if CushionDefaults.conf.we_have_a_pushy? && defaults.pushy?(sym)
+              CushionDefaults.log("You are setting a value for #{sym}, but this is a pushy default and this value will not be returned by any cushion_readers.", :warn)
             end
             instance_variable_set(instance_variable_string, y)
           end
         end
+        CushionDefaults.log("cushion_writer #{sym}= established for #{self}")
       end
     end
 
     def remove_reader(sym)
-      undef_method(sym) if self_has_method?(sym)
+      if self_has_method?(sym)
+        undef_method(sym)
+        CushionDefaults.log("cushion_reader #{sym} removed from #{self}", :info)
+      end
     end
 
     def remove_writer(sym)
       write_sym = "#{sym}=".to_sym
-      undef_method(write_sym) if self_has_method?(write_sym)
+      if self_has_method?(write_sym)
+        undef_method(write_sym)
+        CushionDefaults.log("cushion_writer #{sym}= removed from #{self}", :info)
+      end
     end
 
     # Sets up both +conditional_getters+ and normal +attr_writer+ for +syms+.
@@ -156,6 +168,7 @@ module CushionDefaults
     # - #cushion_readers_for_defaults
     def cushion_defaults
       cushion *defaults.keys
+      CushionDefaults.log("cushions established for #{self}'s defaults': #{defaults.keys.join(', ')}", :info)
     end
 
     def make_pushy(*syms)

data/lib/cushion_defaults/configuration.rb

@@ -1,12 +1,20 @@
+require 'logger'
+
 # Effectively a singleton class, +Configuration+ keeps track of various configuration options for +CushionDefaults+.
+#
+# In addition, it also keeps track of certain state data for +CushionDefaults+.
 class Configuration # :nodoc:
   # adapted from http://brandonhilkert.com/blog/ruby-gem-configuration-patterns/
 
-  attr_accessor :update_readers, :update_writers, :auto_load_from_yaml, :yaml_source_folder, :yaml_source_full_path, :whiny_yaml, :whiny_ignores, :cushion_child_defaults_in_parent, :ignore_attempts_to_set_nil, :blank_str_is_nil
+  attr_accessor :update_readers, :update_writers, :auto_load_from_yaml, :yaml_source_folder, :yaml_source_full_path
+  attr_accessor :record_in_log, :whiny_yaml, :whiny_ignores, :cushion_child_defaults_in_parent, :ignore_attempts_to_set_nil
+  attr_accessor :blank_str_is_nil
+  attr_reader :logger
 
   # Initializes with +#defaults+
   def initialize
     defaults!
+    @we_have_a_pushy = false
   end
 
   # Returns or computes the folder where class-specific yaml files are expected to reside.
@@ -18,9 +26,15 @@ class Configuration # :nodoc:
   #
   # +loaded_config+ :: hash from which options will be derived
   def from_hash(loaded_config)
+    log_str = 'Loading configuration options from hash...'
     loaded_config.each do |key, val|
-      instance_variable_set("@#{key.to_sym}", val) if instance_variable_defined? "@#{key.to_sym}"
+      log_str << "\n\t\t#{key}: #{val}"
+      # We need to be able to use some of the checks and responses in the custom setter methods
+      writer_sym = "#{key}=".to_sym
+      send writer_sym, val if respond_to? writer_sym
+      #instance_variable_set("@#{key.to_sym}", val) if instance_variable_defined? "@#{key.to_sym}"
     end
+    CushionDefaults.log(log_str, :info)
   end
 
   # Defines default configuration settings
@@ -30,6 +44,9 @@ class Configuration # :nodoc:
     self.auto_load_from_yaml = true
     self.yaml_source_folder = 'config/cushion_defaults/'
     self.yaml_source_full_path = nil
+    self.record_in_log = true
+    self.logger = Logger.new $stdout
+    self.log_lvl = Logger::INFO
     self.whiny_yaml = false
     self.whiny_ignores = false
     self.ignore_attempts_to_set_nil = true
@@ -40,6 +57,21 @@ class Configuration # :nodoc:
     defaults!
     self.whiny_yaml = true
     self.whiny_ignores = true
+    self.log_lvl = Logger::DEBUG
+  end
+
+  def logger=(new_logger, should_assign_formatter=true)
+    if new_logger.nil?
+      self.record_in_log = false
+      @logger = nil
+    else
+      if new_logger.respond_to? :info
+        @logger = new_logger
+        assign_formatter_to_logger if should_assign_formatter
+      else
+        CushionDefaults.log("config.logger not set to #{new_logger}, as it does not appear to implement standard logging methods.", :error)
+      end
+    end
   end
 
   def underscore(s)
@@ -53,4 +85,35 @@ class Configuration # :nodoc:
   def yaml_file_for(klass)
     "#{CushionDefaults::configuration.yaml_source_full_path}#{underscore(klass.to_s)+'.yaml'}"
   end
+
+  def log_lvl=(lvl)
+    if @logger
+      @logger.level = lvl
+    end
+  end
+
+  def we_have_a_pushy?
+    @we_have_a_pushy
+  end
+
+  def no_pushies?
+    # Note that if you add a pushy, and then remove it, this will still return false. Basically, the method returns
+    # whether there was, at any point in time, a pushy default.
+    #
+    # The whole handling of pushies can and will be improved in the future.
+    !@we_have_a_pushy
+  end
+
+  def we_have_a_pushy!
+    @we_have_a_pushy = true
+    puts "Just set pushy!. Did it work? #{we_have_a_pushy?}"
+  end
+
+  protected
+
+  def assign_formatter_to_logger
+    logger.formatter = proc do |severity, time, progname, msg|
+      "\nCUSHIONDEFAULTS: #{severity}\n\t\##{progname ? "#{progname} at" : "At"} #{time.strftime('%d %b %Y, %H:%M:%S%p')}\n\t#{msg}\n"
+    end
+  end
 end

data/lib/cushion_defaults/defaults_hash.rb

@@ -26,7 +26,12 @@ module CushionDefaults
     # If +key+ is in +self+ and +y+, then the value of +y+ will replace that in +self+ in the resulting +Hash+.
     # +y+ :: Hash (of any length) whose key/values will be added to this +DefaultsHash+.
     def +(y)
-      y.each {|key, val| self[key] = val}
+      y.each do |key, val|
+        if has_key? key
+          CushionDefaults.log("As #{@owner} already has the default #{key} defined, this call to + is overwriting it.", :info)
+        end
+        self[key] = val
+      end
       self
     end
 
@@ -62,6 +67,7 @@ module CushionDefaults
       @pushy_defaults.delete(key)
       @polite_defaults.delete(key)
       super(key)
+      CushionDefaults.log("Default for #{key} in #{@owner} deleted.")
     end
 
     # Custom clear method. We need to check whether or not we should delete the methods associated with the keys, and we
@@ -73,6 +79,7 @@ module CushionDefaults
       @pushy_defaults.clear
       @polite_defaults.clear
       super
+      CushionDefaults.log("All defaults cleared for #{@owner}.", :info)
     end
 
     # Custom clear method. We need to check whether or not we should delete the methods associated with the key.
@@ -112,13 +119,16 @@ module CushionDefaults
     end
 
     def pushy!(sym)
+      CushionDefaults.conf.we_have_a_pushy!
       @pushy_defaults.add(sym)
       @polite_defaults.delete(sym)
+      CushionDefaults.log(":#{sym} in #{@owner} is now pushy.")
     end
 
     def not_pushy!(sym)
       @pushy_defaults.delete(sym)
       @polite_defaults.add(sym)
+      CushionDefaults.log("#{sym} in #{@owner} is now polite.")
     end
 
     def pushy?(sym)

data/lib/cushion_defaults.rb

@@ -10,25 +10,14 @@ require 'cushion_defaults/defaults_hash'
 # +Klass+.
 module CushionDefaults
 
-  VERSION = '0.0.3'
-
-  # CONFIG
+  VERSION = '0.1.0'
 
   # Location CushionDefaults looks for (optional) config file
   CALLING_PATH = File.expand_path(File.dirname($0)) + '/'
 
   CONFIG_LOCATION = CALLING_PATH + 'config/cushion_defaults.yaml'
 
-  # If set to true, will automatically look at +YAML_PATH+ for each class that includes +CushionDefaults+ to try to
-  # load defaults from yaml file located at the result of +YAML_PROC+.  By default, this would be 'config/klass.yaml'.
-
-  # Relative folder path to yaml file used both automatically if +AUTO_LOAD_FROM_YAML+ and with unparam'd manual calls
-  # to +#defaults_from_yaml+.
-
-  # If true, will complain (i.e., throw a warning) if a yaml file cannot be found for a class, whether called because of
-  # AUTO_LOAD_FROM_YAML or via a manual call to +#defaults_from_yaml+.
-
-  # Create or return a cached (singleton) +Configuration+ object.
+  # Create or return a cached (effectively singleton) +Configuration+ object.
   def self.configuration
     @configuration ||= Configuration.new
   end
@@ -37,6 +26,44 @@ module CushionDefaults
     self.configuration
   end
 
+  def self.preliminary_setup
+    local_conf_path = CALLING_PATH + configuration.yaml_source_folder + 'cushion_defaults.yaml'
+    if File.exists?(CONFIG_LOCATION)
+      t = File.open(CONFIG_LOCATION)
+      log("Found and opened config file at #{CONFIG_LOCATION}", :info)
+    elsif File.exists?(local_conf_path)
+      t = File.open(local_conf_path)
+      log("Found and opened config file at #{local_conf_path}", :info)
+    else
+      t = nil
+      log("No config file found. Looked at #{CONFIG_LOCATION} and #{local_conf_path}.", :info)
+    end
+
+    conf.from_hash(YAML::load(t)) if t
+  end
+
+  def self.log(str, level=:debug)
+    return unless conf.record_in_log
+    caller_method_name = caller_locations(1,1)[0].label.to_s
+    conf.logger.progname = caller_method_name
+    case level
+      when :debug
+        conf.logger.debug {str}
+      when :fatal
+        conf.logger.fatal {str}
+      when :error
+        conf.logger.error {str}
+      when :warn
+        conf.logger.warn {str}
+      when :info
+        conf.logger.info {str}
+      else
+        conf.logger.unknown {str}
+    end
+  end
+
+  self.preliminary_setup
+
   def self.nilish?(y)
     if conf.ignore_attempts_to_set_nil
       y.nil? || (conf.blank_str_is_nil && y.eql?(''))
@@ -48,36 +75,29 @@ module CushionDefaults
   # Yield the configuration object to a block.
   #
   # The following configuration methods are available with the returned object:
-  # - #maintain_getters (boolean) :: If true, cushion_getters will be added/removed automatically as defaults are added/removed.
-  # - #maintain_writers (boolean) :: If true, cushion_setters will be added/removed automatically as defaults are added/removed.
+  # - #update_readers (boolean) :: If true, cushion_readers will be added/removed automatically as defaults are added/removed. Def: false.
+  # - #update_writers (boolean) :: If true, cushion_writers will be added/removed automatically as defaults are added/removed. Def: false.
   # - #auto_load_from_yaml (boolean) :: Specifies whether we should attempt to automatically load defaults from class-specific yaml files. Def: true.
   # - #yaml_source_folder (string)  :: Specifies the folder that contains class-specific yaml files. Def: 'config/cushion_defaults/'.
   # - #yaml_source_full_path (string) :: Specifies the full path for class-specific yaml files. Def: +nil+.
+  # - #record_in_log (boolean) :: If true, module will write to config.logger as appropriate. Def: true.
+  # - #logger (Logger) :: Any object that responds to logging methods. Def: Logger.new
   # - #whiny_yaml (boolean) :: If true, a warning will be issued if a class-specific yaml file cannot be found. Def: false.
   # - #whiny_ignores (boolean) :: If true, a warning will be issued when a variable is not set (or is undefined) due to being nilish. Def: false.
-  # - #cushion_child_defaults_in_parent (boolean) :: If true, then if SubKlass < Klass and getters/setters are added for a default specified in Subklass, then a getter that returns nil will be added to Klass as well. Def: false.
   # - #ignore_attempts_to_set_nil (boolean) :: If true, then if a cushion_writer has been added for :x, then calling var.x = nil will instead remove_instance_variable(x) on var, effectively making it so that var.x will return the default value for x. Def: true.
   # - #blank_str_is_nil (boolean) :: If true (and if #ignore_attempts_to_set_nil), the setter works like Rail's #blank method: if it isn't blank, the instance variable is set. Def: true.
   def self.configure
     yield(configuration)
   end
 
-  if File.exists?(CONFIG_LOCATION)
-    t = File.open(CONFIG_LOCATION)
-  elsif File.exists?(CALLING_PATH + configuration.yaml_source_folder + 'cushion_defaults.yaml')
-    t = File.open(CALLING_PATH + configuration.yaml_source_folder + 'cushion_defaults.yaml')
-  else
-    t = nil
-  end
-
-  conf.from_hash(YAML::load(t)) if t
-
   # Add class methods and set up +DefaultsHash+ when the module is included in a class.
   #
   # If +AUTO_LOAD_FROM_YAML+, then it also searches for a yaml configuration file for the class in the path specified
   # in the config variables.
   def self.included(base)
 
+    log("CushionDefaults has been included in #{base}.")
+
     base.extend(ClassMethods)
 
     if configuration.auto_load_from_yaml
@@ -115,6 +135,8 @@ module CushionDefaults
     if !has_specified? key || (act_if_nilish && CushionDefaults.nilish?(instance_variable_get("@#{key}")))
       default_value = default(key)
       instance_variable_set("@#{key}", default_value)
+    else
+      log("Did not update #{key}")
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cushion_defaults
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors:
 - Ryan Mitchell