예제 #1
0
    def setUp(self):
        self.cwd = os.getcwd()

        self.local_project_testdir = "build-tests/remote-project/build"
        self.local_proj_zip_key = "zip_key.yaml"  # executed from the same directory

        # remove all contents of the build directory and build directory path from prior test run
        if dir_exists('build-tests/remote-project/build'):
            shutil.rmtree('build-tests/remote-project/build')

        self.assertFalse(dir_exists('build-tests/remote-project/build'))

        # create the build directory path
        os.makedirs('build-tests/remote-project/build')

        self.assertTrue(dir_exists('build-tests/remote-project/build'))

        # move the key into the build directory
        fr_key = FileReader('build-tests/remote-project/zip_key.yaml')
        zip_key_data = fr_key.read()
        fw_key = FileWriter('build-tests/remote-project/build/zip_key.yaml')
        fw_key.write(zip_key_data)


        # confirm that the build files are present
        self.assertTrue(file_exists('build-tests/remote-project/build/zip_key.yaml'))

        # get the expected text for outfile write assertions
        self.fourohfour_text = FileReader('standards/404.html').read()
        self.indexhtml_text = FileReader('standards/index.html').read()
        self.jquery_text = FileReader('standards/jquery.js').read()
        self.normalize_text = FileReader('standards/normalize-min.css').read()        
예제 #2
0
파일: cache.py 프로젝트: tstyle/doxx
 def _write_text_file(self, file_path, file_text):
     try:
         fw = FileWriter(file_path)
         fw.write(file_text)
         return True
     except Exception:
         return False
예제 #3
0
 def setUp(self):
     self.cwd = os.getcwd()
     
     self.remote_packagerepo_testdir = "build-tests/remote-package-repo/build"
     self.package_repo_keypath = "build-tests/remote-package-repo/key.yaml"
     self.package_repo_missing_keypath = "build-tests/remote-package-repo/key_missingpackage.yaml"
     
     # remove all contents of the build directory and build directory path from prior test run
     if dir_exists(self.remote_packagerepo_testdir):
         shutil.rmtree(self.remote_packagerepo_testdir)
 
     self.assertFalse(dir_exists(self.remote_packagerepo_testdir))
     
     # create the build directory path with empty directory
     os.makedirs(self.remote_packagerepo_testdir)
 
     self.assertTrue(dir_exists(self.remote_packagerepo_testdir))
     
     # move the key with good file path into the build directory
     fr_key = FileReader('build-tests/remote-package-repo/key.yaml')
     key_data = fr_key.read()
     fw_key = FileWriter('build-tests/remote-package-repo/build/key.yaml')
     fw_key.write(key_data)
     
     # confirm that the build files are present
     self.assertTrue(file_exists('build-tests/remote-package-repo/build/key.yaml'))
예제 #4
0
파일: make.py 프로젝트: tstyle/doxx
 def make_template(self, outpath):
     try:
         fw = FileWriter(outpath)
         fw.write(template_stub)
         if file_exists(outpath):
             stdout("[+] doxx: The template stub '" + outpath + "' is now available in the current directory.")
     except Exception as e:
         stderr("[!] doxx: Unable to write the template stub to disk. Error: " + str(e), exit=1)
예제 #5
0
 def test_http_get_text_exists_request_overwrite(self):
     """Test HTTP GET request with text file write does overwrite existing file when requested to do so"""
     filepath = os.path.join('testfiles', 'testdir', 'test.txt')
     http = HTTP('https://raw.github.com/chrissimpkins/six-four/master/LICENSE')
     fw = FileWriter(filepath)
     fw.write("test")
     http.get_txt_write_file(filepath, overwrite_existing=True)
     self.assertEqual(FileReader(filepath).read().strip(), self.http_string.strip())
예제 #6
0
 def test_http_post_text_file_present_request_overwrite(self):
     """Test HTTP request text file write does occur when file present and request overwrite"""
     filepath = os.path.join('testfiles', 'testdir', 'post.txt')
     if not file_exists(filepath):
         fw = FileWriter(filepath)
         fw.write('test')
     http = HTTP('http://httpbin.org/gzip')
     response = http.post_bin_write_file(filepath, overwrite_existing=True)
     self.assertEqual(True, response)
