Most of the reason why people focus on dungeon generation over this style of generation is because dungeon generation is vastly simpler to explain and implement, lol. Here's a page that explains at least a little of what you are wanting:
http://www-cs-students.stanford.edu/~amitp/game-programming/polygon-map-generation/
I'm not entirely sure what direction
@Slow Fingers is going to go into, but I, at least, think of the problem like this.
1. I need to develop a good data structure format to hold all the details about how each polygon within the game map should be thought of. Polygons are not the whole "regions" of the map (i.e. Africa in the world map is not a single polygon), but instead the pieces the region is made up of. If you wanted a detailed world map, then polygons would be individual pixels (as the world map is highly detailed), but going down to the individual pixel level would mean everything would run very slowly during the generation so most games make the polygons into larger chunks (this can be seen in Civilisation when you pick the World map, as each polygon is a rather large standard Civ hexagon making some of the countries look a little...odd (Australia in particular)). In Amit's example (the page I linked), they are using voronoi polygons. Each polygon should also hold some way of determining what other polygons it is connected to, to make sure that the map is traversable for things like pathfinding.
2. Once I have that data structure, I need to "fill" the world with these polygons in some way. Usually this would be an array, with each position in the array holding a single polygon. If the polygons are irregular sizes, this
can be a tricky process, but in general, I would find some way of boiling everything down to an array or potentially a map.
3. I need to determine how the borders of each "region" are decided. Am I picking competing points and then floodfilling out from them until they hit each other? Am I predefining border sizes? If so, what happens when borders clash? Etc.
4. Once I know how the borders are determined, I need to find each polygon within each border and mark it down somewhere as "belonging" to that bordered region (normally when I am generating stuff like this that kinda gets more granular as you go down, I store it all in a single array, which holds structs which can hold arrays which can hold structs, all the way down. Then, for instance, position 0 in the top array would be "border region 0" and that would hold a struct that contains the border colour, etc, any information about that region, an array of the cells within the borders, and so on for each region).
5. You are basically done at this point. Now would be when I add any non-region related things (such as treasure, or villages, or whatever random stuff you want in the game). This way you can use the existing border structures to figure some stuff out (for instance, you might not want villages to spawn in a bordered region or whatever).
6. Optimisation. This is the real final step, once you have everything sorted out in a way that works, it's time to benchmark and then start thinking about optimisation steps
if needed. It's always best to save this step to the last, instead of trying to optimise throughout the process, because only at this point are you really fully aware of everything that needs to happen and how the overall structure of the generation will interact with itself. Maybe there's a "2D" array somewhere you can convert to a "1D" by using a position conversion key (x + y * width) or whatever. If so, try it out and see if it speeds things up? Etc. But this step is only needed if things are actually running slowly because of the map in some way.
That would be how I would try to approach the problem. I've never done anything like this before and there's almost guaranteed to be some "gotchas" caught up in the steps I describe above, but that's part of figuring out this generation stuff. Tackle it head on as hard as you can and hope you can hit it hard enough to bounce any problems out of the way.