This would relate to the sandbox (not in codebase currently).
TODO: Target should only be spirits now, move to data arg...
14254
function(key, sig, log) {
		gui.Broadcast.$target = this;
		gui.Broadcast.dispatchGlobal(edb.BROADCAST_SCRIPT_INVOKE, {
			key: key,
			sig: sig,
			log: log
		});
	}
592786
function(b) {
			var prefix = "spiritual-broadcast:";
			return prefix + (function() {
				b.target = null;
				b.data = (function(d) {
					if (gui.Type.isComplex(d)) {
						if (gui.Type.isFunction(d.stringify)) {
							d = d.stringify();
						} else {
							try {
								JSON.stringify(d); // @TODO: think mcfly - how come not d = JSON.stringify????
							} catch (jsonexception) {
								d = null;
							}
						}
					}
					return d;
				}(b.data));
				return JSON.stringify(b);
			}());
		}
852081
function(targets_string) {

		var target = {},
			result = [],
			match,
			guid_match,
			config_ref,
			raw_arguments,
			i,
			count,
			flags;

		targets_string = targets_string.trim();

		if (targets_string == '') Lava.t("Code style: empty targets are not allowed");

		while (targets_string.length) {

			match = this._locator_regex.exec(targets_string);
			if (!match) guid_match = /^\d+$/.exec(targets_string);

			if (match) {

				target.locator_type = this.locator_types[targets_string[0]];
				target.locator = match[1];
				target.name = match[2];

			} else if (guid_match) {

				target.locator_type = 'Guid';
				target.locator = +guid_match[0];

			} else {

				match = this._identifier_regex.exec(targets_string);
				if (!match) Lava.t("Malformed targets (1): " + targets_string);
				target.name = match[0];

			}

			if (Lava.schema.DEBUG) {

				if ((target.locator_type == 'Id' || target.locator_type == 'Name') && !Lava.isValidId(target.locator)) Lava.t("Malformed id: " + target.locator);
				else if (target.locator_type == 'Label' && !Lava.VALID_LABEL_REGEX.test(target.locator)) Lava.t("Malformed target label" + target.locator);

			}

			targets_string = targets_string.substr(match[0].length);

			if (targets_string[0] == '(') {

				if (targets_string[1] == ')') Lava.t("Code style: empty target arguments must be removed");

				config_ref = {
					input: targets_string.substr(1),
					tail_length: 0
				};
				raw_arguments = Lava.ExpressionParser.parseWithTailRaw(config_ref, Lava.ExpressionParser.SEPARATORS.COMMA);
				target.arguments = [];

				for (i = 0, count = raw_arguments.length; i < count; i++) {

					flags = raw_arguments[i].flags;
					if (flags.isScopeEval) {

						target.arguments.push({
							type: Lava.TARGET_ARGUMENT_TYPES.BIND,
							data: raw_arguments[i].binds[0]
						});

					} else if (flags.isLiteral || flags.isNumber || flags.isString) {

						target.arguments.push({
							type: Lava.TARGET_ARGUMENT_TYPES.VALUE,
							data: Function('return ' + raw_arguments[i].evaluator_src).apply({})
						});

					} else {

						Lava.t("Expressions are not allowed for target callback arguments, only scope paths and static values");

					}

				}

				targets_string = targets_string.substr(targets_string.length - config_ref.tail_length);

			}

			if (targets_string[0] == ';') {

				targets_string = targets_string.substr(1).trim();

			} else if (targets_string.length) {

				targets_string = targets_string.trim();
				if (Lava.schema.DEBUG && targets_string.length) {
					if (targets_string[0] == ';') Lava.t("Space between semicolon in targets is not allowed");
					Lava.t('Malformed targets (2): ' + targets_string);
				}

			}

			result.push(target);

		}

		return result;

	}
952815
def from_args(cls, target_url, default_url, test_url):
        """"""
        return cls("You're trying to upload to the legacy PyPI site '{}'. "
                   "Uploading to those sites is deprecated. \n "
                   "The new sites are pypi.org and test.pypi.org. Try using "
                   "{} (or {}) to upload your packages instead. "
                   "These are the default URLs for Twine now. \n More at "
                   "https://packaging.python.org/guides/migrating-to-pypi-org/"
                   " .".format(target_url, default_url, test_url)
                   )
