def __createProjectConfig( self ):
message( LOC["CONFIGING_PROJECT"] )
name = self["project_name"] + ".sublime-project"
filename = os.path.join( self["project_directory"], name ).replace( "\\", "/" )
self.__terr.expanData({
"title" : LOC["CREATE_PROJECT_FAIL"],
"error" : LOC["CONFIG_PROJECT_FAIL"],
"file" : filename
})
self.__terr.setTemple(
"${title}\n"
"${error}\n"
"${file}"
)
d = {
"project_name" : self["project_name"]
}
temp = StringTemple( "", self.__dict )
content = ""
with open( self.__projectconfig, "r" ) as fobj:
content += fobj.read()
try:
fobj = open( filename, "w" )
fobj.write( temp.parse( content ) )
except Exception, e:
raise e
def __importTemple( self, temple, project, override = False ):
fqueue = Queue( 0, [ temple ] )
temple = altsep( temple )
project= altsep( project )
while True:
if fqueue.empty(): break
src_dir = altsep( fqueue.get() )
des_dir = src_dir.replace( temple, project )
items = os.listdir( src_dir )
message( "directory:" + src_dir, c = DEBUG )
for item in items:
src = os.path.join( src_dir, item )
des = os.path.join( des_dir, item )
message( "file: " + src, c = DEBUG )
if os.path.isdir( src ):
if not os.path.isdir( des ):
os.makedirs( des )
message( "create directory: " + des, c = DEBUG )
fqueue.put( src )
else:
if not os.path.isfile( des ) or override:
shutil.copy2( src, des )
message( "copy file: " + src, c = DEBUG )
else:
message( "ignore file:" + src, c = DEBUG )
def run(self):
JProject.moduleInit( __name__ )
self.__templist = []
try:
self.__getTempleList()
except Exception, e:
sublime.error_message( LOC["GET_TEMPLE_LIST_FAIL"] )
message( "REAL_ERROR: " + str(e), c = DEBUG )
def __openProject(self):
message( LOC["OPENNING_PROJECT"] )
os.spawnv(
os.P_NOWAIT,
SUBLIME_APP_PATH,
[ '\k', '"%s"' % ( self["project_config_file"] ) ]
)
message( LOC["CREATE_PROJECT_SUCCESS"] )
def __onInputDone( self, index ):
if index == -1: return None
override = sublime.ok_cancel_dialog( LOC["CONFIRM_IMPORT_OVERRIDE"] )
try:
self.__importTemple( self.__templist[index], self.window.folders()[0], override )
except Exception, e:
print e
sublime.error_message( LOC["IMPORT_TEMPLE_FAIL"] )
message( "REAL_ERROR: " + str(e), c = DEBUG )
def __createReleaseDir( self ):
releasepath = os.path.join(
self.__projectpath,
"%s-V%s" % (
self.__config["name"],
self.__config["release"]["variables"]["version"]
)
)
if os.path.isdir( releasepath ):
if DEBUG:
shutil.rmtree( releasepath, True )
else:
raise XError( "directory:<%s> already exists" % (releasepath) )
os.makedirs( releasepath, 0777 )
#DEBUG
message( "RELEASE_PATH: " + releasepath, c = DEBUG )
self.__releasepath = releasepath
def __onInputDone( self, instr ):
message( LOC["WAIT_PLEASE"] )
while True:
if len(instr) == 0:
self.__showInputPanel(False)
return
break
self[self.__input[0]] = instr
callbacks = self.__input[4]
try:
if callbacks:
for callback in callbacks:
callback()
self.__showInputPanel()
except Exception, e:
sublime.error_message( self.__terr.parse() )
self.__terr.setTemple("")
message( "REAL-ERROR: " + str(e), c = DEBUG )
return None
def __showInputPanel( self, new = True ):
if new:
if self.__iqueue.empty():return None
self.__input = self.__iqueue.get()
elif self.__input == None:
return None
message( self.__input[1] )
initinput = self.__input[3]
if initinput and type(initinput) != str:
initinput = initinput()
self.window.show_input_panel(
self.__input[2],
initinput,
self.__onInputDone,
None,
None
)
def __createProjectDestory( self ):
message( LOC["WAIT_PLEASE"] )
name = self["project_name"]
directory = self["project_directory"] = self["project_directory"].replace( "\\", "/" )
self.__terr.expanData({
"title" : LOC["CREATE_PROJECT_FAIL"],
"error" : LOC["CREATE_PROJECT_DIR_FAIL"],
"description" : LOC["DIRECTORY_EXIST"],
"file" : directory
})
self.__terr.setTemple(
"${title}\n"
"${error}\n"
"${description}\n"
"${file}"
)
if os.path.isdir( directory ):
raise XError( "file:<%s> already exists" % (directory) )
os.makedirs( directory, 0777 )
CFG.set( "work_space", os.path.dirname( directory ) )
sublime.save_settings("JProject.sublime-settings")
message( LOC["CREATE_PROJECT_DIR_SUCCESS"] )
def run( self ):
JProject.moduleInit( __name__ )
self.__folders = self.window.folders()
self.__projectpath = self.__folders[0]
self.__config = None
self.__files = []
self.__releasepath = ""
self.__error = ""
message( LOC["RELEASE_PROJECT"] )
for func, msg, errmsg in [
( self.__getProjectConfigFile, "" , LOC["INVALID_PROJECT_CONFIG"] ),
( self.__releaseConfirm , "" , "" ),
( self.__getProjectConfig , LOC["GET_PROJECT_CONFIG"] , LOC["GET_PROJECT_CONFIG_FAIL"] ),
( self.__checkProjectConfig , LOC["CHECK_PROJECT_CONFIG"], LOC["INVALID_PROJECT_CONFIG"] ),
( self.__createReleaseDir , LOC["CREATE_RELEASE_DIR"] , LOC["CREATE_RELEASE_DIR_FAIL"] ),
( self.__copyFileToRelease , LOC["COPY_FILE_TO_RELEASE"], LOC["COPY_FILE_TO_RELEASE_FAIL"] ),
( self.__replaceTag , LOC["REPLACE_TAG"] , LOC["REPLACE_TAG_FAIL"] ),
( self.__openReleaseDir , "" , "")
]:
message( msg )
try:
if func(): break
except Exception, e:
sublime.error_message(
JProjectReleaseCommand.FAIL_message_FORMAT % (
LOC["RELEASE_PROJECT_FAIL"],
errmsg
)
)
if self.__releasepath:
shutil.rmtree( self.__releasepath, True )
#DEBUG
message( "REAL-ERROR: " + str(e), c = DEBUG )
return None
def __replaceTag( self ):
cfg = self.__config["release"]
ig_file_exts = cfg["ignore_file_exts"]
data = { "project_name" : self.__config["name"] }
data.update( cfg["variables"] )
tobj = StringTemple( "", data )
DATE_FORMAT = LOC["DATE_FORMAT"]
TIME_FOMAT = "%H:%M:%S"
DTIME_FORMAT = "%s %s" % ( DATE_FORMAT, TIME_FOMAT )
replace_scope= CFG.get("replace_scope")
#DEBUG
message(
" IG_FILE_EXTS : %s" % ( ig_file_exts ),
c = DEBUG,
prefix = ""
)
for path in self.__files:
ext = os.path.splitext( path )[1].lower()
rpath = path.replace( os.path.dirname( self.__releasepath ), "" )
if ext in ig_file_exts:
message( " [IGNORE]" + rpath, c = DEBUG, prefix = "" )
continue
message( " [REPLACE]" + rpath, c = DEBUG, prefix = "" )
localtime = time.localtime()
tobj.expanData( {
"FILE" : os.path.basename( path ),
"PATH" : os.path.dirname( path ),
"MDATE": time.strftime( DTIME_FORMAT, time.localtime( os.path.getctime( path ) ) ),
"TIME" : time.strftime( TIME_FOMAT , localtime ),
"DATE" : time.strftime( DATE_FORMAT , localtime )
} )
temp = ""
with open( path, "r" )as fobj: temp += fobj.read()
size = len( temp )
#temp = temp.decode("utf8")
content = ""
for item in replace_scope:
if ext not in item["file_ext"]: continue
scopes = []
start = 0
pattern = re.compile( item["pattern"] )
content = ""
tobj.setTemple( "" )
while start < size:
region = re.search( pattern, temp[start:] )
if region:
offset_start = start + region.start()
offset_end = start + region.end()
# print offset_start, offset_end
part = temp[ offset_start:offset_end ]
space = temp[ start:offset_start ]
scopes.append( part )
if re.search( JProjectReleaseCommand.WRITESPACE_RE_PATTERN, space ):
tobj.expanTemple( space + part )
else:
content += tobj.parse() + temp[ start:offset_start ]
tobj.setTemple( part )
start = offset_end
else:
break
content += tobj.parse() + temp[ start: ]
#content = content.encode("utf8")
#DEBUG
if DEBUG:
message(
" %s\n"
" %s\n"
" ---REPLACE SCOPE---\n"
" %s\n"
" -------" % (
item["pattern"],
",".join( item["file_ext"] ),
"\n ".join( [
re.sub( "\n", "\n ", scope.decode("utf8") ) \
for scope in scopes
] )
),
c = DEBUG,
prefix = ""
)
if content:
try:
fobj = open( path, "w" )
fobj.write( content )
except IOError:
raise IOError
finally:
fobj.close()
def __copyFileToRelease( self ):
releasepath = self.__releasepath
qdirs = Queue( 0, [] )
ig_cfg = self.__config["release"]["ignore"]
ig_file_re_patterns = [ re.compile(pattern) for pattern in ig_cfg["file"] ]
ig_folder_re_patterns = [ re.compile(pattern) for pattern in ig_cfg["folder"] ]
ig_folder_re_patterns2= self.__config["release"]["ignore_folder"]
#DEBUG
message(
" IG_FOLDER_P : %s\n"
" IG_FILE_P : %s" % (
ig_cfg["folder"],
ig_cfg["file"]
),
c = DEBUG,
prefix = ""
)
ignore = lambda s,p: bool( [
r for r in p if re.search( r, s )
] )
for folder in self.__folders:
if len(self.__folders) == 1:
root = folder
else:
root = os.path.dirname( folder )
qdirs.put( folder )
message( ">> " + os.path.basename( folder ), prefix = "" )
while True:
if qdirs.empty(): break
directory = qdirs.get()
basedir = os.path.basename( directory )
if ignore( basedir, ig_folder_re_patterns ):
#DEBUG
message( " [-]" + basedir, c = DEBUG, prefix = "" )
continue
new_directory = directory.replace( root, releasepath )
if new_directory != releasepath:
os.makedirs( new_directory )
#DEBUG
message( " [+]" + basedir, c = DEBUG, prefix = "" )
files = os.listdir( directory );
for item in files:
if ignore( item, ig_file_re_patterns ):
#DEBUG
message( " [-]" + item, c = DEBUG, prefix = "" )
continue
path = os.path.join( directory, item )
if os.path.isdir( path ):
qdirs.put( path )
continue
new_path = os.path.join( new_directory, item )
shutil.copyfile( path, new_path )
if not ignore( basedir, ig_folder_re_patterns2 ):
self.__files.append( new_path )
#DEBUG
message( " [+]" + item, c = DEBUG, prefix = "" )
message( "-------------------------------------------", c = DEBUG, prefix = "" )
d = {
"project_name" : self["project_name"]
}
temp = StringTemple( "", self.__dict )
content = ""
with open( self.__projectconfig, "r" ) as fobj:
content += fobj.read()
try:
fobj = open( filename, "w" )
fobj.write( temp.parse( content ) )
except Exception, e:
raise e
finally:
fobj.close()
self["project_config_file"] = filename
message( LOC["CONFIG_PROJECT_SUCCESS"] )
def __openProject(self):
message( LOC["OPENNING_PROJECT"] )
os.spawnv(
os.P_NOWAIT,
SUBLIME_APP_PATH,
[ '\k', '"%s"' % ( self["project_config_file"] ) ]
)
message( LOC["CREATE_PROJECT_SUCCESS"] )
def __getitem__( self, key ): return self.__dict[key]
def __setitem__( self, key, value ): self.__dict[key] = value
