Add Vehicle, Music, and Person to Parse method

Source/Bogus.Tests/HandlebarsTests/ArgumentsTest.cs

@@ -137,4 +137,121 @@ public void can_parse_timespan_with_arguments()
       faker.Parse("{{date.timespan(00:00:25)}}")
          .Should().Be("00:00:15.0880571");
    }
+
+
+   [Fact]
+   public void can_parse_vehicle()
+   {
+      var faker = new Faker();
+      var result = faker.Parse("{{vehicle.manufacturer}}");
+      Assert.NotNull(result);
+   }
+
+   [Fact]
+   public void parse_vehicle_returns_expected_value()
+   {
+      var faker = new Faker();
+      var result = faker.Parse("{{vehicle.manufacturer}}");
+      result.Should().Be("Maserati");
+   }
+
+   [Fact]
+   public void can_parse_music()
+   {
+      var faker = new Faker();
+      var result = faker.Parse("{{music.genre}}");
+      Assert.NotNull(result);
+   }
+
+   [Fact]
+   public void parse_music_returns_expected_value()
+   {
+      var faker = new Faker();
+      var result = faker.Parse("{{music.genre}}");
+      result.Should().Be("Hip Hop");
+   }
+
+   [Fact]
+   public void can_parse_person()
+   {
+      var faker = new Faker();
+      var firstname = faker.Parse("{{person.firstname}}");
+      var lastname = faker.Parse("{{person.lastname}}");
+      var fullname = faker.Parse("{{person.fullname}}");
+
+      Assert.Multiple(() =>
+      {
+         Assert.NotNull(firstname);
+         Assert.NotNull(lastname);
+         Assert.NotNull(fullname);
+         Assert.True($"{firstname} {lastname}" == fullname);
+      });
+   }
+   private class TestClass
+   {
+      public string Name { get; set; }
+   }
+
+   [Fact]
+   public void can_parse_person_in_rulefor()
+   {
+      var faker = new Faker<TestClass>();
+      faker.RuleFor(o => o.Name, (f, o) =>
+      {
+         return f.Parse("{{person.firstname}} {{person.lastname}}");
+      });
+
+      var fakes = faker.Generate(10);
+
+      fakes.Should().OnlyHaveUniqueItems(o => o.Name);
+   }
+
+   [Fact]
+   public void can_parse_all_person_values()
+   {
+      var faker = new Faker();
+
+      var firstname = faker.Parse("{{person.FirstName}}");
+      var lastname = faker.Parse("{{person.LastName}}");
+      var fullname = faker.Parse("{{person.FullName}}");
+      var gender = faker.Parse("{{person.Gender}}");
+      var username = faker.Parse("{{person.UserName}}");
+      var avatar = faker.Parse("{{person.Avatar}}");
+      var email = faker.Parse("{{person.Email}}");
+      var dateofbirth = faker.Parse("{{person.DateOfBirth}}");
+      var geolat = faker.Parse("{{person.AddressGeoLat}}");
+      var geolng = faker.Parse("{{person.AddressGeoLng}}");
+      var street = faker.Parse("{{person.AddressStreet}}");
+      var suit = faker.Parse("{{person.AddressSuite}}");
+      var city = faker.Parse("{{person.AddressCity}}");
+      var state = faker.Parse("{{person.AddressState}}");
+      var zipcode = faker.Parse("{{person.AddressZipCode}}");
+      var phone = faker.Parse("{{person.Phone}}");
+      var website = faker.Parse("{{person.Website}}");
+      var companyname = faker.Parse("{{person.CompanyName}}");
+      var companycatchphrase = faker.Parse("{{person.CompanyCatchPhrase}}");
+      var companybs = faker.Parse("{{person.CompanyBs}}");
+
+
+      firstname.Should().Be("Doris");
+      lastname.Should().Be("Schultz");
+      fullname.Should().Be("Doris Schultz");
+      gender.Should().Be("Female");
+      username.Should().Be("Doris.Schultz");
+      avatar.Should().Be("https://ipfs.io/ipfs/Qmd3W5DuhgHirLHGVixi6V76LhCkZUz6pnFt5AJBiyvHye/avatar/1180.jpg");
+      email.Should().Be("Doris69@yahoo.com");
+      //dateofbirth.Should().Be(""); Not sure the best way to test DOB.
+      geolat.Should().Be("-38.4622");
+      geolng.Should().Be("-0.6396");
+      street.Should().Be("31681 Little Flats");
+      suit.Should().Be("Suite 926");
+      city.Should().Be("Port Simone");
+      state.Should().Be("Rhode Island");
+      zipcode.Should().Be("42504-1131");
+      phone.Should().Be("1-607-290-8836 x5069");
+      website.Should().Be("javier.biz");
+      companyname.Should().Be("MacGyver and Sons");
+      companycatchphrase.Should().Be("Programmable multi-tasking implementation");
+      companybs.Should().Be("e-enable enterprise mindshare");
+   }
 }

