Implement members from another class into current class data
@param {_cClassData} class_data
@param {string} path
343137
function(class_data, path) {

		var implements_source = this._sources[path],
			name,
			references_offset;

		if (Lava.schema.DEBUG) {

			if (!implements_source) Lava.t('Implements: class not found - "' + path + '"');
			for (name in implements_source.shared) Lava.t("Implements: unable to use a class with Shared as mixin.");
			if (class_data.implements.indexOf(path) != -1) Lava.t("Implements: class " + class_data.path + " already implements " + path);

		}

		class_data.implements.push(path);
		references_offset = class_data.references.length;
		// array copy is inexpensive, cause it contains only reference types
		class_data.references = class_data.references.concat(implements_source.references);

		this._extend(class_data, class_data.skeleton, implements_source, implements_source.skeleton, true, references_offset);

	}
1348513
function (path, currentFileInfo, importOptions, callback) {
            var parserImports = this;
            this.queue.push(path);

            var fileParsedFunc = function (e, root, fullPath) {
                parserImports.queue.splice(parserImports.queue.indexOf(path), 1); // Remove the path from the queue

                var importedPreviously = fullPath in parserImports.files || fullPath === rootFilename;

                parserImports.files[fullPath] = root;                        // Store the root

                if (e && !parserImports.error) { parserImports.error = e; }

                callback(e, root, importedPreviously, fullPath);
            };

            if (less.Parser.importer) {
                less.Parser.importer(path, currentFileInfo, fileParsedFunc, env);
            } else {
                less.Parser.fileLoader(path, currentFileInfo, function(e, contents, fullPath, newFileInfo) {
                    if (e) {fileParsedFunc(e); return;}

                    var newEnv = new tree.parseEnv(env);

                    newEnv.currentFileInfo = newFileInfo;
                    newEnv.processImports = false;
                    newEnv.contents[fullPath] = contents;

                    if (currentFileInfo.reference || importOptions.reference) {
                        newFileInfo.reference = true;
                    }

                    if (importOptions.inline) {
                        fileParsedFunc(null, contents, fullPath);
                    } else {
                        new(less.Parser)(newEnv).parse(contents, function (e, root) {
                            fileParsedFunc(e, root, fullPath);
                        });
                    }
                }, env);
            }
        }
657057
function (classes) {
            var extensions = this.props.extensions;

            if (extensions && extensions.get("addClass")) {
                var data = this.getDataForExtension();
                classes = classes + " " + extensions.get("addClass").map(function (callback) {
                    try {
                        return callback(data);
                    } catch (e) {
                        console.error("Exception thrown in FileTreeView addClass provider: " + e, e.stack);
                    }
                }).filter(isDefined).toArray().join(" ");
            }

            return classes;
        }
966118
function (data) {
      var parse = function() {
        var parsed = lazy.extend({}, lazy.parseFilepath(this.path), data);
        if (typeof parsed.ext === 'undefined') {
          parsed.ext = parsed.extname;
        }
        return parsed;
      }.bind(this);
      return this.fragmentCache('path', parse);
    }
610709
function (path, data) {
        var i = 0,
            len = path.length;
        for (;i<len;i++) {
            if (isObject(data) && (path[i] in data)) {
                data = data[path[i]];
            } else {
                data = undefined;
                break;
            }
        }
        return data;
    }
448451
function processClass (options, name, node) {
    processClassConstructor(options, name, node);
    processClassAppend(options, name, node);

    shuffleArray(options, node.children);

    for (let i = 0, max = node.children.length; i < max; i++) {
        let child = node.children[i];

        processClass(options, child, hierarchy[child]);
    }
}
15763
def add_class(class_name)
      @fragment.children.each do |c|
        c['class'] = ((c['class']||'').split(' ') + [class_name]).join(' ')
      end
    end
1054593
def initialize_class(data, *args, **kwargs):
    
    if isinstance(data, dict):
        import_path = data.get('import_path')
        data.update(kwargs)
        Class = import_module(import_path)

        return Class(*args, **data)
    else:
        Class = import_module(data)

        return Class(*args, **kwargs)
835068
def path=(new_path)
      if new_path && !new_path.respond_to?(:to_str)
        raise TypeError, "Can't convert #{new_path.class} into String."
      end
      @path = (new_path || EMPTY_STR).to_str
      if !@path.empty? && @path[0..0] != SLASH && host != nil
        @path = "/#{@path}"
      end

      # Reset dependent values
      remove_instance_variable(:@normalized_path) if defined?(@normalized_path)
      remove_composite_values

      # Ensure we haven't created an invalid URI
      validate()
    end
