method_missing won't catch these guys because they were defined in
 the delegation operation.
548643
def resource(*args, &block)
      resource = @resource.resource(*args, &block)
      resource && ResourceAndAddress.new(resource, @address)
    end
1049660
def method_missing(name, *args)
      copy = self.dup
      copy.instance_eval { @args << [name, *(args.collect { |a| a.to_s })] }
      copy
    end
754402
def method_missing method, *args, &blk
        __reserve__ do |conn|
          if @trace
            conn.trace(@trace) {conn.__send__(method, *args, &blk)}
          else
            conn.__send__(method, *args, &blk)
          end
        end
      end
114317
def method_missing(method_symbol, *method_args)
      if method_args.length > 0
        _set(method_symbol, method_args.first)
      end

      _get(method_symbol)
    end
1177646
def method_missing(m, *args, &block)  
        if @tracker_names.include? m
          @tracker_blocks[m] = block
        else
          super(name, *args, &block)
        end
      end
981952
def method_missing(meth, *args, &block)
      # Check to see if it can be evaluated
      if(matches? meth)
        #Defines the method and caches it to the class
        self.class.send(:define_method, meth) do
          # Splits the method and parameter. See formatize and directionize
          send directionize(meth).to_sym, formatize(meth)
        end
        # calls the method
        send meth, *args, &block
      else
        super
      end
    end
428330
def method_missing(method, *args, &block)
      if respond_to_missing?(method)
        new.public_send(method, *args, &block)
      else
        super
      end
    end
567397
def method_missing(method_id, *args, &bl)
    @em_lock.synchronize{
      EventMachine.send method_id, *args, &bl
    }
  end
1345539
def method_missing(method_name, *arguments, &block)
      ivar = "@#{method_name.to_s.gsub('=', '')}"
      ivar_sym = ":#{ivar}"
      if method_name[-1] == '?'
        return id == method_name[0..-2].to_sym
      elsif method_name[-1] == '='
        define_singleton_method(method_name) do |val|
          instance_variable_set(ivar, val)
        end
      elsif instance_variables.include? ivar_sym
        instance_variable_get(ivar)
      else
        define_singleton_method(method_name) do
          instance_variable_get(ivar)
        end
      end
      send(method_name, *arguments, &block)
    end
545597
def method_missing(method, *args, &block)
      if @__receiver__.respond_to?(method.to_sym)
        @__receiver__.__send__(method.to_sym, *args, &block)
      else
        @__fallback__.__send__(method.to_sym, *args, &block)
      end
    end
1028492
def method_missing(method, *args)
      if (method.to_s =~ /^(.+)(\?|\!)$/)
        value_name = $1.to_sym
        if @state.states.has_key?(value_name)
          case $2
          when '?'
            self.class.class_eval <<-EOC
              def #{method}
                self == #{value_name.inspect}
              end
            EOC
            # Calling `method` on ourselves fails. Something to do
            # w/subclasses. Meh.
            return self == value_name
          when '!'
            self.class.class_eval <<-EOC
              def #{method}
                self.set_value(#{value_name.inspect})
              end
            EOC
            # Calling `method` on ourselves fails. Something to do w/subclasses. Meh.
            return self.set_value(value_name)
          end
        elsif $2 == '?' && aggregates = @state.aggregates[value_name]
          self.class.class_eval <<-EOC
            def #{method}
              @state.aggregates[#{value_name.inspect}].include?(@value)
            end
          EOC
          return aggregates.include?(@value)
        else
          super
        end
      elsif value_for(@value).respond_to?(method)
        value_for(@value).send(method, *args)
      else
        super
      end
    end
795159
def method_missing(meth, *args, &block)
      task meth, *args, &block
    rescue Fudge::Exceptions::TaskNotFound
      super
    end
1185652
def method_missing(method, *args, &block)
      Proxy.new(@lookup_chain).public_send(method, *args, &block)
    end
217698
def method_missing(name, *args)
      if [:create_by_authentication, :create_from_session].include? name
        raise NoMethodError.new("Cannot call method #{name} on class #{self.class} because it is specifically denied.", 'Method Protected')
      else
        self.class.send(name, @session, *args)
      end
    end
353468
def method_missing(name, *args, &block)
      if args.empty? && !block_given? && @arg_names.include?(name)
        @args[name]
      else
        super
      end
    end
365691
def respond_to_missing?(method, include_private = false)
      if method.to_s.starts_with? "*"
        condition_name = method.to_s.split("*")[1].to_sym
        conditions = self.class.scram_conditions
        if conditions && !conditions[condition_name].nil?
          return true
        end
      end
      super
    end
869495
def method_missing(meth, *args, &block)
      # Check to see if it can be evaluated
      if(matches? meth)
        #Defines the method and caches it to the class
        self.class.send(:define_method, meth) do
          # Uses data_field and format_field to translate the metadata.
          # debugger
          Citero.map(_data).send("from_#{_format}").send(meth)
        end
        # calls the method
        send meth, *args, &block
      else
        super
      end
    end