fun_with_patterns 0.0.4 → 0.0.5

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    OWZlYzlkNjQ2MzBkZjY3ZGUxOTUwZTI2MmY0MzYzNDE4MjI1MGJjNA==
+    MTQwYjliNzVlNWFkNmYxMjkxZTU4NTY1NmZjZDEwMmNmMTE5NDU0MQ==
   data.tar.gz: !binary |-
-    ZDM0ZDUzMmY2ZTM2YmJmNTNhNDRhZjg1ODZlMDc3ZjBkOTc0NWRkOA==
+    NDAyMWQ1ZTU4M2JiYjdjODkwMGIwM2IwMjM0YjZlMDYxZGY2M2M5Ng==
 SHA512:
   metadata.gz: !binary |-
-    YzRlM2IwOGMwNWNjN2RhOWJkYjNmYjgyMGU0YjgwMjE3NTU4NWViNDI2MDU2
-    NjY3Yzg3OTRiMzNhZTA3ZGJiY2UwNzg1YzNmMDcwMTk5NDQ1NmFmZTEwMDAx
-    NjU5Nzk5MDc0NDk0YTY1YTk2MzJmNDI1Y2MxMjA1YjE4M2EyMWE=
+    YmFkOTUzMWQ2MTViZDEzZjZjYTY2NzBmZDU5OTE2NjQ0NzgxODQ1ZGRjYjYx
+    MWFhMTgxOGMyMWE0MjVkYWRiNDcxOGYxODg4Y2VmMDQ2Y2JiYWY4MGQ1Mjc2
+    MDQxMzBiMTg4OGQ4YzM1YmJjZDcxM2MxYWY5OTZlNTdkYjg1ZWI=
   data.tar.gz: !binary |-
-    NDZiNWMyOWQxMjUyZDk5ZWUwMWZlNjJjNDVhNmQ0OTk5NjdhY2FjMGIwMzBl
-    ZGEyNDg2MzBlOGZkYTkxNjM1MjBiNjk5Y2M0MDBkNDVmZDA3YzQyM2Q0NTk1
-    NjFlOThjNTNkNGM2YjgzOTE3MjQ1NjhjM2RjMzQzM2QxYzFjNTY=
+    N2EzZjE5OTNlN2YzZmNjMTAwNDE2YTU5NGYxMjFlN2JkMDE1OTJkMjVjNjBl
+    ODQ4YjY0MzI5YWFjYjgxYzg4ZDQ4ZTQ1YWM3OTljY2FlMzllYWZjZTk3ZTZi
+    N2RiNDBlN2EyMjY4ODM0YjU0ZDgxZThjMzM3MTk4MzdhM2VjMmY=

data/CHANGELOG.markdown

@@ -1,6 +1,13 @@
 Changelog
 =========
 
+0.0.5
+-----
+
+Removed Reloadable and Hooks patterns.
+Added `get_and_set_block()` to GetAndSet (declares or runs a block)
+`get_and_set*()` methods can now be called in `Class` and `Module` themselves.
+
 0.0.4
 -----
 

data/Gemfile

@@ -14,4 +14,4 @@ group :development do
   gem 'fun_with_testing', '~> 0.0'
 end         
 
-gem "fun_with_gems", "~> 0.0"
+gem "fun_with_gems", "~> 0.0", ">= 0.0.2"

data/README.rdoc

@@ -63,9 +63,63 @@ For each directory you give it, it will:
 
 You can get some interesting behavior by overwriting individual methods.  For example, loading individual configurations from YAML or JSON or XML.  There's an example in the test/ folder.
 
+The default "style" of loading a file is "eval the contents and return the result."  This may not always be the desired behavior.  Other built in loading styles:
+
+      
+
+
+
 Note: If you want to manage your own registry by redefining loader_pattern_load_from_dir( dir ), loader_pattern_register_item( item ), etc., make sure you handle and report exceptions.
 
 