52317
function includePaths(object, pathsRemaining) {
  debugPrint('INCLUDE', { object, pathsRemaining });
  const path = pathsRemaining.shift();
  const target = object && object[path];

  if (target) {
    if (Array.isArray(target)) {
      object[path] = target.map(pointer => {
        const fetched = fetchObjectByPointer(pointer);
        includePaths(fetched, _.cloneDeep(pathsRemaining));
        return fetched;
      });
    } else {
      if (object[path].__type === 'Pointer') {
        object[path] = fetchObjectByPointer(target);
      }
      includePaths(object[path], pathsRemaining);
    }
  }

  return object;
}
664764
public function classSessionToPostData ($key_list = [], $parent_path_list = []) {
		$key_list = (array) $key_list;
		$key_list = empty($key_list) ? static::GetClassSessionNames() : $key_list;

		$parent_path_list = (array) $parent_path_list;

		if (empty($parent_path_list)) {
			foreach ($key_list as $key) {
				static::overWritePostData($key, static::ReadClassSession($key));
			}
		} else {
			$class_session = static::ReadClassSession($parent_path_list);
			foreach ($key_list as $key) {
				static::overWritePostData($key, isset($class_session[$key]) ? $class_session[$key] : null);
			}
		}
	}
165071
function(path, data) {
        var normalized = normalizePath(null, path, data);
        if (normalized.isKeyword) {
          return 'templateData.keywords.' + path;
        } else if (isGlobalPath(path)) {
          return null;
        } else if (path === 'this' || path === '') {
          return '_parentView.context';
        } else {
          return '_parentView.context.' + path;
        }
      }
221398
def class_defined(filename, class_name, superclass_name)
      @definition_graph[filename] ||= {}
      @definition_graph[filename][class_name] = superclass_name
      class_encountered(filename, class_name)
      class_encountered(filename, superclass_name) if superclass_name
    end
1237992
function (className,config,path,npmPath)
		{
			var source = this.c || process.wns;
			var instance;
			var builder = this.getComponent&&this.getComponent('classBuilder');

			if (!source || !source[className])
			 { return false; }

			if (config.id)
				source[className].build.id = config.id;

			if (source[className].build.extend.indexOf('wnModule')!==-1)
			{
				instance = new source[className](self,config,path,npmPath,builder.classesPath);
			}
			else
				instance = new source[className](config,source);

			if (WNS_TEST && builder)
			{
				console.log('- Testing '+className)
				var tests = builder.classes[className].test;
				for (t in tests)
				{
					//console.log('Testing: '+t);
					tests[t](instance);
				}
			}
			return instance;
		}
1117701
function (data) {
      var include = function (path, includeData) {
        var d = utils.shallowCopy({}, data);
        if (includeData) {
          d = utils.shallowCopy(d, includeData);
        }
        return includeFile(path, opts)(d);
      };
      return fn.apply(opts.context, [data || {}, escapeFn, include, rethrow]);
    }
1093369
function(path) {
            if (!path.inList) {
              return;
            }

            const { node } = path;

            let sibling = path.getSibling(path.key + 1);

            let declarations = [];

            while (sibling.isVariableDeclaration({ kind: node.kind })) {
              declarations = declarations.concat(sibling.node.declarations);

              sibling.remove();

              sibling = path.getSibling(path.key + 1);
            }

            if (declarations.length > 0) {
              path.replaceWith(
                t.variableDeclaration(node.kind, [
                  ...node.declarations,
                  ...declarations
                ])
              );
            }
          }
1157835
public function classSessionToAssignData ($key_list = [], $parent_path_list = []) {
		$key_list = (array) $key_list;
		$key_list = empty($key_list) ? static::GetClassSessionNames() : $key_list;

		$parent_path_list = (array) $parent_path_list;

		$assign_data_set = [];

		if (empty($parent_path_list)) {
			foreach ($key_list as $key) {
				$assign_data_set[$key] = static::ReadClassSession($key);
			}
		} else {
			$class_session = static::ReadClassSession($parent_path_list);
			foreach ($key_list as $key) {
				$assign_data_set[$key] = isset($class_session[$key]) ? $class_session[$key] : null;
			}
		}

		return $assign_data_set;
	}