cushion_defaults 0.5.2 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bca05c80623f43fc5f8d61f016ffb6ee18f832cb
-  data.tar.gz: daa36bc9f2da343a5e4699bd42e6c415da8e80cf
+  metadata.gz: 2a848b1a32c350596b23bfc77dfc4203f4752f89
+  data.tar.gz: 5f1af47223822f820d3b6b6846534e8b5c56617c
 SHA512:
-  metadata.gz: 46c86103b998e49862173cc1456e1c14b6615426e9c1816ac50fa9e964b8386c3b13e27fb403cd597cfd2b65df6e6fbdb7bb556e86de0473ca2a91f7ba172cb5
-  data.tar.gz: 8b149e6f6e9d07047c9768348263ebd90acd1ad7242d2bd3368157accadb26e709ec4c5bf9e5daaf8e9c28df6a4c27a0e73f4856a3210668a45cc35890266f89
+  metadata.gz: 1c69bed3724da4b17b32a6acaf7974598e05eb97cf236d1e784c3ef1d9457e126f6e577e3027b98f5dfb95c0987fec56148dc6fc7b4c64fa08cdeabc5821d123
+  data.tar.gz: 09fec36978d01e46e1774f9f59eddf013b2e43646a41ab4138963edc9c2deb294ee92f8b20d003f8c0307a2c4304fbd74a632cd786f40909565c0e3dc949b544

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # CHANGELOG
 
+## 0.6.x
+
+- 0.6.0
+    - PERFORMANCE:
+        - Performance gains in `#cushion_reader` of 20-100%. Now roughly comparable to `attr_reader`.
+        - In total, execution speed of `#cushion_reader` is 200-400% faster than in v. 0.0.0.
+    - API CHANGE:
+        - The following methods have been deprecated.
+            - `ClassMethods#remove_reader` (see `ClassMethods#remove_cushion_reader`)
+            - `ClassMethods#remove_bang` (see `ClassMethods#remove_cushion_bang`)
+            - `ClassMethods#remove_writer` (see `ClassMethods#remove_writer`)
+        - The now-deprecated methods, when called for `sym`, would remove any method that fit the appropriate reader/bang/writer naming convention. The new methods will only remove CushionDefaults-defined methods.
+        - Making a default pushy or polite now automatically declares a cushion_reader for that default in the relevant class.
+
 ## 0.5.x
 
 - 0.5.2: PERFORMANCE

data/README.md

@@ -647,6 +647,6 @@ When you need or want...
 
 ### When *Shouldn't* I Use CushionDefaults?
 
-1. *When speed is absolutely critical.* CushionDefaults is pretty fast (see `benchmarks/simple_benchmark.rb`), since it runs almost entirely on a series of hash lookups. But there's no way it could be as fast as `attr_accessor`: it just does more, and more computations means more time. If you have hundreds of thousands of calculations that you need performed lightning fast, you should look elsewhere.
+1. *When speed is absolutely critical.* CushionDefaults is very fast (see `benchmarks/simple_benchmark.rb`), since it runs almost entirely on a series of hash lookups and adjusts methods on the fly depending on the current defaults setting. But there's no way it could consistently be as fast as `attr_accessor`: it just does more, and more computations means more time. Current benchmarks show execution speeds of 1.1 to 1.6 times those of `attr_reader` in Ruby 2.1.5, with a smaller factor in Ruby 1.9.3—but this is a difference of 0.01s to 0.05s for 100,000 calls to the reader methods. If you have hundreds of thousands of calculations that you need performed lightning fast, you should look elsewhere; but otherwise, CushionReader should be fast enough for your purposes.
 2. *When working in a Rails environment.* CushionDefaults may eventually spawn a companion project CushionDefaults-Rails, but for now it's just not the right tool for a Rails job. There are plenty of libraries that would be better for this purpose, e.g., [default_value_for](https://github.com/FooBarWidget/default_value_for).
 3. *When you want to keep your dependencies down.* Some people end up with 150 apps on their phones; others end up with 150 gems in their projects. CushionDefaults itself doesn't depend on any other gems (in production), but that still doesn't mean it's worth the extra overhead to use it in every project.

data/lib/cushion_defaults.rb