+More example code!
+
+    class Klass
+      
+      include FunWith::Patterns::Loader
+      loader_pattern_configure( :bracketwise_lookup, 
+                                :warn_on_key_change, 
+                                { :verbose => true, :load } )
+    end
+
+loader_pattern_configure is a quickie method for setting up a variety of behaviors.  Options so far:  
+      
+    :bracketwise_lookup  : instead of calling Klass.loader_pattern_registry_lookup( "string" )
+                           you can just call Klass["string"]
+                            
+    {:key => :<sym>}     : loader determines registry key by calling this method
+      
+    :warn_on_key_changes : If a newly loaded item has an existing registry key, it prints a warning as it overwrites
+      
+    :dont_warn_on_key_changes : (default)
+    :style => :(eval|instance_exec|yaml)  : Use one of the built-in loading styles.  Otherwise, set custom loading
+                                            behavior by defining your own Klass.loader_pattern_register_item
+
+
+The styles need some explanation:
+
+    :eval (default)  : evals the contents of the file and returns the result
+    
+    :instance_exec   : The file contents will run as though inside the object
+                       
+                       Klass.new do
+                         # ----- file contents for boris.rb starts here
+                         self.name "Boris"
+                         self.age 23
+                         self.kill_count 9
+                         # ----- file contents for boris.rb end here
+                       end
+                      
+    :yaml              The file contents describe a YAML hash, with the topmost keys describing
+                       the setter to call in order to set the attribute to that value.  For example,
+                       
+                       ---
+                       - name: Boris
+                       
+                       would end up calling klass_object.name=( "Boris" )
+                       
+
+TODO: I feel like a default label should maybe come out of the filename (zero-config and all that), but haven't built it.
 
 == Reloadable ==
 

data/VERSION

@@ -1 +1 @@
-0.0.4
+0.0.5

data/lib/fun_with/patterns/get_and_set.rb

@@ -17,8 +17,7 @@ module FunWith
       end
       
       # Would also like to do a boolean version which creates
-      # .bool? .bool! and .not_bool!  
-      
+      # .bool? .bool! and .not_bool!
       def get_and_set_boolean( *method_names )
         for name in method_names
           if self.is_a?(Class) || self.is_a?(Module)
@@ -45,6 +44,21 @@ module FunWith
           end
         end
       end
