From ecd171a1e619e7fe397bed8409e765248323c7bb Mon Sep 17 00:00:00 2001 From: Steve Atkinson Date: Sun, 27 Jan 2019 14:22:37 +0000 Subject: [PATCH 1/4] Added the documentation. --- README.md | 1 + doc/hacker.md | 24 ++++++++++++++++++++++++ 2 files changed, 25 insertions(+) create mode 100644 doc/hacker.md diff --git a/README.md b/README.md index 982d698..6137ae8 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ A .NET port of the Ruby [faker](https://github.com/stympy/faker) gem - [Faker.File](doc/file.md) - [Faker.Food](doc/food.md) - [Faker.GameOfThrones](doc/game_of_thrones.md) + - [Faker.Hacker](doc/hacker.md) - [Faker.Internet](doc/internet.md) - [Faker.Lorem](doc/lorem.md) - [Faker.Name](doc/name.md) diff --git a/doc/hacker.md b/doc/hacker.md new file mode 100644 index 0000000..ef42d20 --- /dev/null +++ b/doc/hacker.md @@ -0,0 +1,24 @@ +# Faker.Hacker + +Are you having trouble writing tech-savvy dialogue for your latest screenplay? +Worry not! Hollywood-grade technical talk is ready to fill out any form where you need to look smart. + +```cs +// Full Phrase +Faker.Hacker.SaySomethingSmart() //=> "Try to compress the SQL interface, maybe it will program the back-end hard drive!" + +// Short technical abbreviations +Faker.Hacker.Abbreviation() //=> "RAM" + +// Hacker centric adjectives +Faker.Hacker.Adjective() //=> "open-source" + +// Only the best hacker related nouns +Faker.Hacker.Noun() //=> "bandwidth" + +// Actions that hackers take +Faker.Hacker.Verb() //=> "bypass" + +// Verbs that end in -ing +Faker.Hacker.Ingverb() //=> "synthesizing" +``` \ No newline at end of file From a51377bcc150a407daa43bd874788123443b86a0 Mon Sep 17 00:00:00 2001 From: Steve Atkinson Date: Sun, 27 Jan 2019 14:22:52 +0000 Subject: [PATCH 2/4] Added the data for the Hacker faker. --- src/FakerDotNet/Data/HackerData.cs | 142 +++++++++++++++++++++++++++++ 1 file changed, 142 insertions(+) create mode 100644 src/FakerDotNet/Data/HackerData.cs diff --git a/src/FakerDotNet/Data/HackerData.cs b/src/FakerDotNet/Data/HackerData.cs new file mode 100644 index 0000000..3739450 --- /dev/null +++ b/src/FakerDotNet/Data/HackerData.cs @@ -0,0 +1,142 @@ +using System.Collections.Generic; + +namespace FakerDotNet.Data +{ + internal static class HackerData + { + public static readonly IEnumerable Abbreviations = new[] + { + "TCP", + "HTTP", + "SDD", + "RAM", + "GB", + "CSS", + "SSL", + "AGP", + "SQL", + "FTP", + "PCI", + "AI", + "ADP", + "RSS", + "XML", + "EXE", + "COM", + "HDD", + "THX", + "SMTP", + "SMS", + "USB", + "PNG", + "SAS", + "IB", + "SCSI", + "JSON", + "XSS", + "JBOD" + }; + + public static readonly IEnumerable Adjectives = new[] + { + "auxiliary", + "primary", + "back-end", + "digital", + "open-source", + "virtual", + "cross-platform", + "redundant", + "online", + "haptic", + "multi-byte", + "bluetooth", + "wireless", + "1080p", + "neural, optical", + "solid state", + "mobile" + }; + + public static readonly IEnumerable Nouns = new[] + { + "driver", + "protocol", + "bandwidth", + "panel", + "microchip", + "program", + "port", + "card", + "array", + "interface", + "system", + "sensor", + "firewall", + "hard drive", + "pixel", + "alarm", + "feed", + "monitor", + "application", + "transmitter", + "bus", + "circuit", + "capacitor", + "matrix" + }; + + public static readonly IEnumerable Verbs = new[] + { + "back up", + "bypass", + "hack", + "override", + "compress", + "copy", + "navigate", + "index", + "connect", + "generate", + "quantify", + "calculate", + "synthesize", + "input", + "transmit", + "program", + "reboot", + "parse" + }; + + public static readonly IEnumerable Ingverbs = new[] + { + "backing up", + "bypassing", + "hacking", + "overriding", + "compressing", + "copying", + "navigating", + "indexing", + "connecting", + "generating", + "quantifying", + "calculating, synthesizing", + "transmitting", + "programming", + "parsing" + }; + + public static readonly IEnumerable Phrases = new[] + { + "If we {Verb} the {Noun}, we can get to the {Abbreviation} {Noun} through the {Adjective} {Abbreviation} {Noun}!", + "We need to {Verb} the {Adjective} {Abbreviation} {Noun}!", + "Try to {Verb} the {Abbreviation} {Noun}, maybe it will {Verb} the {Adjective} {Noun}!", + "You can't {Verb} the {Noun} without {Ingverb} the {Adjective} {Abbreviation} {Noun}!", + "Use the {Adjective} {Abbreviation} {Noun}, then you can {Verb} the {Adjective} {Noun}!", + "The {Abbreviation} {Noun} is down, {Verb} the {Adjective} {Noun} so we can {Verb} the {Abbreviation} {Noun}!", + "{Ingverb} the {Noun} won't do anything, we need to {Verb} the {Adjective} {Abbreviation} {Noun}!", + "I'll {Verb} the {Adjective} {Abbreviation} {Noun}, that should {Noun} the {Abbreviation} {Noun}!" + }; + } +} From 9ab06de2097cdc8aeb3eb7be15e9c62858c76fcf Mon Sep 17 00:00:00 2001 From: Steve Atkinson Date: Sun, 27 Jan 2019 14:23:13 +0000 Subject: [PATCH 3/4] Implemented the Hacker faker. --- src/FakerDotNet/Fakers/HackerFaker.cs | 62 +++++++++++++ .../Fakers/HackerFakerTests.cs | 88 +++++++++++++++++++ 2 files changed, 150 insertions(+) create mode 100644 src/FakerDotNet/Fakers/HackerFaker.cs create mode 100644 tests/FakerDotNet.Tests/Fakers/HackerFakerTests.cs diff --git a/src/FakerDotNet/Fakers/HackerFaker.cs b/src/FakerDotNet/Fakers/HackerFaker.cs new file mode 100644 index 0000000..c31fb4b --- /dev/null +++ b/src/FakerDotNet/Fakers/HackerFaker.cs @@ -0,0 +1,62 @@ +using System.Text.RegularExpressions; +using FakerDotNet.Data; + +namespace FakerDotNet.Fakers +{ + public interface IHackerFaker + { + string SaySomethingSmart(); + string Abbreviation(); + string Adjective(); + string Noun(); + string Verb(); + string Ingverb(); + } + + internal class HackerFaker : IHackerFaker + { + private readonly IFakerContainer _fakerContainer; + + public HackerFaker(IFakerContainer fakerContainer) + { + _fakerContainer = fakerContainer; + } + + public string SaySomethingSmart() + { + return Parse(_fakerContainer.Random.Element(HackerData.Phrases)); + } + + public string Abbreviation() + { + return _fakerContainer.Random.Element(HackerData.Abbreviations); + } + + public string Adjective() + { + return _fakerContainer.Random.Element(HackerData.Adjectives); + } + + public string Noun() + { + return _fakerContainer.Random.Element(HackerData.Nouns); + } + + public string Verb() + { + return _fakerContainer.Random.Element(HackerData.Verbs); + } + + public string Ingverb() + { + return _fakerContainer.Random.Element(HackerData.Ingverbs); + } + + private string Parse(string format) + { + var text = Regex.Replace(format, @"\{(\w+)\}", @"{Hacker.$1}"); + + return _fakerContainer.Fake.F(text); + } + } +} diff --git a/tests/FakerDotNet.Tests/Fakers/HackerFakerTests.cs b/tests/FakerDotNet.Tests/Fakers/HackerFakerTests.cs new file mode 100644 index 0000000..0e4bf51 --- /dev/null +++ b/tests/FakerDotNet.Tests/Fakers/HackerFakerTests.cs @@ -0,0 +1,88 @@ +using FakeItEasy; +using FakerDotNet.Data; +using FakerDotNet.Fakers; +using NUnit.Framework; + +namespace FakerDotNet.Tests.Fakers +{ + [TestFixture] + [Parallelizable] + public class HackerFakerTests + { + [SetUp] + public void SetUp() + { + _fakerContainer = A.Fake(); + _hackerFaker = new HackerFaker(_fakerContainer); + + A.CallTo(() => _fakerContainer.Fake).Returns(new FakeFaker(_fakerContainer)); + } + + private IFakerContainer _fakerContainer; + private IHackerFaker _hackerFaker; + + [Test] + public void SaySomethingSmart_returns_something_smart() + { + A.CallTo(() => _fakerContainer.Random.Element(HackerData.Phrases)) + .Returns("Try to {Verb} the {Abbreviation} {Noun}, maybe it will {Verb} the {Adjective} {Noun}!"); + A.CallTo(() => _fakerContainer.Hacker.Verb()) + .ReturnsNextFromSequence("compress", "program"); + A.CallTo(() => _fakerContainer.Hacker.Abbreviation()) + .Returns("SQL"); + A.CallTo(() => _fakerContainer.Hacker.Noun()) + .ReturnsNextFromSequence("interface", "hard drive"); + A.CallTo(() => _fakerContainer.Hacker.Adjective()) + .Returns("back-end"); + + Assert.AreEqual( + "Try to compress the SQL interface, maybe it will program the back-end hard drive!", + _hackerFaker.SaySomethingSmart()); + } + + [Test] + public void Abbreviation_returns_an_abbreviation() + { + A.CallTo(() => _fakerContainer.Random.Element(HackerData.Abbreviations)) + .Returns("RAM"); + + Assert.AreEqual("RAM", _hackerFaker.Abbreviation()); + } + + [Test] + public void Adjective_returns_an_adjective() + { + A.CallTo(() => _fakerContainer.Random.Element(HackerData.Adjectives)) + .Returns("open-source"); + + Assert.AreEqual("open-source", _hackerFaker.Adjective()); + } + + [Test] + public void Noun_returns_a_noun() + { + A.CallTo(() => _fakerContainer.Random.Element(HackerData.Nouns)) + .Returns("bandwidth"); + + Assert.AreEqual("bandwidth", _hackerFaker.Noun()); + } + + [Test] + public void Verb_returns_a_verb() + { + A.CallTo(() => _fakerContainer.Random.Element(HackerData.Verbs)) + .Returns("bypass"); + + Assert.AreEqual("bypass", _hackerFaker.Verb()); + } + + [Test] + public void Ingverb_returns_an_ing_ending_verb() + { + A.CallTo(() => _fakerContainer.Random.Element(HackerData.Ingverbs)) + .Returns("synthesizing"); + + Assert.AreEqual("synthesizing", _hackerFaker.Ingverb()); + } + } +} From d78d879cec6f71dffcd1625b6143bfb0adfd24d5 Mon Sep 17 00:00:00 2001 From: Steve Atkinson Date: Sun, 27 Jan 2019 14:23:35 +0000 Subject: [PATCH 4/4] Added the HackerFaker to the main faker classes. --- src/FakerDotNet/Faker.cs | 1 + src/FakerDotNet/FakerContainer.cs | 3 +++ tests/FakerDotNet.Tests/FakerContainerTests.cs | 6 ++++++ tests/FakerDotNet.Tests/FakerTests.cs | 6 ++++++ 4 files changed, 16 insertions(+) diff --git a/src/FakerDotNet/Faker.cs b/src/FakerDotNet/Faker.cs index fa21d52..162abe5 100644 --- a/src/FakerDotNet/Faker.cs +++ b/src/FakerDotNet/Faker.cs @@ -25,6 +25,7 @@ public static class Faker public static IFoodFaker Food { get; } = Container.Food; public static IFriendsFaker Friends { get; } = Container.Friends; public static IGameOfThronesFaker GameOfThrones { get; } = Container.GameOfThrones; + public static IHackerFaker Hacker { get; } = Container.Hacker; public static IInternetFaker Internet { get; } = Container.Internet; public static ILoremFaker Lorem { get; } = Container.Lorem; public static INameFaker Name { get; } = Container.Name; diff --git a/src/FakerDotNet/FakerContainer.cs b/src/FakerDotNet/FakerContainer.cs index 8133c27..6c4176a 100644 --- a/src/FakerDotNet/FakerContainer.cs +++ b/src/FakerDotNet/FakerContainer.cs @@ -23,6 +23,7 @@ internal interface IFakerContainer IFoodFaker Food { get; } IFriendsFaker Friends { get; } IGameOfThronesFaker GameOfThrones { get; } + IHackerFaker Hacker { get; } IInternetFaker Internet { get; } ILoremFaker Lorem { get; } INameFaker Name { get; } @@ -65,6 +66,7 @@ public FakerContainer() Food = new FoodFaker(this); Friends = new FriendsFaker(this); GameOfThrones = new GameOfThronesFaker(this); + Hacker = new HackerFaker(this); Internet = new InternetFaker(this); Lorem = new LoremFaker(this); Name = new NameFaker(this); @@ -103,6 +105,7 @@ public FakerContainer() public IFoodFaker Food { get; } public IFriendsFaker Friends { get; } public IGameOfThronesFaker GameOfThrones { get; } + public IHackerFaker Hacker { get; } public IInternetFaker Internet { get; } public ILoremFaker Lorem { get; } public INameFaker Name { get; } diff --git a/tests/FakerDotNet.Tests/FakerContainerTests.cs b/tests/FakerDotNet.Tests/FakerContainerTests.cs index 652f2e8..2bab9cd 100644 --- a/tests/FakerDotNet.Tests/FakerContainerTests.cs +++ b/tests/FakerDotNet.Tests/FakerContainerTests.cs @@ -129,6 +129,12 @@ public void GameOfThrones_returns_IGameOfThronesFaker() Assert.IsInstanceOf(_fakerContainer.GameOfThrones); } + [Test] + public void Hacker_returns_IHackerFaker() + { + Assert.IsInstanceOf(_fakerContainer.Hacker); + } + [Test] public void Internet_returns_IInternetFaker() { diff --git a/tests/FakerDotNet.Tests/FakerTests.cs b/tests/FakerDotNet.Tests/FakerTests.cs index 6e0cb28..338893f 100644 --- a/tests/FakerDotNet.Tests/FakerTests.cs +++ b/tests/FakerDotNet.Tests/FakerTests.cs @@ -121,6 +121,12 @@ public void GameOfThrones_returns_IGameOfThronesFaker() Assert.IsInstanceOf(Faker.GameOfThrones); } + [Test] + public void Hacker_returns_IHackerFaker() + { + Assert.IsInstanceOf(Faker.Hacker); + } + [Test] public void Internet_returns_IInternetFaker() {