@@ -31,7 +31,7 @@ require 'cushion_defaults/errors'
 module CushionDefaults
 
   # Version constant
-  VERSION = '0.5.2'
+  VERSION = '0.6.0'
 
   # The path of the first file that includes CushionDefaults.
   CALLING_PATH = File.expand_path(File.dirname($0)) + '/'
@@ -135,6 +135,8 @@ module CushionDefaults
 
     base.extend(ClassMethods)
 
+    base.send :_set_up_cushion_method_sets
+
     if @conf.auto_load_from_yaml
       base.defaults_from_yaml
     else

data/lib/cushion_defaults/class_methods.rb

@@ -1,9 +1,11 @@
+require 'set'
+
 module CushionDefaults
   # A series of class methods to be plopped into any class that includes CushionDefaults.
   module ClassMethods
 
     # Reader for the @defaults@ @DefaultsHash@.
-    attr_reader :defaults
+    attr_reader :defaults, :descendents
 
     # @!attribute [w] defaults
     # Wipe @defaults and replace it with the keys/vals of @replacement_hash@.
@@ -73,6 +75,15 @@ module CushionDefaults
       end
     end
 
+    def _set_up_cushion_method_sets
+      @have_cushion_readers = Set.new
+      @have_bang_readers = Set.new
+      @have_cushion_writers = Set.new
+      @descendents = Set.new
+    end
+
+    private :_set_up_cushion_method_sets
+
     # @!group Reader/Writer
 
     # Sets up a cushion_reader for each :sym in @syms@.
@@ -93,30 +104,80 @@ module CushionDefaults
     # @param syms [*#to_sym] instance variables that should have @cushion_readers@
     # @see Configuration#update_readers
     def cushion_reader(*syms)
-      syms.each do |sym|
-        sym = sym.to_sym
-        if self_or_parent_instance_method?(sym)
-          CushionDefaults.log("#{self} or a parent class already has what looks like a getter method for #{sym_str}", :warn)
-        end
-        instance_variable_sym = "@#{sym}".to_sym
+      # send it with force==true
+      syms.each { |sym| _update_cushion_reader(sym.to_sym, true) }
+      bang_reader *syms if CushionDefaults.conf.bang_things_up
+    end
 
-        # significant performance gains from using this rather than #defaults in method below
-        defaults_cache = @defaults
+    # @api private
+    def _define_cushion_reader_pushy_dynamic(sym)
+      defaults_cache = @defaults
+      define_method(sym) do
+        defaults_cache[sym].call(self, sym)
+        da_default.respond_to?(:call) ? da_default.call(self, sym) : da_default
+      end
+    end
 
-        define_method(sym) do
-          if instance_variable_defined?(instance_variable_sym) && (CushionDefaults.conf.no_pushies? || defaults_cache.not_pushy?(sym))
-            instance_variable_get(instance_variable_sym)
-          else
-            # much faster to save as var
-            da_default = defaults_cache[sym]
-            da_default.respond_to?(:call) ? da_default.call(self, sym) : da_default
-          end
-        end
-        CushionDefaults.log("cushion_reader #{sym} established for #{self}")
+    # @api private
+    def _define_cushion_reader_pushy_static(sym)
+      defaults_cache = @defaults
+      define_method(sym) do
+        defaults_cache[sym]
       end
-      bang_reader *syms if CushionDefaults.conf.bang_things_up
     end
 
