Bit će toliko dugo (ne)koristiš da se sintaksa u međuvremenu skroz izmjenila. Jer ono što je po tvom korištenju regex, nitko danas niđe vidio.
Mislim zaista… još uvijek tvrdiš da su regex izrazi oni selektori za file system koje si postavio? Jel ti to opet muhom pokušavaš zgradu srušit?
Ok si lik (ponekad) … al stvarno ti ne treba što si tvrdoglav ko jarac kad nisi u pravu.
…tj. nakon što bubneš takvu gluoost.
Nema mi gore osobine u čovjeka, nego kada tako očigledno nije u pravu… a ponos mu neda da se ispravi. Baš ono žali Bože karaktera … u suradnji bi radije bio sa potpunim idiotom koji je spreman nešto usvojiti…nego sa full nafilanim znanjem, ali koji ne može prihvatiti da je pogriješio…i onda mućenje vode…nabacivanje nekih nedorečenih linkova… pozivanje na izjave poput …
Nauči materiju, šta da ti kažem. Nisam ja taj koji svaki treći dan ima neki problem koji usljed opšteg nivoa neznanja ne uspijeva apstrahovati i konsekventno - riješiti. Ja sam onaj drugi, što rješava takvima probleme.
Priznaj da si prvi put u životu vidio look behind, look ahead i yagni termine.
To neće promjenit tvoju izrečenu glupost da je ono regex sintaksa…to je samo nastavak mućenja vode, tvoj uobičajeni bijeg.
Što se uopće zamaram s tobom kada imaš obraza sra**, a nemaš obraza stati iza svojih riječi. Ja to zovem kukavicama (da ostanem pristojan) i trudim se nemati posla sa takvima. Uživaj u danu.
Ovdje je bilo korisnik dodataka…malo sam se ažurirao.
// regpath spec. comands included without activating regex:
script.* -> * - zamjenjuje bilo koji karakter, koliko god pojavki karaktera ili niti jedan.
script.??? -> ? - zamjenjuje bilo koji karakter, ali isključivo jedan koji se mora nalaziti na poziciji upitnika
scrip[tr].txt -> [] - uglata zagrada matcha bilo koji karakter koji se nalazi u zagradi
scrip[!tr].txt -> [!] - uglata zagrada sa uskličnikom na prvom mjestu matcha bilo koji karakter koji se NE nalazi u zagradi
script\d.txt -> \d - selektira digit char. Dostupni svi selektori iz regexa: \d \D \w \W ...itd
script\d{3} -> {3} - dostupno numeriranje ponavljanje nekog karaktera. Ekvivalentno se zadaje kao kod nizanja foldera {2-4}, ali može i regex nativno i {2,3}; !!! {2-4} == {2,3}
Moj, dok tpojka ne nauči što je regex, ali bi pametovao. Kao uobičajeno.
Evo cijeli code ovdje:
Postoje nešto dependency metoda: last / take / isArray / isAsocArray / isString
function take($array,$x,$defaultValue=null){
if(isset($array[$x])) return $array[$x];
else return $defaultValue;
}
function isAssocArray($arr){
return array_keys($arr) !== range(0, count($arr) - 1);
}
function isArray($x){
if (gettype($x)!=='array') return false;
if(isAssocArray($x))return false;
return true;
}
function isString($x){
return (gettype($x)==='string') ? true:false;
}
function last($item){
if(isString($item)){
if(strlen($item)) return $item[strlen($item)-1];
return null;
}
if(isArray($item)){
if(count($item)) return $item[count($item)-1];
return null;
}
}
function fileFilter($files, $filters){
/*
//REGPATH - nam omogućava da na lak način filtriramo putanje/pahtove
$files su putanje tipa:
file0.txt
file0.php
folderA/file1.txt
folderA/file1.php
folderA/folderB/file2.txt
folderA/folderB/file2.php
---------------------------------------------
*/
// $filters:
// * -> dohvaća bilo koji file/folder
// */ -> dohvaća samo foldere
// *.txt -> dohvaća bilo koji txt file na bilo kojoj razini
// script.* -> dohvaća sve script fileove, bilo koje ekstenzije na bilo kojoj razini
// *script.* -> dohvaća sve fileove koji završavaju sa script, bilo koje ekstenzije na bilo kojoj razini
// script*.* -> dohvaća sve fileove koji počinju sa script, bilo koje ekstenzije na bilo kojoj razini
// *script*.* -> dohvaća sve fileove koji sadrže script, bilo koje ekstenzije na bilo kojoj razini
// *sc*pt*.* -> dohvaća sve fileove koji sadrže pt nakon sc, bilo koje ekstenzije na bilo kojoj razini
// */*.txt -> dohvaća sve .txt fileove na bilo kojoj razini
// *{0}/*.txt -> dohvaća sve .txt fileove na nultoj razini
// {0}/*.txt -> ------------------||-------------------
// /*.txt -> ------------------||-------------------
// {1-3}/*.txt -> dohvaća sve .txt fileove na dubini 1 i 2.
// {1+}/*.txt -> dohvaća sve .txt fileove na dubini 1 ili većoj.
// */folderA/* -> dohvaća sve što se nalazi na bilo kojoj dubini u folderu "folderA" koji također može biti na bilo kojoj razini
// folderA/* -> --------------------||---------------------
// folderA/*.txt -> dohvaća sve .txt file-ove koji se nalaze direktno u "folderA" (koji može biti na bilo kojoj razini)
// folderA/*/*.txt -> dohvaća sve .txt file-ove koji se nalaze na bilo kojoj razini unutar "folderA" (koji može biti na bilo kojoj razini)
// folderA/{1-4}/*.txt -> dohvaća sve .txt file-ove koji se nalaze unutar prve četiri razine unutar "folderA"
// folderA/*/ -> dohvaća sve foldere koji se nalaze na bilo kojoj dubini unutar "folderA"
// folderA/{1}/ -> dohvaća sve foldere koji se nalaze u folderu "folderA"
// dirA/*/dirB/*/*.txt -> dohvaća sve .txt file-ove koji se nalaze na bilo kojoj dubini unutar foldera "dirB" koji se nalazi na bilo kojoj dubini unutar foldera "dirA" koji se nalazi na bilo kojoj razini
//Excluder:
// -*.txt -> NE dohvaća bilo koji txt file na bilo kojoj razini. Analogno ovome, predznak minus se može dodati na bilo koji selektor da bi dobili Excluder
//Regex:
// !.*\/file\d\.txt -> ako izraz počinje sa !, onda se cijeli izraz komparira po regex searchu. Tako će ovaj selektor obuhvatiti sve fileove na bilo kojoj dubini koji u nazivu imaju broj, tipa: "file1.txt"
// ^.{20,30}\.txt$ -> ako izraz počinje sa ^ ili završava sa $, onda nije potrebno uskličnikom deklarirati da se radi o regex izrazu
//Regex and Excluder
// -!file\\d/.+\\.txt
//Partial regex. - omogućava da mixamo nativna pravila regpatha sa regex pravilima. Možemo bilo koju path sekciju označiti sa početnim "!" i ta sekcija će se testirati po regex pravilima.
// path/to/!folder[ABC]/* -> dohvaća sve što je na putanjama "path/to/folderA", "path/to/folderB" ili "path/to/folderC"
// !Kod partial regexa je zabranjeno koristiti karakter "/" unutar one sekcije koju označavamo sa "!" ...tako je npr syntax error ako se zada selektor: "path/to/folder[ABC\/]/*"
// !Svaki parcijalni regex mora započinjati sa ^ i završavati sa $ ako se želi referirati na početak i kraj izraza naziva file-a kojeg se matcha (To je native regex)
// patth/to/^.{0,2}$/file.* -> ako parcijalni regex počinje sa ^ ili završava sa $, onda nije potrebno uskličnikom deklarirati da se radi o regex izrazu
// regpath placeholders included without activating regex:
// script.* -> * - zamjenjuje bilo koji karakter, koliko god pojavki karaktera ili niti jedan.
// script.??? -> ? - zamjenjuje bilo koji karakter, ali isključivo jedan koji se mora nalaziti na poziciji upitnika
// scrip[tr].txt -> [] - uglata zagrada matcha bilo koji karakter koji se nalazi u zagradi
// scrip[!tr].txt -> [!] - uglata zagrada sa uskličnikom na prvom mjestu matcha bilo koji karakter koji se NE nalazi u zagradi
// script\d.txt -> \d - selektira digit char. Dostupni svi selektori iz regexa: \d \D \w \W ...itd
// script\d{3} -> {3} - dostupno numeriranje ponavljanje nekog karaktera. Pazi to se zadaje isto kao kod nizanja foldera {2-4}, ali može i regex nativno i {2,3}; !!! {2-4} == {2,3}
//CONCLUSION, bez aktivacije regexa smiju se koristiti gotovo sva regex nativna pravila, osim regex komandi: .*/? (Koje postoje, ali imaju drugačiju svrhu )
/* REGEX transformacije
- za svaki file idem kroz sve filtere... i onda gledam gdje ide file...
- za svaki filter:
- gledam jel include or exclude
- ako je regex...izi pizi
- ako nije regex..trebao bi ga transformirati u regex
*/
// * -> .* dohvaća bilo koji file/folder - regex:nepotrebno
// */ -> ^([^/\n]+\/)*
// *{0}/ -> ^([^/\n]+\/){0} !! Moraš {1-4} pretvoriti {1,3} !!! drugi moraš smanjiti
// *.* -> ^([^/\n]+)\.([^./\n]+)$
// *.txt -> ^([^/]+)\.txt$
// script.* -> ^script\.([^./]+)$
// *script.* -> ^[^/]*script\.([^./]+)$
// *script*.* -> ^[^/]*script[^/]*\.([^./]+)$
// */*.txt -> ^([^/\n]+\/)+([^/]+)\.txt$
// *{1}/*.txt -> ^([^/\n]+\/){1}([^/]+)\.txt$
// *{1-3}/*.txt -> ^([^/\n]+\/){1,2}([^/]+)\.txt$
// *{1+}/*.txt -> ^([^/\n]+\/){1,}([^/]+)\.txt$
// folderA/* -> ^folderA\/.*
// fol*erA/* -> ^fol[^/]*erA\/.*
// *.*/ -> -> ako nije na zadnjem mjestu onda se ovo mora tretirati kao folder name
// folderA/*.txt -> ^folderA\/([^/]+)\.txt$
// */folderA/* -> ^([^/\n]+\/)*folderA\/.*
// */folderA/*.txt -> ^([^/\n]+\/)*folderA\/([^/]+)\.txt$
// */folderA/*/* -> ^([^/\n]+\/)*folderA\/([^/\n]+\/)*.*
// */folderA/*/*.txt -> ^([^/\n]+\/)*folderA\/([^/\n]+\/)*([^/]+)\.txt$
// */folderA/*/ -> ^([^/\n]+\/)*folderA\/([^/\n]+\/)*$
// */folderA/*{1}/ -> dohvaća samo sve prve foldere koji se nalaze u folderu "folderA" ...koji može biti bilo gdje na putanji.
$filters = forceArray($filters);
$parsedFilters = [];
$prepareJustNameToRegex = function($name){
// decho("before: ".$name);
$name = str_replace('*', '[^\\/]*', $name);
$name = str_replace('.', "\\.", $name);
$name = str_replace('?', ".", $name);
$name = str_replace('[!', "[^", $name);
//konvertira {2-4} -> {2,3}
$name = preg_replace_callback(/*ALMOST dry: #lsjf98745shf */ "/\\{ *(\\d+)( *\\+)?(?: *- *(\\d+))* *}/", function($m) {
$from = (int)$m[1];
$plus = take($m,2);
$to = (int)take($m,3,-1);
$send = "";
if($to>-1) $send.="{".$from.",".($to-1)."}";
else if($plus) $send.="{".$from.",}";
else $send.="{".$from."}";
return $send;
}, $name);
// decho("after: ".$name);
return $name;
};
foreach ($filters as $filter) {
$excluder = false;
$regex = false;
$filter = trim($filter);
$originalFilter = $filter;
if($filter[0]=='-'){
$excluder = true;
$filter = trim(substr($filter, 1));
}
if($filter[0]=='!'){
$regex = true;
$filter = substr($filter, 1);
}
if($filter[0]=='^' || last($filter)=='$') $regex = true;
$regexFilter = ""; //<< ovo je zapravo parsed filter (ali i regex format)
if($regex){
$regexFilter = $filter;
}else{
if($filter[0]=='/') $filter = '{0}'.$filter; //ako filter počinje sa pathom "/" onda se nalazi na root razini
$filterParts = explode("/", $filter);
//provjera da prvi part nije niti * niti ništa tipa "*{1}" ili "{1}"
if(trim($filterParts[0])!='*' && !preg_match(/*dry: #lsjf98745shf*/ "/\\*? *\\{ *(\\d+)( *\\+)?(?: *- *(\\d+))* *}/", $filterParts[0])){
//ako nije, to znači da nije definirano na kojoj dubini se nalazi....i onda po defaultu može biti na bilo kojoj dubini.
array_unshift($filterParts, '*');
}
$n=-1;
$lastItem = last($filterParts);
$lastIsEmpty = $lastItem===''; //vrijedi za path: "this/is/path/"
foreach ($filterParts as $filterPart) {
$n++;
$filterPart = trim($filterPart);
$isLast = $n==count($filterParts)-1;
$isFile = $isLast ? true:false; //file se može nalaziti samo na zadnjem mjestu
$isFolder = !$isFile; //folder se ne može nalaziti na zadnjem mjestu, jer svi folderi moraju završiti na način: "this/is/path/"
if($isLast && $lastIsEmpty) continue; //ovo je situacija kada je path zadan da završava folderom
$add = '';
$partialRegex = ($filterPart[0]=='!' || $filter[0]=='^' || last($filter)=='$') ? true:false;
if($partialRegex){
if($filterPart[0]=='!') $filterPart = substr($filterPart,1);
//ako partial regex ne započinje sa ^ ..moramo ga proširiti sa početka
if($filterPart[0]!='^') $filterPart = "[^\\/]*".$filterPart;
else $filterPart = substr($filterPart, 1); //u suprotnom moramo maknuti ^ sa početka izraza, jer će se taj izraz naći među drugim izrazima
//ako partial regex ne završava sa $ ..moramo ga proširiti na kraju
if(last($filterPart)!='$') $filterPart = $filterPart."[^\\/]*";
else $filterPart = substr($filterPart, 0,-1); //u suprotnom moramo maknuti $ sa kraja izraza, jer će se taj izraz naći među drugim izrazima
$add.= $filterPart;
if($isFolder)$add.="\\/";
$regexFilter.=$add; continue;
}
if($isFile && $n==0){ //ako je zadan filter za file direktno na prvoj razini, taj file se može bilo gdje na dubini...zato ide...
$add = "([^\\/\\n]+\\/)*";
}
//case: *
if($filterPart=='*'){
if(count($filterParts)==1) $add.= ".*";
else if($isFile) $add.= ".*";
else $add.= "([^\\/\\n]+\\/)*";
$regexFilter.=$add; continue;
}
if($isFile){
$fileName = $prepareJustNameToRegex($filterPart);
$add .= $fileName;
$regexFilter.=$add;
continue;
}
if($isFolder){
// case: *{1-2} ; *{1+}
preg_replace_callback(/*dry: #lsjf98745shf*/ "/\\*? *\\{ *(\\d+)( *\\+)?(?: *- *(\\d+))* *}/", function($m) use(&$add){
$from = (int)$m[1];
$plus = take($m,2);
$to = (int)take($m,3,-1);
$add = "([^\\/\\n]+\\/)";
if($to>-1) $add.="{".$from.",".($to-1)."}";
else if($plus) $add.="{".$from.",}";
else $add.="{".$from."}";
}, $filterPart);
if($add) {$regexFilter.=$add; continue;}
$folderName = $prepareJustNameToRegex($filterPart);
$add .= $folderName.'\/';
$regexFilter.=$add;
continue;
}
}
$regexFilter = "^".$regexFilter."$";
}
$parsedFilters[] = ['regexFilter'=>$regexFilter, 'excluder'=>$excluder, 'originalFilter'=>$originalFilter];
}
$passed = [];
$unpassed = [];
foreach ($files as $file) {
$prolaz = -1;
foreach ($parsedFilters as $val) {
$regexFilter = $val['regexFilter'];
$excluder = $val['excluder'];
//na ovaj način postižemo da zadnji filter koji dotakne neki file...može napraviti promjenu po pitanju hoće li ga includati ili excludati
if($prolaz==0 && $excluder) continue; //nepotrebno je testirati ovaj filter, file je ionako već prošao
if($prolaz==1 && !$excluder) continue; //nepotrebno je testirati ovaj filter, file je ionako već excludan
// decho($val);
$x = preg_match("/".$regexFilter."/", $file);
if($x) {
if($val['excluder']) $prolaz = 0;
else $prolaz = 1;
}
}
if($prolaz===1) $passed[] = $file;
else $unpassed[]=$file;
}
return ['passed'=>$passed, 'unpassed'=>$unpassed];
}
Špansko selo. Kakav crni github, composer, i packagist.
Aj, bar je čovjek nagugl’o pa prisvojio. Bilo bi mi čudno da je osmislio jedinu stvar koja ima smisla. Nije da tvrdim da sav bućkuriš karaktera ovde ima ikakvog smisla.
Promućkaj pa prospi.
Ja ionako imam na svojim projektima direktan upload kroz projekt na development verziju…koje usto mogu biti na nekoliko različitih domena i sve se dešava po automatizmu. Kakav crni github
Što misliš zašto mi treba ovo gore…nego zato što se puno radi sa file-ovima i strukturama.
A ovo što može ova sintaksa koju sam tu sada predstavio, vezano uz filtiranje… može sve.
Budući normativ, budeš vidio. Pusti da vrijeme odradi svoje.
Sa nekim tko ne može priznati da je pogriješio i kada je skroz očigledno da je pogriješio na skroz trivijalnoj stvari gdje nema N od Nedoumica … sa takvom osobom se niti ne može razgovarati o kompleksnijim stvarima uz svo njeno znanje. Jer ta osoba nikada neće znati kada griješi.
S tobom sam to prošao već više puta … i zato me sa tobom ozbiljne rasprave niti malo ne zanimaju.
Čak i da griješim, svoje naume uz tebe ne mogu preispitati.
Ali oke si kao priručna interaktivna enciklopedija…dok god ta enciklopedija ne počme pokazivati da nije knjiga nego da ima ego.
Reče čovjek kojem sam riješio jedno 30+ problema minimum. Pa lol
Drugi put kad uzmeš nečiji kod, navedi izvor jer je najveća kradja da uzmeš a da ekplicitno ne navedeš upotrebu tudjeg koda. Da čisto ljudi ne pomisle da prisvajaš i kitiš se tudjim radom.
Pa vrtim sve na svom frameworku, tako da se ima što raditi sa fileovima.
Osim toga automatizirao sam poprilično toga na relaciji framework - webpack, pa i tu imaš raditi sa fileovima.
Nadalje, kreirao sam svoj programski jezik PHML, koji se parcijalno isto vrti na tom frameworku. Jednog dana možda uspijem i u potpunosti sve upogoniti na PHML-u, za sada mi ovo parcijalno odlično rješava probleme zbog kojih je napravljen, a usput nadograđujem onda taj PHML po svojim potrebama.
To je ipak long-term zalogaj …no tu svakako opet imam štošta raditi sa file-ovima.
Cilj mi je PHML dovesti na razinu da mogu direktno upošljavati programere da rade na mom codu, a da je PHML sigurnosni štit da ne mogu ući dublje u jezgru programa nego ja dopustim određenom programeru putem dozvola.
Na taj način je dugoročno cilj napraviti alat koji će moći razvijati zajednica međusobno nepoznatih ljudi, gdje će postojati striktne dozvole tko što smije raditi na projektu…i te dozvole će cirkulirati hijerarhijom od samog vrha do svakog čovjeka koji je uključen na projektu. I svatko će naravno kontrolirati granu ispod sebe…i u nju moći uključivati svoje ljude.
Jer PHP mi je po tom pitanju pre-slobodan…svatko može pisati code koji želi.
PHML za konačnog programera može biti identično po sintaksi što i PHP, ali framework te fileove tretira kao .phml file-ove i parsira ih u safe-php. A taj safe-php ne može probiti ograničenja koja se nameću sa spomenutim dozvolama onoj osobi koja je kucala .phml iz kojeg je nastao taj safe-php.
To mi se čini preduvjet za veliku firmu gdje bi puno ljudi radilo na istom projektu…a velim, na taj način na isti projekt se mogu uključivati i ljudi koji se međusobno ne poznaju i nužno nemaju garanciju da si međusobno vjeruju.
I nije samo do zajednice programera…nego PHP ovakav kakav je …jednostavno nije imun na viruse. Što svjedočimo recimo na WP-u gdje se različiti ljudi uključuju preko pluginova koje kreiraju…pa vidimo kako se lako ubacuju virusi u priču. PHML je STOP tome. …i onda možeš imati ogrmnu zajednicu koja će štrikati zajednički code. (Isto po principu pluginova i nadoštukavanja na jezgru koju ću ja napraviti. Tj. jezgra već postoji, ali je u razvoju.)
Osim toga i composer je slab na isti vrag…čudi me još da nije pošteno naguz*** zajednicu. Jer tehnički nemaš pojma što ti može sve nakeljiti na projekt … i možeš imati grdih probelma ako si zakačiš neki virus.
Nije da se nisam dobro oznojio da istjeram jedan virus sa 50+ projekata, tako da znam da može biti pakleno ako ti se to desi. I sa takvim nedaćama sam se odlučio boriti na način PHML. A osim toga, proširit će mi se mogućnosti nenormalno…
Svakako, kada djeluješ na ovoj razini na kojoj ja volim raditi, sa file-ovima uvijek ima posla.
Otvorio sam i temu “zašto prekompajlirati code” i objasnio da ako se radi u toj domeni, da ne može postojati “nemoguće”: Zašto pre-kompajlirati code
A ako radiš sa prekompajlerima, uvijek radiš i sa file-ovima.
Jer se uvijek priča svodi na koji source, koji kompajler, koji build folder…
Uglavnom, igram se…i vjerujem da idem dobrim putem da nastane nešto stvarno veliko.
A znam i što to pravim…no otom potom.
Ako si slučajno ozbiljan…pa onda ću ti samo reći da razmišljam ko ti da nikada nigdje nebi stigao. Više manje ako gledaš one-line code, svaka linija je već istipkana u tom nekom sličnom obliku, ako ne i identičnom.
Koliko ti vremena gubiš da sve provjeriš gdje je prvi puta nastalo? Koja si ti smijurija …
Kakav si smjehotres.
Pa provjerio sam jedinu liniju iz te gomile smeća a koja ima smisla.
Provjerio sam je zbog toga što nisam bio siguran da l’ postoji princip il’ funkcija u PHP-u jer se ne sjećam da sam kad vidio. I prvi link mi daje ovo što sam postavio a što si plagir’o.
Da si a ono makar ostanio po nazivu funkcije nego si smislio svoj? lol
Ti prvo nemaš pojma šta znači termin peer review. A drugo, a’ da radim bitnije nešto nego što tebi moram objašnjavati bazične stvari.
Pusti da vrijeme odradi svoje.