Ironic Wolf

	def some_method(*args)
		if args.empty?
			# do something
		elseif args.length == 1 and
			args[0] == :read or
			args[0] == :write or
			args[0] == :readwrite then
 
			# do something 
		else
			raise "Zero or one argument expected"
		end
	end

	def foo(*args)
		if args.empty?
			return something
		elseif args.length == 1 and arg[0].kind_of?(Numeric)
			#do something
		else
			raise "Wrong arg"
		end
	end

	def foo(*args)
		return something if args.empty?
 
		if args.length == 1 and arg[0].kind_of?(Numeric)
			#do something
		else
			raise "Wrong arg"
		end
	end

	def some_method(*args)
		# assert we can handle *args
		assert(arg).empty?.or.length.eql?(1).and.at(0)._{ 
			eql?(:read).eql?(:write).eql?(:readwrite)
		}.end
 
		# do the work
		if arg.empty?
			#do something
		else
			#do something
		end
	end

	def foo(*args)
		assert(args).empty?.or { length.eql?(1).and.at(0).kind_of?(Numeric).end
 
		if args.empty?
			return something
		else
			#do somtehing
		end

	a = [1,2,3]
	assert(a).kind_of?(Array).not.empty?.each { kind_of?(Numeric) }.end
	assert(a).kind_of?(Array).empty?.or.each { 
		kind_of?(Numeric) }.last.eql?(3).end
 
 
	a =[:foo, 1, 2]
	assert(a).nil?.or {
		kind_of?(Array).and.not.empty?.and {
			at(0).kind_of(Symbol).slice(1..-1).each {
				kind_of?(Numeric)
			}
		}
	}.end
 
	a = [1, 1.2, 1.3, 3]
	assert(a).let(:intorfloat?) { 
		kind_of?(Fixnum).or.kind_of?(Float) 
		}.each { intorfloat? }.end
 
	def foo(x,y)
		assert(x).kind_of?(Symbol).and(y).kind_of?(Numeric).end
 
		#or
 
		assert(x).kind_of?(Fixnum).or(y).kind_of?(Fixnum).end		
	end

  class Assert
    alias __class__ class
 
    Object.new.methods.each { |m|       
      unless m == '__id__' or m == '__send__' 
         undef_method m 
      end
    }
 
    def initialize(obj)
      @origin = obj
      @obj = @origin    
      @result = true
      @op = :and
    end
 
    def result
      @result
    end
 
 
    def or(*obj, &block)
      @obj = obj[0] unless obj.empty?
      @op = :or 
      self._(&block) unless block.nil?
      self
    end
 
    def and(*obj, &block)
      @obj = obj[0] unless obj.empty?
      @op = :and
      self._(&block) unless block.nil?
      self
    end
 
    def not
      @op = case @op
      when :and then :not_and
      when :or then :not_or
      when :not_and then :and
      when :not_or then :or
      end
      self
    end
 
    def end(should_raise = true, &block)
      if @result == false
        if block.nil? 
          raise StandardError, "Assertions failed", caller(0).last if  should_raise
        else
          block.call(self)
        end
      end      
    end
 
    def push_result(v)
      if v.kind_of?(TrueClass) or v.kind_of?(FalseClass)
        @result = case @op
        when :and then @result and v
        when :or then @result or v
        when :not_and then self.not; @result and !v
        when :not_or then self.not; @result or !v
        end
        @obj = @origin
      else
        @obj = v
      end
      self
    end
 
    def eval_block(ob, &block)
      raise "Block missing" if block.nil?
      local = Assert.new(ob)
      local.instance_eval(&block)
      push_result(local.result)
    end
 
    def _(&block)
      eval_block(@obj, &block) unless block.nil?
    end
 
    def each(&block)
      raise "Method missing each" if @obj.respond_to?(:each)
 
      @obj.each { |e| eval_block(e, &block) }
      self
    end
 
    def let(sym, &block)
      self.__class__.class_eval do
        define_method(sym) { eval_block(@obj, &block) }
      end
 
      self
    end      
 
 
    def method_missing(m, *args, &block)
      if @obj.respond_to?(m) 
        push_result @obj.send(m, *args, &block)
      else
        raise "Method missing #{m}"
      end
      self
    end
  end
 
def assert(obj)
  Assert.new(obj)
end