Make seeds ref'able, provide for seed configuration

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))):