예제 #7
0
 def test_http_post_text_file_present_request_overwrite(self):
     """Test HTTP request text file write does occur when file present and request overwrite"""
     filepath = os.path.join('testfiles', 'testdir', 'post.txt')
     if not file_exists(filepath):
         fw = FileWriter(filepath)
         fw.write('test')
     http = HTTP('http://httpbin.org/gzip')
     response = http.post_bin_write_file(filepath, overwrite_existing=True)
     self.assertEqual(True, response)
예제 #8
0
 def test_file_gzip_ascii_readwrite(self):
     """Test gzip compression and read from compressed ascii text file in Python 2"""
     if state.py2:
         FileWriter(self.ascii_path).gzip(self.ascii_string)
         gzip_contents = FileReader(self.ascii_path + ".gz").read_gzip()
         self.assertEqual(gzip_contents, self.ascii_string)
     elif state.py3:
         FileWriter(self.ascii_path).gzip(bytes(self.ascii_string, 'utf-8'))
         gzip_contents = FileReader(self.ascii_path + ".gz").read_gzip()
         self.assertEqual(gzip_contents.decode('ascii'), self.ascii_string)
예제 #9
0
 def test_http_post_binary_file_present_request_overwrite(self):
     """Test HTTP POST request binary file write when file does exist and request for overwrite"""
     filepath = os.path.join('testfiles', 'testdir', 'post.gz')
     if not file_exists(filepath):
         fw = FileWriter(filepath)
         fw.write('test')
     http = HTTP('http://httpbin.org/gzip')
     response = http.post_bin_write_file(filepath, overwrite_existing=True)
     self.assertEqual(True, response)
     self.assertEqual(True, file_exists(filepath))
예제 #10
0
 def test_http_post_binary_file_present_request_overwrite(self):
     """Test HTTP POST request binary file write when file does exist and request for overwrite"""
     filepath = os.path.join('testfiles', 'testdir', 'post.gz')
     if not file_exists(filepath):
         fw = FileWriter(filepath)
         fw.write('test')
     http = HTTP('http://httpbin.org/gzip')
     response = http.post_bin_write_file(filepath, overwrite_existing=True)
     self.assertEqual(True, response)
     self.assertEqual(True, file_exists(filepath))
예제 #11
0
 def test_http_get_binary_file_exists_request_overwrite(self):
     """Test HTTP GET request and write binary file executes the write when the file exists and overwrite requested"""
     filepath = os.path.join('testfiles', 'testdir', 'test.tar.gz')
     fw = FileWriter(filepath)
     fw.write("test")
     if not file_exists(filepath):
         raise RuntimeError("Missing test file for the unit test")
     http = HTTP("https://github.com/chrissimpkins/six-four/tarball/master")
     http.get_bin_write_file(filepath, overwrite_existing=True)
     self.assertTrue(file_exists(filepath))
예제 #12
0
 def test_http_get_binary_file_exists_request_overwrite(self):
     """Test HTTP GET request and write binary file executes the write when the file exists and overwrite requested"""
     filepath = os.path.join('testfiles', 'testdir', 'test.tar.gz')
     fw = FileWriter(filepath)
     fw.write("test")
     if not file_exists(filepath):
         raise RuntimeError("Missing test file for the unit test")
     http = HTTP("https://github.com/chrissimpkins/six-four/tarball/master")
     http.get_bin_write_file(filepath, overwrite_existing=True)
     self.assertTrue(file_exists(filepath))
예제 #13
0
 def test_http_get_text_exists_request_overwrite(self):
     """Test HTTP GET request with text file write does overwrite existing file when requested to do so"""
     filepath = os.path.join('testfiles', 'testdir', 'test.txt')
     http = HTTP(
         'https://raw.github.com/chrissimpkins/six-four/master/LICENSE')
     fw = FileWriter(filepath)
     fw.write("test")
     http.get_txt_write_file(filepath, overwrite_existing=True)
     self.assertEqual(
         FileReader(filepath).read().strip(), self.http_string.strip())