+    # @api private
+    def _define_cushion_reader_no_pushy_dynamic(sym)
+      defaults_cache = @defaults
+      instance_variable_sym = "@#{sym}".to_sym
+      define_method(sym) do
+        instance_variable_defined?(instance_variable_sym) ? instance_variable_get(instance_variable_sym) : defaults_cache[sym].call(self, sym)
+      end
+    end
+
+    # @api private
+    def _define_cushion_reader_no_pushy_static(sym)
+      defaults_cache = @defaults
+      instance_variable_sym = "@#{sym}".to_sym
+      define_method(sym) do
+        instance_variable_defined?(instance_variable_sym) ? instance_variable_get(instance_variable_sym) : defaults_cache[sym]
+      end
+    end
+
+    private :_define_cushion_reader_no_pushy_dynamic, :_define_cushion_reader_no_pushy_static, :_define_cushion_reader_pushy_dynamic, :_define_cushion_reader_pushy_static
+
+    # @param sym [Symbol] the attribute to update the cushion_reader for
+    # @param force [boolean] if true, it will always update the method
+    # @api private
+    def _update_cushion_reader(sym, force=false)
+      # This will redefine a method each time the default is changed, but at this point that does not seem like a big
+      # enough performance hit to warrant the checks required to avoid it.
+
+      # force: should we force it to continue? (Basically should only be forced by {#cushion_reader})
+      # include?: if the reader already exists (i.e., it was previously manually created) then continue
+      # update_readers: if we're updating readers automatically, then continue
+      return unless force || @have_cushion_readers.include?(sym) || CushionDefaults.conf.update_readers
+
+      # include?: so we only show this warning once
+      if !@have_cushion_readers.include?(sym) && self_or_parent_instance_method?(sym)
+        CushionDefaults.log("#{self} or a parent class already has what looks like an attr_reader for #{sym}", :warn)
+      end
+
+      # Create one of four cushion_reader methods depending on the state and type of the default value
+      if @defaults.pushy? sym
+        @defaults[sym].respond_to?(:call) ? _define_cushion_reader_pushy_dynamic(sym) : _define_cushion_reader_pushy_static(sym)
+      else
+        default = @defaults[sym]
+        default.respond_to?(:call) ? _define_cushion_reader_no_pushy_dynamic(sym) : _define_cushion_reader_no_pushy_static(sym)
+      end
+      @have_cushion_readers.add sym
+      CushionDefaults.log("cushion_reader #{sym} updated for #{self}")
+    end
+
+    private :_update_cushion_reader
+
+
+
     # Identical to {#cushion_reader} with one important exception: after determining the default value, @bang_reader@
     # goes on to crystallize this default value for the instance.
     #
@@ -224,39 +285,95 @@ module CushionDefaults
       end
     end
 
-    # Undefines the reader for sym in this class (if present).
+    # Undefines the reader for sym in this class (if present). Does not affect ancestor classes.
     # @note This method will delete any method of the form @sym@, not just cushion_readers.
     # @param sym [#to_sym] instance variable to delete reader for
+    # @deprecated
     def remove_reader(sym)
       sym = sym.to_sym
       if self_has_method?(sym)
+        undef_method(sym)
+        @have_cushion_readers.delete(sym)
+        CushionDefaults.log("cushion_reader #{sym} removed from #{self}", :info)
+      end
+    end
+
+    # Undefines the cushion_reader for sym in this class (if present). Does not affect ancestor classes.
+    # @param sym [#to_sym] instance variable to delete cushion_reader for
+    def remove_cushion_reader(sym)
+      sym = sym.to_sym
+      if @have_cushion_readers.delete?(sym) && self_has_method?(sym)
         undef_method(sym)
         CushionDefaults.log("cushion_reader #{sym} removed from #{self}", :info)
       end
     end
 
-    # Undefines any bang method for sym in this class (if present).
+    # Undefines any bang method for sym in this class (if present). Does not affect ancestor classes.
     # @note This method will delete any method of the form @sym!@, not just bang readers.
     # @param sym [#to_sym] instance variable to delete bang method for
+    # @deprecated
     def remove_bang(sym)
-      sym = "sym!".to_sym
+      sym = "#{sym}!".to_sym
       if self_has_method?(sym)
+        undef_method(sym)
+        @have_bang_readers.delete(sym)
+        CushionDefaults.log("bang reader #{sym} removed from #{self}", :info)
+      end
+    end
+
+    # Undefines any bang method for sym in this class (if present). Does not affect ancestor classes.
+    # @note This method will delete any method of the form @sym!@, not just bang readers.
+    # @param sym [#to_sym] instance variable to delete bang method for
+    def remove_cushion_bang(sym)
+      sym = "#{sym}!".to_sym
+      if @have_bang_readers.delete?(sym) && self_has_method?(sym)
         undef_method(sym)
         CushionDefaults.log("bang reader #{sym} removed from #{self}", :info)
       end
     end
 