+      
+      # the name() method can be called with a block (to change the block that is to be executed)
+      # or called with args to get the results of the block.  Uses the internal object variable @name
+      def get_and_set_block( name, *args, &block )
+        eval "define_method( :#{name} ) do |*args, &block|
+                if block.is_a?( Proc )   # oddly, block_given? always returns false when defined this way
+                  raise ArgumentError.new( 'Call #{name}() with either a block or args' ) unless args.length == 0
+                  self.instance_variable_set( :@#{name}, block )
+                  block
+                else
+                  block = self.instance_variable_get( :@#{name} )
+                  ( block || Proc.new{} ).call( *args )
+                end
+              end "
+      end
     end
   end
 end

data/lib/fun_with/patterns/get_and_set_api.rb

@@ -1,11 +1,20 @@
 module FunWith
   module Patterns
     module GetAndSetAPI
-      def activate( classes_to_activate = [Class, Module] )
-        classes_to_activate = [classes_to_activate] unless classes_to_activate.is_a?(Array)
-        
+      # Can pass in an array listing the classes to activate, or just pass in arguments
+      def activate( *classes_to_activate )
+        if classes_to_activate.length == 1 && classes_to_activate.first.is_a?(Array)
+          classes_to_activate = classes_to_activate.first
+        elsif classes_to_activate.length == 0
+          classes_to_activate = [Class, Module]   # no arguments given
+        end
+                
         for klass in classes_to_activate
-          klass.send( :include, FunWith::Patterns::GetAndSet )
+          if klass == Class || klass == Module
+            klass.send( :include, GetAndSet )    # Because individual classes or modules are objects of class Class/Module
+          end
+          
+          klass.send( :extend, GetAndSet )
         end
       end
     end

data/lib/fun_with/patterns/loader/class_methods.rb

@@ -0,0 +1,182 @@
+module FunWith
+  module Patterns
+    module Loader
+      module ClassMethods
+        # By default, looks for .rb files to evaluate
+        # ext => :all  (or "*") to load every file from directory.
+        # ext => :rb (or "rb") to load all .rb files (this is default)
+        # call without arguments to inquire about current extension.
+        def loader_pattern_extension( ext = nil )
+          case ext
+          when nil
+            # do nothing
+          when "*", :all
+            @loader_pattern_extension = "*"
+          else
+            @loader_pattern_extension = ext
+          end
+        
+          @loader_pattern_extension
+        end
+        
+        def loader_pattern_verbose( verbosity = nil )
+          @loader_pattern_verbose = verbosity unless verbosity.nil?
+          @loader_pattern_verbose
+        end
+        
+        def loader_pattern_rescue_failing_item_load( file, &block )
+          file = file.fwf_filepath.expand
+          if file.file?
+            obj = yield
+            STDOUT.puts( "Loaded file #{file}" ) if self.loader_pattern_verbose
+            
+            obj
+          else
+            STDERR.puts( "(#{self.class}) Load failed, no such file: #{file}" )
+          end
+        rescue Exception => e
+          STDERR.puts( "Could not load file #{file}.  Reason: #{e.class.name} #{e.message}" )
+        
+          if self.loader_pattern_verbose
+            STDERR.puts( puts e.backtrace.map{|line| "\t\t#{line}"}.join("\n") )
+            STDERR.puts( "\n" )
+          end
+        
+          nil
+        end
+        
+        # Default, may want to override how the registry behaves.
+        # If you don't provide a key argument, then the object needs to 
+        # respond to .loader_pattern_registry_key()
+        def loader_pattern_register_item( obj, key = nil )
+          return nil if obj.nil?
+          @loader_pattern_registry ||= {}
+        
+          if key.nil?
+            if obj.respond_to?( :loader_pattern_registry_key )
+              key = obj.loader_pattern_registry_key
+            else
+              raise "#{self.class} not registered.  No registry key given, and object does not respond to .loader_pattern_registry_key()."
+            end
+          end
+        
+          if loader_pattern_is_item_registerable?( obj )
+            if @loader_pattern_warn_on_key_changes && loader_pattern_registry_lookup( key )
+              warn( "class #{self} is replacing lookup key #{key.inspect}" )
+            end
+        
+            return @loader_pattern_registry[ key ] = obj
+          else
+            warn( "#{obj} is not an instance of a registerable class.  Registerable classes: #{self.loader_pattern_only_register_classes.inspect}" )
+            return nil
+          end
+        end
+        
+        def loader_pattern_registry_lookup( key )
+          @loader_pattern_registry ||= {}
+          @loader_pattern_registry[key]
+        end
+        
+        def loader_pattern_registry
+          @loader_pattern_registry
+        end
+        
+        def loader_pattern_only_register_classes( *args )
+          if args.length > 0
+            @loader_pattern_only_register_classes = args
+          end
+        
+          @loader_pattern_only_register_classes || []
+        end
+        
+        def loader_pattern_is_item_registerable?( item )
+          return true if loader_pattern_only_register_classes.fwf_blank?
+        
+          for klass in @loader_pattern_only_register_classes
+            return true if item.is_a?( klass )
+          end
+        
+          return false
+        end
+        
+        
+        # Assumes that every file in the directory and subdirectories contain ruby code that
+        # will yield an object that the loader is looking for.  It also automatically
+        # adds the resulting object to a registry.
+        # You may want to override this if you're looking for different behavior.
+        def loader_pattern_load_from_dir( *dirs )
+          for dir in dirs
+            dir = dir.fwf_filepath
+            @loader_pattern_directories ||= []
+            @loader_pattern_directories << dir
+            
+            for file in dir.glob( :ext => self.loader_pattern_extension, :recurse => true )
+              obj = self.loader_pattern_load_item( file )
+              self.loader_pattern_register_item( obj ) if self.loader_pattern_is_item_registerable?( obj )
+            end
+          end
+        end
+        
+        def loader_pattern_loaded_directories
+          @loader_pattern_directories ||= []
+        end
+        
+        # Handle the initial configuration of the class.
+        #  
+        # :bracketwise_lookup : Instead of looking up an object by LoaderBearingClass.loader_pattern_registry_lookup(:keyword)
+        #                       you can simply use LoaderBearingClass[:keyword]
+        #
+        # :warn_on_key_changes : Warns whenever the registry overwrites an existing key.  Useful for debugging, sometimes.
+        #
+        # Some configuration directives are given as hashes.  Multiple directives may be combined into
+        # a single hash.
+        #
+        # {:key => <METHOD_SYM>}  :  The method for asking the object what name it should be lookupable under.
+        #
+        # {:verbose => (true|false)} : How noisy do you want the loading to be?
+        # 
+        # {:style => :eval}
+        #
+        # {:style => :instance_exec}
+        #
+        # {:style => <PROC>}
+        
+        def loader_pattern_configure( *args )
+          for arg in args
+            case arg
+            when :bracketwise_lookup
+              self.extend( Features::BracketwiseLookup )
+            when :warn_on_key_changes
+              @loader_pattern_warn_on_key_changes = true
+            when :dont_warn_on_key_changes
+              @loader_pattern_warn_on_key_changes = false
+            when Hash
+              for key, val in arg
+                case key
+                when :key
+                  self.class_eval do
+                    eval( "alias :loader_pattern_registry_key #{val.to_sym.inspect}" )
+                  end
+                when :verbose
+                  self.loader_pattern_verbose( val )
+                when :style
+                  case val     # styles allowed: :eval, :instance_exec
+                  when :eval
+                    self.extend( LoadingStyles::Eval )
+                  when :instance_exec
+                    self.extend( LoadingStyles::InstanceExec )
+                  when :yaml
+                    self.extend( LoadingStyles::YAML )
+                    self.loader_pattern_extension( [:yml, :yaml] )
+                  else
+                    raise "Unknown Loader loading style: #{val.inspect}"
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fun_with/patterns/loader/features/bracketwise_lookup.rb

@@ -0,0 +1,17 @@
+module FunWith
+  module Patterns
+    module Loader
+      module Features
+        module BracketwiseLookup
+          def []( key )
+            loader_pattern_registry_lookup( key )
+          end
+          
+          def []=( key, val )
+            loader_pattern_register_item( val, key )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fun_with/patterns/loader/loading_styles/eval.rb

@@ -0,0 +1,23 @@
+module FunWith
+  module Patterns
+    module Loader
+      module LoadingStyles
+        module Eval
+          # Default behavior: read the file, evaluate it, expect a ruby object
+          # of the class that the loader pattern is installed on.  If anything goes
+          # wrong (file no exist, syntax error), returns a nil.
+          #
+          # Override in your class if you need your files translated
+          # into objects differently.
+          def loader_pattern_load_item( file )
+            self.loader_pattern_rescue_failing_item_load( file ) do
+              obj = eval( file.read )
+          
+              return obj
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fun_with/patterns/loader/loading_styles/instance_exec.rb

@@ -0,0 +1,24 @@
+module FunWith
+  module Patterns
+    module Loader
+      module LoadingStyles
+        # Assumes the class does not take arguments in its initialize() method.
+        # The contents of the file are run via instance_exec to configure the object.
+        module InstanceExec
+          def loader_pattern_load_item( file )
+            self.loader_pattern_rescue_failing_item_load( file ) do
+              obj = self.new
+              
+              # obj.instance_eval( file.read )
+              obj.instance_exec do
+                eval( file.read )
+              end
+                            
+              return obj
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fun_with/patterns/loader/loading_styles/yaml.rb

@@ -0,0 +1,27 @@
+module FunWith
+  module Patterns
+    module Loader
+      module LoadingStyles
+        module YAML
+          def loader_pattern_load_item( file )
+            self.loader_pattern_rescue_failing_item_load( file ) do
+              obj = self.new
+              
+              hash = Psych.load( file.read )
+              
+              for method, val in hash
+                eq_method = :"#{method}="
+                
+                if obj.respond_to?( eq_method )
+                  obj.send( eq_method, val )
+                end
+              end
+              
+              return obj
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fun_with/patterns/loader.rb

@@ -3,161 +3,8 @@ module FunWith
     module Loader
       def self.included( base )
         base.extend( ClassMethods )
-        base.loader_pattern_extension("rb") if base.loader_pattern_extension.nil?
-      end
-    
-      module ClassMethods
-        # By default, looks for .rb files to evaluate
-        # ext => :all  (or "*") to load every file from directory.
-        # ext => :rb (or "rb") to load all .rb files (this is default)
-        # call without arguments to inquire about current extension.
-        def loader_pattern_extension( ext = nil )
-          case ext
-          when nil
-            # do nothing
-          when "*", :all
-            @loader_pattern_extension = "*"
-          else
-            @loader_pattern_extension = "*.#{ext}"
-          end
-          
-          @loader_pattern_extension
-        end
-        
-        def loader_pattern_verbose( verbosity = nil )
-          @loader_pattern_verbose = verbosity unless verbosity.nil?
-          @loader_pattern_verbose
-        end
-    
-        # Default behavior: read the file, evaluate it, expect a ruby object
-        # of the class that the loader pattern is installed on.  If anything goes
-        # wrong (file no exist, syntax error), returns a nil.
-        #
-        # Override in your class if you need your files translated
-        # into objects differently.
-        def loader_pattern_load_item( file )
-          file = file.fwf_filepath
-          if file.file?
-            obj = eval( file.read )
-            
-            STDOUT.puts( "Loaded file #{file}" ) if self.loader_pattern_verbose
-            return obj
-          else
-            STDERR.puts( "(#{self.class}) Load failed, no such file: #{file}" )
-            return nil
-          end
-        rescue Exception => e
-          STDERR.puts( "Could not load file #{file}.  Reason: #{e.class.name} #{e.message}" )
-          
-          if self.loader_pattern_verbose
-            STDERR.puts( puts e.backtrace.map{|line| "\t\t#{line}"}.join("\n") )
-            STDERR.puts( "\n" )
-          end
-          
-          nil
-        end
-        
-        # Default, may want to override how the registry behaves.
-        # If you don't provide a key argument, then the object needs to 
-        # respond to .loader_pattern_registry_key()
-        def loader_pattern_register_item( obj, key = nil )
-          return nil if obj.nil?
-          @loader_pattern_registry ||= {}
-
-          key = obj.loader_pattern_registry_key if key.nil?
-          
-          if loader_pattern_is_item_registerable?( obj )
-            if @loader_pattern_warn_on_key_changes && loader_pattern_registry_lookup( key )
-              warn( "class #{self} is replacing lookup key #{key.inspect}" )
-            end
-              
-            return @loader_pattern_registry[ key ] = obj
-          else
-            warn( "#{obj} is not an instance of a registerable class.  Registerable classes: #{self.loader_pattern_only_register_classes.inspect}" )
-            return nil
-          end
-        end
-        
-        def loader_pattern_registry_lookup( key )
-          @loader_pattern_registry ||= {}
-          @loader_pattern_registry[key]
-        end
-        
-        def loader_pattern_registry
-          @loader_pattern_registry
-        end
-        
-        def loader_pattern_only_register_classes( *args )
-          if args.length > 0
-            @loader_pattern_only_register_classes = args
-          end
-            
-          @loader_pattern_only_register_classes || []
-        end
-        
-        def loader_pattern_is_item_registerable?( item )
-          return true if loader_pattern_only_register_classes.fwf_blank?
-          
-          for klass in @loader_pattern_only_register_classes
-            return true if item.is_a?( klass )
-          end
-          
-          return false
-        end
-        
-    
-        # Assumes that every file in the directory and subdirectories contain ruby code that
-        # will yield an object that the loader is looking for.  It also automatically
-        # adds the resulting object to a registry.
-        # You may want to override this if you're looking for different behavior.
-        def loader_pattern_load_from_dir( *dirs )
-          for dir in dirs
-            dir = dir.fwf_filepath
-            @loader_pattern_directories ||= []
-            @loader_pattern_directories << dir
-      
-            for file in dir.glob( "**", self.loader_pattern_extension )
-              obj = self.loader_pattern_load_item( file )
-              self.loader_pattern_register_item( obj ) if self.loader_pattern_is_item_registerable?( obj )
-            end
-          end
-        end
-        
-        def loader_pattern_loaded_directories
-          @loader_pattern_directories ||= []
-        end
-        
-        def loader_pattern_configure( *args )
-          for arg in args
-            case arg
-            when :bracketwise_lookup
-              self.class_eval do
-                def self.[]( key )
-                  loader_pattern_registry_lookup( key )
-                end
-                
-                def self.[]=( key, val )
-                  loader_pattern_register_item( val, key )
-                end
-              end
-            when :warn_on_key_changes
-              @loader_pattern_warn_on_key_changes = true
-            when :dont_warn_on_key_changes
-              @loader_pattern_warn_on_key_changes = false
-            when Hash
-              for key, val in arg
-                case key
-                when :key
-                  self.class_eval do
-                    eval( "alias :loader_pattern_registry_key #{val.inspect}" )
-                  end
-                when :verbose
-                  self.loader_pattern_verbose( val )
-                end
-              end
-            end
-          end
-        end
+        base.extend( LoadingStyles::Eval ) # provides a default load_item method
+        base.loader_pattern_extension( :rb ) if base.loader_pattern_extension.nil?
       end
     end
   end

data/lib/fun_with_patterns.rb

@@ -2,9 +2,7 @@ require 'fun_with_gems'
 
 FunWith::Gems.make_gem_fun( "FunWith::Patterns" )
 
-Class.send( :include, FunWith::Patterns::MakeInstancesReloadable )
-Module.send( :include, FunWith::Patterns::MakeInstancesReloadable )
-FunWith::Patterns::Reloadable.extend( FunWith::Patterns::ClassReloaderMethod )
 
 # Activate Object#get_and_set / Module#get_and_set by calling GetAndSet.activate
-FunWith::Patterns::GetAndSet.extend( FunWith::Patterns::GetAndSetAPI )
+FunWith::Patterns::GetAndSet.extend( FunWith::Patterns::GetAndSetAPI )
+

data/test/helper.rb

@@ -15,8 +15,9 @@
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
-require 'fun_with_testing'
 require 'fun_with_patterns'
+require 'fun_with_testing'
+
 
 require_relative 'user'
 require_relative 'yaml_obj'

data/test/test_get_and_set.rb

@@ -1,7 +1,5 @@
 require 'helper'
 
-FunWith::Patterns::GetAndSet.activate
-
 class TestGetAndSet < FunWith::Patterns::TestCase
   context "basics" do
     should "be plumbed correctly" do
@@ -12,6 +10,8 @@ class TestGetAndSet < FunWith::Patterns::TestCase
   context "trial run" do
     should "get and set" do
       c = Class.new
+      FunWith::Patterns::GetAndSet.activate( c )
+
       c.get_and_set( :radio, :radius, :radium )
       c.get_and_set( :radiate )
       c.get_and_set_boolean( :stringy, :flurmish )
@@ -46,6 +46,8 @@ class TestGetAndSet < FunWith::Patterns::TestCase
       m = Module.new
       c = Class.new
 
+      FunWith::Patterns::GetAndSet.activate( m )
+      
       c.send( :include, m )
       
       m.get_and_set( :radio, :radius, :radium )
@@ -73,5 +75,32 @@ class TestGetAndSet < FunWith::Patterns::TestCase
       assert_equal v2, o.radium( v2 )  # ==> "Madame Curie"
       assert_equal v2, o.radium()                 # ==> "Madame Curie"
     end
+    
+    should "get and set blocks" do
+      c = Class.new
+      FunWith::Patterns::GetAndSet.activate( c )
+      c.get_and_set_block( :string_transformation )
+      
+      doubler = c.new
+      assert_respond_to( doubler, :string_transformation )
+      
+      assert_nil doubler.string_transformation( "hello" )
+      
+      doubler.string_transformation do |input|
+        "#{input}#{input}"
+      end
+      
+      assert_equal "hellohello", doubler.string_transformation( "hello" )
+      assert_equal "55", doubler.string_transformation( "5" )
+      
+      stripper = c.new
+      stripper.string_transformation do |input|
+        input.strip
+      end
+      
+      assert_equal "stripped", stripper.string_transformation( "   stripped      ")
+      
+      
+    end
   end
 end

data/test/test_loader_pattern.rb

@@ -11,8 +11,12 @@ class TestLoaderPattern < FunWith::Patterns::TestCase
   
   context "testing User" do
     setup do
-      User.loader_pattern_load_from_dir( FunWith::Patterns.root( "test", "users" ) )
-      User2.loader_pattern_load_from_dir( FunWith::Patterns.root( "test", "users" ) )
+      User.loader_pattern_load_from_dir( FunWith::Patterns.root( "test", "users", "eval" ) )
+      User2.loader_pattern_load_from_dir( FunWith::Patterns.root( "test", "users", "eval" ) )
+      User3.loader_pattern_load_from_dir( FunWith::Patterns.root( "test", "users", "instance_exec" ) )
+      User4.loader_pattern_load_from_dir( FunWith::Patterns.root( "test", "users", "yaml" ) )
+      
+      @user_classes = [User, User2, User3, User4]
     end
     
     should "have all the right methods" do
@@ -22,13 +26,17 @@ class TestLoaderPattern < FunWith::Patterns::TestCase
                       :loader_pattern_register_item,
                       :loader_pattern_load_from_dir,
                       :loader_pattern_configure ]
-        assert_respond_to( User, method )
+        for klass in @user_classes
+          assert_respond_to( klass, method, "#{klass} should respond to ##{method}" )
+        end
       end
     end
     
-    should "load users from test/users and test/users/more" do
-      assert User.loader_pattern_registry_lookup("Gary Milhouse")
-      assert_equal 54, User.loader_pattern_registry_lookup("Gary Milhouse").age
+    should "load users from test/users into various classes" do
+      for klass in @user_classes
+        assert klass.loader_pattern_registry_lookup("Gary Milhouse"), "#{klass} did not load Gary.  Poor Gary."
+        assert_equal 54, klass.loader_pattern_registry_lookup("Gary Milhouse").age, "#{klass} did not load Gary with proper age data."
+      end
     end
     
     should "lookup via brackets" do

data/test/user.rb

@@ -22,4 +22,28 @@ class User2
     @name = name
     @age = age
   end
-end
+end
+
+class User3
+  FunWith::Patterns::GetAndSet.activate( self )
+  
+  get_and_set :name, :age
+  
+  include FunWith::Patterns::Loader
+  loader_pattern_configure( :bracketwise_lookup, 
+                            { :key => :name },
+                            { :style => :instance_exec }   # Create object, run code in configuration file inside the object's context.
+                          )
+                          
+end
+
+class User4
+  attr_accessor :name, :age
+  
+  include FunWith::Patterns::Loader
+  loader_pattern_configure( :bracketwise_lookup, 
+                            { :key => :name }, 
+                            { :style => :yaml }
+                          )
+end
+  

data/test/users/instance_exec/mary.rb

@@ -0,0 +1,2 @@
+name "Mary Masterson"
+age  27

data/test/users/instance_exec/more/gary.rb

@@ -0,0 +1,2 @@
+name "Gary Milhouse"
+age  54

data/test/users/instance_exec/steve.rb

@@ -0,0 +1,2 @@
+name "Steve Sturmond"
+age  72

data/test/users/instance_exec/wanda.rb

@@ -0,0 +1,2 @@
+name "Wanda Wimbledon"
+age  53

data/test/users/yaml/mary.yaml

@@ -0,0 +1,3 @@
+---
+:name: Mary Masterson
+:age: 27

data/test/users/yaml/more/gary.yml

@@ -0,0 +1,3 @@
+---
+:name: Gary Milhouse
+:age: 54

data/test/users/yaml/steve.yaml

@@ -0,0 +1,3 @@
+---
+:name: Steve Sturmond
+:age: 72

data/test/users/yaml/wanda.yml

@@ -0,0 +1,3 @@
+---
+:name: Wanda Wimbledon
+:age: 53

data/test/yaml_obj.rb

@@ -1,7 +1,8 @@
 require 'yaml'
 
 
-# Change the behavior by overriding
+# Change the behavior by overriding loader_pattern_load_item( file )
+# Uses custom method, not LoadingStyle::YAML
 class YamlObj
   include FunWith::Patterns::Loader
   

metadata

@@ -1,19 +1,22 @@
 --- !ruby/object:Gem::Specification
 name: fun_with_patterns
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Bryce Anderson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-31 00:00:00.000000000 Z
+date: 2015-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fun_with_gems
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.2
     - - ~>
       - !ruby/object:Gem::Version
         version: '0.0'
@@ -21,6 +24,9 @@ dependencies:
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.2
     - - ~>
       - !ruby/object:Gem::Version
         version: '0.0'
@@ -48,21 +54,29 @@ extra_rdoc_files:
 files:
 - ./lib/fun_with/patterns/get_and_set.rb
 - ./lib/fun_with/patterns/get_and_set_api.rb
-- ./lib/fun_with/patterns/hooks.rb
 - ./lib/fun_with/patterns/loader.rb
-- ./lib/fun_with/patterns/reloadable.rb
+- ./lib/fun_with/patterns/loader/class_methods.rb
+- ./lib/fun_with/patterns/loader/features/bracketwise_lookup.rb
+- ./lib/fun_with/patterns/loader/loading_styles/eval.rb
+- ./lib/fun_with/patterns/loader/loading_styles/instance_exec.rb
+- ./lib/fun_with/patterns/loader/loading_styles/yaml.rb
 - ./lib/fun_with_patterns.rb
 - ./test/helper.rb
-- ./test/reloadable/my_reloadable.rb
 - ./test/test_get_and_set.rb
-- ./test/test_hooks.rb
 - ./test/test_loader_pattern.rb
-- ./test/test_reloadable_pattern.rb
 - ./test/user.rb
-- ./test/users/mary.rb
-- ./test/users/more/gary.rb
-- ./test/users/steve.rb
-- ./test/users/wanda.rb
+- ./test/users/eval/mary.rb
+- ./test/users/eval/more/gary.rb
+- ./test/users/eval/steve.rb
+- ./test/users/eval/wanda.rb
+- ./test/users/instance_exec/mary.rb
+- ./test/users/instance_exec/more/gary.rb
+- ./test/users/instance_exec/steve.rb
+- ./test/users/instance_exec/wanda.rb
+- ./test/users/yaml/mary.yaml
+- ./test/users/yaml/more/gary.yml
+- ./test/users/yaml/steve.yaml
+- ./test/users/yaml/wanda.yml
 - ./test/yaml_obj.rb
 - ./test/yamls/mike/mike_amazon.yaml
 - ./test/yamls/mike/mike_gmail.yaml

data/lib/fun_with/patterns/hooks.rb

@@ -1,47 +0,0 @@
-module FunWith
-  module Patterns
-    module Hooks
-      def add_hook_before( method, &block )
-        hook_pattern_install_hooks_for_method( method )
-      end
-      
-      def add_hook_after( method, &block )
-        hook_pattern_install_hooks_for_method( method )
-        
-      end
-      
-      def hook_pattern_hooks_installed_for_method?( method )
-        self.respond_to?( :"#{method}_method_without_hooks" )
-      end
-      
-      def hook_pattern_install_hooks_for_method( method )
-        return false if hook_pattern_hooks_installed_for_method?( method )
-        
-        alias :"#{method}_method_without_hooks" :"#{method}"
-        
-        @hook_pattern_hooks ||= {}
-        @hook_pattern_hooks[method] ||= {}
-        @hook_pattern_hooks[method][:before] ||= []
-        @hook_pattern_hooks[method][:after] ||= []
-        
-
-        # http://stackoverflow.com/questions/4470108/when-monkey-patching-a-method-can-you-call-the-overridden-method-from-the-new-i
-        old_method = instance_method(method)
-
-        # define_method(:bar) do
-        #   old_bar.bind(self).() + ' World'
-        # end
-        
-        define_method( method ) do |*args, &block|
-          self.hook_pattern_run( @hook_pattern_hooks[method][:before], *args, &block )
-          old_method.bind( self ).call( *args, &block )
-          self.hook_pattern_run( @hook_pattern_hooks[method][:after], *args, &block )
-        end
-      end
-      
-      def hook_pattern_run( hookset, *args, &block )
-        puts "running hookset"
-      end
-    end
-  end
-end

data/lib/fun_with/patterns/reloadable.rb

@@ -1,33 +0,0 @@
-warn( "Something wrong with the  Reloadable class.  Flaky.  Not recommended for use." )
-module FunWith
-  module Patterns
-    # A bare-bones reloading system.  Useful when the entire file defines exactly one
-    # class or module, with no dependencies or side-effects.
-    module Reloadable
-      def reload!
-        FunWith::Patterns::Reloadable.reload_class( self )
-      end
-      
-      def reloader_filepath
-        @reloader_filepath
-      end
-    end
-    
-    module MakeInstancesReloadable
-      def reloadable!
-        self.extend( FunWith::Patterns::Reloadable )
-        kaller = caller.first.gsub(/:\d+:in.*/, '')
-        @reloader_filepath = kaller.fwf_filepath.expand
-      end
-    end
-    
-    module ClassReloaderMethod
-      def reload_class( klass )
-        if file = klass.reloader_filepath
-          Object.send( :remove_const, klass.name.to_sym )
-          file.load
-        end
-      end
-    end
-  end
-end

data/test/reloadable/my_reloadable.rb

@@ -1,7 +0,0 @@
-class MyReloadable
-  reloadable!
-  
-  def square( x )
-    x * x
-  end
-end

data/test/test_hooks.rb

@@ -1,25 +0,0 @@
-require 'helper'
-
-class TestHooksPattern < FunWith::Patterns::TestCase
-  _context "first try" do
-    should "set up a class with hooks" do
-      class A
-        include FunWith::Patterns::Hooks
-        
-        def called_x_times()
-          @called_x_times ||= 0
-          @called_x_times
-        end
-        
-        add_hook_before( :called_x_times ) do
-          @called_x_times ||= 0
-          @called_x_times += 1
-        end
-      end
-      
-      a = A.new
-      
-      assert_one( a.called_x_times() )
-    end
-  end
-end

data/test/test_reloadable_pattern.rb

@@ -1,33 +0,0 @@
-require 'helper'
-
-class TestReloadablePattern < FunWith::Patterns::TestCase
-  context "testing basics" do
-    setup do
-      Class.send( :include, FunWith::Patterns::Reloadable )
-      assert_has_instance_method( Class, :reload! )
-      assert_has_instance_method( Class, :reloadable! )
-      
-      assert_respond_to( Object, :reload!)
-      assert_respond_to( Object, :reloadable!)
-    end
-    
-    should "reload MyReloadable" do
-      refute defined?(MyReloadable)
-      FunWith::Patterns.root( "test", "reloadable", "my_reloadable.rb" ).requir
-      assert defined?(MyReloadable)
-      assert_respond_to( MyReloadable.new, :square )
-      
-      MyReloadable.class_eval do
-        remove_method :square
-      end
-      
-      refute_respond_to( MyReloadable.new, :square )
-      
-      MyReloadable.reload!
-      
-      assert defined?(MyReloadable)
-      
-      assert_respond_to( MyReloadable.new, :square )
-    end
-  end
-end