예제 #14
0
 def test_file_gzip_utf8_readwrite_explicit_decode(self):
     """Test gzip compression and read from compressed unicode text file with explicit utf-8 decode"""
     if state.py2:
         FileWriter(self.unicode_path).gzip(self.unicode_string)
         gzip_contents = FileReader(self.unicode_path + ".gz").read_gzip("utf-8") # when read with explicit utf-8 decoding, strings should match
         self.assertEqual(gzip_contents, self.unicode_string)
     elif state.py3:
         FileWriter(self.unicode_path).gzip(bytes(self.unicode_string, 'utf-8'))
         gzip_contents = FileReader(self.unicode_path + ".gz").read_gzip("utf-8") # when read with explicit utf-8 decoding, strings should match
         self.assertEqual(gzip_contents, self.unicode_string)
예제 #15
0
파일: build.py 프로젝트: tstyle/doxx
 def write_project_runner_key(self, project_key_path):
     key_data_string = "\n\n"  # maintain a couple of newlines between the build specification section and the key data section
     if len(self.key_data) > 0:
         for the_key in self.key_data:
             key_data_string = key_data_string + the_key + ": " + self.key_data[the_key] + "\n" # recreate the YAML from the local key.yaml file to append to the project.yaml file
     # if there is no key data, not necessary to write any additional data to the file.  when doxx key is instantiated it will handle the lack of replacement data
     
     # append the local key file ('key.yaml') key data to the project meta data to prepare for the build
     try:
         fw = FileWriter(project_key_path)
         fw.append(key_data_string)  # append local key data to the project.yaml file
     except Exception as e:
         stderr("[!] doxx: Unable to write the temporary key file for your project build. Error: " + str(e), exit=1)
예제 #16
0
    def test_file_ascii_safewrite(self):
        """Test safe_write() to confirm does not overwrite existing file"""
        os.remove(self.ascii_path) #remove the existing text file for tests
        if os.path.exists(self.ascii_path):
            raise IOError("The ascii test file was not deleted. (test_IO.py.test_file_ascii_safewrite)")
        else:
            safe_response = FileWriter(self.ascii_path).safe_write(self.ascii_string) # attempt safe_write when no preexisting file present
            ascii_text = FileReader(self.ascii_path).read()
            self.assertEqual(ascii_text, self.ascii_string) # assert that the correct text was written
            self.assertEqual(safe_response, True) # assert that returns True when file not present and writes

            if os.path.exists(self.ascii_path):
                    self.assertEqual(FileWriter(self.ascii_path).safe_write(self.ascii_string), False) #confirm that returns False to calling function when there is a pre-existing file
            else:
                raise IOError("The ascii test file is not present (test_IO.py.test_file_ascii_safewrite)")
예제 #17
0
 def test_file_ascii_readwrite_string_type(self):
     FileWriter(self.ascii_path).write(self.ascii_string) # file write
     ascii_text = FileReader(self.ascii_path).read() # file read
     if state.py2:
         self.assertEqual(type(unicode("test string")), type(ascii_text)) #python 2 treats all input as unicode type
     elif state.py3:
         self.assertEqual(type(str("test string")), type(ascii_text)) #python 3 treats all input as str
예제 #18
0
 def test_file_readutf8_writeutf8_string_type(self):
     FileWriter(self.unicode_path).write_utf8(self.unicode_string)
     unicode_text = FileReader(self.unicode_path).read_utf8()
     if state.py2:
         self.assertEqual(type(unicode("test string")), type(unicode_text)) # confirm that python2 treats as unicode
     elif state.py3:
         self.assertEqual(type(str("test string")), type(unicode_text)) # confirm that python3 treats as str
예제 #19
0
파일: pull.py 프로젝트: tstyle/doxx
def pull_text_file(url, text_file_name):
    """pulls a remote text file and writes to disk"""
    # pull the binary file data
    http = HTTP(url)
    try:
        if http.get_status_ok():
            text_data = http.res.text
            # write text data to disk
            try:
                fw = FileWriter(text_file_name)
                fw.write(text_data)
            except Exception as e:
                stderr("[!] doxx: File write failed for '" + text_file_name + "'.  Error: " + str(e), exit=1)
        else:
            fail_status_code = http.res.status_code
            stderr("[!] doxx: Unable to pull '" + url + "' (HTTP status code " + str(fail_status_code) + ")", exit=1)
    except Exception as e:
        stderr("[!] doxx: Unable to pull '" + url + "'. Error: " + str(e), exit=1)
