Define a method.
@method defineMethod
@static
@param name {String}
@param meta {Object}
@param [target] {Object}
164466
function (name, meta, target) {
            if (!__define.defineMethod(target || this.prototype, name, meta)) {
                this._methods_.push(name);
            }

            return this;
        }
201357
function( name, method ) {
			var m = this.settings.messages[name];
			return m && (m.constructor === String ? m : m[method]);
		}
1206263
def set_meta(self, name, format, *args):
        
        return lib.zcert_set_meta(self._as_parameter_, name, format, *args)
1299139
function createMethod(name, fn) {
        return function () {
          var self = this, tmp = self._super, ret;

          self._super = _super[name];
          ret = fn.apply(self, arguments);
          self._super = tmp;

          return ret;
        };
      }
26285
function overrideMethod(name, f) {
            // Use Object.defineProperty to prevent methods from appearing in
            // the subject's for in loop
            if (_es5_object_supported) {
                Object.defineProperty(subject, name, {
                    value: f
                });
            } else {
                subject[name] = f;
            }
        }
813112
function(clazz, metaData) {
        this.applyMethods(clazz, metaData.clazz_methods || {});
        this.applyMethods(clazz.prototype, metaData.methods || {});
    }
1191024
def EXT method_name, *description, **metadata, &body
  INSTANCE_METHOD \
    method_name, 
    *description,
    **metadata \
  do
    subject do
      
    end
  end
end
26450
def method_missing(method_name, *_args)
      if attrs.key?(method_name.to_s)
        attrs[method_name.to_s]
      else
        super(method_name)
      end
    end
1143512
function(name, method) {
        API.prototype[name] = function() {
            var api = this;
            var args = Array.prototype.slice.call(arguments);
            this.chain(function(next) {
                var cargs = [].slice.call(arguments);

                cargs = args.concat(cargs);

                // args.push(next);
                method.apply(api, cargs);
            });
            return this;
        };
        return this;
    }
1037953
function(name) {
    if (this[name]) {
      this[name].apply(this, [].slice.call(arguments, 1));
    }
    this._super.apply(this, arguments);
  }
641352
function(name, value, metaName) {
            if (_.isObject(name)) {
                _.each(name, function(value, name) {
                    this.meta(name, value);
                }, this);
                return;
            }

            if (metaName == null) metaName = "name";
            var mt = this.$('meta['+metaName+'="'+name+'"]');
            if (mt.length === 0) {
                mt =  $("<meta>", {}).attr(metaName, name).appendTo('head');
            }
            if (value != null) {
                mt.attr('content', value);
                return this;
            } else {
                return mt.attr('content');
            }
        }
115695
public static TraceEvent meta(String name, Object... args) {
        return new TraceEvent(TraceEventType.METADATA, name, null, args);
    }
473557
def method_missing(m, *args)
      # the method href would have been defined while initializing the object
      client.send(:do_post, [ href, m.to_s ].join('/'), *args)
    end
1002000
function(name, method){
        
            //create instrumented version of function
            var newMethod = function () {
    
                var start = new Date(),
                    retval = method.apply(this, arguments),
                    stop = new Date();
                
                saveDataPoint(name, stop-start);
                
                return retval;                
            
            };     

            //copy the function properties over
            lang.augmentObject(newMethod, method);
            
            //assign prototype and flag as being profiled
            newMethod.__yuiProfiled = true;
            newMethod.prototype = method.prototype;
            
            //store original method
            container[name] = method;
            container[name].__yuiFuncName = name;
            
            //create the report
            createReport(name);

            //return the new method
            return newMethod;
        }
318325
function() {

    //if the name was not set by the last meta file set it based on the file path
    if( (!this.name || this.name === 'Class') && typeof this.filePath === 'string' ) {
      this.name = path.basename(this.filePath);
    }

    //make sure the meta object exists
    if( typeof this.meta !== 'object' ) {
      console.log(colors.gray('class meta:'), 'not found!');
      this.meta = {};
    }

    //make sure the meta methods object exists
    if( typeof this.meta.methods !== 'object' ) {
      console.log(colors.yellow('class meta:'), 'missing methods object!');
      this.meta.methods = {};
    }

    //loop through methods in the meta object
    for( var method in this.meta.methods ) {

      //delete any method from meta that does not actually exist on the class
      if( !(method in this) ) {
        console.log(colors.yellow('class missing method:'), {class: this.name, method: method});
        delete this.meta.methods[method];
      }

    }

    /*
    //loop through methods in the class
    for( var method in this ) {

      if( typeof this[method] === 'function' ) {

        //alert about methods missing from the meta data
        if (!(method in this.meta.methods)) {
          console.log(colors.yellow('meta missing method:'), {class: this.name, method: method});
        }

      }
    }
    //*/

  }
581223
def define_singleton_method(method_name, content=Proc.new)
      (class << self; self; end).class_eval do
        undef_method(method_name) if method_defined?(method_name)
        if String === content
          class_eval("def #{method_name}() #{content}; end")
        else
          define_method(method_name, &content)
        end
      end
    end
1267850
function buildMethodMap(methods) {
  // Makes a fake set of initial methods
  var methodMap = {};
  methods.forEach(function(method) {
    methodMap[method.name] = getMethod(method.name);
  });
  return methodMap;
}