Use Project objects in main program

1 files changed, 25 insertions, 29 deletions

diff --git a/ick b/ick
index 1b39387..88b9c55 100755
--- a/ick
+++ b/ick
@@ -58,8 +58,8 @@ class Ick(cliapp.Application):
         statedir = ick['state']
         targets = self.get_targets(ick)
         projects = self.get_projects(ick)
-        for project_name, project in projects.items():
-            self.build_project(statedir, project_name, project, targets)
+        for project in projects:
+            self.build_project(statedir, project, targets)
 
     def get_targets(self, ick):
         targets = icklib.create_targets_from_ick(ick)
@@ -68,44 +68,40 @@ class Ick(cliapp.Application):
             targets = [t for t in targets if t.name in wanted_names]
         return targets
 
-    def pick_from_dict(self, items, names):
-        if names:
-            return dict((name, items[name]) for name in names)
-        else:
-            return items
-
     def get_projects(self, ick):
-        return self.pick_from_dict(
-            ick.get('projects', {}),
-            self.settings['project'])
+        projects = icklib.create_projects_from_ick(ick)
+        wanted_names = self.settings['project']
+        if wanted_names:
+            projects = [p for p in projects if p.name in wanted_names]
+        return projects
 
-    def build_project(self, statedir, project_name, project, targets):
+    def build_project(self, statedir, project, targets):
         self.logger.log(
-            'Building project {project_name}', project_name=project_name)
+            'Building project {project_name}', project_name=project.name)
 
         clone = icklib.GitClone()
-        clone.set_dirname(self.get_git_dir(statedir, project_name))
-        clone.set_url(project['git'])
+        clone.set_dirname(self.get_git_dir(statedir, project))
+        clone.set_url(project.git_url)
         clone.sync_from_url()
-        clone.checkout(project['branch'])
+        clone.checkout(project.git_branch)
 
         meta = BuildMetadata()
         meta.commit = clone.get_HEAD_commit()
 
-        if not self.needs_to_be_built(statedir, project_name, meta.commit):
+        if not self.needs_to_be_built(statedir, project, meta.commit):
             with self.logger:
                 self.logger.log(
                     'No need to build {project_name}',
-                    project_name=project_name)
+                    project_name=project.name)
             return
 
-        build_dir = self.get_next_build_dir(statedir, project_name)
+        build_dir = self.get_next_build_dir(statedir, project)
         for target in targets:
-            self.build_on_target(project_name, project, target, clone)
+            self.build_on_target(project, target, clone)
         self.save_build_metadata(build_dir, meta)
 
-    def needs_to_be_built(self, statedir, project_name, current_commit):
-        builds_dir = os.path.join(statedir, project_name, 'builds')
+    def needs_to_be_built(self, statedir, project, current_commit):
+        builds_dir = os.path.join(statedir, project.name, 'builds')
         if os.path.exists(builds_dir):
             basenames = os.listdir(builds_dir)
             if basenames:
@@ -124,8 +120,8 @@ class Ick(cliapp.Application):
         meta.commit = obj['commit']
         return meta
 
-    def get_next_build_dir(self, statedir, project_name):
-        builds_dir = os.path.join(statedir, project_name, 'builds')
+    def get_next_build_dir(self, statedir, project):
+        builds_dir = os.path.join(statedir, project.name, 'builds')
         if os.path.exists(builds_dir):
             basenames = os.listdir(builds_dir)
         else:
@@ -139,17 +135,17 @@ class Ick(cliapp.Application):
         os.makedirs(build_dir)
         return build_dir
 
-    def get_git_dir(self, statedir, project_name):
-        return os.path.join(statedir, project_name, 'git')
+    def get_git_dir(self, statedir, project):
+        return os.path.join(statedir, project.name, 'git')
 
-    def build_on_target(self, project_name, project, target, clone):
+    def build_on_target(self, project, target, clone):
         with self.logger:
             self.logger.log(
                 'Building {project_name} on {target_name}',
-                project_name=project_name, target_name=target.name)
+                project_name=project.name, target_name=target.name)
             remote_git_dir = self.rsync_to_target(clone.dirname, target)
             try:
-                for command in project.get('commands', []):
+                for command in project.commands:
                     self.run_on_target(target, command, remote_git_dir)
             except cliapp.AppException:
                 cliapp.ssh_runcmd(address, ['rm', '-rf', remote_git_dir])