Fabricate | PHP data generator for Testing inspired on Fabrication

Sadly I've not found anything that fits 100% of the bill, but there are a few tools that might give you some more flexibility in this area:

1. Virtual Nodes and Relationships

https://neo4j.com/labs/apoc/4.1/virtual/virtual-nodes-rels/. These are nodes and rels that live for the duration of the query. However, they're for visualisation only, and you can't perform matches on them. For example, this returns the virtual nodes & rels:

The parameterless form of super() relies on it being physically placed inside a class body - the Python machinnery them will, under the hood, create a __class__ cell variable referring that "physical" class (roughly equivalent to a non-local variable), and place it as the first parameter in the super() call.

For methods not written inside class statements, one have to resort to explicitly placing the parameters to super, and these are the child class, and the instance (self).

The easier way to do that in your code is to define the methods inside your factory function, so they can share a non-local variable containing the newly created class in the super call: ​

When the change method in Changer runs, @input is an instance variable specific to that Changer instance, and it is nil.

You want your change method to work on the input argument being provided to it, rather than @input.

Git's facilities for dealing with detected corrupt objects are ... primitive at best. The usual way is to go to some backup, but in this case, that option seems to be out. (But consider local backups, e.g., Time Machine if you have it.)

If the corrupt object (blob in this case) is a loose object, and you know the correct content, you can remove the bad loose object file and use git hash-object -w to create a correct loose object file, which neatly fixes everything. Presumably, however, you don't know the correct content, which is what led you to this:

1. Fabricate a correct blob using git hash-object. But then it will have a different hash.

That is, you make up some content—presumably all-new—and write it to the object store with git hash-object -w or git hash-object -w -t blob (-t blob is the default). That's all fine as far as it goes, but it doesn't replace the bad object.

Can I just rename the file?

No, that won't help: the commit contains a tree object, or series of tree objects, that provide the name and then refer to the file's content by blob hash ID. Those trees will continue to exist. They refer, by hash ID, to the corrupted blob object: they say, e.g., "when extracting this commit, file path/to/file is mode 100644 (rw-r--r--) and comes from blob ". Like all Git objects, once written, they may not be changed—overwriting their data simply produces a corrupt object, i.e., one whose data hash doesn't match the hash name by which Git is told to retrieve the data.

You would therefore need to make up replacement tree objects. These in turn require replacing the commit object, which requires replacing all "downstream" commits (commits that have this commit as any ancestor). At this point you'd be better off using git filter-repo or equivalent. (Making this work as a general way of recovering from corrupted repositories would go a long way to fixing the "primitive at best" that I started off with here, and long-term, that might be the way to go.)

1. Replace the corrupt blob in the two affected commits by git replace.

This might actually work pretty well, and afterward, you can run git filter-repo or the old git filter-branch to re-copy the repository to one that lacks a reference to the corrupt blob object.¹ Combine this, at least conceptually (you wouldn't necessarily need to use git replace-object at all) with some sort of repair option to filter-repo and we're getting somewhere in terms of a proper repair facility.

Is there any potential danger with that?

It leaves the corrupt blob in the repository. This might have some effect on future attempts to repack, so I'd definitely want to use the git filter-* tricks.

1. The corruption is about 15 commits deep in history. I could reset to the commit before the corruption and manually redo the changes. Perhaps I could then rebase the later commits.

This is essentially a by-hand version of the git filter-* method after git replace.

Using git filter-repo to do it is safer in a sense, as filter-repo uses git fast-export and git fast-import "under the covers" so as to build an all-new repository from the original input. This means the newly-built repository—the result of the fast-import—never had any corrupted object introduced into it in the first place. The real question here is whether git fast-export will work on the repository that has the corrupted blob, perhaps after using git replace or some other trick.

¹Note: I say "can" here as if it's merely a matter of running the commands. That might actually be the case! But it might be that the git fast-export operation dies partway through, having stumbled over the corrupt object. So this may turn out to be a Small Matter of Programming. In theory it should be do-able as we won't need or want the bad object for any purpose.

If you provide a reproducible example (i.e. an example on a data set that we can all run on our machines), we can better help you out.

The gtsummary package exports a plot() method you can use to construct a forest plot. Example below!

We can try assign

Add this parameter to the command line when running pyinstaller:

--collect-data cloudscraper

You can create flow of your stages like this:

The model that has the foreign key, in this case Credential, is the one that is required to have a user_id value to be persisted. This means that there needs to be a user (either in memory or in the database) before creating a credential. This is the reason why using build works for you.

If the user exists in memory, rails will be smart enough to create that one first before creating the credential. It seems to me that when you use build with Fabricate it’s initializing a user and a credential so when the user is saved, it saves the credential with the newly created user.

Note that the docs use this syntax for belongs_to, not has_one. It seems that you may need to refer to the callbacks section of the documentation to fix this issue.