1020774
function (pluginName, targetName, targetData) {
        if (arguments.length < 2) {
          throw (new Error('expected at least 2 arguments'));
        }

        if (arguments.length === 2) {
          targetData = targetName;
          targetName = lib.getNameUID(prefix, data.id);
        }

        gtx.configFor(pluginName, targetName, targetData);

        lib.pushUnique(data.plugins, pluginName);
        lib.pushHash(plugins, pluginName, data);

        lib.pushUnique(tasks, pluginName + ':' + targetName);
      }
211440
function() {
		this.attributes = ["gui"];
		this._arrivals = Object.create(null);
		this._channels = [];
		this._spirits = {
			incoming: [], // spirits just entered the DOM (some milliseconds ago)
			inside: Object.create(null), // spirits positioned in page DOM ("entered" and "attached")
			outside: Object.create(null) // spirits removed from page DOM (currently "detached")
		};
		gui.Broadcast.add(gui.BROADCAST_TODOM, {
			onbroadcast: function() {
				gui._getready();
				gui.Guide.$startGuiding();
				gui._nowready();
			}
		});
		return this;
	}
733009
function (sender, key) {
/*Line 50 - 'AtomBinding.js' */                // update target....
/*Line 51 - 'AtomBinding.js' */                // most like end of path...
/*Line 52 - 'AtomBinding.js' */                if (this.path == null || this.path.length == 0)
/*Line 53 - 'AtomBinding.js' */                    return;
/*Line 54 - 'AtomBinding.js' */                var ae = new AtomEnumerator(this.path);
/*Line 55 - 'AtomBinding.js' */                var obj = this.control;
/*Line 56 - 'AtomBinding.js' */                var objKey = null;
/*Line 57 - 'AtomBinding.js' */                while (ae.next()) {
/*Line 58 - 'AtomBinding.js' */                    objKey = ae.current();
/*Line 59 - 'AtomBinding.js' */                    objKey.value = obj;
/*Line 60 - 'AtomBinding.js' */                    if (!obj)
/*Line 61 - 'AtomBinding.js' */                        return;
/*Line 62 - 'AtomBinding.js' */                    if (!ae.isLast())
/*Line 63 - 'AtomBinding.js' */                        obj = AtomBinder.getValue(obj, objKey.path);
/*Line 64 - 'AtomBinding.js' */                }
/*Line 65 - 'AtomBinding.js' */                var value = null;
/*Line 66 - 'AtomBinding.js' */                if (this.jq) {
/*Line 67 - 'AtomBinding.js' */                    switch (this.key) {
/*Line 68 - 'AtomBinding.js' */                        case "valueAsDate":
/*Line 69 - 'AtomBinding.js' */                            value = this.element.valueAsDate;
/*Line 70 - 'AtomBinding.js' */                            break;
/*Line 71 - 'AtomBinding.js' */                        case "checked":
/*Line 72 - 'AtomBinding.js' */                            value = this.element.checked ? true : false;
/*Line 73 - 'AtomBinding.js' */                            break;
/*Line 74 - 'AtomBinding.js' */                        default:
/*Line 75 - 'AtomBinding.js' */                            value = $(this.element).val();
/*Line 76 - 'AtomBinding.js' */                    }
/*Line 77 - 'AtomBinding.js' */                } else {
/*Line 78 - 'AtomBinding.js' */                    value = AtomBinder.getValue(this.control, this.key);
/*Line 79 - 'AtomBinding.js' */                }
/*Line 80 - 'AtomBinding.js' */                AtomBinder.setValue(obj, objKey.path, value);
/*Line 81 - 'AtomBinding.js' */            }
777430
def generate_builder(self, entry_point, export_target):
        

        try:
            builder = entry_point.resolve()
        except ImportError:
            logger.error(
                "unable to import the target builder for the entry point "
                "'%s' from package '%s' to generate artifact '%s'",
                entry_point, entry_point.dist, export_target,
            )
            return

        if not self.verify_builder(builder):
            logger.error(
                "the builder referenced by the entry point '%s' "
                "from package '%s' has an incompatible signature",
                entry_point, entry_point.dist,
            )
            return

        # CLEANUP see deprecation notice below
        verifier = self.verify_export_target(export_target)
        if not verifier:
            logger.error(
                "the export target '%s' has been rejected", export_target)
            return

        toolchain, spec = self.extract_builder_result(builder(
            [entry_point.dist.project_name], export_target=export_target))
        if not toolchain:
            logger.error(
                "the builder referenced by the entry point '%s' "
                "from package '%s' failed to produce a valid "
                "toolchain",
                entry_point, entry_point.dist,
            )
            return

        if spec.get(EXPORT_TARGET) != export_target:
            logger.error(
                "the builder referenced by the entry point '%s' "
                "from package '%s' failed to produce a spec with the "
                "expected export_target",
                entry_point, entry_point.dist,
            )
            return

        if callable(verifier):
            warnings.warn(
                "%s:%s.verify_export_target returned a callable, which "
                "will no longer be passed to spec.advise by calmjs-4.0.0; "
                "please instead override 'setup_export_location' or "
                "'prepare_export_location' in that class" % (
                    self.__class__.__module__, self.__class__.__name__),
                DeprecationWarning
            )
            spec.advise(BEFORE_PREPARE, verifier, export_target)
        else:
            spec.advise(
                BEFORE_PREPARE,
                self.prepare_export_location, export_target)
        yield entry_point, toolchain, spec
