Proof of concept for a lazy Enumerator

hallon_enumerator.rb

require 'ostruct'
require 'delegate'

module Hallon
  class Enumerator < SimpleDelegator
    attr_reader :size

    def initialize(size, pointer, &block)
      @pointer = pointer
      @items   = Array(0...size)
      @size    = size

      klass = Class.new(SimpleDelegator) do
        class_eval(&block)
        attr_reader :index
        attr_reader :pointer
        private     :pointer

        def initialize(index, pointer)
          @pointer = pointer
          @index   = index
        end

        alias_method :__getobj__, :object
      end

      super(klass)
    end

    def [](*args)
      result = @items[*args]

      if result.respond_to?(:map)
        result.map { |i| new(i, @pointer) }
      else
        new(result, @pointer)
      end
    end
  end
end

tracks = Hallon::Enumerator.new(10, "FFI::Pointer") do
  def object
    puts "(object called)"
    # This represents the real object on this index.
    OpenStruct.new(:artist => "Kim Burgestrand")
  end

  def create_time
    "(##{index} in #{pointer}) 26 Sept 2011"
  end

  def creator
    "le Kim Burgestrand"
  end

  def self.total
    42
  end
end

puts "Size: #{tracks.size}"
puts "Total: #{tracks.total}"
puts "Create time: #{tracks[0].create_time}"
puts "Creator: #{tracks[0].creator}"
puts "Artist: #{tracks[0].artist}"

With this, I want:

1. owner.items[x] to be an item that responds to all methods available to items.
2. owner.items[x].y to equal owner.items_y[x]
3. owner.items.z to equal owner.z_items

But it’s merely a proof of concept. I don’t yet know if I consider this a good idea.