* Created IPS package

* Major overhaul in progress

8 files changed, 293 insertions, 209 deletions

diff --git a/ips/__init__.py b/ips/__init__.py
new file mode 100644
index 0000000..0ca8f44
--- /dev/null
+++ b/ips/__init__.py
@@ -0,0 +1,7 @@
+from . import env
+from . import config
+from . import build
+from . import task
+
+if __name__ == '__main__':
+    pass
\ No newline at end of file
diff --git a/ips/build.py b/ips/build.py
new file mode 100644
index 0000000..dad63b7
--- /dev/null
+++ b/ips/build.py
@@ -0,0 +1,125 @@
+from . import env, task
+from pprint import pprint
+import os
+import shutil
+import subprocess
+import string
+
+
+class Build(env.Environment):
+    def __init__(self, ipsfile):
+        # Parent Config parses configuration data in .ips file
+        # Inherited members are used to populate package information
+        # as well as build tasks
+        super(Build, self).__init__(ipsfile)
+        
+        os.chdir(self.env['IPSBUILD'])
+        # Create list of build tasks
+        ordered_tasks = ['prep', 'build', 'install']
+        self.controller = task.TaskController()
+
+        # Assign built-in IPS tasks
+        self.controller.task(task.NamedTask('Extract source', self.source_unpack))
+        self.controller.task(task.NamedTask('Create buildroot', self.create_buildroot))
+        self.controller.task(task.NamedTask('Create metadata', self.create_metadata))
+
+        # Assign user defined .ips tasks in build order
+        for user_task in ordered_tasks:
+            self.controller.task(task.NamedTask(user_task, self.exec_scripted_process, self.script_dict[user_task]))
+
+    def exec_scripted_process(self, *p):
+        """Execute script in .ips
+        This function needs to be rewritten BAD
+        """
+        os.chdir(self.env_pkg['BUILD'])
+        for t in map(list, p):
+            for i in t:
+                if not i:
+                    continue
+                for e in i:
+                    t = string.Template(string.join(e))
+                    e = t.safe_substitute(self.env_pkg)
+                    print("+ {0:s}".format(e))
+                    output = subprocess.check_output(e)
+                    if output:
+                        print("+ {0:s}".format(output))
+        os.chdir(self.env['IPSBUILD'])
+        return True
+    
+    def source_unpack(self, *p):
+        path = os.path.relpath(self.env_pkg['SOURCES'], self.env['IPSBUILD'])
+        if not os.path.exists(path):
+            print("{0:s}: does not exist".format(path))
+            return False
+        
+        ext = {
+               '.tar': '{0:s} xf {1:s} -C {2:s}'.format(self.tool['tar'], path, self.env['BUILD']),
+               '.tar.gz': '{0:s} xfz {1:s} -C {2:s}'.format(self.tool['tar'], path, self.env['BUILD']),
+               '.tar.bz2': '{0:s} xfj {1:s} -C {2:s}'.format(self.tool['tar'], path, self.env['BUILD']),
+               '.tar.xz': '{0:s} xfJ {1:s} -C {2:s}'.format(self.tool['tar'], path, self.env['BUILD']),
+               '.gz': self.tool['gunzip'],
+               '.bz2': self.tool['bunzip'],
+               '.zip': self.tool['unzip']
+        }
+        cmd = []
+        for k, v in ext.items():
+            if k in path:
+                cmd = v.split()
+                print(string.join(cmd))
+                subprocess.check_output(cmd)
+                break
+        return True
+
+    def create_buildroot(self, *p):
+        path = self.env_pkg['BUILDROOT']
+        if os.path.exists(path):
+            shutil.rmtree(path)
+        os.mkdir(path)
+        return True
+
+    def create_metadata(self, *p):
+        output = []
+        meta_map = {
+                     'pkg.fmri': self.key_dict['name'],
+                     'pkg.description': self.key_dict['description'],
+                     'pkg.summary': self.key_dict['summary'],
+                     'variant.arch': self.key_dict['arch'],
+                     'info.upstream_url': self.key_dict['upstream_url'],
+                     'info.source_url': self.key_dict['source_url'],
+                     'info.classification': self.key_dict['classification']
+                     }
+        template = file('c:\\users\\jhunk\\documents\\projects\\aptana\\ipsbuild\\metadata.tpl', 'r')
+        for line in template.readlines():
+            for k, v in meta_map.items():
+                if k in line:
+                    # pkg.fmri requires special attention to build the proper
+                    # package name IPS wants
+                    if k == 'pkg.fmri':
+                        output.append(line.replace('{}',
+                           self.key_dict['group'] +
+                           "/" +
+                           self.key_dict['name'] +
+                           "@" +
+                           self.key_dict['version'] +
+                           "," +
+                           self.key_dict['release']
+                           ))
+                        continue
+                    # The rest of the value replacements are rather simple
+                    output.append(line.replace('{}', v))   
+        
+        manifest = file(os.path.join(self.env_pkg['BUILDROOT'], self.complete_name + '.p5m.1'), 'w+')
+        for line in output:
+            manifest.writelines(line)
+        print(manifest.name)
+        manifest.close()
+        return True
+
+    def create_package_list(self, *p):
+        pass
+
+
+    def show_summary(self):
+        print("Summary of {0:s}".format(self.key_dict['name']))
+        for k, v in sorted(self.key_dict.items()):
+            print("+ {0:s}: {1:s}".format(k, v))
diff --git a/ips/config.py b/ips/config.py
new file mode 100644
index 0000000..45aa204
--- /dev/null
+++ b/ips/config.py
@@ -0,0 +1,59 @@
+import shlex
+import string
+
+class Config(object):
+    def __init__(self, ipsfile):
+        super(Config, self).__init__()
+        key_dict = {
+                'name': '',
+                'version': '',
+                'release': '',
+                'maintainer': '',
+                'group': '',
+                'upstream_url': '',
+                'source_url': '',
+                'description': '',
+                'summary': '',
+                'classification': '',
+                'arch': '',
+                'license': ''
+                }
+
+        script_dict = {
+                  'build': [],
+                  'prep': [],
+                  'install': [],
+                  'files': []
+                  }
+
+        expandable = []
+        for line in file(ipsfile).readlines():
+            parts = shlex.split(line)
+            t = string.Template(parts)
+            expandable.append(t)
+        
+        for key in key_dict:
+            for line in file(ipsfile).readlines():
+                parts = shlex.split(line)
+                if key + ":" in parts:
+                    key_dict[key] = parts[1]
+
+        found_data = False
+        code_section = ['%build', '%prep', '%install']
+    
+        for section in code_section:
+            for line in file(ipsfile).readlines():
+                if line.startswith('#'):
+                    continue
+                parts = shlex.split(line)
+                if '%end' in parts:
+                    found_data = False
+                if section in parts:
+                    found_data = True
+                    continue
+                if found_data:
+                    script_dict[section.strip('%')].append(parts)
+
+        self.key_dict = key_dict
+        self.script_dict = script_dict
+                        
\ No newline at end of file
diff --git a/ips/env.py b/ips/env.py
new file mode 100644
index 0000000..b7f611a
--- /dev/null
+++ b/ips/env.py
@@ -0,0 +1,45 @@
+import os
+import sys
+from . import config
+
+
+class Environment(config.Config):
+    def __init__(self, ipsfile):
+        super(Environment, self).__init__(ipsfile)
+        if sys.platform == 'linux2' \
+            or sys.platform == 'sunos5':
+            self.__basepath = os.path.join(os.environ['HOME'], 'ipsbuild')
+        else:
+            self.__basepath = os.path.join(os.environ['USERPROFILE'], 'ipsbuild')
+            
+        self.env = {
+                'IPSBUILD': self.pathgen(''),
+                'BUILDROOT': self.pathgen('BUILDROOT'),
+                'BUILD': self.pathgen('BUILD'),
+                'SPECS': self.pathgen('SPECS'),
+                'SOURCES': self.pathgen('SOURCES'),
+                'PKGS': self.pathgen('PKGS'),
+                'SPKGS': self.pathgen('SPKGS')
+                }
+        
+        self.complete_name = self.key_dict['name'] + '-' + self.key_dict['version']
+        self.env_pkg = {
+                'BUILDROOT': os.path.join(self.env['BUILDROOT'], self.complete_name),
+                'BUILD': os.path.join(self.env['BUILD'], self.complete_name),
+                'SOURCES': os.path.join(self.env['SOURCES'], os.path.basename(self.key_dict['source_url'])),
+                'PKGS': os.path.join(self.env['PKGS'], self.complete_name),
+                'SPKGS': os.path.join(self.env['SPKGS'], self.complete_name)
+                }
+
+        self.tool = {
+                    'tar': 'tar',
+                    'unzip': 'unzip',
+                    'gunzip': 'gunzip',
+                    'bunzip': 'bunzip'
+                    }
+
+        if sys.platform == 'sunos5':
+            self.tool['tar'] = 'gtar'
+
+    def pathgen(self, path):
+        return os.path.join(self.__basepath, path)
diff --git a/ips/task.py b/ips/task.py
new file mode 100644
index 0000000..6c84d51
--- /dev/null
+++ b/ips/task.py
@@ -0,0 +1,45 @@
+# class TaskController(list):
+#     def __init__(self):
+#         super(TaskController, self).__init__()
+#         self._store = []
+# 
+#     def task(self, task):
+#         super(TaskController, self).append(task)
+# 
+#     def do_tasks(self):
+#         for task in super(TaskController, self).__iter__():
+#             retval = task.run()
+#             if not retval:
+#                 exit(retval)
+                
+class TaskController(object):
+    def __init__(self):
+        self.stack = []
+
+    def task(self, t):
+        """
+        t: Task object
+        """
+        self.stack.append(t)
+    
+    def do_tasks(self):
+        """ FILO execution of tasks
+        """
+        #self.stack.reverse()
+        for i in self.stack:
+            i.run()
+
+class NamedTask(object):
+    def __init__(self, name, func, *args):
+        self.name = name
+        self.task = func
+        self.task_args = args
+        print("New task: {0:s} {1:s}".format(self.name, self.task))
+
+    def run(self):
+        print("Running task: {0:s}".format(self.name))
+        status = self.task(self.task_args)
+        return status
+
+class InternalTask(NamedTask):
+    pass
\ No newline at end of file
diff --git a/ips/test.py b/ips/test.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/ips/test.py
diff --git a/ipsbuild.py b/ipsbuild.py
index dd9d26f..8f3088a 100644
--- a/ipsbuild.py
+++ b/ipsbuild.py
@@ -1,214 +1,14 @@
+#!/usr/bin/env python
+
 # Solaris 11 IPS
 # Automate package creation
 
 from pprint import pprint
-import subprocess
-import shlex
-import argparse
-import string
-import sys
-import os
-
-class IPS_Environment(object):
-    def __init__(self):
-        super(IPS_Environment, self).__init__()
-        self._basepath = os.path.join(os.environ['HOME'], 'ipsbuild')
-        self.env = {
-                'BUILDROOT': self.pathgen('BUILDROOT'),
-                'BUILD': self.pathgen('BUILD'),
-                'SPECS': self.pathgen('SPECS'),
-                'SOURCES': self.pathgen('SOURCES'),
-                'PKGS': self.pathgen('PKGS'),
-                'SPKGS': self.pathgen('SPKGS')
-                }
-
-        self.tool = {
-                    'tar': 'tar',
-                    'unzip': 'unzip',
-                    'gunzip': 'gunzip',
-                    'bunzip': 'bunzip'
-                    }
-
-        if sys.platform == 'solaris':
-            self.tool['tar'] = 'gtar'
-
-
-    def pathgen(self, path):
-        return os.path.join(self._basepath, path)
-
-class IPS_Config(object):
-    def __init__(self, ipsfile):
-        super(IPS_Config, self).__init__()
-        key_dict = {
-                'name': '',
-                'version': '',
-                'release': '',
-                'maintainer': '',
-                'group': '',
-                'upstream_url': '',
-                'source_url': '',
-                'description': '',
-                'summary': '',
-                'classification': '',
-                'arch': '',
-                'license': ''
-                }
-
-        script_dict = {
-                  'build': [],
-                  'prep': [],
-                  'install': [],
-                  'files': []
-                  }
-
-        for key in key_dict:
-            for line in file(ipsfile).readlines():
-                parts = shlex.split(line)
-                if key + ":" in parts:
-                    key_dict[key] = parts[1]
-
-        found_data = False
-        code_section = ['%build', '%prep', '%install']
-        for section in code_section:
-            for line in file(ipsfile).readlines():
-                parts = shlex.split(line)
-                if '%end' in parts:
-                    found_data = False
-                if section in parts:
-                    found_data = True
-                    continue
-                if found_data:
-                    script_dict[section.strip('%')].append(parts)
-
-        self.key_dict = key_dict
-        self.script_dict = script_dict
-
-
-class IPS_TaskController(list):
-    def __init__(self):
-        super(IPS_TaskController, self).__init__()
-        self._store = []
-
-    def task(self, task):
-        super(IPS_TaskController, self).append(task)
-
-    def do_tasks(self):
-        for task in super(IPS_TaskController, self).__iter__():
-            self._store.append(task.run())
-
-class IPS_NamedTask(object):
-    def __init__(self, name, task_list):
-        if type(task_list) is not type(list):
-            TypeError("task must be a list")
-
-        self.name = name
-        self.task = task_list
-
-    def run(self):
-        print("Running task: {0:s}".format(self.name))
-        for step in self.task:
-            print("+ {0:s}".format(step))
-
-class IPS_Build(IPS_Config, IPS_Environment):
-    def __init__(self, ipsfile):
-        # Parent IPS_Config parses configuration data in .ips file
-        # Inherited members are used to populate package information
-        # as well as build tasks
-        super(IPS_Build, self).__init__(ipsfile)
-        # Um, super and multiple inheritance SUCKS... back to Python2 style
-        #IPS_Environment.__init__(self)
-
-        # Create list of build tasks
-        ordered_tasks = ['prep', 'build', 'install']
-        self.controller = IPS_TaskController()
-
-        # Assign built-in IPS tasks
-        self.controller.task(IPS_NamedTask('Extract source', self.source_unpack()))
-        self.controller.task(IPS_NamedTask('Create buildroot', self.create_buildroot()))
-        self.controller.task(IPS_NamedTask('Create metadata', self.create_metadata()))
-
-        # Assign user defined .ips tasks in build order
-        for user_task in ordered_tasks:
-            self.controller.task(IPS_NamedTask(user_task, self.script_dict[user_task]))
-
-
-    def source_unpack(self):
-        path = os.path.join(self.env['SOURCES'],
-                            os.path.basename(self.key_dict['source_url']))
-        ext = {
-               '.tar': '{0:s} xf {1:s} -C {2:s}'.format(self.tool['tar'], path, self.env['BUILD']),
-               '.tar.gz': '{0:s} xfz {1:s} -C {2:s}'.format(self.tool['tar'], path, self.env['BUILD']),
-               '.tar.bz2': '{0:s} xfj {1:s} -C {2:s}'.format(self.tool['tar'], path, self.env['BUILD']),
-               '.tar.xz': '{0:s} xfJ {1:s} -C {2:s}'.format(self.tool['tar'], path, self.env['BUILD']),
-               '.gz': self.tool['gunzip'],
-               '.bz2': self.tool['bunzip'],
-               '.zip': self.tool['unzip']
-        }
-        cmd = []
-        for k, v in ext.items():
-            if k in path:
-                cmd = v.split()
-                subprocess.check_output(cmd)
-                break
-        return [cmd]
-
-    def create_buildroot(self):
-        path = os.path.join(self.env['BUILDROOT'],
-                            self.key_dict['name'] +
-                            "-" +
-                            self.key_dict['version'])
-        if os.path.exists(path):
-            os.remove(path)
-        os.mkdir(path)
-        return [path]
-
-    def create_metadata(self):
-        output = []
-        meta_map = {
-                     'pkg.fmri': self.key_dict['name'],
-                     'pkg.description': self.key_dict['description'],
-                     'pkg.summary': self.key_dict['summary'],
-                     'variant.arch': self.key_dict['arch'],
-                     'info.upstream_url': self.key_dict['upstream_url'],
-                     'info.source_url': self.key_dict['source_url'],
-                     'info.classification': self.key_dict['classification']
-                     }
-        template = file('metadata.tpl', 'r')
-        for line in template.readlines():
-            for k, v in meta_map.items():
-                if k in line:
-                    # pkg.fmri requires special attention to build the proper
-                    # package name IPS wants
-                    if k == 'pkg.fmri':
-                        output.append(line.replace('{}',
-                           self.key_dict['group'] +
-                           "/" +
-                           self.key_dict['name'] +
-                           "@" +
-                           self.key_dict['version'] +
-                           "," +
-                           self.key_dict['release']
-                           ).strip('\n'))
-                        continue
-                    # The rest of the value replacements are rather simple
-                    output.append(line.replace('{}', v).strip('\n'))
-        return output
-
-    def create_package_list(self):
-        pass
-
-
-    def show_summary(self):
-        print("Summary of {0:s}".format(self.key_dict['name']))
-        for k, v in sorted(self.key_dict.items()):
-            print("+ {0:s}: {1:s}".format(k, v))
-
-
-
+import ips
 
 testfile = "test.ips"
-build = IPS_Build(testfile)
+build = ips.build.Build(testfile)
 #build.show_summary()
-build.controller.do_tasks()
 #build.source_unpack()
-
+build.controller.do_tasks()
+print("I made it to the end")
\ No newline at end of file
diff --git a/test.ips b/test.ips
index 45a95e8..aceb91f 100644
--- a/test.ips
+++ b/test.ips
@@ -18,10 +18,13 @@ license:       GPL
 %end
 
 %build
-configure --prefix=/usr
-make
+python -m compileall -f .
+#configure --prefix=/usr
+#make
 %end
 
 %install
-make install
+mkdir $BUILDROOT/usr/bin
+cp testpkg.pyc $BUILDROOT/usr/bin
+#make install
 %end
\ No newline at end of file