docs: update .editorconfig and reformat readmes

Author: iluwatar

Diff for: .editorconfig

@@ -31,7 +31,7 @@ end_of_line = lf
 indent_size = 4
 indent_style = space
 insert_final_newline = false
-max_line_length = 120
+max_line_length = off
 tab_width = 4
 ij_continuation_indent_size = 8
 ij_formatter_off_tag = @formatter:off
@@ -355,6 +355,7 @@ ij_markdown_format_tables = true
 ij_markdown_insert_quote_arrows_on_wrap = true
 ij_markdown_keep_indents_on_empty_lines = false
 ij_markdown_keep_line_breaks_inside_text_blocks = true
+ij_markdown_max_line_length = off
 ij_markdown_max_lines_around_block_elements = 1
 ij_markdown_max_lines_around_header = 1
 ij_markdown_max_lines_between_paragraphs = 1

Diff for: abstract-document/README.md

@@ -10,35 +10,27 @@ tag:
 
 ## Intent
 
-The Abstract Document design pattern is a structural design pattern that aims to provide a consistent way to handle
-hierarchical and tree-like data structures by defining a common interface for various document types. It separates the
-core document structure from specific data formats, enabling dynamic updates and simplified maintenance.
+The Abstract Document design pattern is a structural design pattern that aims to provide a consistent way to handle hierarchical and tree-like data structures by defining a common interface for various document types. It separates the core document structure from specific data formats, enabling dynamic updates and simplified maintenance.
 
 ## Explanation
 
-The Abstract Document pattern enables handling additional, non-static properties. This pattern uses concept of traits to
-enable type safety and separate properties of different classes into set of interfaces.
+The Abstract Document pattern enables handling additional, non-static properties. This pattern uses concept of traits to enable type safety and separate properties of different classes into set of interfaces.
 
 Real world example
 
-> Consider a car that consists of multiple parts. However, we don't know if the specific car really has all the parts,
-> or just some of them. Our cars are dynamic and extremely flexible.
+> Consider a car that consists of multiple parts. However, we don't know if the specific car really has all the parts, or just some of them. Our cars are dynamic and extremely flexible.
 
 In plain words
 
 > Abstract Document pattern allows attaching properties to objects without them knowing about it.
 
 Wikipedia says
 
-> An object-oriented structural design pattern for organizing objects in loosely typed key-value stores and exposing the
-> data using typed views. The purpose of the pattern is to achieve a high degree of flexibility between components in a
-> strongly typed language where new properties can be added to the object-tree on the fly, without losing the support of
-> type-safety. The pattern makes use of traits to separate different properties of a class into different interfaces.
+> An object-oriented structural design pattern for organizing objects in loosely typed key-value stores and exposing the data using typed views. The purpose of the pattern is to achieve a high degree of flexibility between components in a strongly typed language where new properties can be added to the object-tree on the fly, without losing the support of type-safety. The pattern makes use of traits to separate different properties of a class into different interfaces.
 
 **Programmatic Example**
 
-Let's first define the base classes `Document` and `AbstractDocument`. They basically make the object hold a property
-map and any amount of child objects.
+Let's first define the base classes `Document` and `AbstractDocument`. They basically make the object hold a property map and any amount of child objects.
 
 ```java
 public interface Document {
@@ -84,8 +76,7 @@ public abstract class AbstractDocument implements Document {
 }
 ```
 
