Builds the dependencies associated with this resource.

 @return [Array<Puppet::Relationship>] list of relationships to other resources
179753
def builddepends
    # Handle the requires
    self.class.relationship_params.collect do |klass|
      if param = @parameters[klass.name]
        param.to_edges
      end
    end.flatten.reject { |r| r.nil? }
  end
1291990
def add_classes(relations)
      relations.each do |cls|
        extract(cls[:doc]).each_with_index do |ex, i|
          @examples << {
            :id => cls[:name] + "-" + i.to_s,
            :name => cls[:name] + " example #" + (i+1).to_s,
            :href => '#!/api/' + cls[:name],
            :code => ex[:code],
            :options => ex[:options],
          }
        end
      end

      self
    end
438225
public function buildRelations()
    {
        $this->addRelation('Country', '\\Thelia\\Model\\Country', RelationMap::MANY_TO_ONE, array('country_id' => 'id', ), 'CASCADE', null);
        $this->addRelation('DealerShedules', '\\Dealer\\Model\\DealerShedules', RelationMap::ONE_TO_MANY, array('id' => 'dealer_id', ), 'CASCADE', null, 'DealerSheduless');
        $this->addRelation('DealerContact', '\\Dealer\\Model\\DealerContact', RelationMap::ONE_TO_MANY, array('id' => 'dealer_id', ), 'CASCADE', null, 'DealerContacts');
        $this->addRelation('DealerContent', '\\Dealer\\Model\\DealerContent', RelationMap::ONE_TO_MANY, array('id' => 'dealer_id', ), 'CASCADE', 'RESTRICT', 'DealerContents');
        $this->addRelation('DealerFolder', '\\Dealer\\Model\\DealerFolder', RelationMap::ONE_TO_MANY, array('id' => 'dealer_id', ), 'CASCADE', 'RESTRICT', 'DealerFolders');
        $this->addRelation('DealerBrand', '\\Dealer\\Model\\DealerBrand', RelationMap::ONE_TO_MANY, array('id' => 'dealer_id', ), 'CASCADE', 'RESTRICT', 'DealerBrands');
        $this->addRelation('DealerProduct', '\\Dealer\\Model\\DealerProduct', RelationMap::ONE_TO_MANY, array('id' => 'dealer_id', ), 'CASCADE', 'RESTRICT', 'DealerProducts');
        $this->addRelation('DealerAdmin', '\\Dealer\\Model\\DealerAdmin', RelationMap::ONE_TO_MANY, array('id' => 'dealer_id', ), 'CASCADE', 'RESTRICT', 'DealerAdmins');
        $this->addRelation('DealerI18n', '\\Dealer\\Model\\DealerI18n', RelationMap::ONE_TO_MANY, array('id' => 'id', ), 'CASCADE', null, 'DealerI18ns');
        $this->addRelation('DealerVersion', '\\Dealer\\Model\\DealerVersion', RelationMap::ONE_TO_MANY, array('id' => 'id', ), 'CASCADE', null, 'DealerVersions');
    }
1223278
def relationships
      rels = Axlsx::Relationships.new
      rels << Relationship.new(self, WORKBOOK_R, WORKBOOK_PN)
      rels << Relationship.new(self, CORE_R, CORE_PN)
      rels << Relationship.new(self, APP_R, APP_PN)
      rels.lock
      rels
    end
779118
function mapDependencies(dependencies) {
  var deps;

  deps = (dependencies) ? Object.keys(dependencies) : [];

  return deps.map(function(name) {
    return {
      name: name,
      version: dependencies[name]
    };
  });
}
315155
def self_relationship_options
      keys       = model_key.map { |property| property.name }
      repository = self.repository
      {
        :child_key              => keys,
        :parent_key             => keys,
        :child_repository_name  => repository.name,
        :parent_repository_name => repository.name,
      }
    end
413774
public function getRelations()
    {
        if (!$this->relationsBuilt) {
            $this->buildRelations();
            $this->relationsBuilt = true;
        }

        return $this->relations;
    }
96147
def missing_dependencies
      missing = []
      dependency_versions(:recursive => false).each do |pkg, target_versions|
        found = false
        target_versions.each do |_target, versions|
          dependency = dependency_for(pkg)
          found = versions.any? { |version| dependency.match?(pkg, version) }
        end
        missing << pkg unless found
      end
      missing
    end