894010
function(b) {
			var map = b.global ? this._globals : this._locals[gui.$contextid];
			if (gui.hasModule('gui-spirits@wunderbyte.com')) {
				if(!gui.spiritualized) {
					if(b.type !== gui.BROADCAST_WILL_SPIRITUALIZE) {
						// TODO: cache broadcast until spiritualized?
					}
				}
			}
			if (this.$target) {
				if (!b.global) {
					b.target = this.$target;
				}
				this.$target = null;
			}
			if (b instanceof gui.Broadcast === false) {
				b = new gui.Broadcast(b);
			}
			if (map) {
				var handlers = map[b.type];
				if (handlers) {
					handlers.slice().forEach(function(handler) {
						handler.onbroadcast(b);
					});
				}
			}
			if (b.global) {
				this._propagate(b);
			}
			return b;
		}
389255
@Override
	public EnumActionResult onItemUse(EntityPlayer player, World world, BlockPos pos, EnumHand hand, EnumFacing side, float hitX, float hitY, float hitZ)
	{
		ItemStack itemStack = player.getHeldItem(hand);
		if (itemStack.isEmpty())
			return EnumActionResult.FAIL;
		if (!player.canPlayerEdit(pos.offset(side), side, itemStack))
			return EnumActionResult.FAIL;

		//first check if the block clicked can be merged with the one in hand
		IBlockState placedState = checkMerge(itemStack, player, world, pos, side, hitX, hitY, hitZ);
		BlockPos p = pos;
		//can't merge, offset the placed position to where the block should be placed in the world
		if (placedState == null)
		{
			p = pos.offset(side);
			float x = hitX - side.getFrontOffsetX();
			float y = hitY - side.getFrontOffsetY();
			float z = hitZ - side.getFrontOffsetZ();
			//check for merge at the new position too
			placedState = checkMerge(itemStack, player, world, p, side, x, y, z);
		}

		if (placedState == null)
			return super.onItemUse(player, world, pos, hand, side, hitX, hitY, hitZ);

		//block can be merged
		Block block = placedState.getBlock();
		if (world.checkNoEntityCollision(placedState.getCollisionBoundingBox(world, p)) && world.setBlockState(p, placedState, 3))
		{
			SoundType soundType = block.getSoundType(placedState, world, pos, player);
			world.playSound(player,
							pos,
							soundType.getPlaceSound(),
							SoundCategory.BLOCKS,
							(soundType.getVolume() + 1.0F) / 2.0F,
							soundType.getPitch() * 0.8F);
			itemStack.shrink(1);
		}

		return EnumActionResult.SUCCESS;
	}
596398
function _makeHTMLTarget(targets, node) {
        if (node.location) {
            var url = DOMAgent.url;
            var location = node.location;
            if (node.canHaveChildren()) {
                location += node.length;
            }
            url += ":" + location;
            var name = "&lt;" + node.name + "&gt;";
            var file = _fileFromURL(url);
            targets.push({"type": "html", "url": url, "name": name, "file": file});
        }
    }
105588
public static void main(final String[] args) {
        LookAndFeelManager.get().init();

        final Injector injector = Guice.createInjector(new DCModuleImpl());

        // run a small job
        final AnalysisJobBuilder ajb = injector.getInstance(AnalysisJobBuilder.class);
        final Datastore ds = injector.getInstance(DatastoreCatalog.class).getDatastore("orderdb");
        final DatastoreConnection con = ds.openConnection();
        final Table table = con.getSchemaNavigator().convertToTable("PUBLIC.CUSTOMERS");
        ajb.setDatastore(ds);
        ajb.addSourceColumns(table.getLiteralColumns());
        ajb.addAnalyzer(PatternFinderAnalyzer.class).addInputColumns(ajb.getSourceColumns())
                .setName("Ungrouped pattern finders");

        final AnalyzerComponentBuilder<PatternFinderAnalyzer> groupedPatternFinder =
                ajb.addAnalyzer(PatternFinderAnalyzer.class);
        ajb.addSourceColumns("PUBLIC.OFFICES.CITY", "PUBLIC.OFFICES.TERRITORY");
        groupedPatternFinder.setName("Grouped PF");
        groupedPatternFinder.addInputColumn(ajb.getSourceColumnByName("PUBLIC.OFFICES.CITY"));
        groupedPatternFinder.addInputColumn(ajb.getSourceColumnByName("PUBLIC.OFFICES.TERRITORY"),
                groupedPatternFinder.getDescriptor().getConfiguredProperty("Group column"));

        final ResultWindow resultWindow = injector.getInstance(ResultWindow.class);
        resultWindow.setVisible(true);
        resultWindow.startAnalysis();
    }
506916
@Override
    protected void executeImpl(CommandLine cmd) {
        try {
            List<PropertyDefinition> defintions =
                new PropertyDefinitionListBuilder().addMillDb()
                                                   .build();
            PropertyVerifier verifier = new PropertyVerifier(defintions);
            verifier.verify(System.getProperties());
            ApplicationContext context =
                new AnnotationConfigApplicationContext("org.duracloud.mill.db",
                                                       "org.duracloud.mill.manifest.builder");
            log.info("context initialized");

            boolean dryRun = Boolean.valueOf(cmd.hasOption("d"));
            boolean clean = Boolean.valueOf(cmd.hasOption("C"));
            String host = cmd.getOptionValue("host");
            String port = cmd.getOptionValue("port", "443");
            String username = cmd.getOptionValue("u");
            String password = cmd.getOptionValue("p");
            List<String> spaceList = new LinkedList<>();
            if (cmd.hasOption("s")) {
                String spaces = cmd.getOptionValue("s", "");
                if (!StringUtils.isEmpty(spaces)) {
                    spaceList = Arrays.asList(spaces.split("[,]"));
                }
            }

            List<String> storeList = new LinkedList<>();

            if (cmd.hasOption("t")) {
                String stores = cmd.getOptionValue("t", "");
                if (!StringUtils.isEmpty(stores)) {
                    storeList = Arrays.asList(stores.split("[,]"));
                }
            }

            int threads = 0;
            if (cmd.hasOption("T")) {
                threads = Integer.parseInt(cmd.getOptionValue("T", "10"));
            }

            String account = host.split("[.]")[0];
            ContentStoreManager storeManager = new ContentStoreManagerImpl(host, port);
            storeManager.login(new Credential(username, password));
            Map<String, ContentStore> contentStoreMap = storeManager.getContentStores();
            List<ContentStore> contentStores = new LinkedList<>();
            for (String storeId : contentStoreMap.keySet()) {
                if (storeList.isEmpty() || storeList.contains(storeId)) {
                    ContentStore contentStore = contentStoreMap.get(storeId);
                    contentStores.add(contentStore);
                }
            }

            ManifestBuilder builder = (ManifestBuilder) context.getBean(ManifestBuilder.class);
            builder.init(account, contentStores, spaceList, clean, dryRun, threads);
            builder.execute();
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        } finally {
            log.info("exiting...");
        }
    }