Source/Bogus/Faker.cs

@@ -92,17 +92,26 @@ public string Parse(string str)
          this.System,
          this.Commerce,
          this.Database,
-         this.Random);
+         this.Random,
+         this.Music,
+         this.Vehicle,
+         this.ParsePerson);
    }
 
 
    private Person person;
+   private Bogus.PersonParseWrapper.Person parseperson;
 
    /// <summary>
    /// A contextually relevant fields of a person.
    /// </summary>
    public Person Person => person ??= new Person(this.Random, this.localDateTimeRef, this.Locale);
 
+   /// <summary>
+   /// A wrapper to allow for Person to be passed into Parse method.
+   /// </summary>
+   [RegisterMustasheMethods]
+   internal Bogus.PersonParseWrapper.Person ParsePerson => parseperson ??= new Bogus.PersonParseWrapper.Person(this.Random, this.localDateTimeRef, this.Locale);
 
    private DateTime? localDateTimeRef;
 
@@ -364,6 +373,7 @@ public T PickRandomWithout<T>(params T[] exclude) where T : struct, Enum
    internal void NewContext()
    {
       person = null;
+      parseperson = null;
       this.capturedGlobalIndex = Interlocked.Increment(ref GlobalUniqueIndex);
       Interlocked.Increment(ref IndexFaker);
    }

Source/Bogus/PersonParseWrapper.cs

@@ -0,0 +1,127 @@
+#pragma warning disable 1591
+
+using System;
+
+namespace Bogus.PersonParseWrapper
+{
+
+   /// <summary>
+   /// Creates a wrapper around Person to allow for lazy loading of Bogus.Person which facilitates parsing.
+   /// </summary>
+   public class Person
+   {
+
+      Lazy<Bogus.Person> lazyPerson;
+
+      /// <summary>
+      /// Initialising Lazy loading of Bogus.Person to prevent it from interfering with seeds during unit tests.
+      /// </summary>
+      /// <param name="randomizer"></param>
+      /// <param name="refDate"></param>
+      /// <param name="locale"></param>
+      internal Person(Randomizer randomizer, DateTime? refDate, string locale = "en")
+      {
+         lazyPerson = new(() => new Bogus.Person(randomizer, refDate, locale));
+      }
+
+      public string Gender()
+      {
+         return lazyPerson.Value.Gender.ToString();
+      }
+
+      public string FirstName()
+      {
+         return lazyPerson.Value.FirstName;
+      }
+
+      public string LastName()
+      {
+         return lazyPerson.Value.LastName;
+      }
+
+      public string FullName()
+      {
+         return lazyPerson.Value.FullName;
+      }
+
+      public string UserName()
+      {
+         return lazyPerson.Value.UserName;
+      }
+
+      public string Avatar()
+      {
+         return lazyPerson.Value.Avatar;
+      }
+
+      public string Email()
+      {
+         return lazyPerson.Value.Email;
+      }
+
+      public DateTime DateOfBirth()
+      {
+         return lazyPerson.Value.DateOfBirth;
+      }
+
+      public double AddressGeoLat()
+      {
+         return lazyPerson.Value.Address.Geo.Lat;
+      }
+
+      public double AddressGeoLng()
+      {
+         return lazyPerson.Value.Address.Geo.Lng;
+      }
+
+      public string AddressStreet()
+      {
+         return lazyPerson.Value.Address.Street;
+      }
+
+      public string AddressSuite()
+      {
+         return lazyPerson.Value.Address.Suite;
+      }
+
+      public string AddressCity()
+      {
+         return lazyPerson.Value.Address.City;
+      }
+
+      public string AddressState()
+      {
+         return lazyPerson.Value.Address.State;
+      }
+
+      public string AddressZipCode()
+      {
+         return lazyPerson.Value.Address.ZipCode;
+      }
+
+      public string Phone()
+      {
+         return lazyPerson.Value.Phone;
+      }
+
+      public string Website()
+      {
+         return lazyPerson.Value.Website;
+      }
+
+      public string CompanyName()
+      {
+         return lazyPerson.Value.Company.Name;
+      }
+
+      public string CompanyCatchPhrase()
+      {
+         return lazyPerson.Value.Company.CatchPhrase;
+      }
+
+      public string CompanyBs()
+      {
+         return lazyPerson.Value.Company.Bs;
+      }
+   }
+}

Source/Bogus/Tokenizer.cs

@@ -23,7 +23,7 @@ static Tokenizer()
 
    public static void RegisterMustashMethods(Type type)
    {
-      MustashMethods = type.GetProperties()
+      MustashMethods = type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
          .Where(p => p.IsDefined(typeof(RegisterMustasheMethodsAttribute), true))
          .SelectMany(p =>
             {