예제 #20
0
 def setUp(self):
     self.sysfilepath = make_path("testfiles", "testdir", "systest.txt")
     self.sysdirpath = make_path("testfiles", "testdir")
     self.bogusfilepath = make_path("testfiles", "testdir",
                                    "bogusfile.text")
     self.metafilepath = make_path("testfiles", "keep", "metadata.txt")
     self.dir_file_path = make_path("testfiles", "keep")
     self.dir_file_list = [
         "file1.txt", "file2.txt", "file3.py", "metadata.txt", "test.tar.gz"
     ]
     FileWriter(self.sysfilepath).write("test")
예제 #21
0
파일: pullkey.py 프로젝트: tstyle/doxx
def run_pullkey(package_name):
    normalized_package_name = package_name.lower().strip()
    package = OfficialPackage()
    key_file_url = package.get_package_key_url(normalized_package_name)
    try:
        stdout("[*] doxx: Pulling the remote key file...")
        http = HTTP(key_file_url)
        if http.get_status_ok():
            key_file_text = http.res.text
            fr = FileWriter('key.yaml')
            try:
                fr.write(key_file_text)
            except Exception as e:
                stderr("[!] doxx: Unable to write the 'key.yaml' file to disk. Error: " + str(e), exit=1)
            stdout("[*] doxx: Key file pull complete")
        elif http.res.status_code == 404:
            stderr("[!] doxx: Unable to pull the key file because the requested package could not be found. (HTTP status code: 404)", exit=1)
        else:
            stderr("[!] doxx: Unable to pull the key file.  (HTTP status code: " + str(http.res.status_code) + ")", exit=1)
    except Exception as e:
        stderr("[!] doxx: Unable to pull the key file. Error: " + str(e), exit=1)
        
예제 #22
0
파일: pull.py 프로젝트: tstyle/doxx
def decompress_gzip(gz_filename):
    """decompress gzip compressed file"""
    # decompress the gzip'd file
    f = gzip.open(gz_filename, 'rb')
    file_content = f.read()
    f.close()
    
    # monkeypatch for Python 3 byte string read issue
    if is_py3():
        file_content = str(file_content)
    
    # get the base file name for the decompressed file write
    filename_split = gz_filename.split('.')
    if len(filename_split) == 2:
        basename = filename_split[0]
    elif len(filename_split) > 2:
        basename = filename_split[0] + '.' + filename_split[1]  # concatenate first two parts of file name (e.g. example + '.' + 'tar' )
    else:
        basename = gz_filename
        
    # write the file locally
    fw = FileWriter(basename)
    fw.write(file_content)
예제 #23
0
파일: make.py 프로젝트: tstyle/doxx
 def make_project(self):
     try:
         # project.yaml file write
         fw_projyaml = FileWriter('project.yaml')
         fw_projyaml.write(project_yaml_stub)
         
         # pkey.yaml file write
         fw_pkey = FileWriter('pkey.yaml')
         fw_pkey.write(key_stub)
         
         # templates directory write
         if not dir_exists('templates'):
             os.mkdir('templates')
             
         # template.doxt file in templates directory
         template_stub_path = os.path.join('templates', 'stub.doxt')
         fw_template = FileWriter(template_stub_path)
         fw_template.write(template_stub)
         
         # confirm for user
         if file_exists('project.yaml'):
             stdout("[+] doxx: 'project.yaml' ... check")
         else:
             stderr("[!] doxx: There was an error writing the 'project.yaml' key file to your project directory")
             
         if file_exists('pkey.yaml'):
             stdout("[+] doxx: 'pkey.yaml' ... check")
         else:
             stderr("[!] doxx: There was an error writing the 'pkey.yaml' key file to your project directory")
             
         if file_exists(template_stub_path):
             stdout("[+] doxx: '" + template_stub_path + "' ... check")
         else:
             stderr("[!] doxx: There was an error writing the '" + template_stub_path + "' template file to your project directory")
     except Exception as e:
         stderr("[!] doxx: Unable to write project files to disk.  Error: " + str(e), exit=1)
