API Method to easily get the properties of an object

Feature Requests Engine Features
#13

Well, there does not seem to be any way of traversing the tree without GetChildren, since that content is completely dynamic.
By contrast, if you know the type of the instance, you know all properties that it has statically.

I think the only compelling usage example is custom serialization.[/quote]

That’s true. At the time I had some kind of complex idea that you could use the descendant API to loop through things and organize it based on that. That would be very unpractical though compared to :GetChildren()

[quote] For the GetProperties() and SetProperties()

How would you represent nil?

I like GetProperties(), or any other method to get data from the API Dump.
That would be amazing, a new service “WikiService” or “ClassService” or “API Dump Thingy Service”.
That would just have methods as GetAllClasses(), GetClassHierarchie(), GetProperties(class), …
(A bit as I did in: Documentation - Roblox Creator Hub Other wiki people already altered it a lot) [/quote]

:GetProperties() would probably just return nil if you give it an invalid parameter.
If :SetProperties() doesn’t find any matches within the properties table then it would do nothing and issue out an error.

[quote] The other big use case is plugins. In fact, I just wrote an API Dump → Giant Lua table parser just today to use in a plugin that I’m making, which will take a selected object in the game hierarchy, and generate a ModuleScript which when called creates the object in question. The idea being that the generated module is actually in a human-readable format, so that you can make further modifications to it in code.

Another example where we’ve needed a way to get metadata on the games team several times: In a “CreateShadowText” function. We need to know what properties to copy over to the shadow text objects when the original text object changes and what properties to not copy over because they are actually changes to locked / readonly properties, but we have no way of doing that without using a hard-coded lookup table of special cases, or by using pcall on every single property change. [/quote]

Thanks for providing some examples Stravant! I didn’t actually think of that.

These API additions wouldn’t be used all the time, but in special cases like what Stravant explained and for serialization purposes I could see these being useful. It’s true that you know what properties it has, but at first, but you may not know the values or need to keep track of the initial properties of multiple different objects as they dynamically change. And as I said, there is no simple way to get all of the properties at once, or a specific group easily without spending a bunch of time writing special property checking code.

#14

I’ve seen recent issues where these API additions would prove useful. I would like to spark conversation on my age-old addition.

#15

If you’re willing to enable HttpEnabled, you can just retrieve the contents of this page:
http://anaminus.github.io/rbx/raw/api/latest.txt

It’s not part of the ROBLOX domain so you wouldn’t need to use a proxy to access it. Plugins no longer require you to create a NetworkServer to use HttpService if that was an issue for you in the past.

#16

[quote] If you’re willing to enable HttpEnabled, you can just retrieve the contents of this page:
http://anaminus.github.io/rbx/raw/api/latest.txt

It’s not part of the ROBLOX domain so you wouldn’t need to use a proxy to access it. Plugins no longer require you to create a NetworkServer to use HttpService if that was an issue for you in the past. [/quote]

While this is a neat solution, should we really need httpservice in order to have a maintenance free way of getting details about a object?

1 Like
#17

No – the API dump and ReflectionMetadata should be included in a studio/client-readable location and we should be able to read the contents of those files. Regardless of what’s best though, if you don’t want to put your projects on hold for a year or three, HttpService is really your only option at this point.

1 Like
#18

That’s true. Based on the previous discussion, zeuxcg mostly didn’t see practical uses for this kind of thing. This is why I think this is a under-thought-about issue.

2 Likes
#19

This kind of thing is too meta for use in actual games. The only real application here is for the development of games, so I think it’s better off staying outside the API. What I would prefer is improvements to the the API dump. Some things I’d like:

  • An API dump in a standard format (like JSON). The current API dump format has ambiguities that make it potentially difficult to parse (if the Studio settings class were ever added, all hell would break loose). This is also a good chance to include more detailed information, such as by incorporating ReflectionMetadata.
  • A reliable way to detect new versions of Roblox. What would great is a web API that receives a timestamp and returns a list of versions that were deployed after the given time.
  • A platform-independent way of getting API dumps (such as a web API). Right now, getting it depends on being able to run an executable and having all the required dependencies, which usually means running on Windows or some other non-Linux platform.
#20

Another use would just be serialization methods for datastores.
Ex: Stravant’s Instance Encoder module and Merely’s Online Studio uses a parsed ReflectionMetadata that needs to be updated for new features.

3 Likes
#21

I’d like to be able to get the properties of an object, because of it’s use in making a script builder with a good properties, and workspace view to use as well, without being able to get the properties, you have to use a messy table of all known property names of Instances, and risk some instances erroring if it doesn’t allow you to index ClassName

#22

[quote] Another use would just be serialization methods for datastores.
Ex: Stravant’s Instance Encoder module and Merely’s Online Studio uses a parsed ReflectionMetadata that needs to be updated for new features. [/quote]

Mine just uses the API dump, which is retrieved from http://anaminus.github.io/rbx/raw/api/latest.txt
It seems to successfully encode and decode most properties, and I haven’t had any issues just yet. The only time where an issue could occur is when the API dump changes order, and it doesn’t seem as if that’s going to happen any time soon.

#24

I still think this needs to be a thing. At least :getproperties()
Even if it has limited use cases so does a lot of the rest of the API. It makes those use cases a heck of a lot easier.
APIs are about simplifying those complex processes or having a standardized way of doing it.

2 Likes
#25

What are you doing and why do you need this feature to do it?

If something like this were implemented, I would prefer a method that gets documentation on a class. It would feel like API bloat though; I’d be especially hesitant to add new properties/methods to everything because if someone had an instance in a folder of that name it would break this code: “require(script.Parent.GetProperties)”

#26

I’d rather have something for plugins to get a machine-readable API dump tbh

#27

Shouldn’t have to rely on the API dump.[quote=“Tomarty, post:25, topic:7536, full:true”]
What are you doing and why do you need this feature to do it?

If something like this were implemented, I would prefer a method that gets documentation on a class. It would feel like API bloat though; I’d be especially hesitant to add new properties/methods to everything because if someone had an instance in a folder of that name it would break this code: “require(script.Parent.GetProperties)”
[/quote]

Look at previous examples. Plugins and serializations are key use cases.
Adding anything is bound to break someone’s code.

#28

Why? It provides exactly the information you’re asking for and more?

1 Like
#29

I shouldn’t be limited to names of properties without important information about inheritance and security context.

2 Likes
#30

Because you still have to manually parse it when on the C++ side ROBLOX doesn’t.
By that point you might as well just grab it off the wiki.(Manually or httpservice)

The point of the API is to grab the properties and not have to parse the entirety of the metadata.
API method could have parameters to lift those limitations.

1 Like
#31

ROBLOX could provide it in tabular form as they do for various other methods (e.g. GetGroupInfoAsync)

1 Like
#32

Not viable because you’d need to update the plugin every week.

Not viable because it relies on HttpEnabled.

Emphasis on machine readable. It could either be delivered as a json table or a lua dictionary.

2 Likes
#33

Oh, no, this topic again :frowning:
So… what would be the order of applying properties from such a table? Any design insights?

2 Likes