Make seeds ref'able, provide for seed configuration

Fixes:
 - #106
 - #561

dbt/loader.py

@@ -192,7 +192,8 @@ def load_project(cls, root_project, all_projects, project, project_name,
  all_projects=all_projects,
  root_dir=project.get('project-root'),
  relative_dirs=project.get('data-paths', []),
- resource_type=NodeType.Seed)
+ resource_type=NodeType.Seed,
+ macros=macros)
 
 
 # node loaders

dbt/model.py

@@ -5,6 +5,7 @@
 from dbt.compat import basestring
 
 from dbt.utils import split_path, deep_merge, DBTConfigKeys
+from dbt.node_types import NodeType
 
 
 class SourceConfig(object):
@@ -24,11 +25,12 @@ class SourceConfig(object):
  'bind'
  ]
 
- def __init__(self, active_project, own_project, fqn):
+ def __init__(self, active_project, own_project, fqn, node_type):
  self._config = None
  self.active_project = active_project
  self.own_project = own_project
  self.fqn = fqn
+ self.node_type = node_type
 
  # the config options defined within the model
  self.in_model_config = {}
@@ -133,7 +135,10 @@ def get_project_config(self, project):
  for k in SourceConfig.ExtendDictFields:
  config[k] = {}
 
- model_configs = project.get('models')
+ if self.node_type == NodeType.Seed:
+ model_configs = project.get('data')
+ else:
+ model_configs = project.get('models')
 
  if model_configs is None:
  return config

dbt/node_runners.py

@@ -79,16 +79,16 @@ def raise_on_first_error(self):
  return False
 
  @classmethod
- def is_model(cls, node):
- return node.get('resource_type') == NodeType.Model
+ def is_refable(cls, node):
+ return node.get('resource_type') in [NodeType.Model, NodeType.Seed]
 
  @classmethod
  def is_ephemeral(cls, node):
  return dbt.utils.get_materialization(node) == 'ephemeral'
 
  @classmethod
  def is_ephemeral_model(cls, node):
- return cls.is_model(node) and cls.is_ephemeral(node)
+ return cls.is_refable(node) and cls.is_ephemeral(node)
 
  def safe_run(self, flat_graph, existing):
  catchable_errors = (dbt.exceptions.CompilationException,
@@ -175,7 +175,7 @@ def do_skip(self):
  def get_model_schemas(cls, flat_graph):
  schemas = set()
  for node in flat_graph['nodes'].values():
- if cls.is_model(node) and not cls.is_ephemeral(node):
+ if cls.is_refable(node) and not cls.is_ephemeral(node):
  schemas.add(node['schema'])
 
  return schemas

dbt/parser.py

@@ -39,15 +39,15 @@ def resolve_ref(flat_graph, target_model_name, target_model_package,
  current_project, node_package):
 
  if target_model_package is not None:
- return dbt.utils.find_model_by_name(
+ return dbt.utils.find_refable_by_name(
  flat_graph,
  target_model_name,
  target_model_package)
 
  target_model = None
 
  # first pass: look for models in the current_project
- target_model = dbt.utils.find_model_by_name(
+ target_model = dbt.utils.find_refable_by_name(
  flat_graph,
  target_model_name,
  current_project)
@@ -56,7 +56,7 @@ def resolve_ref(flat_graph, target_model_name, target_model_package,
  return target_model
 
  # second pass: look for models in the node's package
- target_model = dbt.utils.find_model_by_name(
+ target_model = dbt.utils.find_refable_by_name(
  flat_graph,
  target_model_name,
  node_package)
@@ -67,7 +67,7 @@ def resolve_ref(flat_graph, target_model_name, target_model_package,
  # final pass: look for models in any package
  # todo: exclude the packages we have already searched. overriding
  # a package model in another package doesn't necessarily work atm
- return dbt.utils.find_model_by_name(
+ return dbt.utils.find_refable_by_name(
  flat_graph,
  target_model_name,
  None)
@@ -201,7 +201,7 @@ def parse_node(node, node_path, root_project_config, package_project_config,
  fqn = get_fqn(node.get('path'), package_project_config, fqn_extra)
 
  config = dbt.model.SourceConfig(
- root_project_config, package_project_config, fqn)
+ root_project_config, package_project_config, fqn, node['resource_type'])
 
  node['unique_id'] = node_path
  node['empty'] = ('raw_sql' in node and len(node['raw_sql'].strip()) == 0)

dbt/utils.py

@@ -125,14 +125,14 @@ def model_immediate_name(model, non_destructive):
  return "{}__dbt_tmp".format(model_name)
 
 
-def find_model_by_name(flat_graph, target_name, target_package):
+def find_refable_by_name(flat_graph, target_name, target_package):
  return find_by_name(flat_graph, target_name, target_package,
- 'nodes', NodeType.Model)
+ 'nodes', [NodeType.Model, NodeType.Seed])
 
 
 def find_macro_by_name(flat_graph, target_name, target_package):
  return find_by_name(flat_graph, target_name, target_package,
- 'macros', NodeType.Macro)
+ 'macros', [NodeType.Macro])
 
 
 def find_by_name(flat_graph, target_name, target_package, subgraph,
@@ -146,7 +146,7 @@ def find_by_name(flat_graph, target_name, target_package, subgraph,
 
  resource_type, package_name, node_name = node_parts
 
- if (resource_type == nodetype and
+ if (resource_type in nodetype and
  ((target_name == node_name) and
  (target_package is None or
  target_package == package_name))):