-    # Undefines any writer for sym in this class (if present).
+    # Undefines any writer for sym in this class (if present). Does not affect ancestor classes.
     # @note This method will delete any method of the format 'sym=', not just cushion_writers.
     # @param sym [#to_sym] instance variable to delete writer for
+    # @deprecated
     def remove_writer(sym)
       write_sym = "#{sym}=".to_sym
       if self_has_method?(write_sym)
+        undef_method(write_sym)
+        @have_cushion_writers.delete(write_sym)
+        CushionDefaults.log("cushion_writer #{sym}= removed from #{self}", :info)
+      end
+    end
+
+    # Undefines any writer for sym in this class (if present). Does not affect ancestor classes.
+    # @note This method will delete any method of the format 'sym=', not just cushion_writers.
+    # @param sym [#to_sym] instance variable to delete writer for
+    def remove_cushion_writer(sym)
+      write_sym = "#{sym}=".to_sym
+      if @have_cushion_writers.delete?(write_sym) && self_has_method?(write_sym)
         undef_method(write_sym)
         CushionDefaults.log("cushion_writer #{sym}= removed from #{self}", :info)
       end
     end
 
+    def _hide_cushion_reader(sym)
+      # Called (1) when a cushion reader exists and (2) the reader needs to be hidden
+      alias_method "_#{sym}_hidden".to_sym, sym
+      remove_method sym
+    end
+
+    def _reveal_cushion_reader(sym)
+      # Called (1) when a previous cushion reader exists but (2) it was hidden due to a parent's sym becoming pushy
+      alias_method sym, "_#{sym}_hidden".to_sym
+      remove_method "_#{sym}_hidden".to_sym
+      # Things might have changed, so we should update the method
+      @have_cushion_readers.add sym
+      _update_cushion_reader sym
+    end
+
+    private :_hide_cushion_reader, :_reveal_cushion_reader
+
+
     # Sets up both {#cushion_reader}s and {#cushion_writer}s for @syms@. Will set up {#bang_reader}s if
     # {CushionDefaults::Configuration#bang_things_up Configuration#bang_things_up} is true.
     # @param syms [*#to_sym] Those instance variables that should have {#cushion_reader}s and {#cushion_writer}s.
@@ -377,16 +494,59 @@ module CushionDefaults
 
     # Declare each sym to be pushy. Pushy defaults will be returned by {#cushion_reader}s regardless of what the
     # instance variables are set to.
+    #
+    # This will automatically create {#cushion_reader}'s for all variables made pushy.
     def make_pushy(*syms)
-      syms.each { |sym| @defaults.pushy!(sym) }
+      syms.each do |sym|
+        @defaults.pushy!(sym)
+        _update_cushion_reader(sym, true)
+      end
     end
 
     # Declare each sym to be polite. A polite default operates as normal. This is useful to override an ancestor class'
     # pushy declaration.
+    #
+    # This will automatically create {#cushion_reader}'s for all variables made polite.
     def make_polite(*syms)
-      syms.each { |sym| @defaults.not_pushy!(sym) }
+      syms.each do |sym|
+        @defaults.not_pushy!(sym)
+        _update_cushion_reader(sym, true)
+      end
     end
 
+    # Called when a variable either becomes pushy or _may_ have become pushy.
+    def _cascade_pushy_symbol(sym)
+      # if we get down far enough, it may no longer be pushy (we read a polite)
+      # at that point, we can assume accurate state
+      return unless @defaults.pushy? sym
+      if self_has_method? sym
+        if @defaults.pushy_in_parent? sym
+          # if it's pushy in a parent now, then hide the reader
+          # we hide it rather than delete it because we want to be able to restore a manually-created cushion_reader if
+          # this is later made not-polite
+          _hide_cushion_reader sym
+          @have_cushion_readers.delete sym
+          # cascade it down to descendents
+          @descendents.each { |desc| desc._cascade_pushy_symbol sym if respond_to? :_cascade_pushy_symbol }
+        else
+          # if it's pushy in us (has to be, if not pushy in parent) then just update the reader
+          _update_cushion_reader sym
+          # also, if it's pushy in us, we don't need to look at descendents any more, so no need to call
+        end
+      end
+    end
+
+    # Called when a variable either becomes polite or _may_ have become polite.
+    def _cascade_polite_symbol(sym)
+      # if we get down far enough, it may become pushy again
+      return unless @defaults.not_pushy? sym
+      _reveal_cushion_reader(sym) if self_has_method? "_#{sym}_hidden".to_sym
+      # cascade it down to descendents
+      @descendents.each { |desc| desc._cascade_polite_symbol sym if respond_to? :_cascade_polite_symbol }
+    end
+
+    private :_cascade_pushy_symbol, :_cascade_polite_symbol
+
     # @!endgroup
 
     # Ensure that if class @Klass@ includes @CushionDefaults@, then any class that subclasses @Klass@ will include it as
