vIPer | vIPer : a new tool for IPython notebooks

The standard way of doing this while avoiding globals would be to define a struct that represents your server, and its methods would be the handlers. Then the methods share the struct's data, and you place things like your mongo client in there.

Something like this (in your admin package):

I don't have any issue if I use cmd.PersistentFlags().Lookup("name").

I appreciate this might not be the correct answer for everyone, but this is what worked for me. I was struggling with trying to debug this and for the sake of time, I concluded that just creating everything programmatically would be easier. There are numerous tutorials for this, but I took the following structure: Stevia library used to set constraints for components and add subview

• As described in https://TheSwiftDev.com/the-ultimate-viper-architecture-tutorial that teaches VIPER in its purest/original form (without some of the tangents that have appeared in recent years), VIPER is all about zones (or layers) of quarantined/divorced-apart functionality that speak to each other interzone via an app-domain data structs (many of which are the simpler E entities in the VIPER acronym) and the app-domain messages that each zone publish as their interzone API. In effect, each V I P R zone of VIPER presents a sort of façade to the other zones:

1. while keeping UI/Apple-think/Android-think quarantined within V view zone, because such UI matters are not purely app-domain;
2. while keeping sensor/datastore/networking/Apple-think/Android-think quarantined/divorced within I interactor zone, because such data-acquisition/data-exchange matters are not purely app-domain;
3. while keeping navigation/Apple-think/Android-think/iOS-think/MacOS-think quarantined/divorced within R router zone, because such navigation matters are not purely app-domain (e.g., is the error presented by a pop-up modal dialog box or by a nonmetal dialog box or appending to the end of a scrolling log window-pane? as depending on which OS/platform) With all that in mind:

• The UI-centric CustomVC and its UI-centric subclasses go into V view zone in VIPER. A façade at the perimeter of V view zone translates interzone app-domain entity-based messages to intrazone UI concepts, constructs, and method invocations of Apple-think frameworks or Android-think frameworks.
• The business logic (which is obviously purely app-domain by definition) goes in the P presenter zone in VIPER. Whether there is a CustomPresenter superclass direct analogue in P presenter zone or whether P presenter zone models it differently due P presenter zone's own needs is a designer's choice, taking into account local taste. My point is that there is no strict rule to obey zealously there; not every way of organizing code in V view zone is the way to organizing code in P presenter zone.
• The navigation goes in the R router zone in VIPER. A façade at the perimeter of R router zone translates interzone app-domain entity-based messages to intrazone navigation concepts, constructs, and method invocations of Apple-think frameworks or Android-think frameworks. For example, the navigation might be different on iOS than on MacOS than on an Android port of the same app, because a pop-up modal dialog box versus a semipermanent nonmodal dialog box versus a window-pane might exist in your app's designed UI on certain platform(s) but not on other platform(s). Especially for navigation, ponder just a moment while working on, say, a currently iOS-only app, whether that might be done differently on, say, a desktop MacOS app or on an Android port of the app. If your current architecture of the app is anything like Massive View Controller, you might have navigation quite comingled with UI (which is one symptom of the massive of Massive View Controller antipattern); you will need then need to meticulously tease navigation apart from UI so that navigation & UI get quarantined/divorced separate from each other. Whether there is a CustomRouter superclass direct analogue in R router zone or whether R router zone models it differently due R router zone's own needs is a designer's choice, taking into account local taste. My point is that there is no strict rule to obey zealously there; not every way of organizing code in V view zone is the way to organizing code in R router zone.
• The sensor, datastore, and networking goes in the I interactor zone of VIPER. A façade at the perimeter of I interactor zone translates interzone app-domain entity-based messages to intrazone sensor/datastore/networking concepts, constructs, and method invocations of Apple-think frameworks or Android-think frameworks or 3rd-party libraries/frameworks. In this zone especially, ponder a little bit whether the quarantine/divorce is so clean & perfect that you can swap out non-app-domain infrastructure X for a different non-app-domain infrastructure Y, such as swap out a database instead of Apple Core Data that perhaps your app outgrew. Whether there is a CustomInteractor superclass direct analogue in I interactor zone or whether I interactor zone models it differently due I interactor zone's own needs is a designer's choice, taking into account local taste. My point is that there is no strict rule to obey zealously there; not every way of organizing code in V view zone is the way to organizing code in I interactor zone.
• The purely app-domain lingua franca interzone is partially simple entities in E entity zone, but more & more nowadays it is also reactive functional-programming-lite effect-event subscriptions & flows, such as RxSwift or Realm. RxSwift if the lingua-franca interzone programming language is Swift (or its Android analogues RxKotlin or RxJava or ZIO+CatsEffect if in Scala if the lingua-franca interzone programming language is one of those 3 languages) can be chosen by the designer as the official app-domain purity. Realm is messier because it does much of what RxSwift does, but when Realm is in interzone lingua franca, now Realm in the datastore interactor zone has not been kept quarantined within its proper datastore-interactor compartment, so now Realm cannot be swapped out as easily for some even better datastore technology in the future. The main moral of the story is: wisely overtly design & choose what comprises the pure app-domain lingua franca entities, messaging, philosophy, dependencies, etc interzone because that is the portion you need to live with unchanged as the app evolves to new OSes, new platforms, new infrastructure.