예제 #24
0
 def replace_test_files(self):
     """replace the erased test files in the test directories"""
     # replace the files in the with-only-templates directory
       # make the directory
     if not dir_exists(make_path(self.onlytemplates_dir, 'templates')):
         os.makedirs(make_path(self.onlytemplates_dir, 'templates'))
         
     with_only_templates_files = ['key.yaml', 'pkey.yaml', 'project.yaml', 'templates/404.doxt', 'templates/index.doxt', 'templates/normalize.doxt']
     
     for the_file in with_only_templates_files:
         fw = FileWriter(make_path(self.onlytemplates_dir, the_file))
         fw.write("unimportant text")
         
     # replace the files in the with-templates-other-files directory
         # make the directory if not present
     if not dir_exists(make_path(self.otherfiles_dir, 'templates')):
         os.makedirs(make_path(self.otherfiles_dir, 'templates'))
         
     with_other_files = ['key.yaml', 'pkey.yaml', 'project.yaml', 'templates/404.doxt', 'templates/index.doxt', 'templates/normalize.doxt', 'templates/dontdeleteme.txt']
     for the_file in with_other_files:
         fw = FileWriter(make_path(self.otherfiles_dir, the_file))
         fw.write("unimportant text")
예제 #25
0
파일: build.py 프로젝트: tstyle/doxx
    def multi_process_run(self, template_path, iolock, outputlock):
        """Render replacements over multiple template files as defined in doxx key file using multiple processes (public method)"""
        #-------------------------------------------------------------------------------
        # NOTE : changes in this method require the same changes to single_template_run
        #-------------------------------------------------------------------------------
        ## Load the data
        if len(template_path) > 6 and (template_path[0:7] == "http://" or template_path[0:8] == "https://"):
            template = RemoteDoxxTemplate(template_path)
            try:
                result = template.load_data()  # load remote template file through HTTP or HTTPS protocol
                if result[0] == False:  # if the method responds False, then HTTP data load was not successful
                    outputlock.acquire()
                    stderr(result[1], exit=0)  # write out the returned error message in result[1] position of the tuple
                    outputlock.release()
                    sys.exit(1)  # release the lock before raising SystemExit
            except Exception as e:
                outputlock.acquire()
                stderr("[!] doxx: Unable to load the remote template file '" + template_path + "'. Error message: " + str(e), exit=0)
                outputlock.release()
                sys.exit(1)  # release the lock before raising SystemExit
        elif file_exists(template_path):
            template = DoxxTemplate(template_path)
            
            iolock.acquire()  # acquire the IO lock for template file read
            try:
                template.load_data()  # load local data
            except Exception as e:
                outputlock.acquire()
                stderr("[!] doxx: Unable to read the local template file '" + template_path + "'. Error message: " + str(e), exit=0)
                outputlock.release()
                sys.exit(1)  # release the lock before raising SystemExit
            iolock.release()  # release the IO lock for template file read
        else:
            outputlock.acquire()  # acquire the stderr lock
            stdout("[!] doxx: Unable to find the requested template file " + template_path)  # print error message in standard output, multi-file run so do not end execution of application       
            outputlock.release()  # release the stderr lock

        ## Split the data
        try:
            template.split_data()  # split the data sections
        except Exception as e:
            outputlock.acquire()
            stderr("[!] doxx: Unable to parse the template data.  Please verify the template syntax and try again.  Error message: " + str(e), exit=0)
            outputlock.release()
            sys.exit(1)  # release the lock before raising SystemExit
            
        ## Parse the data for errors
        error_parse_result = template.parse_template_for_errors()
        
        if error_parse_result[0] == True:          # if there was a parsing error
            outputlock.acquire()
            stderr(error_parse_result[1], exit=0)  # print the returned error message to stderr and exit application
            outputlock.release()
            sys.exit(1)  # release the lock before raising SystemExit
    
        ## Parse the template text
        try:
            template.parse_template_text()
        except Exception as e:
            outputlock.acquire()
            stderr("[!] doxx: An error occurred during the attempt to parse the template file. Error message: " + str(e), exit=0)
            outputlock.release()
            sys.exit(1)  # release the lock before raising SystemExit
        
        # determine whether this is a verbatim template file (no replacements) or the key file did not include replacement keys
        if template.verbatim is True or self.no_key_replacements is True:
            # write template.text out verbatim
            try:
                # if the requested destination directory path does not exist, make it
                outfile_dir_path = make_path(os.path.dirname(self.key_path), os.path.dirname(template.outfile))
                try:
                    iolock.acquire()
                    if not outfile_dir_path == '' and not dir_exists(outfile_dir_path):
                        make_dirs(outfile_dir_path)
                    iolock.release()
                except Exception as e:
                    iolock.release()  # release the lock then re-raise the exception
                    raise e
                # write the file
                outfile_path = make_path(os.path.dirname(self.key_path), template.outfile)
                # then write the file out verbatim
                try:
                    iolock.acquire()
                    fw = FileWriter(outfile_path)
                    fw.write(template.text)
                    iolock.release()
                except Exception as e:
                    iolock.release()  # catch and release the iolock before re-raising the exception
                    raise e
                
                outputlock.acquire()
                stdout("[+] doxx: -- " + outfile_path + " ... check")
                outputlock.release()
            except Exception as e:
                outputlock.acquire()
                stderr("[!] doxx: There was a file write error with '" + template_path + "'. Error message: " + str(e), exit=0)
                outputlock.release()
                sys.exit(1)  # release the lock before raising SystemExit
        else:
            # template meta data is in template.meta_data
            # template text is in template.text
            # perform the text replacements:
            try:
                ink_template = InkTemplate(template.text)
                ink_renderer = InkRenderer(ink_template, self.key_data)
                rendered_text = ink_renderer.render()
            except Exception as e:
                outputlock.acquire()
                stderr("[!] doxx: An error occurred during the text replacement attempt.  Error message: " + str(e), exit=0)            
                outputlock.release()
                sys.exit(1)  # release the lock before raising SystemExit
        
            # if the requested destination directory path does not exist, make it
            outfile_dir_path = make_path(os.path.dirname(self.key_path), os.path.dirname(template.outfile))
            try:
                iolock.acquire()
                if not outfile_dir_path == '' and not dir_exists(outfile_dir_path):
                    make_dirs(outfile_dir_path)
                iolock.release()
            except Exception as e:
                outputlock.acquire()
                stderr("[!] doxx: Unable to create directory path '" + outfile_dir_path + "' for your file write. Error: " + str(e), exit=0)
                outputlock.release()
                iolock.release()
                sys.exit(1)  # release the iolock before raising SystemExit
                
            outfile_path = make_path(os.path.dirname(self.key_path), template.outfile)
            
            try:
                iolock.acquire()
                fw = FileWriter(outfile_path)
                fw.write(rendered_text)
                iolock.release()
            except Exception as e:
                outputlock.acquire()
                stderr("[!] doxx: Unable to write the file '" + outfile_path + "'. Error: " + str(e), exit=0)
                outputlock.release()
                iolock.release()
                sys.exit(1)  # release the iolock before raising SystemExit
                
            outputlock.acquire()
            stdout("[+] doxx: -- " + outfile_path + " ... check")
            outputlock.release()
