Fix cyclic-reference problem

Author: QuickWrite

src/main/java/net/quickwrite/fluent4j/ast/placeable/AttributeReference.java

@@ -70,6 +70,12 @@ public FluentElement getArgumentResult(final AccessorBundle bundle) {
             return this;
         }
 
+        if (bundle.getAccessedStorage().alreadyAccessed(attribute)) {
+            return this;
+        }
+
+        bundle.getAccessedStorage().addElement(attribute);
+
         final List<FluentElement> elementList = attribute.getElements();
 
         if (elementList.size() != 1) {

src/main/java/net/quickwrite/fluent4j/ast/placeable/MessageReference.java

@@ -37,9 +37,9 @@ public String stringValue() {
 
     @Override
     public CharSequence getResult(final AccessorBundle bundle) {
-        return bundle
+         return bundle
                 .getBundle()
-                .getMessage(this.stringValue(), bundle.getArguments())
+                .getMessage(this.stringValue(), bundle)
                 .orElse("{" + this.stringValue() + "}");
     }
 

src/main/java/net/quickwrite/fluent4j/ast/placeable/TermReference.java

@@ -41,7 +41,9 @@ protected boolean check(final String string) {
 
     @Override
     public CharSequence getResult(final AccessorBundle bundle) {
-        return this.getArgumentResult(bundle).getResult(new AccessorElementsBundle(bundle.getBundle(), this.getArguments(bundle)));
+        return bundle.getBundle()
+                .getTerm(this.functionName, new AccessorElementsBundle(bundle.getBundle(), this.getArguments(bundle), bundle.getAccessedStorage()))
+                .orElse("{-" + this.functionName + "}");
     }
 
     /**
@@ -50,13 +52,7 @@ public CharSequence getResult(final AccessorBundle bundle) {
      */
     @Override
     public FluentElement getArgumentResult(final AccessorBundle bundle) {
-        final FluentTerm term = bundle.getBundle().getTerm(this.functionName);
-
-        if (term == null) {
-            return new StringLiteral("{-" + this.functionName + "}");
-        }
-
-        return term;
+        return new StringLiteral(getResult(bundle).toString());
     }
 
     @Override

src/main/java/net/quickwrite/fluent4j/ast/placeable/VariableReference.java

@@ -60,7 +60,7 @@ public FluentElement getArgumentResult(final AccessorBundle bundle) {
             return new StringLiteral("{$" + content + "}");
         }
 
-        return arguments.getNamed(content);
+        return argument;
     }
 
     @Override

src/main/java/net/quickwrite/fluent4j/util/bundle/DirectFluentBundle.java

@@ -2,6 +2,9 @@
 
 import net.quickwrite.fluent4j.ast.FluentMessage;
 import net.quickwrite.fluent4j.ast.FluentTerm;
+import net.quickwrite.fluent4j.util.bundle.args.AccessorBundle;
+
+import java.util.Optional;
 
 public interface DirectFluentBundle extends FluentBundle {
     /**
@@ -21,6 +24,24 @@ public interface DirectFluentBundle extends FluentBundle {
      */
     FluentTerm getTerm(final String key);
 
+    /**
+     * Returns the {@link FluentTerm} that is being stored
+     * for the {@code key}.
+     *
+     * <p>
+     * So when the {@code .ftl}-files contain:
+     * <pre>
+     *     -test = Hello World!
+     * </pre>
+     * it would return the {@link FluentTerm} for the key
+     * {@code test} but {@code null} for anything else.
+     *
+     * @param bundle The bundle that is being used as an argument
+     * @param key    The key that the {@link FluentTerm} is stored in.
+     * @return The term itself
+     */
+    Optional<String> getTerm(final String key, final AccessorBundle bundle);
+
     /**
      * Returns the {@link FluentMessage} that is being stored
      * for the {@code key}.
@@ -38,4 +59,23 @@ public interface DirectFluentBundle extends FluentBundle {
      * @return The message itself
      */
     FluentMessage getMessage(final String key);
+
+    /**
+     * Returns the {@link FluentMessage} that is being stored
+     * for the {@code key}.
+     *
+     * <p>
+     * So when the {@code .ftl}-files contain:
+     * <pre>
+     *     test = Hello World!
+     * </pre>
+     * <p>
+     * it would return the {@link FluentMessage} for the key
+     * {@code test} but {@code null} for anything else.
+     *
+     * @param key    The key that the {@link FluentMessage} is stored in.
+     * @param bundle The bundle that is being used as an argument
+     * @return The message itself
+     */
+    Optional<String> getMessage(final String key, final AccessorBundle bundle);
 }

src/main/java/net/quickwrite/fluent4j/util/bundle/ResourceFluentBundle.java

@@ -9,6 +9,8 @@
 import net.quickwrite.fluent4j.functions.AbstractFunction;
 import net.quickwrite.fluent4j.util.BuiltinFunctions;
 import net.quickwrite.fluent4j.util.args.FluentArgs;
+import net.quickwrite.fluent4j.util.bundle.args.AccessedStorageBundle;
+import net.quickwrite.fluent4j.util.bundle.args.AccessorBundle;
 import net.quickwrite.fluent4j.util.bundle.args.AccessorElementsBundle;
 
 import java.util.*;
@@ -48,16 +50,6 @@ public ResourceFluentBundle(final ULocale locale, final FluentResource resource)
         this.addResource(resource);
     }
 
-    @Override
-    public FluentTerm getTerm(final String key) {
-        return this.terms.get(key);
-    }
-
-    @Override
-    public FluentMessage getMessage(final String key) {
-        return this.messages.get(key);
-    }
-
     @Override
     public void addResource(final FluentResource resource) {
         for (final FluentElement element : resource.getElements()) {
@@ -106,16 +98,60 @@ public boolean hasMessage(final String key) {
 
     @Override
     public Optional<String> getMessage(final String key, final FluentArgs arguments) {
+        return getMessage(
+                key,
+                new AccessorElementsBundle(
+                        this,
+                        arguments != null ? arguments : FluentArgs.EMPTY_ARGS,
+                        new AccessedStorageBundle())
+        );
+    }
+
+    @Override
+    public FluentTerm getTerm(final String key) {
+        return this.terms.get(key);
+    }
+
+    @Override
+    public Optional<String> getTerm(final String key, final AccessorBundle bundle) {
+        final FluentTerm term = this.getTerm(key);
+
+        if (term == null) {
+            return Optional.empty();
+        }
+
+        if (bundle.getAccessedStorage().alreadyAccessed(term)) {
+            return Optional.empty();
+        }
+
+        bundle.getAccessedStorage().addElement(term);
+
+        return Optional.of(
+                term.getResult(bundle).toString()
+        );
+    }
+
+    @Override
+    public FluentMessage getMessage(final String key) {
+        return this.messages.get(key);
+    }
+
+    @Override
+    public Optional<String> getMessage(final String key, final AccessorBundle bundle) {
         final FluentMessage message = this.getMessage(key);
 
         if (message == null) {
             return Optional.empty();
         }
 
+        if (bundle.getAccessedStorage().alreadyAccessed(message)) {
+            return Optional.empty();
+        }
+
+        bundle.getAccessedStorage().addElement(message);
+
         return Optional.of(
-                message.getResult(
-                        new AccessorElementsBundle(this, arguments != null ? arguments : FluentArgs.EMPTY_ARGS)
-                ).toString()
+                message.getResult(bundle).toString()
         );
     }
 

src/main/java/net/quickwrite/fluent4j/util/bundle/args/AccessedStorage.java

@@ -0,0 +1,9 @@
+package net.quickwrite.fluent4j.util.bundle.args;
+
+import net.quickwrite.fluent4j.ast.FluentBase;
+
+public interface AccessedStorage {
+    boolean alreadyAccessed(final FluentBase element);
+
+    void addElement(final FluentBase element);
+}

src/main/java/net/quickwrite/fluent4j/util/bundle/args/AccessedStorageBundle.java

@@ -0,0 +1,24 @@
+package net.quickwrite.fluent4j.util.bundle.args;
+
+import net.quickwrite.fluent4j.ast.FluentBase;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class AccessedStorageBundle implements AccessedStorage {
+    private final Set<FluentBase> elementSet;
+
+    public AccessedStorageBundle() {
+        this.elementSet = new HashSet<>();
+    }
+
+    @Override
+    public boolean alreadyAccessed(final FluentBase element) {
+        return this.elementSet.contains(element);
+    }
+
+    @Override
+    public void addElement(final FluentBase element) {
+        this.elementSet.add(element);
+    }
+}

src/main/java/net/quickwrite/fluent4j/util/bundle/args/AccessorBundle.java

@@ -7,4 +7,6 @@ public interface AccessorBundle {
     DirectFluentBundle getBundle();
 
     FluentArgs getArguments();
+
+    AccessedStorage getAccessedStorage();
 }

src/main/java/net/quickwrite/fluent4j/util/bundle/args/AccessorElementsBundle.java

@@ -6,10 +6,13 @@
 public class AccessorElementsBundle implements AccessorBundle {
     private final DirectFluentBundle bundle;
     private final FluentArgs arguments;
+    private final AccessedStorage accessedStorage;
 
-    public AccessorElementsBundle(final DirectFluentBundle bundle, final FluentArgs arguments) {
+    public AccessorElementsBundle(final DirectFluentBundle bundle, final FluentArgs arguments, final AccessedStorage accessedStorage) {
         this.bundle = bundle;
         this.arguments = arguments;
+
+        this.accessedStorage = accessedStorage;
     }
 
     @Override
@@ -21,4 +24,9 @@ public DirectFluentBundle getBundle() {
     public FluentArgs getArguments() {
         return this.arguments;
     }
+
+    @Override
+    public AccessedStorage getAccessedStorage() {
+        return this.accessedStorage;
+    }
 }