1015528
function buildJoinRelations () {
    // if no joins specified then do nothing
    if (!defined(this.args.join)) {
        return
    }
    // get join as array
    var joins = Array.isArray(this.args.join) ? this.args.join : [this.args.join]
    // add each join
    _.each(joins, join => {
        // join may be passed as string that is name of relation to join on
        if (typeof join === 'string') {
            join = {
                relation: join,
            }
        }
        // require join to be object
        assert.ok(join && typeof join === 'object', 'left join must be string or object')
        // add join to query
        this.buildJoinRelation(join)
    })
}
1222485
public function getDependencies()
    {
        $dependencies = [];
        if ($this->extendsClassDefinition && $this->extendsClassDefinition instanceof self) {
            $dependencies[] = $this->extendsClassDefinition;
        }

        foreach ($this->implementedInterfaceDefinitions as $interfaceDefinition) {
            if ($interfaceDefinition instanceof self) {
                $dependencies[] = $interfaceDefinition;
            }
        }

        return $dependencies;
    }
163112
public List<HealthDependencyPresenter> getDependencies() {
    List<HealthDependencyPresenter> dependencies = Lists.newArrayList();
    if (dto.getDependencies().isPresent()) {
      for (HealthDependencyDto dependencyDto : dto.getDependencies().get()) {
        dependencies.add(new HealthDependencyPresenter(dependencyDto));
      }
    }
    return dependencies;
  }
1004069
def _build_dependencies(self):
        
        for module in list(self.values()):
            module.set_all_dependencies(find_dependencies([module.name], self))
147018
public List<HealthDependencyDto> doDependencyListing() {
    List<HealthDependencyDto> listing = Lists.newArrayList();
    for (HealthDependency dependency : healthDependencies.values()) {
      listing.add(dependencyDtoBuilder(dependency).build());
    }
    return listing;
  }
1192872
public String prettyDependencies() {
        StringBuilder b = new StringBuilder();
        b.append(id()).append('\n');
        for (Iterator<Script> ite = dependencies.iterator(); ite.hasNext(); ) {
            Script n = ite.next();
            prettyDependencies(b, !ite.hasNext(), 0, n);
        }
        return b.toString();
    }
7420
function buildDependencyGraph(module, dependencies, graph) {
	if (module && !graph[module]) {
		graph[module] = [];
	}

	var dependencyNames = Object.keys(dependencies);
	dependencyNames.forEach(function(dependencyName) {
		var dependency = dependencies[dependencyName];

		if (module && graph[module].indexOf(dependencyName) === -1) {
			graph[module].push(dependencyName);
		}

		// Traverse down to this dependency dependencies:
		// Dependency-ception.
		if (dependency.dependencies) {
			buildDependencyGraph(dependencyName, dependency.dependencies, graph);
		}
	});
}
918877
def relationships
      r = Relationships.new
      child_objects.each { |child| r << child.relationship }
      r
    end
914681
private Collection<DependencyInfo> collectChildrenDependencies(DependencyInfo dependency, List<String> groupLines) {
        logger.debug("Collect child dependencies of {}, total group-lines = {}", dependency.getGroupId(), groupLines.size());
        Collection<DependencyInfo> dependencies = new LinkedList<>();
        boolean dependencyLine = false;
        for (String line : groupLines) {
            if (!dependencyLine && line.startsWith(FOUR_SPACES + dependency.getGroupId() + Constants.WHITESPACE)) {
                dependencyLine = true;
                getDependencyFromLine(dependency, line);
            } else if (dependencyLine) {
                if (line.startsWith(SIX_SPACES)) {
                    DependencyInfo childDependency = new DependencyInfo();
                    String lineWithoutSpaces = line.substring(SIX_SPACES.length());
                    childDependency.setGroupId(lineWithoutSpaces.substring(0, lineWithoutSpaces.indexOf(Constants.WHITESPACE)));
                    childDependency.setChildren(collectChildrenDependencies(childDependency, groupLines));
                    // prevent adding dependencies without sha1 or artifact id version and dependency type.
                    if(dependency.getSha1() == null && dependency.getArtifactId() == null) {
                        logger.warn(DEPENDECYERROR, dependency.getGroupId());
                    } else {
                        dependencies.add(childDependency);
                    }
                } else {
                    // move to the next dependency parent with its children
                    break;
                }
            }
        }
        return dependencies;
    }