gather 0.0.3

data/History.txt

@@ -0,0 +1,2 @@
+== 0.0.3
+* Make into a rubyforge gem

data/Manifest.txt

@@ -0,0 +1,8 @@
+History.txt
+Manifest.txt
+README
+Rakefile
+lib/gather.rb
+lib/changes.rb
+script/destroy
+script/generate

data/README

@@ -0,0 +1,22 @@
+== gather
+
+A gem that provides modules to make working with properties a bit easier.
+
+For example:
+
+  class SumThing
+    include Gather
+    property :thing, :spla, :gumf, :troob
+  end
+ 
+  s = SumThing.new.gather :spla => 'five', :thing => 'sigma' do
+    troob %w{one two three four}
+    gumf 15 % 4
+  end
+
+Or
+
+  s = SumThing.new.gather :spla => 'five', :thing => 'sigma' do |s|
+    s.troob = %w{one two three four}
+    s.gumf = 15 % 4
+  end

data/Rakefile

@@ -0,0 +1,27 @@
+%w[rubygems rake rake/clean fileutils newgem rubigen].each { |f| require f }
+require File.dirname(__FILE__) + '/lib/version.rb'
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new('gather', Gather::VERSION) do |p|
+  p.developer('John Anderson', 'panic@semiosix.com')
+  p.changes              = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  p.rubyforge_name       = 'clevic'
+  # p.extra_deps         = [
+  #   ['activesupport','>= 2.0.2'],
+  # ]
+  p.extra_dev_deps = [
+    ['newgem', ">= #{::Newgem::VERSION}"]
+  ]
+  
+  p.clean_globs |= %w[**/.DS_Store tmp *.log]
+  path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
+  p.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/,''), 'rdoc')
+  p.rsync_args = '-av --delete --ignore-errors'
+end
+
+require 'newgem/tasks' # load /tasks/*.rake
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# task :default => [:spec, :features]

data/lib/changes.rb

@@ -0,0 +1,315 @@
+require 'gather.rb'
+
+class NilClass
+  def call_if( *args ); end
+end
+
+class Proc
+  alias_method :call_if, :call
+end
+
+=begin rdoc
+Same as Gather, except that history is kept for changes, and on_change
+is called each time a property value changes.
+=end
+module Changes
+  include Gather
+  
+  class Change
+    attr_accessor :old, :new
+    def initialize
+      @old = []
+      @new = nil
+    end
+  end
+  
+  # Gather values from the hash and the block, using the gather method.
+  unless instance_methods.include? 'initialize'
+    def initialize( hash = {}, &block )
+      init_properties( hash, &block )
+    end
+  end
+  
+  # should probably use an object creation hook to do this
+  def init_properties( hash, &block )
+    @changes = {}
+    gather( hash, &block )
+  end
+  
+  def changed?
+    changes.empty?
+  end
+  
+  def changes( *symbols )
+    if symbols.empty?
+      @changes ||= {}
+    else
+      symbols.map{|x| changes[x] }
+    end
+  end
+  
+  # called after the property has changed
+  # including classes should define this
+  def on_change( property, old, new )
+  end
+  
+  attr_writer :change_history
+  def change_history
+    @change_history ||= []
+  end
+  
+  # make a mark in the change history
+  def mark
+    new_changes = @changes.clone
+    new_changes.each{|k,v| new_changes[k] = v.clone}
+    change_history << new_changes
+  end
+  
+  # restore the last mark. Do not emit any changes.
+  def restore
+    @changes = change_history.pop unless change_history.empty?
+  end
+  
+  # reset the passed properties, or all if none are specified
+  def reset!( *properties )
+    if properties.empty?
+      @changes = {}
+    else
+      properties.each {|x| changes[x] = Change.new}
+    end
+  end
+  
+  # execute the block, undo the given symbols, and
+  # return the result of the executed block. If no symbols
+  # are given, just use mark and restore
+  def preserve( *symbols )
+    mark if symbols.empty?
+    retval = yield
+    if symbols.empty?
+      restore
+    else
+      symbols.each {|symbol| undo( symbol ) }
+    end
+    retval
+  end
+  
+  def undo( symbol )
+    unless changes[symbol].old.empty?
+      current = send( symbol )
+      if changes[symbol] && changes[symbol].old
+        eval "@#{symbol.to_s} = changes[:#{symbol.to_s}].old.pop"
+      end
+      current
+    end
+  end
+  
+  # Add the property methods if
+  # they don't already exist, and if dynamic is in effect, which is
+  # the default. If static is in effect, the normal method_missing
+  # behaviour will be invoked.
+  def method_missing(sym, *args)
+    if self.class.dynamic?
+      self.class.property sym
+      send( sym, *args )
+    else
+      super
+    end
+  end
+  
+  # Return a collection of property symbols
+  def property_names
+    self.class.properties.to_a
+  end
+  
+  module ClassMethods
+    include Gather::ClassMethods
+    # Remove all but the absolutely essential methods from this class.
+    # Useful if you want a dynamic property list, but
+    # can have some surprising side effects, obviously.
+    def blankslate!
+      # remove unused methods that might clash with user accessors
+      keep_methods = %w( __send__ __id__ self send class inspect instance_eval instance_variables )
+      instance_methods.each do |method|
+        undef_method( method ) unless keep_methods.include?( method )
+      end
+    end
+    
+    def module_name( symbol )
+      "#{symbol.to_s.capitalize}Property"
+    end
+    
+    # For each property in symbols, add methods:
+    #  instance.property as reader
+    #  instance.property( value ) as writer
+    #  instance.property = value as writer
+    #  instance.before_property {|old,new| ... }
+    #  instance.after_property {|old,new| ... }
+    #  instance.on_property {|old,new| ... }
+    #  instance.property_changed?
+    #  instance.undo_property!
+    def property( *symbols )
+      @stripper ||= /^([^\= ]+)\s*\=?\s*$/
+      symbols.each do |sym|
+        property = @stripper.match( sym.to_s )[1]
+        
+        # TODO false here until I figure out how to remove properties
+        unless false && const_defined?( module_name( property ).to_sym )
+          own_properties << property.to_sym
+          line, st = __LINE__, <<-EOF
+            module #{module_name( property )}
+            
+            public
+            def #{property}(*val)
+              if val.empty?
+                @#{property}
+              else
+                self.#{property} = *val
+              end
+            end
+            
+            def on_#{property}( &block )
+              @on_#{property}_block = block
+            end
+            
+            def after_#{property}( &block )
+              @after_#{property}_block = block
+            end
+            
+            def before_#{property}( &block )
+              @before_#{property}_block = block
+            end
+            
+            def #{property}=(*new_value)
+              unwrapped_value = new_value.size == 1 ? new_value[0] : new_value
+              return if unwrapped_value == @#{property}
+              
+              @before_#{property}_block.call_if( @#{property}, unwrapped_value )
+              
+              changes[:#{property}] ||= Change.new
+              changes[:#{property}].old << @#{property}
+              changes[:#{property}].new = unwrapped_value
+              
+              @#{property} = unwrapped_value
+              
+              @after_#{property}_block.call_if( changes[:#{property}].old, unwrapped_value )
+              @on_#{property}_block.call_if( changes[:#{property}].old, unwrapped_value )
+              on_change( :#{property}, changes[:#{property}].old, unwrapped_value )
+            end
+            
+            def #{property}_changed?
+              changes.has_key?(:#{property}) && !changes[:#{property}].old.empty?
+            end
+            
+            # Undo the last change and return the undone value.
+            # return nil if there were no changes to undo
+            def undo_#{property}!
+              undo( :#{property} )
+            end
+            
+            def reset_#{property}!
+              changes[x] = Change.new
+            end
+            
+            private
+            def direct_#{property}=( value )
+              @#{property} = value
+            end
+            
+            end # module
+          EOF
+          class_eval st, __FILE__, line + 1
+        end
+        
+        # always include the module, for re-definitions
+        class_eval "include #{property.capitalize}Property"
+      end
+    end
+    
+    # not working yet. Once the module has been added, it seems like
+    # adding it again does not redefine the methods, even if they were
+    # removed in the interim.
+    #~ def remove( *symbols )
+      #~ symbols.each do |sym|
+        #~ if defined?( sym )
+          #~ # undefine methods
+          #~ module_const = eval "#{self.name}::#{module_name( sym )}"
+          #~ module_const.instance_methods.each do |im|
+            #~ undef_method( im )
+          #~ end
+          
+          #~ # remove from properties
+          #~ properties.delete sym
+        #~ end
+      #~ end
+    #~ end
+    
+    # Do not allow accessors to be added dynamically. In other words,
+    # a subclass like this
+    #  class IndexCollector
+    #    static_properties :row, :column
+    #  end
+    # will fail if used like this
+    #  collector = IndexCollector.new( :row => 4, :column => 6 ) do
+    #    other 'oops'
+    #  end
+    # because :other isn't added by static_properties.
+    def static_properties( *syms )
+      @dynamic = false
+      property( *syms )
+    end
+    
+    # Allow accessors to be added dynamically, the default.
+    def dynamic_properties( *syms )
+      @dynamic = true
+      property( *syms )
+    end
+    
+    def dynamic!; @dynamic = true; end
+    def static!; @dynamic = false; end
+    
+    def dynamic?
+      # don't optimise this to @dynamic ||= true, because it will reset
+      # an @dynamic of false to true
+      @dynamic = false if @dynamic.nil?
+      @dynamic
+    end
+    
+  # might use this instead of operation
+  #~ def method_added( *args )
+    #~ super
+  #~ end
+  
+    # define a method 'name' (which can be symbol or a string)
+    # which takes args and a block
+    # calls gather and then executes the block. Any changes made
+    # from args and block are rolled back
+    # name! will not roll back values
+    def operation( name, &body )
+      # save the block to be executed later
+      class_eval "@@#{name.to_s}_operation_block = body"
+      
+      # define the new method called name
+      class_eval <<-EOF, __FILE__, __LINE__.to_i + 1
+        def #{name.to_s}( args = {}, &block )
+          preserve do
+            gather( args, &block )
+            instance_eval( &@@#{name.to_s}_operation_block )
+          end
+        end
+      EOF
+      
+      # define new method called name!
+      class_eval <<-EOF, __FILE__, __LINE__.to_i + 1
+        def #{name.to_s}!( args = {}, &block )
+          gather( args, &block )
+          instance_eval( &@@#{name.to_s}_operation_block )
+        end
+      EOF
+    end
+  end
+  
+  def self.included( base )
+    base.extend( ClassMethods )
+  end
+  
+end

data/lib/gather.rb

@@ -0,0 +1,96 @@
+require 'set'
+
+# Provides instance method gather and class method property
+# Allows properties to be Enumerable.
+module Gather
+  # Evaluate the block and gather options from args. Even if it's nil.
+  # Return self
+  def gather( args = {}, &block )
+    unless args.nil?
+      args.each do |key,value|
+        self.send( key, value )
+      end
+    end
+    
+    unless block.nil?
+      if block.arity == -1
+        instance_eval &block
+      else
+        yield self
+      end
+    end
+    self
+  end
+
+  # return a hash of the properties
+  def to_hash( properties = self.class.properties )
+    properties.inject({}) {|s,x| s[x] = send(x); s}
+  end
+  
+  # set all values specified in the hash
+  def merge!( hash )
+    hash.each {|k,v| send( k, v ) }
+  end
+  
+  # return a new hash merged with the argument
+  def merge( hash )
+    to_hash.merge( hash )
+  end
+  
+  def []( symbol )
+    send( symbol )
+  end
+  
+  def []=( symbol, value )
+    send( symbol, value )
+  end
+  
+  def each( &block )
+    self.class.properties.each( &block )
+  end
+  include Enumerable
+
+  def self.included( base )
+    base.extend( ClassMethods )
+  end
+  
+  module ClassMethods
+    # return properties for only this class
+    def own_properties
+      @properties ||= Set.new
+    end
+    
+    # return properties for this class and ancestors
+    def properties
+      own_properties +
+      if superclass.respond_to? :properties
+        superclass.properties
+      else
+        []
+      end
+    end
+    
+    def property( *symbols )
+      @stripper ||= /^([^\= ]+)\s*\=?\s*$/
+      symbols.each do |sym|
+        stripped = @stripper.match( sym.to_s )[1]
+        own_properties << stripped.to_sym
+        line, st = __LINE__, <<-EOF
+          def #{stripped}(*val)
+            if val.empty?
+              @#{stripped}
+            else
+              @#{stripped} = val.size == 1 ? val[0] : val
+            end
+          end
+          
+          def #{stripped}=(*val)
+            @#{stripped} = val.size == 1 ? val[0] : val
+          end
+        EOF
+        class_eval st, __FILE__, line + 1
+      end
+    end
+
+  end
+end

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:newgem_simple, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:newgem_simple, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: gather
+version: !ruby/object:Gem::Version 
+  version: 0.0.3
+platform: ruby
+authors: 
+- John Anderson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-30 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: newgem
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.0
+    version: 
+description: ""
+email: 
+- panic@semiosix.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+files: 
+- History.txt
+- Manifest.txt
+- README
+- Rakefile
+- lib/gather.rb
+- lib/changes.rb
+- script/destroy
+- script/generate
+has_rdoc: true
+homepage: A gem that provides modules to make working with properties a bit easier.
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: clevic
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: ""
+test_files: []
+