Make attribute references accessible everywhere

Author: QuickWrite

src/main/java/net/quickwrite/fluent4j/ast/FluentBase.java

@@ -96,19 +96,6 @@ private FluentPlaceable getPlaceable(final StringSlice content) {
 
         boolean canSelect = placeable instanceof FluentSelectable;
 
-        if (!canSelect && content.getChar() == '.') {
-            content.increment();
-            StringSlice slice = StringSliceUtil.getIdentifier(content);
-
-            if (placeable instanceof TermReference) {
-                placeable = new AttributeReference.TermAttributeReference(placeable, slice);
-            } else {
-                placeable = new AttributeReference(placeable, slice);
-            }
-
-            canSelect = true;
-        }
-
         StringSliceUtil.skipWhitespaceAndNL(content);
 
         if (canSelect && content.getChar() == '-') {

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

@@ -21,7 +21,7 @@
  * -term-test = { -term.attribute }
  * </pre>
  */
-public class AttributeReference implements FluentPlaceable, FluentArgumentResult {
+public class AttributeReference implements FluentPlaceable, FluentSelectable, FluentArgumentResult {
     protected final FluentPlaceable reference;
     protected final String attributeIdentifier;
 

src/main/java/net/quickwrite/fluent4j/util/StringSliceUtil.java

@@ -169,42 +169,60 @@ private static FluentPlaceable expressionGetDefault(final StringSlice slice) {
 
         skipWhitespaceAndNL(slice);
 
-        if (slice.getChar() == '(') {
-            slice.increment();
+        return switch (slice.getChar()) {
+            case '(' -> expressionGetFunction(slice, expression, isTerm);
+            case '.' -> expressionGetAttribute(slice, expression, isTerm);
+            default -> expression;
+        };
 
-            int start = slice.getPosition();
+    }
 
-            int open = 0;
+    private static FluentPlaceable expressionGetFunction(final StringSlice slice, FluentPlaceable expression, final boolean isTerm) {
+        slice.increment();
 
-            while (!(slice.getChar() == ')' && open == 0)) {
-                if (slice.isBigger()) {
-                    throw new FluentParseException(")", "EOF", slice.getAbsolutePosition());
-                }
+        int start = slice.getPosition();
 
-                if (slice.getChar() == '(') {
-                    open++;
-                }
+        int open = 0;
 
-                if (slice.getChar() == ')') {
-                    open--;
-                }
+        while (!(slice.getChar() == ')' && open == 0)) {
+            if (slice.isBigger()) {
+                throw new FluentParseException(")", "EOF", slice.getAbsolutePosition());
+            }
 
-                slice.increment();
+            if (slice.getChar() == '(') {
+                open++;
             }
 
-            if (!isTerm) {
-                expression = new FunctionReference(
+            if (slice.getChar() == ')') {
+                open--;
+            }
+
+            slice.increment();
+        }
+
+        expression = (!isTerm) ?
+                new FunctionReference(
                         expression.stringValue(),
                         slice.substring(start, slice.getPosition())
-                );
-            } else {
-                expression = new TermReference(
+                ) :
+                new TermReference(
                         expression.stringValue(),
                         slice.substring(start, slice.getPosition())
                 );
-            }
 
-            slice.increment();
+        slice.increment();
+
+        return expression;
+    }
+
+    private static FluentPlaceable expressionGetAttribute(final StringSlice slice, FluentPlaceable expression, final boolean isTerm) {
+        slice.increment();
+        final StringSlice identifier = StringSliceUtil.getIdentifier(slice);
+
+        if (isTerm) {
+            expression = new AttributeReference.TermAttributeReference(expression, identifier);
+        } else {
+            expression = new AttributeReference(expression, identifier);
         }
 
         return expression;