Support for Portable Object format

[dodyg]

Please combine this with Portable Object support (https://www.nuget.org/packages/OrchardCore.Localization/). It is so much nicer than RESX.

[earloc]

I´d love to get a deeper dive into that topic. To further assist in a possible adoption, would you be so kind and provide details about what you´d expect from TypealizR once support has been implemented?
Would be great also if you could provide a sample-project and describe the behaivor once TypealizR ran on such a sample.

[dodyg]

These are two sample projects that use OrchardCore.Localization.

• https://github.com/dodyg/practical-aspnetcore/blob/net6.0/projects/localization/localization-5
• https://github.com/dodyg/practical-aspnetcore/blob/net6.0/projects/localization/localization-6

[earloc]

Ok, these samples seem to be a good foundation to gather more insights of what schould be done.

Are the provided .po-files "feature-complete"? Or could there be more going on in them? From what I currently see, I would propose the following design:

When we feed a source-generator with the following content of a *.po-file

msgid "Hello"
msgstr "Howdy"

msgctxt  "Greet Friend"
msgid "Hello"
msgstr "Howdy friend"

msgctxt  "Greet Lover"
msgid "Hello"
msgstr "Hello my darling"

msgctxt  "Greet Somebody"
msgid "Hello {name:s}"
msgstr "Hello {0}"

the following class(es) should be generated:

class ExtensionBase {
    protected readonly Localize;
    public ExtensionBase (IStringLocalizer localize) {
      Localize = localize;
    }
  }
class Greet_LoverExtensions : ExtensionBase  {
    internal Greet_LoverExtensions (IStringLocalizer localize) : base (localize) {}
    public LocalizedString Hello() => Localize["Hello"]; // returns "Howdy friend"
}

class Greet_FriendExtensions : ExtensionBase  {
    internal Greet_FriendExtensions (IStringLocalizer localize) : base (localize) {}
    public LocalizedString Hello() => Localize["Hello"]; // returns "Howdy my darling"
}

class Greet_SomebodyExtensions : ExtensionBase  {
    internal Greet_SomebodyExtensions (IStringLocalizer localize) : base (localize) {}
    public LocalizedString Hello(string name) => Localize["Hello {name:s}", name]; // returns "Hello <name>"
}

class PortableObjectExtensions : ExtensionBase{
    internal PortableObjectExtensions  (IStringLocalizer localize) : base (localize) {
        Greet_Friend = new(localize);
        Greet_Lover = new(localize);
        Greet_Somebody  = new(localize);
    }

  LocalizedString Hello() => Localize["Hello"]; // returns "Howdy"

 internal Greet_LoverExtensions Greet_Friend { get; }
 internal Greet_FriendExtensions  Greet_Lover { get; }
 internal Greet_SomebodyExtensions Greet_Somebody { get; }
}

Then consumers would just need to instantiate the outer-type once and re-use it e.g. via Dependency-Injection.

Should this work? Or is an instance of IStringLocalizer always bound to their respictive msgctx (which I currently guess)?

Where does AddPortableObjectLocalization come from in your samples?

From https://github.com/OrchardSkills/OrchardSkills.OrchardCore.Localization/blob/main/LocalizationTheme/Localization/fr-FR.po there seem to be a complete other usage, where msgctxt looks like it could be used as a T for IStringLocalizer<T>, I guess. This would dramatically simplify the implementation, as it would be mostly the same as the current ResX-base approach, where always have to be some marker-type of some sort.

[earloc]

So, if we could use the content of msgctxt as the T for IStringLocalizer<T>, this could be done.

But what if it is just an arbitrary string, like in your samples?

Should the source-generator just generate an empty marker-type, which then could be used with:

var fac = context.RequestServices.GetService<IStringLocalizerFactory>();
var local = fac.Create(typeof(Greet_Lover); // var is IStringLocalizer<Greet_Lover>

Then the source-generator would just generate the according extension-methods:

static class IStringLocalizerExtensions_Greet_Lover {
  static LocalizedString Hello(this IStringLocalizer<Greet_Lover> that) => that["Hello"]; // returns "Hello my darling"
}

[dodyg]

PO also support plural forms - not sure how it can work in code generation

msgid "You have %d new message" 
msgid_plural "You have %d new messages" 
msgstr[0] "Sie haben %d neue Nachricht" 
msgstr[1] "Sie haben %d neue Nachrichten"

https://localizely.com/po-file/

[earloc]

This looks rather straight forward. Using msgid_plural as the generated method-name and then performing something like this:

static class IStringLocalizerExtensions_??? {
  static LocalizedString You_have__count__new_messages(this IStringLocalizer<???> that, int count) 
    => (count == 1) ? 
        that["Sie haben %d neue Nachricht", count] : //single
        that["Sie haben %d neue Nachrichten", count];  // plural
}

(The above static logic might need to be made some sort of dynamic, as this seems to originate from the PO-File header .

[earloc]

Do you know if the index-notation [0] in msgstr[0] is just an index, or really an actual number which get´s compared somehow according to https://localizely.com/language-plural-rules/

[earloc]

I think these guys here already tackled this somehow. WIll have a deeper look, when I find the time.

https://github.com/fintermobilityas/i18n.core/tree/a010e9d8c27a49513546586b605e9305e2e6c328/src/i18n.Core/PortableObject

[earloc]

Even https://github.com/OrchardSkills/OrchardSkills.OrchardCore.Localization/tree/main/OrchardSkills.OrchardCore.CMS/Localization/it looks like there is tooling around generation of those files. Looks like there are even references to usages of the respective msgids...

[earloc]

Hey @dodyg, hope you´re doin´ well and had some nice holidays, so far.

Are you still interested in this? I recently made some refactorings during work on #23 which might make supporting this relatively easy ( I guess).

Still have no discrete idea about how the actual "support" would look like, though, as already mentioned above.

I´ll kepp this discussion around a little bit more, but will eventually close it in 2-3 weeks.

[dodyg]

Let me check the code base and try some ideas. The plural form of PO can make things a tad bit complicated.

[earloc]

The main quetstion here is still: "how´d you want to use the generated code".

I mostly start with pseudo code expressing what I want to do...No need for code-diving atm, I guess.

Beware that I´m in the middle of a rather broader refactoring of the internals, though.

So, as an input it would be nice to have some useful samples of *.po-files, and then maybe some fictional client code, which uses the code which might have emitted. Something like this

From there we could ellaborate how this might fit into TypealizR at all.

[flyingfishfuse]

I got a notification that I was mentioned in this thread... uhhhhhh... github bug or hack? I dont recall ever using this software...

[earloc]

yeah, dunno either where this came from. I also had an email in my inbox, but when I looked here, the comment was not there. Seems like GitHub already detected it as Spam ;)