So no, once all the UI, business logic, and sensor/datastore/networking data-acquisition/exchange has been entirely separated from each other, the view controllers would no longer have anything directly to do with CustomPresenter or with CustomInteractor or CustomRouter, most especially no inheritance from them. All interactions among CustomUI & its subclasses versus CustomPresenter & its subclasses (if any) versus CustomInteractor & its subclasses (if any) versus CustomRouter & its subclasses (if any) would be via pure app-domain messaging (or effect-event subscription) interzone via app-domain lightweight entities—i.e., indirect interaction through V view zone's façade and/or I interactor zone's façade with P presenter zone.

• Router is navigation; navigation is router. You should not think the way that you phrased the question, because “implement … router … across navigation component” will mislead your thinking. https://TheSwiftDev.com/the-ultimate-viper-architecture-tutorial is succinct and clear in establishing good thinking regarding VIPER, although even it could be even better if it drove the following point home even more intensely: 100% of the messaging & data-structures/entities & concepts interlayer between V I P R layers must be strictly app-domain concepts that have nothing to do with Apple-think or Android-think or Microsoft-think. All of the {Apple-frameworks-think, Android-think, Microsoft/UWP-think} must be quarantined within each the V I R layers and never appear at all in the P and E layers.
• It is best to learn navigation from VIPER and MVVM-C examples. The C of MVVM-C is almost exactly the same as the R of VIPER; both are responsible for navigation. There are multiple example/sample apps (as well as few open-source full-fledged apps) that use either VIPER or MVVM-C. Search for them via Bing or Google. You can learn the R of VIPER just as well from the C of MVVM-C if MVVM-C was done properly with strictly app-domain concepts/data-structures/messaging/entities flowing between VM & C without contamination between VM & C layers from {Android-think, Apple-think, Microsoft-think}. Even if messaging between VM & C layers is muddled with {Apple-think, Android-think, Microsoft-think} in some sample/example MVVM-C app, you can still learn from it by translating the operating-environment-pollution interlayer to strictly-app-domain information flows interlayer, but that is pretty much the how-to-convert-my-app-to-reactive/Rx technique by inserting {RxKotlin, RxSwift, RxScala, ZIO+CatsEffect} effect/outcome-centric reactive information flows interlayer instead of some {Android, Apple, Microsoft}-centric delegate/callback mechanism.
• Because VIPER and MVVM-C and Clean all need a pure app-domain interzone way of messaging that has {Apple-think, Android-think, Microsoft-think} quarantined within each layer/zone (e.g., keeping Apple-think/Android-think/Microsoft-think ways of representing UI strictly quarantined within view layer in VIPER; keeping Apple-think/Android-think/Microsoft-think ways of representing navigation strictly quarantined within router layer in VIPER), quite often design teams choose to use an event-driven functional-programming-esque reactive way of representing the strictly app-domain messaging that is flowing between each of the V I P R layers in VIPER (with E entities being the lingua franca of representing app-domain concepts between layers). As such, you can often use such reactive frameworks (e.g., RxSwift when in Apple world; ZIO or Cats Effect or RxScala when in the Scala school of thought within Android world; RxKotlin when in the Kotlin school of thought within Android world) as the primary search word for sample or example apps for that reactive framework, then cherry picking from the list of results the example or sample apps that are VIPER or MVVM-C, such as in https://AwesomeOpenSource.com/projects/rxswift where the description indicates which ones teach VIPER's or MVVM-C's R or C techniques that you will find quite instructive.

