This class overrides this method
540806
def clean_up(self):
        
        self.submenu.join()
        self.menu.clear_screen()
        self.menu.resume()
1121535
def method_missing(name, *args, &block)
      if self.class.resources.keys.include?(name)
        resources[name] ||= self.class.resources[name].new(self)
        resources[name]
      else
        super
      end
    end
1076504
function() {
          // TODO: remove unshifting 
          expected.unshift(actual)
          this.result = matcher.match.apply(this, expected)
          this.passed = negate ? !this.result : this.result
          if (!this.passed) this.message = matcher.message.call(this, actual, expected, negate, matcher.name)
          return this
        }
520355
private static void applyOverrides() {
        // Get the appropriate InputStream to read overrides from, if any.
        InputStream stream = getContentTypesPropertiesStream();
        if (stream == null) {
            return;
        }

        try {
            try {
                // Read the properties file...
                Properties overrides = new Properties();
                overrides.load(stream);
                // And translate its mapping to ours...
                for (Map.Entry<Object, Object> entry : overrides.entrySet()) {
                    String extension = (String) entry.getKey();
                    String mimeType = (String) entry.getValue();
                    add(mimeType, extension);
                }
            } finally {
                stream.close();
            }
        } catch (IOException ignored) {
        }
    }
950258
public function methodChanged(): void
    {
        assert($this->offsetExists(self::VAR_LINE_METHOD));

        if (self::METHOD_POST === $this->offsetGet(self::VAR_LINE_METHOD)) {
            $this->offsetSet(self::VAR_BODY, null);
            if ($this->offsetExists(self::VAR_PARSED_POST)
                && is_null($this->offsetGet(self::VAR_PARSED_POST))) {
                $this->offsetSet(self::VAR_PARSED_POST, new MutableArray());
            }
            if ($this->offsetExists(self::VAR_PARSED_FILES)
                && is_null($this->offsetGet(self::VAR_PARSED_FILES))) {
                $this->offsetSet(self::VAR_PARSED_FILES, new MutableArray());
            }
        } else if (self::METHOD_PUT === $this->offsetGet(self::VAR_LINE_METHOD)) {
            if ($this->offsetExists(self::VAR_BODY)
                && is_null($this->offsetGet(self::VAR_BODY))) {
                $this->offsetSet(self::VAR_BODY, '');
            }
            $this->offsetSet(self::VAR_PARSED_POST, null);
            $this->offsetSet(self::VAR_PARSED_FILES, null);
        } else {
            $this->offsetSet(self::VAR_BODY, null);
            $this->offsetSet(self::VAR_PARSED_POST, null);
            $this->offsetSet(self::VAR_PARSED_FILES, null);
        }
    }
768016
def modify_class(original_class, modifier_class, override=True):
    
    # get members to add
    modifier_methods = inspect.getmembers(modifier_class, inspect.ismethod)
    
    # set methods
    for method_tuple in modifier_methods:
        name = method_tuple[0]
        method = method_tuple[1]
        if isinstance(method, types.UnboundMethodType):
            if hasattr(original_class, name) and not override:
                return None
            else:
                setattr(original_class, name, method.im_func)
1096780
function(callback, thisp) {
		this._callback = callback ? callback : null;
		this._pointer = thisp ? thisp : null;
		if (this._now) {
			this.now();
		}
	}
9986
function () {

    /*  Tagging arbitrary member as $final
        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */

        $assertThrows (function () {

            var A = $prototype ({
                        constructor: $final (function () {}) })

            var B = $extends (A, {
                        constructor: function () {} }) },   // will throw Error

            _.matches ({ message: 'Cannot override $final constructor' }))

    /*  Tagging whole prototype as $final
        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */

        $assertThrows (function () {

            var A = $prototype ($final ({}))
            var B = $extends (A) }, // will throw Error

             _.matches ({ message: 'Cannot derive from $final-marked prototype' })) }
1035800
function override(child, fn) {
    child.prototype[fn.name] = fn;
    fn.inherited = child.super_.prototype[fn.name];
}
1041333
function( config ) {
			!is_obj( config ) || Object.keys( config ).forEach( function( key ) {
				if ( typeof config[key] == 'function' && typeof this[key] == 'function' ) // this allows you to override a method for a
					this[__override__]( key, config[key] );         // specific instance of a Class, rather than require
				else                                                // you extend the Class for a few minor changes
					this[key] = config[key];                        // NB: can also be achieved by creating a `singleton`
			}, this );

			util.def( this, __config__, { value : config }, 'r', true );
		}
739030
function() {
    for (var name in this.changes) {
      if (this.changes.hasOwnProperty(name)) {
        this.attributes[name] = this.changes[name][0]
      }
    }

    this.changes = {}
    return this
  }
404887
function() {
            var args = slice.call(arguments);
            args.unshift(this);
            return _.extend.apply(this, args);
        }
563544
function (name, value) {
            var overriddenMember = this._extend.prototype[name];
            if (undefined !== overriddenMember) {
                this._checkOverridenMember(value, overriddenMember);
            }
        }
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});
        }

      }
    }
    //*/

  }
66654
function () {
                if (this._overriddenClasses != null) {
                    for (var i in this._overriddenClasses) {
                        var clsInfos = this._overriddenClasses[i];

                        // restore the global classpath to point to the original
                        var ns = Aria.nspace(clsInfos.clsNs);
                        ns[clsInfos.clsName] = clsInfos.initialClass;

                        // also restore require cache
                        var initialClasspath = clsInfos.clsNs + "." + clsInfos.clsName;
                        var cacheKey = Aria.getLogicalPath(initialClasspath, ".js", true);
                        require.cache[cacheKey] = clsInfos.cachedModule;
                    }
                    this._overriddenClasses = null;
                }
            }
1146219
function createOverride(sXHRMethod) {

		mRegistry[sXHRMethod] = Object.create(null);

		//  backup the original function
		mXHRFunctions[sXHRMethod] = window.XMLHttpRequest.prototype[sXHRMethod];

		window.XMLHttpRequest.prototype[sXHRMethod] = function() {
			var oArgs = arguments;

			// call the original function first
			mXHRFunctions[sXHRMethod].apply(this, oArgs);

			// call the registered callbacks in order of their registration
			for (var sName in mRegistry[sXHRMethod]) {
				mRegistry[sXHRMethod][sName].apply(this, oArgs);
			}

		};

	}
482313
protected void overrideTableExtractors() {
        StandardTableTarget.MAIN.setTableExtractor(new TableExtractor() {
            @Override
            public Table extract(final Table table) {
                if (table instanceof Dialog) {
                    return ((Dialog) table).getContentTable();
                } else if (table instanceof VisDialog) {
                    return ((VisDialog) table).getContentTable();
                }
                return table;
            }
        });
        StandardTableTarget.BUTTON.setTableExtractor(new TableExtractor() {
            @Override
            public Table extract(final Table table) {
                if (table instanceof Dialog) {
                    return ((Dialog) table).getButtonTable();
                } else if (table instanceof VisDialog) {
                    return ((VisDialog) table).getButtonsTable();
                }
                return table;
            }
        });
    }