qtext 0.6.7 → 0.6.8

data/lib/qtext/hash_collector.rb

@@ -1,120 +0,0 @@
-# A DSL class that allows options to be collected for a field
-# definition using a block and/or a hash.
-#  hash = { :colour => :red, :hue => 15 }
-#  collector = HashCollector.new( hash ) do |hc|
-#    hc.saturation = 17
-#    hc.opacity = 0.43
-#    hc.grooviness = 100
-#  end
-# or like this (without the block parameter)
-#  collector = HashCollector.new( hash ) do
-#    saturation 17
-#    opacity 0.43
-#    grooviness = 100
-#  end
-# either way, a call to collector.to_hash will result in
-#  { :hue=>15, :saturation=>17, :opacity=>0.43, :grooviness=>100, :colour=>:red }
-# and the following accessors will be added
-#  collector.hue
-#  collector.hue( some_value )
-#  collector.hue = some_value
-# for hue, saturation, opacity, grooviness and colour.
-class HashCollector
-  # 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
-  
-  # Collect values from the hash and the block, using the collect method.
-  def initialize( hash = {}, &block )
-    @hash = hash || {}
-    gather( &block )
-  end
-  
-  # evaluate the block and collect options from args. Even if it's nil.
-  def collect( args = {}, &block )
-    @hash.merge!( args || {} )
-    unless block.nil?
-      if block.arity == -1
-        instance_eval &block
-      else
-        yield self
-      end
-    end
-  end
-  
-  # return a hash of the collected elements
-  def to_hash
-    @hash
-  end
-  
-protected
-  
-  # Modified from Jim Freeze's article.
-  # For each symbol, add accessors to allow:
-  #  instance.symbol as reader
-  #  instance.symbol( value ) as writer
-  #  instance.symbol = value as writer
-  def self.dsl_accessor( *symbols )
-    @stripper ||= /^([^\= ]+)\s*\=?\s*$/
-    symbols.each do |sym|
-      stripped = @stripper.match( sym.to_s )[1]
-      line, st = __LINE__, <<-EOF
-        def #{stripped}(*val)
-          if val.empty?
-            @hash[:#{stripped}]
-          else
-            @hash[:#{stripped}] = val.size == 1 ? val[0] : val
-          end
-        end
-        
-        def #{stripped}=(*val)
-          @hash[:#{stripped}] = val.size == 1 ? val[0] : val
-        end
-      EOF
-      class_eval st, __FILE__, line + 1
-    end
-  end
-  
-  # Do not allow accessors to be added dynamically. In other words,
-  # a subclass like this
-  #  class IndexCollector < HashCollector
-  #    dsl_static
-  #    dsl_accessor :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 dsl_accessor.
-  def self.dsl_static
-    @dynamic = false
-  end
-  
-  # Allow accessors to be added dynamically, the default.
-  def self.dsl_dynamic
-    @dynamic = true
-  end
-  
-  def self.dynamic?
-    # don't optimise this to @dynamic ||= true, because it will reset
-    # an @dynamic of false to true
-    @dynamic = true if @dynamic.nil?
-    @dynamic
-  end
-
-  # Originally from Jim Freeze's article. Add the accessor methods if
-  # they don't already exist, and if dsl_dynamic is in effect, which is
-  # the default. If dsl_static is in effect, the normal method_missing
-  # behaviour will be invoked.
-  def method_missing(sym, *args)
-    if self.class.dynamic?
-      self.class.dsl_accessor sym
-      send( sym, *args )
-    else
-      super
-    end
-  end
-  
-end

data/test/test_hash_collector.rb

@@ -1,180 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-class OtherThing < HashCollector
-  dsl_static
-  dsl_accessor :thing, :other
-end
-
-class BuildOn < HashCollector
-  dsl_accessor :ook
-end
-
-class TestHashCollector < Test::Unit::TestCase
-  def setup
-    @hash = { :colour => :red, :hue => 15 }
-    @collected_hash = { :saturation => 17, :opacity => 0.43, :grooviness => 100 }
-    @full_hash = @hash.merge( @collected_hash )
-    @collector = HashCollector.new
-  end
-  
-  def teardown
-  end
-  
-  context 'static hash collector' do
-    setup do
-      @collector = OtherThing.new
-    end
-    
-    should "throw NoMethodError on collection" do
-      assert_raise( NoMethodError ) do
-        @collector.collect { thing 2; blah 3 }
-      end
-      assert_raise( NoMethodError ) do
-        @collector.collect {|c| c.blah = 3 }
-      end
-      assert_raise( NoMethodError ) { @collector.blah }
-      assert_raise( NoMethodError ) { @collector.blah = 5 }
-    end
-
-    should "understand defined attributes" do
-      assert_nothing_raised do
-        @collector.collect do
-          thing 1
-          other 2
-        end
-      end
-      
-      assert_nothing_raised { @collector.thing = 2 }
-      assert_nothing_raised { @collector.other = 4 }
-    end
-    
-    should "be dynamic" do
-      assert BuildOn.dynamic?
-    end
-  end
-  
-  def assert_collected( collector )
-    assert_equal 17, collector.saturation
-    assert_equal 0.43, collector.opacity
-    assert_equal 100, collector.grooviness
-  end
-  
-  def assert_hashed( collector )
-    assert_equal :red, collector.colour
-    assert_equal 15, collector.hue
-  end
-  
-  should "collect from a hash" do
-    @collector.collect( @hash )
-    assert_equal @hash, @collector.to_hash
-  end
-
-  should 'not fail on a nil hash' do
-    @collector.collect nil
-    assert_equal 0, @collector.to_hash.size
-  end
-  
-  should 'collect from a block, with dsl setters' do
-    @collector.collect do
-      saturation 17
-      opacity 0.43
-      grooviness 100
-    end
-    assert_collected( @collector )
-    assert_equal @collected_hash, @collector.to_hash
-  end
-
-  should 'collect from a block, with = setters' do
-    @collector.collect do |hc|
-      hc.saturation = 17
-      hc.opacity = 0.43
-      hc.grooviness = 100
-    end
-    assert_collected( @collector )
-    assert_equal @collected_hash, @collector.to_hash
-  end
-  
-  should 'collect from a hash and block, with dsl setters' do
-    @collector.collect( @hash ) do
-      saturation 17
-      opacity 0.43
-      grooviness 100
-    end
-    assert_collected( @collector )
-    assert_hashed( @collector )
-    assert_equal @full_hash, @collector.to_hash
-  end
-  
-  should 'collect from a hash and block with = setters' do
-    @collector.collect( @hash ) do |hc|
-      hc.saturation = 17
-      hc.opacity = 0.43
-      hc.grooviness = 100
-    end
-    assert_collected( @collector )
-    assert_hashed( @collector )
-    assert_equal @full_hash, @collector.to_hash
-  end
-  
-  should 'not fail construction with a nil hash' do
-    collector = HashCollector.new nil
-    assert_equal 0, @collector.to_hash.size
-  end
-  
-  should 'construct from a hash and block, with dsl setters' do
-    collector = HashCollector.new( @hash ) do
-      saturation 17
-      opacity 0.43
-      grooviness 100
-    end
-    assert_collected( collector )
-    assert_hashed( collector )
-    assert_equal @full_hash, collector.to_hash
-  end
-  
-  should 'construct from a hash and bslock with = setters' do
-    collector = HashCollector.new( @hash ) do |hc|
-      hc.saturation = 17
-      hc.opacity = 0.43
-      hc.grooviness = 100
-    end
-    assert_collected( collector )
-    assert_hashed( collector )
-    assert_equal @full_hash, collector.to_hash
-  end
-  
-  should 'not conflict with Object methods' do
-    hc = HashCollector.new do
-      display 'something'
-      sample "This is a long string designed to test the code to the very limits of possibility."
-    end
-    
-    assert_equal 'something', hc.display
-    assert_equal "This is a long string designed to test the code to the very limits of possibility.", hc.sample
-  end
-  
-  should 'work when called with &block instead of a do ... end' do
-    options = gather_block do
-      display    'activity'
-      order      'lower(activity)'
-      sample     'Troubleshooting'
-      conditions 'active = true'
-    end
-    assert_equal 'activity', options[:display]
-  end
-  
-  should 'work when called with options and &block instead of a do ... end' do
-    options = gather_block :blah => 'ook' do
-      display    'activity'
-      order      'lower(activity)'
-      sample     'Troubleshooting'
-      conditions 'active = true'
-    end
-    assert_equal 'activity', options[:display]
-    assert_equal 'ook', options[:blah]
-  end
-  
-  def gather_block( options = {}, &block )
-    HashCollector.new( options, &block ).to_hash
-  end
-end