To set the ground-rules of this answer, https://TheSwiftDev.com/the-ultimate-viper-architecture-tutorial describes the most-normative original-school-of-thought variant of what VIPER is and what it is intended to accomplish as self-discipline. (Other derivative viewpoints have arisen in the past several years, but I'll use this original school of thought in this answer for all-the-wood-behind-1-arrow clarity & pedagogical reasons.)

• I am going to politely reject OP's usage of “module” with respect to VIPER. Instead, VIPER is 5 zones {view for UI, interactor for datastore/networking/sensors, presenter for app-domain ‘business’ rules, entities for app-domain-centric [not datastore-centric, not network-centric, not sensor-centric] data structures, router for navigation} of quarantine & some degree of divorce. Someone might just say that zone & module are 100% synonyms/congruent, but I am going to tease them apart as separate interpretations. The 5 V I P E R zones are all about the divorce/quarantine from each other to stamp out Massive View Controller antipattern/code-smell software-architecture https://khanlou.com/2015/12/massive-view-controller and https://www.hackingwithswift.com/articles/159/how-to-refactor-massive-view-controllers, which is a mobile-app variant of the older-era Big Ball of Mud antipattern/code-smell software-architecture http://www.laputan.org/mud/mud.html#BigBallOfMud

• Modules on the other hand can be interpreted as finer-grained than the 5 V I P E R zones. Let's do that here. Each zone of VIPER can be further subdivided into modules of like-topic portions of that zone, such as all the (sub)views comprising a scene/screen/containing-view or any other subcategorization of the app that one's heart desires. Module demarcation can be orthogonal (or oblivious) to the 5 V I P E R zones. Indeed, a designer might choose to have the same module demarcation within each of 2 or more V I P E R zones. Or just as validly, a designer might choose to have a quite-different module demarcation within view zone than within interactor zone than within presenter zone, because they each by happenstance focus on a different way of decomposing that isolated/divorced/quarantined zone in a way that is sensible only within that zone (and would make little sense over in some other 4 zones). Hence, from this answer's vantage, we won't mention modules anymore because it is a local taste within each zone, unrelated to the OP's intended goal.

• Each zone in properly-accomplished VIPER architecture has been quarantined so that UI-specific topics never escaped outside of view zone (e.g., into most-temptingly presenter zone or router zone or [usually a lesser temptation unless heavily mimicking nonVIPER examples for sensor or networking data acquisition] interactor zone). Because of this quarantine, the OP's goal is effectively to have a quite-different router/navigation zone that drives the app in testing mode through its various scenes/screens/modal-dialogs in a way that might even be unnatural for the human-being-user variant of the app & its router navigation. But the entire purpose long-term for VIPER software architecture is to swap out a whole zone because it has such impeccable quarantine/divorce—literally like swapping out one spouse for another via marriage divorce. That is what OP is effectively seeking: the wholesale swapping out (primarily) the human-being-user variant of the router zone with a test-mock router zone that drives the app via script-like marching orders to march the UI in ways that take annoyingly too much effort to accomplish via human-being-user UI actions. The mocked/scripted substitute router zone is free to ‘short-circuit’ as it pleases to skip portions of the UI as long as any accumulated state that would have been naturally built up is backfilled as part of the mocking scriptedness. If router would not have had access to whichever methods/API are necessary to accomplish that backfilling of accumulated state when short-circuited navigating to a portion/screen/scene of the UI, then either a) that separation of concerns is eroded so that the mocked/scripted substitute router zone is less quarantined than its regular human-user variant or b) some other zone needs some degree of mocking to backfill that canned accumulated state to cooperate with the mocked/scripted substitute router zone.