-Next we define an enum `Property` and a set of interfaces for type, price, model and parts. This allows us to create
-static looking interface to our `Car` class.
+Next we define an enum `Property` and a set of interfaces for type, price, model and parts. This allows us to create static looking interface to our `Car` class.
 
 ```java
 public enum Property {
@@ -180,38 +171,21 @@ And finally here's how we construct and use the `Car` in a full example.
 
 ## Applicability
 
-This pattern is particularly useful in scenarios where you have different types of documents that share some common
-attributes or behaviors, but also have unique attributes or behaviors specific to their individual types. Here are some
-scenarios where the Abstract Document design pattern can be applicable:
+This pattern is particularly useful in scenarios where you have different types of documents that share some common attributes or behaviors, but also have unique attributes or behaviors specific to their individual types. Here are some scenarios where the Abstract Document design pattern can be applicable:
 
-* Content Management Systems (CMS): In a CMS, you might have various types of content such as articles, images, videos,
-  etc. Each type of content could have shared attributes like creation date, author, and tags, while also having
-  specific attributes like image dimensions for images or video duration for videos.
+* Content Management Systems (CMS): In a CMS, you might have various types of content such as articles, images, videos, etc. Each type of content could have shared attributes like creation date, author, and tags, while also having specific attributes like image dimensions for images or video duration for videos.
 
-* File Systems: If you're designing a file system where different types of files need to be managed, such as documents,
-  images, audio files, and directories, the Abstract Document pattern can help provide a consistent way to access
-  attributes like file size, creation date, etc., while allowing for specific attributes like image resolution or audio
-  duration.
+* File Systems: If you're designing a file system where different types of files need to be managed, such as documents, images, audio files, and directories, the Abstract Document pattern can help provide a consistent way to access attributes like file size, creation date, etc., while allowing for specific attributes like image resolution or audio duration.
 
-* E-commerce Systems: An e-commerce platform might have different product types such as physical products, digital
-  downloads, and subscriptions. Each type could share common attributes like name, price, and description, while having
-  unique attributes like shipping weight for physical products or download link for digital products.
+* E-commerce Systems: An e-commerce platform might have different product types such as physical products, digital downloads, and subscriptions. Each type could share common attributes like name, price, and description, while having unique attributes like shipping weight for physical products or download link for digital products.
 
-* Medical Records Systems: In healthcare, patient records might include various types of data such as demographics,
-  medical history, test results, and prescriptions. The Abstract Document pattern can help manage shared attributes like
-  patient ID and date of birth, while accommodating specialized attributes like test results or prescribed medications.
+* Medical Records Systems: In healthcare, patient records might include various types of data such as demographics, medical history, test results, and prescriptions. The Abstract Document pattern can help manage shared attributes like patient ID and date of birth, while accommodating specialized attributes like test results or prescribed medications.
 
-* Configuration Management: When dealing with configuration settings for software applications, there can be different
-  types of configuration elements, each with its own set of attributes. The Abstract Document pattern can be used to
-  manage these configuration elements while ensuring a consistent way to access and manipulate their attributes.
+* Configuration Management: When dealing with configuration settings for software applications, there can be different types of configuration elements, each with its own set of attributes. The Abstract Document pattern can be used to manage these configuration elements while ensuring a consistent way to access and manipulate their attributes.
 
-* Educational Platforms: Educational systems might have various types of learning materials such as text-based content,
-  videos, quizzes, and assignments. Common attributes like title, author, and publication date can be shared, while
-  unique attributes like video duration or assignment due dates can be specific to each type.
+* Educational Platforms: Educational systems might have various types of learning materials such as text-based content, videos, quizzes, and assignments. Common attributes like title, author, and publication date can be shared, while unique attributes like video duration or assignment due dates can be specific to each type.
 
-* Project Management Tools: In project management applications, you could have different types of tasks like to-do
-  items, milestones, and issues. The Abstract Document pattern could be used to handle general attributes like task name
-  and assignee, while allowing for specific attributes like milestone date or issue priority.
+* Project Management Tools: In project management applications, you could have different types of tasks like to-do items, milestones, and issues. The Abstract Document pattern could be used to handle general attributes like task name and assignee, while allowing for specific attributes like milestone date or issue priority.
 
 * Documents have diverse and evolving attribute structures.
 
@@ -221,10 +195,7 @@ scenarios where the Abstract Document design pattern can be applicable:
 
 * Maintainability and flexibility are critical for the codebase.
 
-The key idea behind the Abstract Document design pattern is to provide a flexible and extensible way to manage different
-types of documents or entities with shared and distinct attributes. By defining a common interface and implementing it
-across various document types, you can achieve a more organized and consistent approach to handling complex data
-structures.
+The key idea behind the Abstract Document design pattern is to provide a flexible and extensible way to manage different types of documents or entities with shared and distinct attributes. By defining a common interface and implementing it across various document types, you can achieve a more organized and consistent approach to handling complex data structures.
 
 ## Consequences
 

Diff for: abstract-factory/README.md

@@ -14,32 +14,25 @@ Kit
 
 ## Intent
 
-The Abstract Factory design pattern provides a way to create families of related objects without specifying their
-concrete classes. This allows for code that is independent of the specific classes of objects it uses, promoting
-flexibility and maintainability.
+The Abstract Factory design pattern provides a way to create families of related objects without specifying their concrete classes. This allows for code that is independent of the specific classes of objects it uses, promoting flexibility and maintainability.
 
 ## Explanation
 
 Real-world example
 
-> To create a kingdom we need objects with a common theme. The elven kingdom needs an elven king, elven castle, and
-> elven army whereas the orcish kingdom needs an orcish king, orcish castle, and orcish army. There is a dependency
-> between the objects in the kingdom.
+> To create a kingdom we need objects with a common theme. The elven kingdom needs an elven king, elven castle, and elven army whereas the orcish kingdom needs an orcish king, orcish castle, and orcish army. There is a dependency between the objects in the kingdom.
 
 In plain words
 
-> A factory of factories; a factory that groups the individual but related/dependent factories together without
-> specifying their concrete classes.
+> A factory of factories; a factory that groups the individual but related/dependent factories together without specifying their concrete classes.
 
 Wikipedia says
 
-> The abstract factory pattern provides a way to encapsulate a group of individual factories that have a common theme
-> without specifying their concrete classes
+> The abstract factory pattern provides a way to encapsulate a group of individual factories that have a common theme without specifying their concrete classes
 
 **Programmatic Example**
 
-Translating the kingdom example above. First of all, we have some interfaces and implementation for the objects in the
-kingdom.
+Translating the kingdom example above. First of all, we have some interfaces and implementation for the objects in the kingdom.
 
 ```java
 public interface Castle {
@@ -134,8 +127,7 @@ public class OrcKingdomFactory implements KingdomFactory {
 }
 ```
 
-Now we have the abstract factory that lets us make a family of related objects i.e. elven kingdom factory creates elven
-castle, king and army, etc.
+Now we have the abstract factory that lets us make a family of related objects i.e. elven kingdom factory creates elven castle, king and army, etc.
 
 ```java
 var factory=new ElfKingdomFactory();
@@ -156,11 +148,7 @@ This is the elven castle!
         This is the elven Army!
 ```
 
-Now, we can design a factory for our different kingdom factories. In this example, we created `FactoryMaker`,
-responsible for returning an instance of either `ElfKingdomFactory` or `OrcKingdomFactory`. The client can
-use `FactoryMaker` to create the desired concrete factory which, in turn, will produce different concrete objects (
-derived from `Army`, `King`, `Castle`). In this example, we also used an enum to parameterize which type of kingdom
-factory the client will ask for.
+Now, we can design a factory for our different kingdom factories. In this example, we created `FactoryMaker`, responsible for returning an instance of either `ElfKingdomFactory` or `OrcKingdomFactory`. The client can use `FactoryMaker` to create the desired concrete factory which, in turn, will produce different concrete objects (derived from `Army`, `King`, `Castle`). In this example, we also used an enum to parameterize which type of kingdom factory the client will ask for.
 
 ```java
 public static class FactoryMaker {
@@ -203,8 +191,7 @@ Use the Abstract Factory pattern when
 * The system should be independent of how its products are created, composed, and represented
 * The system should be configured with one of the multiple families of products
 * The family of related product objects is designed to be used together, and you need to enforce this constraint
-* You want to provide a class library of products, and you want to reveal just their interfaces, not their
-  implementations
+* You want to provide a class library of products, and you want to reveal just their interfaces, not their implementations
 * The lifetime of the dependency is conceptually shorter than the lifetime of the consumer.
 * You need a run-time value to construct a particular dependency
 * You want to decide which product to call from a family at runtime.
@@ -214,8 +201,7 @@ Use the Abstract Factory pattern when
 
 Example use cases
 
-* Selecting to call to the appropriate implementation of FileSystemAcmeService or DatabaseAcmeService or
-  NetworkAcmeService at runtime.
+* Selecting to call to the appropriate implementation of FileSystemAcmeService or DatabaseAcmeService or NetworkAcmeService at runtime.
 * Unit test case writing becomes much easier
 * UI tools for different OS
 
@@ -258,4 +244,5 @@ Trade-offs
 * [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59)
 * [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b)
 * [Java Design Patterns: A Hands-On Experience with Real-World Examples](https://amzn.to/3HWNf4U)
-* [Design Patterns in Java](https://amzn.to/3Syw0vC)
+* [Design Patterns in Java](https://amzn.to/3Syw0vC)
+* 

Diff for: active-object/README.md

@@ -8,22 +8,17 @@ tag:
 
 ## Intent
 
-The Active Object design pattern provides a safe and reliable way to implement asynchronous behavior in concurrent
-systems. It achieves this by encapsulating tasks within objects that have their own thread and message queue. This
-separation keeps the main thread responsive and avoids issues like direct thread manipulation or shared state access.
+The Active Object design pattern provides a safe and reliable way to implement asynchronous behavior in concurrent systems. It achieves this by encapsulating tasks within objects that have their own thread and message queue. This separation keeps the main thread responsive and avoids issues like direct thread manipulation or shared state access.
 
 ## Explanation
 
-The class that implements the active object pattern will contain a self-synchronization mechanism without using '
-synchronized' methods.
+The class that implements the active object pattern will contain a self-synchronization mechanism without using 'synchronized' methods.
 
 Real-world example
 
-> The Orcs are known for their wildness and untameable soul. It seems like they have their own thread of control based
-> on previous behavior.
+> The Orcs are known for their wildness and untameable soul. It seems like they have their own thread of control based on previous behavior.
 
-To implement a creature that has its own thread of control mechanism and expose its API only and not the execution
-itself, we can use the Active Object pattern.
+To implement a creature that has its own thread of control mechanism and expose its API only and not the execution itself, we can use the Active Object pattern.
 
 **Programmatic Example**
 
@@ -83,8 +78,7 @@ public abstract class ActiveCreature {
 }
 ```
 
-We can see that any class that will extend the ActiveCreature class will have its own thread of control to invoke and
-execute methods.
+We can see that any class that will extend the ActiveCreature class will have its own thread of control to invoke and execute methods.
 
 For example, the Orc class:
 
@@ -98,8 +92,7 @@ public class Orc extends ActiveCreature {
 }
 ```
 
-Now, we can create multiple creatures such as Orcs, tell them to eat and roam, and they will execute it on their own
-thread of control:
+Now, we can create multiple creatures such as Orcs, tell them to eat and roam, and they will execute it on their own thread of control:
 
 ```java
   public static void main(String[]args){