[LC66] Refreshing file freshening; the continuation

do [Music] [Music] do [Music] do so [Music] [Music] do [Music] [Music] do [Music] i think we should be good to go this is a little bit of an experimental stream i'm not sure if the camera is doing the same thing that it used to do uh the uh the version of obs that i'm using has been bumped up from the 25.0.1 or two that i was using i think 0.1 to the latest version 25.0.8 which was uh sort of fraught with peril because i use slackware as a linux distribution and it doesn't have a package repository in the same sense as things like debian and ubuntu do for the purposes of just quickly upgrading packages and it turns out that there is a library that hasn't been updated in five years that was updated in february and the obs people jumped right on the bandwagon on that so there was a little bit of machinations on my part behind the scenes to compile a local version of that in a place where obs could see it and the rest of the applications that are pre-compiled on the system don't just to make sure everything is kosher and uh so far it seems good it was a bit of a pain to get it all up and running but uh among other things there are webcam controls right in now which uh there weren't before there's also something that i've been uh thinking about trying let me just take this off so it doesn't cause annoying issues in the stream proper which is the idea of streaming from my linux machine to the say the windows laptop that's immediately to the left of me and having that uh be the thing that runs obs and shootout because then i could run stream labs instead which i think uh might be a little bit better uh in regards to a lot of things that i'd like to do um with the stream in general but that's something that never really have time to play with these sort of things so i think uh we're probably pretty good and are ready to go here everything still seems stable i'm seeing my voice uh meter pop there so we're still having problems someone mentioned last week hopefully the camera is still okay it seems like it might possibly be zoomed in in some weird fashion um i'm not entirely sure i'd have to look back and see but it was mentioned in the last stream that occasionally everything sort of turned a weird shade of blue hopefully this version stops that from happening um i didn't really have a chance to check into that too much i'm tempted to want to play with the camera a little bit more now that it look i'm looking at it and it seems like it might not be quite where it used to be it might have been a little more zoomed out than it is right now but uh one of the things that they fixed in versions of obs after 25.01.1 was um spontaneous crashing if you were to open the options panel so i don't really want to fiddle with that right now because the stream proper is going on live so let's say we transition ourselves into some sublime text live stream action [Music] and away we go so uh hello fellows of blind text fanatics odat nerd here back with another sublime text live stream this is uh live stream number 66 if i remember correctly for a data in the vicinity of the 9th of january february march april may june not good with dates and times i know my birthday but i don't know how old i am and the purpose of today's uh live stream is uh as is usually the case to do some sublime text package and plugin development and ask any questions that people might have about sublime text inside of the chat now the topic of today's live stream is some more features in override audit my package in the last couple of streams we've been working on some new features and we're going to continue in that phase this is something that actually was about 10 streams ago uh hello ashwin uh when we were working on fixing up or adding uh the ability to freshen um all overrides that are expired but not modified which is something that was also a requested feature and one of the things that was blocking that was a little bit of stuff that sort of related to stuff that we've done in the last couple of streams which is conducting enough of a diff between two things to know whether or not they're different or not so we sort of set that to the side and went on to work on other things and so the idea tonight is to go back to that which is probably going to require a little bit of re-looking at code that was done since then i did a little bit of that before the stream and uh rebased some branches to get a good sense for what it was we're actually trying to accomplish and uh what we have here on the screen right now is just a quick little plug-in uh that i whipped up a little bit earlier it was mentioned a couple of days ago on the discord that although monica which is the color scheme that i use is the default for sublime text it doesn't have quite as many scopes as mariana does which is the color scheme that is used by sublime merge by default when you use the dark scheme and as a result maybe i'm not getting as much syntax highlighting as i might technically like so um in order to just get a sense for what might be uh different between those two things i whipped up this quick little plug-in that loads both of those uh different color schemes pulls out the rules sorts them and shows a diff of what rules appear in one that don't appear in another just to sort of get a sense for what could possibly be added and then of course i sort of skyped off a little bit into the discussion of monacai pro which is a package that is uh commercial it's 10 euro which if you're me is something on the order of 15 canadian dollars the theme itself i'm not a fan of the theme but it does have various versions of monaca including monacai classic which according to this particular plugin has way more scopes i don't know what that might really apply to me because mostly i'm looking at python code and i was unable to see any real difference uh but i have put out uh some feelers on the discord to see if anybody else has a sense of that and i've really only i only played with it a little bit with python i haven't really looked at say typescript which is the other language i use a lot and uh c although i haven't really done a lot of that to see if there's something extra going on in those that would make it worth the money for that sort of thing uh ironically the monaco pro color scheme or theme package potentially has colored icons for the sidebar but i never really got a chance to play with that because one of the things that it does is force the sidebar font to follow the standard font face and uh while i like this font for the purposes of looking at code i'm not interested in it being used in the sidebar and the basically it didn't look good to me maybe there's some more configuring that could happen there i'm not sure um but let's go ahead and jump into the one from the packages folder shall we and i don't know what i've been doing with this thing i've been changing this file all day accidentally yeah okay well that's uh that's all well and good let's go reopen that this of course is a file that will eventually be uh coming along with another feature that we maybe handled after this one which is the ability to make patches and ashwin says i love the adaptive theme and the default monakai i do as well uh i sort of i don't even know that i really had an idea for using any other color scheme uh monica has just always been the default since back in 2016 at least when i started using sublime and i liked i like a darker darker color in all of my tools and it wasn't until maybe a year later that uh the adaptive theme came out and i switched to that from the default theme which i had been using because i was never really able to find another theme on package control that looked good to me the the main problem i had with the default theme as it existed when i started using sublime was that the console was white even though everything else was dark but i kept using it anyway because it was better than the light theme that was there at the time if i remember correctly and then when adaptive came out i immediately uh grabbed onto that one because it makes everything nice and dark there are there are a few different kinds in the monacai pro package of different tints of colors for monakai one of which is monica classic which seems to mimic these same colors but have tons more scope coverage so there may be something in there that would be cool i'm not entirely sure but the theme itself no one of the things i don't like about a lot of themes that i've run across and all the time that i've been using sublime is ones that change the tabs to be square instead of um well they used to be round and now they're sort of angley a little bit but also to a degree um ones that try to hide the boundary between them so you just see the names of files up there not even with like a separator between them i find that very hard to deal with personally okay so let's see let's go ahead and close a few files here we'll probably need to open some fresh and all that's one that we're definitely going to need and i i did some uh rebasing of branches that used to be based off of master onto this new preview 2.2.2 branch which is going to be the next version that comes out probably with the changes from the last couple of streams and these if we can get everything working nicely and ended up with some conflicts because it turns out i was fiddling with the menus and some of those things so we may also need to do some setup in here as well let's get this back to the help that we are expecting it to see we don't need a version of that there and let's go ahead and size this a little bit just because yeah i'm really thinking of getting back on the origami train of using control k r control r for resizing rows but uh now that i'm using it for something else and i've been using it for so long i don't really want to swap that the other way okay so let's go and check into this so we are on currently branch refreshing which is different in a variety of ways i guess i should point out the the overall idea of things that we're trying to do here would be something like you create an override report and you see some stuff in it and some of the things are expired if you will so maybe let's set a little bit of that stuff up so if we went to the package directory and say into the python folder and touch python build for [Music] shoot look minus d yes minus d 10 years ago python dot sublime build so if we look at it now it's from 2010 instead of 2020 for example and if i was to refresh this report that file gets an x uh next to it which means it is a potentially expired override which just means that the version of the file that exists inside of the package or more specifically the sublime package file that is representing this is newer than the file on disk which means that the package has been updated after a file modification was made and as a result of that possibly there's something being masked there because sublime always uses an override in place of a package file no matter what without warning you without telling you even if one of them is newer than the other which is the whole reason for this package existing and let's go ahead and throw another one in here as well let's say in the make whoops in the make file folder like so so we would touch that take it back and all right that's not going to work in there is it the make sublime build file we'll do the same thing with that and up in the default package we'll do the same thing but only for paste from history like so so if we refresh the report there are some things in here now one of the features of uh of this package is that we can right click on a package an override that is expired and get this freshen option which asks you if you want to do it and then basically touches the file on disk you can do it on a package and then freshen all of the ones in a particular package and the new thing that we've added or we will be adding is this option here freshen all expired overrides which uh the purpose of this is to pluck all of the overrides that are currently expired and diff them to see which ones are uh actually modified and freshen everything that is um not modified but leave other ones there so if you had say for example you were working on syntaxes in the sublime text packages repository and you had a bunch of files that were in there you could easily come in and just say all the ones that haven't been modified i'm cool with those only show me the ones that i'm interested in which sort of ties into what we've been doing in the last couple of streams as well and ashwin is saying i tried a few themes but don't like those rectangular tabs and love sublime's default trapezoidal tabs for me at least i can distinguish tabs much better indeed i saw when i first started using sublime a lot of hate for this tab style that sublime had at the time which was more sort of a rounded corner kind of thing not not a rounded rectangle but more of an actual curve which looked kind of different than other things at the time like i think uh you know firefox and such with tabs had a slightly different style and everybody was or a lot of people were hating on it but i always liked that too it seemed like a it looks a little different than everything else it's not necessary for everything to look exactly the same so what we have done so far but not in there is the idea that there's a command in here freshen all expired overrides that will appear in anything where an override appears expired so for and that includes not only in this report but also in bulk diffs so if we were to look in this one there shouldn't be an option for fresh and all because there's nothing that's expired in this particular uh diff report but if we did it for the default package and bulk diff that one then we would see fresh in all expired overrides and now in explaining that i realize that that is actually probably not um what we wanted well this has freshened all expired overrides which seems like it would freshen absolutely everything maybe that's something that should be in here i think it's probably better to do it the way that we we're thinking of with all files that are not modified so we'll probably want to change uh that sort of thing but that command is only available as of right now in here and via work that we've done it implements this command which uh basically just calls freshen override for every package that says that it has something expired and that freshen override method uh is freshening absolutely everything inside of the package whether it's a diff or not um so there's a little bit of work to be done there but let's go ahead and skip back through all of the stuff um that happened here which essentially was stuff like we added that command and a context menu to be able to find it and add it to the main menu and the tab context menu those are all about exposing this particular command and we note that most of these don't have uh the main menu one has a caption the context menu one i would imagine uh doesn't because most of the context menu items uh dynamically come up with their own captions and then we have the new command which was implemented to just do absolutely nothing except know whether or not it should enable or disable itself based on whether or not anything appears to be over written inside of the actual report itself and then we moved on to there to saying that there is a uh there is a method let me just drag this up a little bit yeah goodness gracious well that's a pretty big one okay this is the actual class itself um the thing that we actually use to uh do the diffing previously or sorry the freshening previously you would execute the freshen command and you would just pass it the name of a package as a string like default or something along those lines and from that it would create a package info instance which is the class that is a part of the library an override audit that does all of the work of looking to see if there's a if there's a folder in the packages folder if there's a package file in the installed packages folder if there's a package file in the shipped packages folder and then gathering the contents of things to see what is an override and what isn't an override and dependency information and all that good stuff which is everything that the core override audit actually needs to be able to do anything that's how it used to work um and that's because you would actually invoke the command from the command palette and then you know you would be asked which one of these packages do you want you'd pick default and then it would go out and actually collect the information for the package that you selected and then do the freshening operation now we're wanting to do this potentially from a state of we already have as much information as we need maybe because of other means maybe some part of override audit that has already gathered a package info instance has decided it wants to freshen something and in that case it it already has an instance of this class it doesn't make sense for this code to go out and make another fresh one so this is a very simple modification that allows you to pass into this particular thread when it runs either an instance of that class or a name of this of it as a string and then it creates one if it's a string otherwise it just uses the actual uh thing so that was a little thing there and this is one of those you know we're sort of working towards um something and uh i really i feel like i got a sneeze coming here i don't know if it's ever going to arrive but it's driving me crazy um this one is allow this to work viewless and the reason for this particular change is if we were to come over here and freshen one of these things one of the things the freshen command does is look into the view find the package that you did a fresh and in find the override inside of that package and then modify the buffer to remove this if it successfully freshens it so as you're freshening things this report actually sort of self modifies so you can see things that you have freshened and things that you haven't and based on that again this command is meant to be executed while you're looking at a report and you click here and you pick i want to freshen this override so it would actually be invoked from this view but maybe we don't want that again if we just decided to execute fresh and all unexpired overrides then um or sorry expression all expired unchanged overrides is probably a better way to say that maybe we want to do that when there's not a view and this is just as simple as um if you actually were given a view then it can modify the package there's a command that's built in to do that because this command is a window command or running from a thread in the background but it's certainly not running inside the context of a text command and of course we can't modify a buffer without being in a text command i believe uh this uh this is actually coming from a background thread so and uh then we just you know in a couple of places i ensure that uh if there is of you do something and as a result it's okay for us not to have a view here previously it used to be uh it would get mad as a matter of fact that should probably uh change a little bit because it doesn't matter if it's not given a view maybe we'll go ahead and oops fix that too you know while we're at it oh it's gonna be like that is it right right right uh not given a package like so first part of our little thing this is why we're sort of going over this because this happened ten streams ago so a little ways back i mean sort of sitting on this trying to think of the best way to proceed and then now allow for multiple freshens at one time so there used to be let's go ahead and maybe close that up and we can see a little bit more stuff here if we were to look um there is a method for freshen override as we can see there whose purpose is uh or used to be you'd give it the name of a package like default and the name of an override inside of it uh like say paste from history.pie and it would do all of the work for you it would say pop up a confirmation box that says would you like to freshen this and if you say yes to that then it would spin off an override freshen thread and pass it the name of the package and the name of the override that was provided and if you provide a package but not an override then it would just try to freshen everything inside of that particular package that happens to be expired but for the purposes of looking at a report like this and saying freshen all um unmodified expired overrides there could be many of them and there could be many packages and instead of splitting the thread to just to do one thing in default and then spinning off another thread to do one in make file and then spinning off another thread to do one in python which doesn't seem like a particularly great idea we modified the freshen override method so that instead of passing it a single package and a single override you can pass it a list of packages and a list of overrides and there may or may not need to be more work that is done in here there is a to do here but the idea there is that instead of doing it for just one thing it could do it for multiple things by stepping through them and we might even see a little bit of that down in this part where the actual thread is doing stuff there was a fair bit of work that had to happen for something like that in order to work but that's what this is doing now there's still some stuff that has to be um worked on here because if we can see if we look in the left if you just passed the name of a package like default then the um the confirmation dialog if it's turned on would just say would you like to refresh are you sure you want to refresh all expired overrides in default and you would say yes no or if you passed it the name of an actual override then it would say uh confirm you want to freshen default slash paste from history.pie so you're you're being asked if you have the setting turned on what you want if you want to confirm and it tells you exactly what it is and uh currently this is just saying this stuff because there's uh more things that have to happen there like the list of all the packages or the list of all of the overrides or maybe after a certain number we say would you like to freshen these 19 things there's probably a limit to how much stuff you can put in the dialog box and actually have it appear on the screen so a little bit of work had to their thought had to go into how we convey that information in there so i just sort of left that for them for the end if you will and then lastly there's the actual command itself uh which we could actually see if we were to look in the actual code which is calling this with uh some stuff actually let's go ahead and look at this in the actual uh code itself this command is either always available visible or only visible when it's enabled depending on the command line argument always visible which is something that all over idotic commands do because i don't want them to be in the context menu unless they actually apply and otherwise they should but i don't want that to block if a user wants to modify a context menu of some sort if you wanted to modify the menu to have commands in there then you should be in control of whether or not things are hidden or not so all the override audit commands take an argument um that is always visible that's a boolean and if that is set then this thing always is visible otherwise it's only visible if it's currently enabled and as we can see in this one when it's enabled it gets the report type and if it gets a report type and it's not the package report then it finds the actual target of the command and gets the list of all of the packages that have expired overrides and only enables itself if there's at least one of them which is how it knows whether it's an override report or a bulk diff of a single package or booked if of all packages or what there might actually be in there and the description is fresh and all expired packet all expired overrides which is again slightly wrong and this is currently refreshing every override because what we're doing is grabbing just a list of every package and uh shooting it through excuse me which is uh right here on line 22. it's getting the list of every package that is currently expired and passing that in and um because it's refreshing absolutely everything it needs to have a list of overrides that matches this this is all to do with how previously you'd give it the name of a package and none to freshen a whole package or the name of a package in the name of an override to freshen a specific thing the way we expanded it out uh each one of them could be a list but if they're a list they both have to have the same number of items so you can say package list and a list of five things but then you need a list of five nuns to say that all overrides in those packages or what this should actually be doing is coming up with the list of every override that needs to be freshened that is not modified and then uh explode that list out so it could pass it in and everything could be freshened so with all of that i'm pretty sure this stuff works for what it is except for the couple of to do's in here which has to do with whether or not the uh excuse me whether or not the menu is actually there or not the confirmation dialog box which again item i still need to think a little bit more about how that would work there's probably some minimum number of refreshes that could happen before it just switches to are you sure you want to freshen 15 overrides in 12 packages or something along those lines something that gives you an impression that something exciting is going to happen um i kind of can't remember why this takes keyword arguments i guess most of the commands do because it's uh yeah if i had if i had to uh guess the reason most of the commands in override audit take a a keyword argument list instead of explicit ones um because they're meant to work from inside um a view like so or also from the context menu in the tab and in a tab there's other arguments that need to be there for the uh the file index and the group index to be able to find it which is why this all these commands derive from a helper class called context helper which is able to figure out the view the target of the view based on the arguments we got is something which could be the file that you actually right clicked in or in the case where it's a tab the actual view is not the same as where the command actually is executing though there's a little bit of extra work that has to happen there um i think maybe the first thing we might do just because we have that is modifications to the main menu and the commands file because those things that we added aren't technically correct fresh and all expired unmodified overrides whoops unchanged it should be unchanged shouldn't it freshen all expired unchanged maybe we want a version of this actually that works both ways as a matter of fact um in which case maybe there needs to be more stuff in here unfortunately this is slightly backwards from the other ones because the other ones are excluding unchanged now we're including unchanged if we wanted to do something like that maybe we do maybe someone wants to just absolutely freshen everything without caring it would be easy enough to add later ah so yeah i mean when it comes right down to it the difference between um all expired unchanged overrides and just all expired overrides whether they're changed or not all comes down to whether you just say package list none times blah or if you actually investigate to see what the list needs to be so if we add an investigation to this we could easily flip that around if we wanted to in fact we could probably even include that as an argument in this command and not actually included in anything that might actually be a nice way to go for that freshen all because that does require this to change too yeah why did i not decide i guess everything in the main menu has a specific caption that's kind of funky i was surprised would have thought that i would have done that in a different way um let's go ahead over here and do freshen all shoot i already forget what order i did that expired unchanged unchanged override so if we were to look over here the nice thing about this uh then is we should probably i'll throw a thing in here if we actually filter the list to things that that are only unchanged we need to handle the idea there might not be any right now we don't have to be worrying about that because the command only enables itself when there is something and the command the underlying code is smart enough to do nothing if it doesn't find anything anyway but i don't like the idea of dispatching uh the fresh and override call which might spin off a thread if there's not going to actually do anything um we saw that in the main menu we saw that there those are the only places that stuff sort of sort of happened right i'm kind of unhappy about the order that i rebased these things i wasn't thinking i should have rebased refreshing last so that it was at the top of the list and made things a little bit nicer but what can you do um yeah so if we looked here actually command file menu file oh the context menu right right right context and tab context but the one shoot yeah all right um so we don't need to worry about the context in the tab context but i guess we just modify the command itself expired unmodified and unchanged i really have a hard time coming up with do yeah so with that in place uh we should see it up in this menu yeah cool and in this one as well so we might actually just go ahead and whoops and this is one of those things that may change we'll stage that stage that stage that and that and then say verbiage alteration now one thing that we kind of need to know in order to filter this to only things that are changed and an example of this if i was to bulk diff this this file is expired you know because i did stuff but it is definitely modified i modify my paste from history so that it uses a quick panel instead of a menu for example um but these other ones well i guess this one's they might actually all be modified now that i think about it should probably do that for something that's not to make sure that that actually works let's see that one definitely has a change and that one definitely has a change so let's say we actually create an override and the default package for this and then just save it and do what i call it add line before more than one ad line in here hmm adline in braces you say why is that not showing up in this report that's interesting oh there it is maybe i didn't do something that i thought i did how is this different from anything is it no well in that case let's delete that one we already have one in here that we don't care about there we go so this one if we were to uh diff it is completely unchanged but this one uh if we were to div it is not so if we test this in the default package we should be able to distinguish whether one or both of these things is actually needing to be modified at all now the reason i was thinking about this apart from the fact that we sort of set it aside is because one of the things that i was pondering is the best way to determine um this and whether or not a file is actually different or not oh shoot let's go ahead and here we go like so um and that's kind of something that we did with the last couple of streams when we worked on the the other stuff um the override actually detecting to see you know using the the diff or whatever so the thought occurs um if we were to look in the commands if i can remember what it was that we modified where might be the best place to grab the thing i guess this one is the easier to look at thing um we actually had a filter up here somewhere right hmm exclude unchanged let's see where we're doing uh this okay output package output package uh filter unmodified overrides that's a thing that we're interested in all right so we kind of already have what we need here it takes a list of overrides from a particular package and returns a copy of the list that's filtered so overrides that have not been changed are removed it's kind of the opposite of what it is we actually want isn't it the idea previously was you would give it 15 overrides and it would say these five are not modified but what we actually want is the things that hmm well let's go ahead and work our way through that uh shall we so we might say that oh look at that that just fits that's fancy okay now for the purposes of this we're not actually going to call that we might just say refreshing freshening and uh this for the time being oops and that's what i'm going for reload that uh which should have worked so that if i was to pick the all doo pression all expired unchanged overrides and hid it it says freshening default makefile and python none none so the first thing we might want to do is um we don't care about that we do care about that we don't care about this we don't care about this let's go ahead and clean this down a tit so we're a little bit nicer for the stuff we're looking at hide that maybe shoot that over there so we can oops take a look at that while we're doing stuff which is one of the reasons why i like to use this particular layout for things um so this guy so let's see this is assuming that it has to be invoked from a report you can't just invoke it otherwise i'm okay with that um i think what we want do i actually have something in here that tells you about expired get a list of all overwritten files for this package which are older than the source of blind package file um technically i think that information could be plucked directly from here and i would wager that uh and that's what i thought um it gets called with a package list and an override list so we would pass that into the override freshen thread and i think this would be responsible for pulling that information out whoops went too far its process is this where it gets the list of packages uh possibly creates one if it needs to that's the diff that we saw earlier uh override list is the list of all overrides that were provided to the actual thread when it was spun off and for each package the package get the package info the override is the override list at the given index oh because it's it's thinking singly if override is not none then it's doing a single thing otherwise it's doing the whole package and those are the things that do all the work that i remember now for two so if you passed it a single override this is where it calls package info dot expired override files which is how many other times is this called in here let me just trace through this code real quick like if you told it to different entire package then it will get the list of expired overrides from that package with simple is true and that's simple overrides are the ones you're most familiar with non-simple overrides are overriding an entire package that ships with sublime by replacing the sublime package file in the install packages folder it's a thing you can do hardly anybody ever does it i've never actually seen anybody do it except for myself when i was working on this package um and there's probably people out there that might do it that never ask for help from sublime authors or something [Music] and in that case it would iterate through each one and touch them if you do it for a single override then it will touch the one file and then it calls expired override files to see if it needs to clean the package so one of the things i know is that the package class over here normally caches some results uh like so so uh if it's simple and there's a list of expired overrides then it would immediately return the list that it gathered previously otherwise it will actually calculate them and this is the bit of magic code that compares the last modification time of the file on disk and of the zip file that represents the package to know if it is uh expired or not and if the package file is newer than the file then and there you go because uh zip files don't necessarily have a time inside of them that is useful they don't have any time zone information or anything so we go by the package file instead um so one potential issue here that we need to ponder in this operation is that if this needs to only do something with expired packages then in that particular case it would need to call this method to find all of the expired files and then one by one call filter unmodified over call filter unmodified overrides to pluck out things probably reverse the sense of the call because right now this is throwing away things that are expired we need that to work in the other direction which is a simple set operation and then we call this method with that stuff but if we do that then by calling the method in the class it's going to cache the list of things that are expired and then when the freshening code gets in there it'll never mark a package as clean if it freshens everything because when it calls the method to see hey what's expired in here it's going to end up getting the cashed information which is from before it did anything which means that part of this needs to be able to throw the cash away for something like this maybe we pass an extra method here we could also just set expired overrides to none and that'll oh not to none we need to delete the entry for that if it exists self.expired overrides uh is a dictionary there's a simple and a non-simple uh version of it as we can see here so there's there's basically a true and a false for simple and non-simple expired overrides even though pretty well yeah expired overrides as non-simple is the package itself and not just uh the contents so it kind of works the same way there's not a lot of support in override audit for working with that situation because it's so uncommon but it will tell you if such a thing is out of date um i don't think you can freshen one though we'll worry about that if anybody ever mentions that it's a problem so here we go we get the list of packages and then we need to build up the list of overrides so we might say overrides is equal to this and then both of the places where this exists we could just change this to overrides like so which makes that a little bit nicer um right now it's trying to freshen all packages everywhere so what if don't do that thank you what if we said um what do right now it's going to do only unchanged so we say include changed is equal to kwrx.js include changed and the default for that is false like so and we could say also here include changed like so reload that and if we came back and triggered the command we verify uh oh okay why did that not show up weird uh fresh and all expired unchanged override maybe we'll say fresh all like so and it ends up as false and some of that action so now if we were to say [Music] if not include changed i may have named that funky right now if include change is false you don't want to freshen changed files only unchanged files so this is one of those weird ones when this when this value is false we don't want to do something we only want to do something when it is true so if we say if include changed then doing a filter like so uh and in that case maybe i'll bring this down over here just to make that a little bit easier should probably just invoke it with the key binding to be perfectly honest uh f a fresh and all there we go and we don't see it saying anything there because of the way we named that um i like the idea of this i don't know what a good name for this is that allows you to do it and then the code doesn't look dumb maybe we want this to say only unchanged shoot is that what i was calling it in the other thing exclude unchanged yeah okay so only unchanged the default for only unchanged is true did i just reverse this into an unfortunate state i bet i probably did uh because if the default for only unchanged is true then we wanted to say if not only unchanged let's see if that happens that has the effect that we're interested in oh maybe i should have changed it in all the places and not just in most of the places my bad [Music] oh no that's not what we want and we get that so yeah i guess we want something like that the default is to only freshen unchanged files right right right that makes sense so if we were to do this and say that then it says doing a filter but right now it's doing nothing and only when you pass only unchanged as false would it not do a filter which would leave this value the way that it is right now so all we need to do now is figure out the list of overrides for uh that are actually unchanged for the particular thing that you're doing something inside of we probably also want this to work not just for all packages but for a single package as well which i believe could be done by taking an explicit package that's probably the idea that i had for this but it was easiest uh when we were implementing the code originally to just do it for everything um so we would need to say for package info for package in package list and if it's pulling it from a setting then it's just going to be the name of the package so then we need to actually create a package info which i'm not really including in here at all um where's an example of what we're interested in here oh sorry that's not the core this one's the core yeah that definitely needs one of those we're looking for oh i'm looking in the wrong thing right right it's down here this one viewless no multiple freshens at one time that's the stub that's this package info and i'm pretty sure we're gonna we would have to uh import that from there so yeah yeah that's probably not good and let's see um whoops from lib how's that for a guess shoot did i not go down i bet you i didn't go down far enough because i am in the commands one to there probably needed that but now we got to quit and restart because automatic package reloader doesn't like reloading things that went pear-shaped okay and uh yeah we're happy now we could even say print like so and then when we trigger it whoop crap no stop it ah shoot i have been doing that far too often lately i keep hitting the p instead of the o there we go so that is working if we only want to do unchanged then we would say print the name of the package because that's the thing we got and then we say unmodified is equal to package info dot filter unmodified override oops sorry uh this one whoa expired override files is what we're looking for and simple equals true which is not something you don't have to specify it with the argument name there but because for a lot of this stuff values are true or false to uh and those aren't necessarily useful uh just to look at it and know what it means i did it this way because then i can easily tell exactly what i probably intended to do there so if that's the list of unmodified things then as a set then if we came over to here um filtered is equal to filter unmodified overrides in package info for unmodified so if this gives us oops this should be pardon me that's the list of all expired overrides then we filter unmodified ones that would give us only files that haven't been modified so we probably need what um expired minus that and then say whoops my how close am i to getting that correct on the first try probably not super close um let's do this first then right so that works let's let's print both of them just to make sure that i remember how this is working um oops yeah like that like that don't do that so they end up being the same both ways huh how many things in this are actually expired two that's interesting does this thing actually modify the set maybe that's why it's going wrong that would be unfortunate i see oh right don't do it that way that's dumb that's a little bit of a potential bug huh okay these are the two things that are expired that's the thing that's modified and the reason that wasn't doing what i thought was because if i did this both of them intend to be the same that's because it's removing things directly from the set i should be wrapping this uh this is in the core huh for temporary purposes something like that should make those two things go back to being the other way no oh wait wait wait wait result equals set overrides like so and then we go bang bang bang result pardon me it doesn't matter if you iterate over a copy if you're going to still modify the thing anyway and oh what well that's interesting override diff result has no attribute removed i'm not entirely surprised oh okay let's uh let's take that back for a second to make sure i didn't do something dumb there overrides is a list and not a set is that the issue you think just because i wrote this last week that i'd remember how it actually works no well that's unlikely to be the cause of result suddenly being an override diff result oh because i reused the name did i just uh yeah let's go ahead and good grief whoops yeah okay so yeah that makes perfect sense um take that back to being a set because it most likely is those are both that that's probably 150 000 times less dumb did oh really why is that an issue now when it wasn't an issue before well easy enough to fix that is kind of ditchy though [Music] okay so now we get the result that we want kind of weirded out about why that didn't cause a problem before i have a feeling no it must have been a list maybe we should just double check into that because it's going to bug me uh that's the one we're working on right now filter unmodified normal overrides oh shoot normal overrides is the result of overrides not actually as well it's a set but it's not the set we want it to be but that's okay because that's uh neither here nor there but okay so yeah i'm uh ridiculously weirded out about how that was working but now i think we should be able to say expired minus that so we know if we did a bulk diff of the default package that's the one we're going to concern ourselves with right here if we bulk diff yawn package paste from history should remain and the other one is no things found right so if we did this oh wait did we go backwards on this no we didn't uh previously there are two things that are expired but only this one um is the thing that is unchanged pace from history is changed so it wouldn't be triggered and as a result those ones also would not go so that's giving us everything that we want there and we could kick that out and kick both of those out now an issue with this is how we build up this list um i can think of a lot of ways to do it but how many of them are actually clean is the issue the way that it's done right now the list of packages and the list of overrides inside of that package to freshen need to both be the exact same length so if there's two packages in package list then overrides has to be none twice in the list which is what we see on lines 28 and 29 right now and in that case the freshening code would just pluck the list of everything expired and flush them all if we want to do only unchanged ones then that is modified we can't do a one-to-one here we need to have a different package list and the different overrides that we apply to replace those ones so maybe we might say if not only unchanged this else this and then say well maybe we'll do it up here freshen every override in every package so i think if we did this um nope we end up yeah because those have not actually been set yet so we would grab that and put it here like this so that it could still iterate over things um without actually pulling it that's not great so i'd probably jimmy jam that around a little bit package list is referenced before assignment all right because i haven't actually put anything in it yet at that point right right um okay let's do this package list is that um if we're not doing only unchanged it works like that otherwise let's go ahead and put this back to the way i had it like so because that just looks a little nicer than you pulling that thing out of there twice actually maybe we do that slightly differently maybe we call this one packages and then we can say package list equals packages otherwise like so um and we need to say package list is equal to an empty list and overrides is equal to an empty list like this and get the information for this actual package get the list of things that are expired filter the unmodified ones out so that and remove that from expired so we get the we might actually call this unchanged like so to get basically the list of unchanged overrides that have that expired overrides that are unchanged which we get by getting all expired overrides filtering out the ones that haven't been modified and then removing those ones from the original list because filter unmodified goes in the wrong direction and i don't know that they necessarily want to make a filter modified overrides now over here or maybe make this uh one over here take a boolean for that when it's easy enough to do this way i don't know maybe that's a good idea we'll worry about that at another time also we need to change that before we commit this too because this isn't a set it's a it's a package file set which is slightly different and hopefully would work with a constructor like that we should probably test that otherwise we might be unhappy a package file set is a set that can or can not be paste case sensitive depending on the platform that you're running it on uh because linux is case sensitive and windows and mac os are not and that plays into how sublime it deals with override so we need to do the same thing because you know basically uh case doesn't matter in an override on windows it'll still work in sublime anyway because it does case folding internally or uses raw file system access or something override audit is would be case sensitive always because sets are case sensitive so one of the first things i wrote for this is the package file set that knows to be case sensitive or not um four [Music] four override and unchanged package list append and i think that might be what we want for something like this so let's see ah did not spell that correctly so it's only freshening one thing in the default package it's freshening add line before because that's the only override in this entire thing that hasn't been modified in some fashion this is modified i modified this for some reason and i can't even remember why at this point what if we did this yeah revert that and then if we swap back over to here um that one actually needs to be marked as expired for this to freshen doesn't it yeah so do like so and now we do and we end up with two things default applescript uh oh oh so right default and add line before and applescript comments i forgot the the interleave that's given us the information that we want for that okay oops don't do that pardon me um if the default value for this was a pulse like so and we reload that then if we came in here and did far we end up with default applescript make file python none none none none because it's just gonna try to freshen everything in everywhere so that is more or less what we need to do in order for that so that would take away this is freshening every expired override in every package but it should actually be executing a diff to determine what files are actually unmodified and that so we might say actually maybe we don't handle that case here let us check out the freshen thread does this say anything if you tell it to do nothing no such package no such override no files needed freshening all right so we don't need to worry about that i don't think we can just go ahead and dunk all of that out of there like so now one thing i did want to check here um from override audit dot lib dot packages import package file set so if i said that no is that not how sets work if i said y equals package file set x dandy my magic override actually works for something like that perfect so we would come to here and change this to package whoops file set like so and we need to is that already in here oh it is cool they don't even need to do anything with that swank okay so let's go ahead and jump back to there um filter yeah i really got in my own head about the idea of having this have a boolean so i don't have to do it over here that's an unfortunate turn of events for me um let us first say uh f4 core let's stage this and say don't modify input set in place as the fix for that which is this bit here because i don't think that that is a particularly good idea now we can't check this in yet because we haven't actually tested it and does anything we don't want it to say it's freshening such d such we want it to actually do it and only unchanged we want to actually be defaulted to true like so so in order to test this and i think i might want to do this just bung it over on this thing over here for a second because i'm probably going to need to run some touch commands here to undo some stuff so this as we said should only freshen this file and this file but no others so if i did this oh maybe we better make sure we did that if i will even pressing that to make absolutely for sure that it's all up to date and then we do fresh and all unexpired unchanged overrides and it says want to freshen the stuff and we can say cancel and then you know nothing will happen we can do it again and say one impression of stuff let's say no still nothing happens i mean why would that be different but you know always get to check and if we say yes it says it freshened to package resources if we looked in the console it freshened default add line before and applescript comments only the two things those are all sent to the status possibly and we even see here that um this was modified and that was modified the two things that it did so i'm going to go over here and say touch date equals 10 years ago whoops um default slash add line before and applescript comments so we can put those back to the state they were in before as a matter of fact we might also include in there default paste from history i'm just typing those same commands that i you saw me typing before make file make dot sublime build and python python dot sublime build so we run that we can see uh oh right the comments file changed on disk the modification time change so it uh reloaded the meta information for that um so refresh that everything goes back to exactly the state it was before if we change this to say false which would allow it to freshen absolutely everything even if it has been changed and then we said fresh and all and said confirm the stuff yes uh it freshened five package resources and we see here everything got nicely cleaned up like so so i'm gonna come back over here and hit that one more time so both of those are working the way we might want them to now one last thing was in the actual excuse me refreshing thread which is here in the core weirdly yeah apr is real handy i'm i'm real happy that i i realized what weird thing apr by the way if you're unfamiliar ashley just mentioned in the comments is automatic package reloader makes working with packages a lot easier one of the things i did in one of the streams back was fix my package so that it would work with that um basically just because automatic package reloaded reloads things in a specific way which didn't work for me and realistically it has to load things in the order that it was um so i hadn't used it for a while because it was breaking in this particular package but it makes life a lot easier the only thing i don't like about it is if it has a problem loading a package then you have to quit and restart to get anything to load again but there's probably not a good way around that so don't put syntax errors in your code and you're good to go um one of the things um what was it what was it in here that we were worried about the call to expired override files [Music] um touching single overrides uh what does clean package do it oh it removes it from there okay so here's the thing to test um we go back to here only unchanged yes we want that to be there by default we can add another command to this let's reload that it all works so the idea here is we reload this if i was to say fresh and all expired unchanged it should only freshen the two things right we're going to go ahead and say yes to that i guess no i guess that way it says it freshened two resources and one of those was default one of them was applescript now this clean package call did i just uh bunk it out of the way here no it's in this code clean package says if there is a view then we want to modify the settings because there is a setting named override audit expired packages that's applied to all reports that keeps a list of all the packages that have expired overrides inside of them so that it knows when you right click on something whether there's something expired in there so see for example freshen all fresh and expired overrides in just in the package default but down here in html it doesn't appear because it knows there isn't anything in there and what this clean package call is doing is saying get the list of those packages and for each one um remove this package from the the list of stuff or remove from the package list the package that we told it to clean which in this case if we did a single override would be the name of the package that came from now here it didn't do anything and i i'm guessing um no it actually worked there too [Music] i was that's the thing i was um unclear about what it would do but yeah that seems to have worked i was a little concerned that because we call expired override files and it caches the result um that because we actually modified something out from under it but we may have actually made that cleverer because it was already previously working so maybe we don't need to worry about that right now so that all seems to be uh cool and i've been thinking for the week the idea of um let's go ahead and move this back up to here for the time being um the idea of the excluding unchanged for all packages and then there's just also all packages the idea that if we wanted to freshen we would we only want to probably allow someone to freshen all unchanged overrides and not freshen everything wholesale because you could mask a problem that way and if you were a power user such as the person that asked for this facility then they could easily add an entry to the command palette to give themselves the ability to freshen absolutely everything even if it's a modified file which i think is a good i've been i was thinking what's the best do we go for completeness in commands and have a fresh and all expired overrides including unchanged um or including changed and and fresh and all unchanged overrides in the menu here so that you could do it both ways because that is the complete way to do it and clearly a code can do it but i'm really trying to work from a position of override audit is meant to keep you safe in your package use and your overrides to let you know when there are problems so i don't really want to provide too many capabilities for you out of the box if you're unaware as a user to subvert the predictions that it provides you but they're still there if you're enough of a power user to know how to do it then you're probably in a good position to be yeah trust me i just want to flush everything i don't care about it right now i can always worry about it later if i want to so i think that's where i want to go with that and let's just see oh okay that didn't work so i guess there is a little something that we need in here um for that particular one i thought it would be cool enough not to get into issues core inline oh the package list ends up empty right i guess it assumes you're going to give it something oh yeah yeah yeah all right let's see in this version of core that's a little bit bigger roundabout line 794. this part is important um we could do this that's probably the easiest way to do this process gets triggered you know the way all of these um background worker threads work uh is that they have a constructor that gets called to grab some sort of information and once all the information is done it calls process which is kind of like run but after extra work has been done and it gets all of the arguments from an argument dictionary and previously it would make sure that the list of packages in the list of overrides is the same i think there's a to do somewhere that says if the length of the override it should be possible for the package list to be any length and the override list to be empty if it was just going to diff everything but no that's an easy enough thing to do and then previously it would say it needs to know if there's missing parameters but since it's potentially possible for us to invoke this with empty lists i think it it's a good idea to do it this way so if the list of packages is the same length that's okay they would both be empty and then if the list is zero well nothing needed to happen and then i guess this one may not need to be here in that case because if the length of the package list is none although what does not return for something like this oh i guess it could be none so we'll leave that in there for the time being um but with that change in place if we said freshen all expired unchanged overrides we just we well i guess we get that and then no files needed freshening right um so this is um part of the other thing then i guess shoot with that realization let's take this out we'll put it in a different place in the core if you call fresh and override this is the place where yeah during the multi-item rewrite this was partially modified but it needs to be smart enough to display the confirm information since there's more of it now and it should infer a list of none the same length as the package list for the override list if override list is none because we might just want to pass a list of packages and be done with it yeah so that's sort of moving that one line of you know none times length of package list from the other place to here so that's neither here nor there this is the stuff that we have been working uh with a little bit so here um is the bit where we could say if length of package list equals zero then uh oh shoot sublime dot status message is this the one it's deprecated use the one from the window instead well poop i guess we would just do a log for something like that anyway log no [Music] files need to be freshened there's also another potential issue with this in that this call is getting this should be threaded so let's go like this since it gathers package information when it runs because the uh freshen override here takes a list of things it confirms with you that you want to freshen them and then it spins up a thread to do it to make sure that it happens in the background and it doesn't hang the ui if there's a lot of things to freshen or whatever probably not necessary but you know why borrow problems and as a result this should be doing the same thing everything else that does something with a list of packages spits off a thread to do it to gather the information on the packages in question basically this call invokes a file scan and actually one of the things you can do with the package info if i was to look at um i think oh sorry package list this holds a list of packages we could actually create one of these with the names of the packages that we're interested in and it would do the scan for all of them all at once and pull them out which is how we should be doing this and that should be happening in a thread but this is sort of the you know hardcore building it up version um and it should create a package list object and not a bunch of singles yeah just to remind myself of that when the time comes um so when you run this command it needs to know if it should be enabled by doing that and then the actual run should be spawning off a thread that gathers this information maybe even the other freshman thread with some extra arguments that's not something we're going to worry about here because we're very close to the stream time limit for this evening and i don't really get into that much stuff probably but that's something that definitely needs to to happen to make this a good experience and in that case that's the bit where um it should be actually saying there's absolutely actually nothing to be done here so maybe we don't even do it in freshen overrides maybe we just assume fresh and over i wish here's override freshened thread which takes the list of packages in the list of overrides um this is the thing that actually does the work and we can even see it here saying package list equals package list which is the one that we were provided um so there's probably a little bit more cleaning to do there but if that's not in the core uh then it is in here instead and instead of calling that method we might say if uh thus go ahead and do this if yeah it's package list in this one if the length of the package list is equal to zero or if not package list probably another way to go but i like that no files need to be freshened and then we would say status equals true and dialogue equals true i believe is the magic of that and then we can return it and in that case uh when we do the thing here remember last time we did this it got mad at us because there was nothing to freshen but now if we do it oh maybe we should import the log call huh dang probably looks something like that i'm gonna do this because i don't like uh there's probably a nicer flake gate way to do it but i don't like those to go over the list and i don't like them to wrap i don't think i should probably investigate that and some other stuff too like in this one way up near the top yeah see i'm importing from lib packages a bunch of times i don't like the way uh that looks otherwise um sorry how about that no files need to be freshened right which could even be smarter than it is right now um whoops because it could the message could be different um message equals there are no unchanged expired overrides to freshen okay let's do that first so this would be the message um and then we say if not only unchanged then maybe maybe we should have done that in a smarter way yeah like so probably would have been the clever way to pull that off okay so if we were to do it here like this and say fresh in all we get there are no unchanged expired overrides to freshen isn't the most great verbiage um and if we were to flip the state of this to false is the default because that's easier than modifying the binding when we come back to this and freshen everything and now it's saying that there is something to do and we could go ahead and say yes to that it freshened three things and now this is another test of the other part uh we can't freshen everything in here um and that's something that has to be in there we can't invoke the command right now but if we had an override report that was open and something helping outside of this like if you touched the file manually or freshened it yourself while sublime was quit then a lot of these commands go based on status information they get from the view themselves which is i think the best we can do for that because otherwise it would constantly have to be looking at the disk to see if things are changing out from under it you know to the sense where when you create a new override this report automatically refreshes we don't have any api that lets us track package contents without doing it ourselves and so i don't think it's a good idea to be using you know our own inotify instances just for that when sublime's already doing it for get files and for checking its own things plus that's not something i want to deal with in a plug-in because it works different depending on the platform that you're on if we try to run the command manually which would be override audit and all window dot run oh come on you override audit freshen all like so oh i suppose it decides it doesn't need to run in that case right well i'm going to leave that in there anyway what i said was still true this is just not a good way to test it because the command disables itself if it doesn't think there's something in there so what we would need to do i guess we could test it out we could we could touch let's see from 10 years ago html comment i'm sorry applescript applescript comments okay so here's where this sort of comes in if we do this it thinks that is expired for right now then i run the touch command again over in this folder but without the 10 years ago part so now as far as the disk is concerned that's not actually expired but as far as a report is concerned it is which could happen if we quit this uh and then restarted sublime later it's going to persist this information in the settings and everything so we should be able to still trigger the command because it knows not to expire it knows to enable itself because it thinks something is but that code should actually be creating package info instances just realized why that thing did the way what i thought it should it's creating the package info twice i'll get back to that in a second so this i think should say there's nothing defreshing yeah i would have thought yeah it still says no files need freshening it's a little bit uh out of date there because of the state of things there so yeah now one of the things just to go back to that because i just realized what was going on where i said um the code in the core in the override freshened thread itself which is down here has this clean package which it gets called in this case if you freshen a single override then try to touch it and if it worked and that package no longer has overrides then clean the package which means remove it from the settings so the command nose is not supposed to execute in that context anymore this method as we saw when we looked over here is caching the result so i thought it would be a problem that the command up here gathers the list of expired overrides in order to figure out what it needs to actually do so that when it gets to this part it can't actually do it right but that wasn't the case and it still cleaned it anyway the reason for that is that this command is creating its own package info up here and it has its own instance where it does the scan and then when we spin off this thread it does it again and creates a new instance so it's not cached in there one of the things that will change not tonight is that um actually not necessarily change per se in this particular bit but when you run this thread you can give it a package list that's a name of a list of names of packages or just packages itself and if it already has the packages it won't try to go out and fetch them again so this should actually be putting these package info instances in and not um the names of the actual things themselves so that's you know one of those commits we actually made way back when to stop it from doing the very thing that it's doing right now when we do that then this needs to be careful to clean that list out after it gathers it so that the other one can still do something with it because we need to call this here and then again later or we need to refactor a bunch of stuff but so i guess what we could do just for here is so let's let's go ahead and turn that off and say what was it that we actually did here in this point after all of the other stuff was done we modified this command so that instead of freshening absolutely everything every time now it instead asks gets that argument whether or not it should do auto fresh enough only unchanged files or all files then um if it's only supposed to if it's not supposed to be only unchanged then it just takes every single package and just says freshen the lot otherwise it needs to scan over the list of packages create a thing for each one which is gathering the information for the package then getting the list of override packages throwing away the unmodified ones inverting the sense of that to come up with the list of things that are expired and unchanged which is the opposite of what this does and then adding items to this list so that we can call fresh and override the way we did before but with a more succinct targeted list for things and i think uh let's we might call this flesh out oops flesh out freshen more nice lean back things don't quite work and of course i'll clean that up a little bit more and there's also some change log entries that need to happen in there as well because this is going to be part of this release now so we'll go ahead and commit that one in and bring that back so we're we're doing pretty good on that regard i think and we'll see how this all shakes out i need to a little bit more testing and clean cleanup and refactoring of some stuff here we'll see how that all shakes out maybe next week's stream might actually be doing another release and continuing in on other stuff we'll have to see how all of that stuff sort of shakes out for the time being so let's go ahead and close that and let's say that we go ahead and do a little bit of this action here so i think uh we're gonna messy hair go ahead and call the stream there we're pretty much at the uh two hour mark at this point yeah it's not too bad probably a few minutes shy because we i was doing some last minute setup but i'm pretty pleased with how uh obs didn't blow anything up on me so that's nice um i'm just gonna click this for a second yeah that's not too shabby um see how well all of this works uh when all is said and done because this is uh a newly compiled version something's getting mad under there still haven't dropped any frames cool if you missed the beginning part uh the intro to the stream i did a bunch of work behind the scenes hand compiling a version of the latest version of obs for linux which required compiling a bunch of libraries for interfacing with the x library that had been modified for the first time in like four or five years and that is not the sort of package you just want to update on your system willy-nilly because any application that's installed might want the older version so there was a fair bit of jiggling around behind the scenes working on how to manual builds of obs to get that working which seems to have worked well um i do need to do a couple more things to tidy up what i did so it's more repeatable while i'm remembering it but i'm pretty pleased with the results of all of that and i'll be even more pleased if i watch the stream replay back and everything seems to have worked okay i've been kind of watching it out of the corner of my eye but we know how these things go so um that's gonna do it for uh this stream thanks so much for watching we will be back next week same sublime time same sublime channel doing some live streams probably going to be something override audit replay related one way or the other i want to get another release pushed out so that might be tidying up what we did tonight to get it ready for a release it might be starting with the release of that and going on to something else i might do the release within the week and maybe we'll just start more in on stuff from a ways back creating patches and whatnot we'll see what's going on for there remember you can always subscribe if you'd like to be uh notified when i'm going live you can always drop questions uh in the live chat if you're watching live or in the comment section below any live stream if you have any questions about stuff and we can cover that in the next uh live stream and i also have a channel my primary channel linked down in the description of the video where i do weekly sublime text tutorials uh interleaving regular tutorials with plugin 101 i course on teaching you how to do the stuff that i'm doing here but with more hands-on actually explaining what's happening instead of just watching me make stupid bugs and i believe monday's video is going to be in that regard working on actually doing a couple of things with plug-in endpoints and tying in with last time not last week's but the previous plugin 101 video on the plug-in lifecycle showing why those plug-in loaded and unloaded methods might be important for you and giving a concrete example of why it is they exist but until um all of that stuff this is uh oh that nerd thanking you for watching and asking you until the next stream or the next video please have a sublime day you

Channel: Terence Martin

Views: 29

Rating: 5 out of 5

Keywords:

Id: nntvxCftt04

Length: 123min 48sec (7428 seconds)

Published: Wed Jun 10 2020