• But to accomplish this swap-out of the usual router zone with a mechanistic/test/mocked router zone for script-like navigation of the UI, the interactor zone especially must be mocked out too to drive canned datastore content, canned network content, and canned sensor content/acquisition in a script-like manner as well in ways that cooperate with the testing/mocked router variant. Indeed, the quarantine/divorce so sought after in the usual app-domain human-being-user variant of the app is the prize, but far less quarantine perhaps no divorce at all might be the laudable goal between the mocked/testing router zone and the mocked/testing interactor zone, which might conspire together quite intimately to accomplish their scripted/canned mocking functionality together as one mindset. So what is good divorce/quarantine separation of concerns for the human-being-user primary variant of the app would likely be disastrous separation in the OP's mocking/testing variant of the app, because in effect there is no such separation of concerns between the scripted/mocked router zone substituted in and the scripted/mocked interactor zone substituted in.

• One would hope that the presenter's business-rules quasi-backend-esque processing doesn't need to be mocked out, as hopefully the enforcement of those app-domain business rules are not going to get in the way of mechanistic driving of the UI 1) with mocked/scripted navigation via the substituted router zone and 2) with mocked/scripted data from mocked/scripted sensors, mocked/scripted datastore, and/or mocked/scripted networking. If some app-domain needs to separate out pure UI testing in view zone from pure business-rules/quasi-backend testing in presenter zone, then a mocked-UI view zone would test/drive the real presenter zone and a mocked-business-rule presenter zone (with perhaps alternate-reality/fuzzed business rules) would test/enforce-more-strictly the real view zone.

• Conversely, if the developers of an app failed to 100% quarantine, say, UI topics within view zone, then the ability to swap out the UI-contaminated nonview zones is eroded perhaps fatally to the point that nonview zone cannot be swapped out with a testing/mock substitute of that nonview zone. To accomplish this 100% strict quarantine interzone among the V I P E R zones requires overt self-discipline of assuring that 100% of the interzone messaging/method-invocation is expressed in purely app-domain concepts without contamination from Apple-think or its constructs, Android-think or its concepts, and so forth. Each V I P R zone (other than rather simple entities in E) usually needs a façade layer at the perimeter of each zone to interwork intrazone concepts with app-domain interzone concepts, such as quarantining all of Apple-think UI constructs or Android-think UI concepts within view zone so that only higher-order-thought app-domain concepts are exchanged interzone—likewise with a façade at the perimeter of interactor zone for interworking the quarantine of datastore-centric or sensor-centric or networking-centric constructs intrazone away from higher-order-thought app-domain concepts interzone.

• Likewise, instead of fully automatic scripted navigation, another testing/mock substitute of the router navigation zone could fast-forward the human-being user to a particular portion/screen/scene of the UI for manual interaction for semiautomated testing. The fast forwarding could be to a relatively unfilled-out screen/scene. Or the fast forwarding could be to, say, an editing-something screen with canned elaborate entity to edit already loaded, which is especially useful if the canned elaborate entity is especially pernicious in exercising some use-case or just the right combination of situations for reproduction of a bug.

I had no issues running this on my machine.
I suggest you try catching the error on read file and see if that helps.
You can also provide the file path if needed.

spf13/viper predominantly uses mapstructure package to convert between one native Go type to another i.e. when un-marshaling. You need to define an annotation that would cause any unused values to this map. There is an option to collect such reminder values. You need to modify the map to take an interface as

Let's say a user runs the command like this: cobra-sketch --flag1 "hello". "hello" will be stored in the var flag1 string variable you have assigned to the flag, to check if the input matches any regexp, you can do: