refactor(policy): refactor policy management to use Role model

- Replaced Policy references with Role in PolicyManager and RoleEvaluator classes.
- Updated related methods and properties to reflect the change from policies to roles.
- Introduced a new Role model to encapsulate role-based access control logic.
- Adjusted integration and unit tests to validate the new role-based structure.

Author: dgarciasquare1

lib/src/core/policy_manager.dart

@@ -3,7 +3,7 @@ import 'package:flutter_policy_engine/src/core/interfaces/i_policy_evaluator.dar
 import 'package:flutter_policy_engine/src/core/interfaces/i_policy_storage.dart';
 import 'package:flutter_policy_engine/src/core/memory_policy_storage.dart';
 import 'package:flutter_policy_engine/src/core/role_evaluator.dart';
-import 'package:flutter_policy_engine/src/models/policy.dart';
+import 'package:flutter_policy_engine/src/models/role.dart';
 import 'package:flutter_policy_engine/src/utils/json_handler.dart';
 import 'package:flutter_policy_engine/src/utils/log_handler.dart';
 
@@ -40,7 +40,7 @@ class PolicyManager extends ChangeNotifier {
   IPolicyEvaluator? _evaluator;
 
   /// Internal cache of loaded policies, keyed by policy identifier.
-  Map<String, Policy> _policies = {};
+  Map<String, Role> _roles = {};
 
   /// Indicates whether the policy manager has been initialized with policy data.
   bool _isInitialized = false;
@@ -54,15 +54,15 @@ class PolicyManager extends ChangeNotifier {
   ///
   /// The returned map cannot be modified directly. Use [initialize] to update
   /// the policy collection.
-  Map<String, Policy> get policies => Map.unmodifiable(_policies);
+  Map<String, Role> get roles => Map.unmodifiable(_roles);
 
   /// Initializes the policy manager with policy data from JSON.
   ///
   /// Parses the provided [jsonPolicies] and loads them into the internal cache.
   /// This method should be called before using any policy-related functionality.
   ///
   /// [jsonPolicies] should be a map where keys are policy identifiers and values
-  /// are JSON representations of [Policy] objects.
+  /// are JSON representations of [Role] objects.
   ///
   /// Throws:
   /// - [JsonParseException] if policy parsing fails completely
@@ -118,30 +118,30 @@ class PolicyManager extends ChangeNotifier {
         }
 
         // Create the policy and add to valid policies
-        final policy = Policy(
-          roleName: key,
+        final role = Role(
+          name: key,
           allowedContent: value.cast<String>(),
         );
-        validPolicies[key] = policy.toJson();
+        validPolicies[key] = role.toJson();
       }
 
-      _policies = JsonHandler.parseMap(
+      _roles = JsonHandler.parseMap(
         validPolicies,
-        (json) => Policy.fromJson(json),
+        (json) => Role.fromJson(json),
         context: 'policy_manager',
         allowPartialSuccess: true,
       );
 
       // Only create evaluator if we have at least some policies
-      if (_policies.isNotEmpty) {
-        _evaluator = RoleEvaluator(_policies);
-        await _storage.savePolicies(_policies);
+      if (_roles.isNotEmpty) {
+        _evaluator = RoleEvaluator(_roles);
+        await _storage.savePolicies(_roles);
         _isInitialized = true;
 
         LogHandler.info(
           'Policy manager initialized successfully',
           context: {
-            'loaded_policies': _policies.length,
+            'loaded_policies': _roles.length,
             'total_policies': jsonPolicies.length,
           },
           operation: 'policy_manager_initialized',

lib/src/core/role_evaluator.dart

@@ -1,5 +1,5 @@
 import 'package:flutter_policy_engine/src/core/interfaces/i_policy_evaluator.dart';
-import 'package:flutter_policy_engine/src/models/policy.dart';
+import 'package:flutter_policy_engine/src/models/role.dart';
 import 'package:meta/meta.dart';
 
 /// A policy evaluator that determines access permissions based on role-based policies.
@@ -8,7 +8,7 @@ import 'package:meta/meta.dart';
 /// role-based access control functionality. It evaluates whether content is
 /// allowed for a specific role by checking against predefined policies.
 ///
-/// Each role is associated with a [Policy] that defines the rules for content
+/// Each role is associated with a [Role] that defines the rules for content
 /// evaluation. If no policy exists for a given role, access is denied by default.
 ///
 /// Example usage:
@@ -25,7 +25,7 @@ class RoleEvaluator implements IPolicyEvaluator {
   /// Creates a new [RoleEvaluator] with the specified policies.
   ///
   /// The [policies] parameter should contain a mapping of role names to their
-  /// corresponding [Policy] objects. Each policy defines the rules for content
+  /// corresponding [Role] objects. Each policy defines the rules for content
   /// evaluation for that specific role.
   ///
   /// Throws an [ArgumentError] if [policies] is null.
@@ -35,8 +35,8 @@ class RoleEvaluator implements IPolicyEvaluator {
   ///
   /// This map contains all available policies that can be evaluated by this
   /// evaluator. The key is the role name and the value is the corresponding
-  /// [Policy] object.
-  final Map<String, Policy> _policies;
+  /// [Role] object.
+  final Map<String, Role> _policies;
 
   /// Evaluates whether the specified content is allowed for the given role.
   ///
@@ -45,11 +45,11 @@ class RoleEvaluator implements IPolicyEvaluator {
   ///
   /// Returns `true` if:
   /// - A policy exists for the [roleName]
-  /// - The policy's [Policy.isContentAllowed] method returns `true` for the [content]
+  /// - The policy's [Role.isContentAllowed] method returns `true` for the [content]
   ///
   /// Returns `false` if:
   /// - No policy exists for the [roleName]
-  /// - The policy's [Policy.isContentAllowed] method returns `false` for the [content]
+  /// - The policy's [Role.isContentAllowed] method returns `false` for the [content]
   ///
   /// Parameters:
   /// - [roleName]: The name of the role to evaluate permissions for

lib/src/models/policy.dart renamed to lib/src/models/role.dart

@@ -17,25 +17,25 @@ import 'package:collection/collection.dart';
 /// );
 /// ```
 @immutable
-class Policy {
+class Role {
   /// Creates a new policy with the specified role name and allowed content.
   ///
-  /// The [roleName] identifies the role this policy applies to.
+  /// The [name] identifies the role this policy applies to.
   /// The [allowedContent] list contains the content types or actions that are
   /// permitted for this role. The [metadata] provides additional configuration
   /// options and defaults to an empty map if not specified.
   ///
-  /// Throws an [ArgumentError] if [roleName] is empty or [allowedContent] is null.
-  const Policy({
-    required this.roleName,
+  /// Throws an [ArgumentError] if [name] is empty or [allowedContent] is null.
+  const Role({
+    required this.name,
     required this.allowedContent,
     this.metadata = const {},
   });
 
   /// The name of the role this policy applies to.
   ///
   /// This should be a unique identifier for the role within your application.
-  final String roleName;
+  final String name;
 
   /// List of content types or actions that are allowed for this role.
   ///
@@ -52,7 +52,7 @@ class Policy {
 
   /// Creates a copy of this policy with the given fields replaced by new values.
   ///
-  /// Returns a new [Policy] instance with the same values as this one,
+  /// Returns a new [Role] instance with the same values as this one,
   /// except for the fields that are explicitly provided in the parameters.
   ///
   /// Example:
@@ -62,13 +62,13 @@ class Policy {
   ///   metadata: {'priority': 'low'},
   /// );
   /// ```
-  Policy copyWith({
-    String? roleName,
+  Role copyWith({
+    String? name,
     List<String>? allowedContent,
     Map<String, dynamic>? metadata,
   }) =>
-      Policy(
-        roleName: roleName ?? this.roleName,
+      Role(
+        name: name ?? this.name,
         allowedContent: allowedContent ?? this.allowedContent,
         metadata: metadata ?? this.metadata,
       );
@@ -88,15 +88,15 @@ class Policy {
 
   /// Compares this policy with another object for equality.
   ///
-  /// Two policies are considered equal if they have the same [roleName] and
+  /// Two policies are considered equal if they have the same [name] and
   /// the same [allowedContent] (regardless of order). The [metadata] is not
   /// considered in the equality comparison.
   @override
   bool operator ==(Object other) {
     if (identical(this, other)) return true;
-    if (other is! Policy) return false;
+    if (other is! Role) return false;
 
-    if (roleName != other.roleName) return false;
+    if (name != other.name) return false;
     if (allowedContent.length != other.allowedContent.length) return false;
 
     // Sort both lists to ensure order-independent comparison (same as hashCode)
@@ -108,22 +108,22 @@ class Policy {
 
   /// Returns the hash code for this policy.
   ///
-  /// The hash code is based on the [roleName] and [allowedContent] fields.
+  /// The hash code is based on the [name] and [allowedContent] fields.
   /// The allowedContent is sorted to ensure consistent hash codes regardless of order.
   @override
   int get hashCode {
     final sortedContent = List<String>.from(allowedContent)..sort();
-    return Object.hash(roleName, const ListEquality().hash(sortedContent));
+    return Object.hash(name, const ListEquality().hash(sortedContent));
   }
 
   /// Returns a string representation of this policy.
   ///
   /// The string includes the role name, allowed content, and metadata.
   @override
   String toString() =>
-      'Policy(roleName: $roleName, allowedContent: $allowedContent, metadata: $metadata)';
+      'Policy(roleName: $name, allowedContent: $allowedContent, metadata: $metadata)';
 
-  /// Creates a [Policy] instance from a JSON map.
+  /// Creates a [Role] instance from a JSON map.
   ///
   /// The JSON map should contain:
   /// - `roleName`: A string representing the role name
@@ -141,12 +141,12 @@ class Policy {
   /// };
   /// final policy = Policy.fromJson(json);
   /// ```
-  factory Policy.fromJson(Map<String, dynamic> json) {
-    final roleName = json['roleName'];
+  factory Role.fromJson(Map<String, dynamic> json) {
+    final name = json['roleName'];
     final allowedContent = json['allowedContent'];
     final metadata = json['metadata'];
 
-    if (roleName == null || roleName is! String) {
+    if (name == null || name is! String) {
       throw ArgumentError('roleName must be a non-null string');
     }
     if (allowedContent == null || allowedContent is! List) {
@@ -156,8 +156,8 @@ class Policy {
       throw ArgumentError('All allowedContent items must be strings');
     }
 
-    return Policy(
-      roleName: roleName,
+    return Role(
+      name: name,
       allowedContent: allowedContent.cast<String>(),
       metadata:
           metadata is Map<String, dynamic> ? metadata : <String, dynamic>{},
@@ -179,7 +179,7 @@ class Policy {
   /// // }
   /// ```
   Map<String, dynamic> toJson() => {
-        'roleName': roleName,
+        'roleName': name,
         'allowedContent': allowedContent,
         'metadata': metadata,
       };