예제 #26
0
파일: build.py 프로젝트: tstyle/doxx
 def single_template_run(self, template_path):
     """Render replacements using a single template file as defined in a doxx key file (public method)"""
     #----------------------------------------------------------------------------
     # NOTE : changes in this method require the same changes to multi_process_run
     #----------------------------------------------------------------------------       
     ## Load the data
     # remote templates
     if len(template_path) > 6 and (template_path[0:7] == "http://" or template_path[0:8] == "https://"):
         template = RemoteDoxxTemplate(template_path)
         try:
             result = template.load_data()
             if result[0] == False:  # if the method responds False, then HTTP data load did not work
                 stderr(result[1], exit=1)  # write out the returned error message in result[1] position of the tuple
                 # halt execution if unsuccessful
         except Exception as e:
             stderr("[!] doxx: Unable to load the remote template file '" + template_path + "'. Error message: " + str(e), exit=1)
     # local templates        
     elif file_exists(template_path):
         template = DoxxTemplate(template_path)
         try:
             template.load_data()
         except Exception as e:
             stderr("[!] doxx: Unable to read the local template file '" + template_path + "'. Error message: " + str(e), exit=1)
     else:
         stderr("[!] doxx: Unable to find the requested template file " + template_path, exit=1)  # print error message and halt execution of application
      
     ## Split the data  
     try:
         template.split_data()
     except Exception as e:
         stderr("[!] doxx: Unable to parse the template data.  Please verify the template syntax and try again.  Error message: " + str(e), exit=1)
     
     ## Parse data for errors
     error_parse_result = template.parse_template_for_errors()
     
     if error_parse_result[0] == True:          # if there was a parsing error
         stderr(error_parse_result[1], exit=1)  # print the returned error message to stderr and exit application
     
     ## Then parse the template text and load instance attributes for the text replacement with Ink below
     try:
         template.parse_template_text()
     except Exception as e:
         stderr("[!] doxx: An error occurred while parsing the template file. Error message: " + str(e), exit=1)
 
     # determine whether this is a verbatim template file (no replacements) or the key file did not include replacement keys
     if template.verbatim is True or self.no_key_replacements is True:
         # write template.text out verbatim
         try:
         # if the requested destination directory path does not exist, make it
             outfile_dir_path = make_path(os.path.dirname(self.key_path), os.path.dirname(template.outfile))
             if not outfile_dir_path == '' and not dir_exists(outfile_dir_path):
                 make_dirs(outfile_dir_path)
             # write the file
             outfile_path = make_path(os.path.dirname(self.key_path), template.outfile)
             fw = FileWriter(outfile_path)
             fw.write(template.text)
             stdout("[+] doxx: '" + outfile_path + "' build... check")
         except Exception as e:
             stderr("[!] doxx: There was a file write error. Error message: " + str(e), exit=1)        
     else:
         # template meta data is in template.meta_data
         # template text is in template.text
         # perform the text replacements:         
         try:
             ink_template = InkTemplate(template.text)
             ink_renderer = InkRenderer(ink_template, self.key_data)
             rendered_text = ink_renderer.render()
         except Exception as e:
             stderr("[!] doxx: An error occurred during the text replacement attempt.  Error message: " + str(e), exit=1)
     
         # if the requested destination directory path does not exist, make it
         outfile_dir_path = make_path(os.path.dirname(self.key_path), os.path.dirname(template.outfile))
         if not outfile_dir_path == '' and not dir_exists(outfile_dir_path):
             make_dirs(outfile_dir_path)
 
         # write rendered file to disk
         try:
             outfile_path = make_path(os.path.dirname(self.key_path), template.outfile)
             fw = FileWriter(outfile_path)
             fw.write(rendered_text)
             stdout("[+] doxx: -- " + outfile_path + " ... check")
         except Exception as e:
             stderr("[!] doxx: There was an error with the rendered file write. Error message: " + str(e), exit=1)
예제 #27
0
 def test_file_utf8_append_works_with_utf8(self):
     FileWriter(self.unicode_path).write_utf8(self.unicode_string)
     FileWriter(self.unicode_path).append(self.unicode_string)
     unicode_text = FileReader(self.unicode_path).read_utf8()
     self.assertTrue(len(unicode_text)>0)
     self.assertEqual(unicode_text, (self.unicode_string*2))
예제 #28
0
 def test_file_utf8_readas_writeas(self):
     """Test read_as & write_as with utf-8 encoding"""
     FileWriter(self.unicode2_path).write_as(self.unicode_string, "utf-8")
     unicode_text = FileReader(self.unicode2_path).read_as("utf-8")
     self.assertEqual(unicode_text, self.unicode_string)
예제 #29
0
 def test_file_utf8_write_noraise_unicodeerror(self):
     """Test write of a utf-8 file with write method does not raise UnicodeEncodeError in Python 2 or 3"""
     FileWriter(self.unicode_path).write(self.unicode_string)
     unicode_text = FileReader(self.unicode_path).read_utf8()
     self.assertEqual(self.unicode_string, unicode_text)
예제 #30
0
 def test_file_append_utf8_missing_file(self):
     """Test append of unicode text raises IOError when file missing"""
     with (self.assertRaises(IOError)):
         FileWriter(self.bogus_path).append_utf8(self.unicode_string)
예제 #31
0
 def test_file_bin_readwrite(self):
     """Test read and write of binary data"""
     FileWriter(self.binary_path).write_bin(self.binary_string)
     bin_data = FileReader(self.binary_path).read_bin()
     self.assertEqual(bin_data, self.binary_string)
예제 #32
0
 def test_file_utf8_readwrite_noraise_unicodeerror(self):
     """Test read and write does not raise unicode errors in Python 2 or 3"""
     FileWriter(self.unicode_path).write(self.unicode_string)
     unicode_text = FileReader(self.unicode_path).read()
     self.assertEqual(self.unicode_string, unicode_text)
예제 #33
0
 def test_file_ascii_readwrite(self):
     """Test write and read of ascii encoded file"""
     FileWriter(self.ascii_path).write(self.ascii_string) # file write
     ascii_text = FileReader(self.ascii_path).read() # file read
     self.assertEqual(ascii_text, self.ascii_string)
예제 #34
0
 def test_file_append_missing_file(self):
     """Test append of ascii text raises IOError when file missing"""
     with (self.assertRaises(IOError)):
         FileWriter(self.bogus_path).append(self.ascii_string)
예제 #35
0
 def test_file_readlines(self):
     """Test line reads with ascii text"""
     FileWriter(self.multiline_path).write(self.multiline_string)
     line_list = FileReader(self.multiline_path).readlines()
     self.assertEqual(line_list, self.multiline_list)
예제 #36
0
 def test_file_utf8_readwrite(self):
     """Test write and read of a utf-8 encoded file"""
     FileWriter(self.unicode_path).write_utf8(self.unicode_string)
     unicode_text = FileReader(self.unicode_path).read_utf8()
     self.assertEqual(unicode_text, self.unicode_string)
예제 #37
0
 def test_file_readlines_unicode(self):
     """Test line reads with unicode text"""
     FileWriter(self.unicode_path).write_utf8(self.multiline_unicode_string)
     line_list = FileReader(self.unicode_path).readlines_utf8()
     self.assertEqual(line_list, self.uni_multi_list)
예제 #38
0
 def test_file_readlines_as_ascii(self):
     """Test line reads with readlines_as from ascii file"""
     FileWriter(self.ascii_path).write(self.multiline_string)
     line_list = FileReader(self.ascii_path).readlines_as("ascii")
     self.assertEqual(line_list, self.multiline_list)
예제 #39
0
 def test_file_ascii_readwrite_append(self):
     """Test append of ascii text to existing file"""
     FileWriter(self.ascii_path).append(self.ascii_string) #append a second string of the ascii text
     ascii_text = FileReader(self.ascii_path).read()
     self.assertEqual(ascii_text, (self.ascii_string)*2) #confirm that it equals two of the ascii strings
예제 #40
0
 def test_file_bin_read_unicode_as_bin(self):
     """Test read of unicode as binary with decode"""
     FileWriter(self.unicode_path).write_utf8(self.unicode_string)
     bin_data = FileReader(self.unicode_path).read_bin() #read unicode file as binary
     uni_text = bin_data.decode("utf-8") #decode to utf-8
     self.assertEqual(uni_text, self.unicode_string)
예제 #41
0
 def test_file_readlines_as_utf8(self):
     """Test line reads with readlines_as from utf8 file"""
     FileWriter(self.unicode_path).write_utf8(self.multiline_unicode_string)
     line_list = FileReader(self.unicode_path).readlines_as("utf-8")
     self.assertEqual(line_list, self.uni_multi_list)