@@ -396,6 +556,8 @@ module CushionDefaults
     # @api private
     def inherited(inheritor)
       inheritor.send :include, CushionDefaults
+      @descendents << inheritor
+      super inheritor
     end
 
     protected

data/lib/cushion_defaults/defaults_hash.rb

@@ -77,8 +77,9 @@ module CushionDefaults
       key = key.to_sym
       return unless has_key? key
       remove_methods_as_needed(key)
-      @pushy_defaults.delete(key)
-      @polite_defaults.delete(key)
+      #TODO Need some better way to handle when @pushy_defaults is emptied or cleared. Need to talk to children.
+      @owner.send :_cascade_polite_symbol, key if @pushy_defaults.delete? key
+      @owner.send :_cascade_pushy_symbol, key if @polite_defaults.delete? key
       @frozen_defaults.delete(key)
       super(key)
       CushionDefaults.log("Default for #{key} in #{@owner} deleted.")
@@ -89,9 +90,9 @@ module CushionDefaults
     def clear
       keys.each do |key|
         remove_methods_as_needed(key.to_sym)
+        @owner.send :_cascade_polite_symbol, key if @pushy_defaults.delete? key
+        @owner.send :_cascade_pushy_symbol, key if @pushy_defaults.delete? key
       end
-      @pushy_defaults.clear
-      @polite_defaults.clear
       @frozen_defaults.clear
       super
       CushionDefaults.log("All defaults cleared for #{@owner}.", :info)
@@ -163,6 +164,9 @@ module CushionDefaults
       CushionDefaults.conf.we_have_a_pushy!
       @pushy_defaults.add(sym)
       @polite_defaults.delete(sym)
+
+      @owner.send :_cascade_pushy_symbol, sym
+
       CushionDefaults.log(":#{sym} in #{@owner} is now pushy.")
     end
 
@@ -170,6 +174,11 @@ module CushionDefaults
     def not_pushy!(sym)
       @pushy_defaults.delete(sym)
       @polite_defaults.add(sym)
+
+      @owner.send :_cascade_polite_symbol, sym
+
+      # we may need now to define a reader for it
+      @owner.send :_update_cushion_reader, sym
       CushionDefaults.log("#{sym} in #{@owner} is now polite.")
     end
 
@@ -220,7 +229,7 @@ module CushionDefaults
     # @see Configuration#update_writers
     # @see ClassMethods#cushion
     def add_methods_as_needed(key)
-      @owner.cushion_reader key.to_sym if CushionDefaults.conf.update_readers
+      @owner.send :_update_cushion_reader, key
       @owner.cushion_writer key.to_sym if CushionDefaults.conf.update_writers
     end
 
@@ -231,9 +240,9 @@ module CushionDefaults
     # @see ClassMethods#remove_reader
     # @see ClassMethods#remove_writer
     def remove_methods_as_needed(key)
-      @owner.remove_reader key.to_sym if CushionDefaults.conf.update_readers
-      @owner.remove_bang key.to_sym if CushionDefaults.conf.update_readers
-      @owner.remove_writer key.to_sym if CushionDefaults.conf.update_writers
+      @owner.remove_cushion_reader key.to_sym if CushionDefaults.conf.update_readers
+      @owner.remove_bang_reader key.to_sym if CushionDefaults.conf.update_readers
+      @owner.remove_cushion_writer key.to_sym if CushionDefaults.conf.update_writers
     end
 
     protected

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cushion_defaults
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.6.0
 platform: ruby
 authors:
 - Ryan Mitchell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-12 00:00:00.000000000 Z
+date: 2014-12-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec