From 05e063ba6b740d406a72956ed7b48e73f189e005 Mon Sep 17 00:00:00 2001 From: Mahmoud Ben Hassine Date: Fri, 26 Apr 2019 15:54:18 +0200 Subject: [PATCH] Move common rule factories code in an abstract class --- .../org/jeasy/rules/mvel/MVELRuleFactory.java | 50 ++--------- .../org/jeasy/rules/spel/SpELRuleFactory.java | 50 ++--------- .../rules/support/AbstractRuleFactory.java | 82 +++++++++++++++++++ 3 files changed, 92 insertions(+), 90 deletions(-) create mode 100644 easy-rules-support/src/main/java/org/jeasy/rules/support/AbstractRuleFactory.java diff --git a/easy-rules-mvel/src/main/java/org/jeasy/rules/mvel/MVELRuleFactory.java b/easy-rules-mvel/src/main/java/org/jeasy/rules/mvel/MVELRuleFactory.java index e4b2e6c..174c0bb 100644 --- a/easy-rules-mvel/src/main/java/org/jeasy/rules/mvel/MVELRuleFactory.java +++ b/easy-rules-mvel/src/main/java/org/jeasy/rules/mvel/MVELRuleFactory.java @@ -29,7 +29,6 @@ import org.jeasy.rules.support.*; import org.mvel2.ParserContext; import java.io.Reader; -import java.util.Arrays; import java.util.List; /** @@ -37,16 +36,10 @@ import java.util.List; * * @author Mahmoud Ben Hassine (mahmoud.benhassine@icloud.com) */ -public class MVELRuleFactory { +public class MVELRuleFactory extends AbstractRuleFactory { private RuleDefinitionReader reader; - private static final List ALLOWED_COMPOSITE_RULE_TYPES = Arrays.asList( - UnitRuleGroup.class.getSimpleName(), - ConditionalRuleGroup.class.getSimpleName(), - ActivationRuleGroup.class.getSimpleName() - ); - /** * Create a new {@link MVELRuleFactory} with a given reader. * @@ -105,22 +98,14 @@ public class MVELRuleFactory { */ public Rules createRules(Reader rulesDescriptor, ParserContext parserContext) throws Exception { Rules rules = new Rules(); - List ruleDefinition = reader.read(rulesDescriptor); - for (RuleDefinition mvelRuleDefinition : ruleDefinition) { - rules.register(createRule(mvelRuleDefinition, parserContext)); + List ruleDefinitions = reader.read(rulesDescriptor); + for (RuleDefinition ruleDefinition : ruleDefinitions) { + rules.register(createRule(ruleDefinition, parserContext)); } return rules; } - private static Rule createRule(RuleDefinition ruleDefinition, ParserContext context) { - if (ruleDefinition.isCompositeRule()) { - return createCompositeRule(ruleDefinition, context); - } else { - return createSimpleRule(ruleDefinition, context); - } - } - - private static Rule createSimpleRule(RuleDefinition ruleDefinition, ParserContext parserContext) { + protected Rule createSimpleRule(RuleDefinition ruleDefinition, ParserContext parserContext) { MVELRule mvelRule = new MVELRule() .name(ruleDefinition.getName()) .description(ruleDefinition.getDescription()) @@ -132,29 +117,4 @@ public class MVELRuleFactory { return mvelRule; } - private static Rule createCompositeRule(RuleDefinition ruleDefinition, ParserContext parserContext) { - CompositeRule compositeRule; - String name = ruleDefinition.getName(); - switch (ruleDefinition.getCompositeRuleType()) { - case "UnitRuleGroup": - compositeRule = new UnitRuleGroup(name); - break; - case "ActivationRuleGroup": - compositeRule = new ActivationRuleGroup(name); - break; - case "ConditionalRuleGroup": - compositeRule = new ConditionalRuleGroup(name); - break; - default: - throw new IllegalArgumentException("Invalid composite rule type, must be one of " + ALLOWED_COMPOSITE_RULE_TYPES); - } - compositeRule.setDescription(ruleDefinition.getDescription()); - compositeRule.setPriority(ruleDefinition.getPriority()); - - for (RuleDefinition composingRuleDefinition : ruleDefinition.getComposingRules()) { - compositeRule.addRule(createRule(composingRuleDefinition, parserContext)); - } - - return compositeRule; - } } diff --git a/easy-rules-spel/src/main/java/org/jeasy/rules/spel/SpELRuleFactory.java b/easy-rules-spel/src/main/java/org/jeasy/rules/spel/SpELRuleFactory.java index b404947..9b744ab 100644 --- a/easy-rules-spel/src/main/java/org/jeasy/rules/spel/SpELRuleFactory.java +++ b/easy-rules-spel/src/main/java/org/jeasy/rules/spel/SpELRuleFactory.java @@ -30,7 +30,6 @@ import org.springframework.expression.ParserContext; import org.springframework.expression.common.TemplateParserContext; import java.io.Reader; -import java.util.Arrays; import java.util.List; /** @@ -38,16 +37,10 @@ import java.util.List; * * @author Mahmoud Ben Hassine (mahmoud.benhassine@icloud.com) */ -public class SpELRuleFactory { +public class SpELRuleFactory extends AbstractRuleFactory { private RuleDefinitionReader reader; - private static final List ALLOWED_COMPOSITE_RULE_TYPES = Arrays.asList( - UnitRuleGroup.class.getSimpleName(), - ConditionalRuleGroup.class.getSimpleName(), - ActivationRuleGroup.class.getSimpleName() - ); - /** * Create a new {@link SpELRuleFactory} with a given reader. * @@ -106,22 +99,14 @@ public class SpELRuleFactory { */ public Rules createRules(Reader rulesDescriptor, ParserContext parserContext) throws Exception { Rules rules = new Rules(); - List ruleDefinition = reader.read(rulesDescriptor); - for (RuleDefinition spelRuleDefinition : ruleDefinition) { - rules.register(createRule(spelRuleDefinition, parserContext)); + List ruleDefinitions = reader.read(rulesDescriptor); + for (RuleDefinition ruleDefinition : ruleDefinitions) { + rules.register(createRule(ruleDefinition, parserContext)); } return rules; } - private static Rule createRule(RuleDefinition ruleDefinition, ParserContext context) { - if (ruleDefinition.isCompositeRule()) { - return createCompositeRule(ruleDefinition, context); - } else { - return createSimpleRule(ruleDefinition, context); - } - } - - private static Rule createSimpleRule(RuleDefinition ruleDefinition, ParserContext parserContext) { + protected Rule createSimpleRule(RuleDefinition ruleDefinition, ParserContext parserContext) { SpELRule spELRule = new SpELRule() .name(ruleDefinition.getName()) .description(ruleDefinition.getDescription()) @@ -133,29 +118,4 @@ public class SpELRuleFactory { return spELRule; } - private static Rule createCompositeRule(RuleDefinition ruleDefinition, ParserContext parserContext) { - CompositeRule compositeRule; - String name = ruleDefinition.getName(); - switch (ruleDefinition.getCompositeRuleType()) { - case "UnitRuleGroup": - compositeRule = new UnitRuleGroup(name); - break; - case "ActivationRuleGroup": - compositeRule = new ActivationRuleGroup(name); - break; - case "ConditionalRuleGroup": - compositeRule = new ConditionalRuleGroup(name); - break; - default: - throw new IllegalArgumentException("Invalid composite rule type, must be one of " + ALLOWED_COMPOSITE_RULE_TYPES); - } - compositeRule.setDescription(ruleDefinition.getDescription()); - compositeRule.setPriority(ruleDefinition.getPriority()); - - for (RuleDefinition composingRuleDefinition : ruleDefinition.getComposingRules()) { - compositeRule.addRule(createRule(composingRuleDefinition, parserContext)); - } - - return compositeRule; - } } diff --git a/easy-rules-support/src/main/java/org/jeasy/rules/support/AbstractRuleFactory.java b/easy-rules-support/src/main/java/org/jeasy/rules/support/AbstractRuleFactory.java new file mode 100644 index 0000000..e969805 --- /dev/null +++ b/easy-rules-support/src/main/java/org/jeasy/rules/support/AbstractRuleFactory.java @@ -0,0 +1,82 @@ +/** + * The MIT License + * + * Copyright (c) 2019, Mahmoud Ben Hassine (mahmoud.benhassine@icloud.com) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package org.jeasy.rules.support; + +import org.jeasy.rules.api.Rule; + +import java.util.Arrays; +import java.util.List; + +/** + * Base class for rule factories. + * + * @param parser context type + * + * @author Mahmoud Ben Hassine (mahmoud.benhassine@icloud.com) + */ +public abstract class AbstractRuleFactory { + + private static final List ALLOWED_COMPOSITE_RULE_TYPES = Arrays.asList( + UnitRuleGroup.class.getSimpleName(), + ConditionalRuleGroup.class.getSimpleName(), + ActivationRuleGroup.class.getSimpleName() + ); + + protected Rule createRule(RuleDefinition ruleDefinition, C context) { + if (ruleDefinition.isCompositeRule()) { + return createCompositeRule(ruleDefinition, context); + } else { + return createSimpleRule(ruleDefinition, context); + } + } + + protected abstract Rule createSimpleRule(RuleDefinition ruleDefinition, C parserContext); + + protected Rule createCompositeRule(RuleDefinition ruleDefinition, C parserContext) { + CompositeRule compositeRule; + String name = ruleDefinition.getName(); + switch (ruleDefinition.getCompositeRuleType()) { + case "UnitRuleGroup": + compositeRule = new UnitRuleGroup(name); + break; + case "ActivationRuleGroup": + compositeRule = new ActivationRuleGroup(name); + break; + case "ConditionalRuleGroup": + compositeRule = new ConditionalRuleGroup(name); + break; + default: + throw new IllegalArgumentException("Invalid composite rule type, must be one of " + ALLOWED_COMPOSITE_RULE_TYPES); + } + compositeRule.setDescription(ruleDefinition.getDescription()); + compositeRule.setPriority(ruleDefinition.getPriority()); + + for (RuleDefinition composingRuleDefinition : ruleDefinition.getComposingRules()) { + compositeRule.addRule(createRule(composingRuleDefinition, parserContext)); + } + + return compositeRule; + } + +}