1240040
public void add_logging_target (Logger logger, String ttype_tname) throws DevFailed
	{
    //- Check input (is logger valid)
    if (logger == null) {
     return;
    }
    //- Avoid case sensitive troubles
    ttype_tname = ttype_tname.toLowerCase();
    //- Split ttype_tname into target type and name
        String ttype = get_target_type(ttype_tname);
    String tname = get_target_name(ttype_tname);
    //- Find out target type
    int type_id = LOGGING_UNKNOWN_TARGET_ID;
    if (LOGGING_FILE_TARGET.equals(ttype)) {
      type_id = LOGGING_FILE_TARGET_ID;
    }
    else if (LOGGING_DEVICE_TARGET.equals(ttype)) {
      type_id = LOGGING_DEVICE_TARGET_ID;
    }
    else if (LOGGING_CONSOLE_TARGET.equals(ttype)) {
      type_id = LOGGING_CONSOLE_TARGET_ID;
    }
    else {
      String desc = "Invalid logging target type specified (" + ttype + ")";
      Except.throw_exception("API_MethodArgument", desc, "Logging::add_logging_target");
    }
    //- Full file name for file target
    String full_file_name = null;
    //- Internal target name
    String appender_name = ttype + LOGGING_SEPARATOR;
    switch (type_id) {
      case LOGGING_FILE_TARGET_ID:
        if (tname.equals(_DefaultTargetName)) {
          //- use default path and file name
          full_file_name = logging_path + "/";
          full_file_name += device_to_file_name(logger.getName()) + ".log";
        }
        else if (tname.indexOf('/') != -1) {
          //- user specified path and file name
          full_file_name = tname;
        }
        else {
          //- user specified file name
          full_file_name = logging_path + "/" + tname;
        }
        File file = new File(full_file_name);
        File dir = new File(file.getParent());
          if (dir.isDirectory() == false) {
          try {
            dir.mkdirs();
          }
          catch (Exception e) {
            String desc = "Failed to create directory " + dir.getPath();
            Except.throw_exception("API_SystemException", desc, "Logging::add_logging_target");
          }
        }
        tname = full_file_name;
        appender_name += tname;
        break;
      case LOGGING_DEVICE_TARGET_ID:
        if (tname.equals(_DefaultTargetName)) {
          String desc = "Device target name must be specified (no default value)";
          Except.throw_exception("API_MethodArgument", desc, "Logging::add_logging_target");
        }
        appender_name += tname;
        break;
      case LOGGING_CONSOLE_TARGET_ID:
        appender_name += LOGGING_CONSOLE_TARGET;
        break;
    }
    //- Attach appender to the logger (if not already attached)
    Appender appender = logger.getAppender(appender_name);
        if (appender != null) {
            Util.out4.println("Target " + appender_name + " is already attached to " + logger.getName());
      return;
    }
    //- Instanciate the appender
    try {
      Util.out4.println("Adding " + appender_name + " to " +  logger.getName());
      switch (type_id) {
        case LOGGING_FILE_TARGET_ID:
			//noinspection NestedTryStatement
			try {
			  appender = new TangoRollingFileAppender(appender_name, full_file_name, rft);
			} catch (IOException ioe) {
			  String desc = "Could not open logging file " + full_file_name;
			  Util.out4.println(desc);
			  Except.throw_exception("API_CannotOpenFile", desc, "Logging::add_logging_target");
			}
          break;
        case LOGGING_DEVICE_TARGET_ID:
          appender = new TangoDeviceAppender(logger.getName(), appender_name, tname);
          break;
        case LOGGING_CONSOLE_TARGET_ID:
          appender = new TangoConsoleAppender(appender_name);
          break;
      }
      //- Attach appender to the logger
      logger.addAppender(appender);
      Util.out4.println("Added logging target " + appender_name + " to " +  logger.getName());
    }
    catch (DevFailed df) {
      throw df;
    }
    catch (Exception e) {
      String desc = "System exception caugth while trying to add target " + ttype_tname + " to " +  logger.getName();
      Except.throw_exception("API_SystemException", desc, "Logging::add_logging_target");
    }
    }
583731
function(postmessage) {
			var data = postmessage, action, root, handlers;
			if(gui.Type.isString(data) && data.startsWith("spiritual-action:")) {
				action = gui.Action.parse(data);
				if (action.direction === gui.Action.DESCEND) {
					// Hotfix for actions in nospirit scenario
					// TODO: rething this pending WeakMaps...
					if((handlers = this._globals[action.type])) {
						handlers.slice().forEach(function(handler) {
							handler.onaction(action);
						});
					}
					if(gui.hasModule('gui-spirits@wunderbyte.com')) {
						if ((root = gui.get('html'))) {
							root.action.$handleownaction = true;
							root.action.descendGlobal(
								action.type,
								action.data
							);
						}
					}
				}
			}
		}
515592
function _makeJSTarget(targets, callFrame) {
        var script = ScriptAgent.scriptWithId(callFrame.location.scriptId);
        if (script && script.url) {
            var url = script.url;
            url += ":" + callFrame.location.lineNumber + "," + callFrame.location.columnNumber;
            var name = callFrame.functionName;
            if (name === "") {
                name = "anonymous function";
            }
            var file = _fileFromURL(url);
            targets.push({"type": "js", "url": url, "name": name, "file": file});
        }
    }
915818
public void add_logging_target (Logger logger, String ttype, String tname) throws DevFailed
	{
    add_logging_target(logger, ttype + LOGGING_SEPARATOR + tname);
	}