policy 1.2.0 → 2.0.0

data/lib/policy/base.rb

@@ -0,0 +1,122 @@
+# encoding: utf-8
+
+module Policy
+
+  # Policy object class interface
+  #
+  # Includes <tt>ActiveModel::Validation</tt> and a list of methods
+  # to compose policies.
+  module Base
+
+    # Composes the policy with others by AND method
+    #
+    # @overload and(*others)
+    #   Returns a composition of the policy with other policies
+    #
+    #   The composition is valid when all policies are valid.
+    #
+    #   @example
+    #     composition = one_policy.and(another)
+    #     one_policy.valid?  # => true
+    #     another.valid?     # => false
+    #     composition.valid? # => false
+    #
+    #   @param [Policy::Base, Array<Policy::Base>] others
+    #     other policies to compose the current policy with
+    #
+    #   @return [Policy::Base] the composed policy
+    #
+    # @overload and()
+    #   Returns a negator object expecting negation of another policy
+    #
+    #   @example
+    #     composition = one_policy.and.not(another)
+    #     one_policy.valid?  # => true
+    #     another.valid?     # => false
+    #     composition.valid? # => true
+    #
+    #   @return [#not]
+    def and(*others)
+      compose And, others
+    end
+
+    # Composes the policy with others by OR method
+    #
+    # @overload or(*others)
+    #   Returns a composition of the policy with other policies
+    #
+    #   The composition is valid when any policy is valid.
+    #
+    #   @example
+    #     composition = one_policy.or(another)
+    #     one_policy.valid?  # => true
+    #     another.valid?     # => false
+    #     composition.valid? # => true
+    #
+    #   @param [Policy::Base, Array<Policy::Base>] others
+    #     other policies to compose the current policy with
+    #
+    #   @return [Policy::Base] the composed policy
+    #
+    # @overload or()
+    #   Returns a negator object expecting negation of another policy
+    #
+    #   @example
+    #     composition = one_policy.or.not(another)
+    #     one_policy.valid?  # => false
+    #     another.valid?     # => false
+    #     composition.valid? # => true
+    #
+    #   @return [#not]
+    def or(*others)
+      compose Or, others
+    end
+
+    # Composes the policy with others by XOR method
+    #
+    # @overload xor(another)
+    #   Returns a composition of the policy with other policies
+    #
+    #   The composition is valid when both valid and invalid policies
+    #   are present
+    #
+    #   @example
+    #     composition = one_policy.xor(another)
+    #     one_policy.valid?  # => true
+    #     another.valid?     # => true
+    #     composition.valid? # => false
+    #
+    #   @param [Policy::Base, Array<Policy::Base>] others
+    #     other policies to compose the current policy with
+    #
+    #   @return [Policy::Base] the composed policy
+    #
+    # @overload xor()
+    #   Returns a negator object expecting negation of another policy
+    #
+    #   @example
+    #     composition = one_policy.xor.not(another)
+    #     one_policy.valid?  # => false
+    #     another.valid?     # => false
+    #     composition.valid? # => true
+    #
+    #   @return [#not]
+    def xor(*others)
+      compose Xor, others
+    end
+
+    # @private
+    def self.included(klass)
+      klass.instance_eval { include ActiveModel::Validations }
+    end
+
+    private
+
+    def compose(composer, policies)
+      return composer.new(self, *policies) if policies.any?
+      Negator.new(self, composer)
+    end
+
+  end # module Base
+
+end # module Policy

data/lib/policy/base/and.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+module Policy
+
+  module Base
+
+    # Composition of two policies
+    #
+    # The policy is valid if both its parts are valid.
+    # {#valid?} method picks errors from its parts in case any is invalid.
+    #
+    # @example (see #valid?)
+    #
+    # @api private
+    class And < Node
+
+      # Checks whether every policy is valid
+      #
+      # Mutates the policy by adding {#errors} from its invalid part.
+      #
+      # @example
+      #   first.valid?  # => true
+      #   second.valid? # => false
+      #
+      #   composition = Policy::Base::And.new(first, second)
+      #   composition.valid?                  # => false
+      #   composition.errors == second.errors # => true
+      #
+      # @return [Boolean]
+      def valid?
+        super { return true unless any_invalid? }
+      end
+
+    end # class And
+
+  end # module Base
+
+end # module Policy

data/lib/policy/base/negator.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+module Policy
+
+  module Base
+
+    # Composes a policy with an argument of its {#not} method
+    #
+    # @api private
+    class Negator
+
+      # @!scope class
+      # @!method new(policy, composer)
+      # Creates the negator object, expecting {#not} method call
+      #
+      # @param [Policy::Base] policy
+      #   the policy to be composed with negations of other policies
+      # @param [Class] composer
+      #   the composer for policies
+      #
+      # @return [Policy::Base::Negator]
+      def initialize(policy, composer)
+        @policy   = policy
+        @composer = composer
+      end
+
+      # Returns a composition of the {#policy} with negations of other policies
+      #
+      # @param [Policy::Base, Array<Policy::Base>] policies
+      #
+      # @return [Policy::Base]
+      def not(*policies)
+        composer.new policy, *policies.flat_map(&Not.method(:new))
+      end
+
+      # @!attribute [r] policy
+      # The the policy to be composed with negations of other policies
+      #
+      # @return [Policy::Base]
+      attr_reader :policy
+
+      # @!attribute [r] composer
+      # The the composer for policies
+      #
+      # @return [Class]
+      attr_reader :composer
+
+    end # class Negator
+
+  end # module Base
+
+end # module Policy

data/lib/policy/base/node.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+module Policy
+
+  module Base
+
+    # The base class for composite policies
+    #
+    # @api private
+    class Node
+      include Policy::Base
+
+      # @!scope class
+      # @!method new(*policies)
+      # Creates the node (composite policy) from its parts
+      #
+      # @param [<Policy::Base>, Array<Policy::Base>] policies
+      #
+      # @return [Policy::Base::Node]
+      def initialize(*policies)
+        @policies = policies
+      end
+
+      # @!attribute [r] policies
+      # The parts of the composite policy
+      #
+      # @return [Array<Policy::Base>]
+      attr_reader :policies
+
+      # @abstract
+      # Validates a composed policy and picks errors from its parts
+      #
+      # @return [false]
+      def valid?
+        errors.clear
+        yield # returns true if a composition valid
+        policies.each(&method(:pick_errors_from))
+        false
+      end
+
+      private
+
+      def any_valid?
+        policies.detect(&:valid?)
+      end
+
+      def any_invalid?
+        policies.detect(&:invalid?)
+      end
+
+      def pick_errors_from(item)
+        item.errors.full_messages.each { |text| errors.add :base, text }
+      end
+
+    end # class Node
+
+  end # module Base
+
+end # module Policy

data/lib/policy/base/not.rb

@@ -0,0 +1,42 @@
+module Policy
+
+  module Base
+
+    # Negation of given policy
+    #
+    # It is invalid when given policy is valid.
+    # Doesn't add any {#errors}.
+    #
+    # @example (see #valid?)
+    #
+    # @api private
+    class Not < Node
+
+      # @!scope class
+      # @!method new(policy)
+      # Creates the policy negation
+      #
+      # @param [Array<Policy::Base>] policy
+      #
+      # @return [Policy::Base::Node]
+      def initialize(_)
+        super
+      end
+
+      # Checks whether negated policy is invalid
+      #
+      # @example
+      #   negation = Policy::Base::Not.new(some_policy)
+      #   some_policy.valid? # => true
+      #   negation.valid?    # => false
+      #
+      # @return [Boolean]
+      def valid?
+        super { return true if any_invalid? }
+      end
+
+    end # class Not
+
+  end # module Base
+
+end # module Policy

data/lib/policy/base/or.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+module Policy
+
+  module Base
+
+    # Composition of two policies
+    #
+    # The policy is valid if any of its parts is valid.
+    # {#valid?} method picks errors from its parts in case both are invalid.
+    #
+    # @example (see #valid?)
+    #
+    # @api private
+    class Or < Node
+
+      # Checks whether any part of composition is valid
+      #
+      # Mutates the policy by adding {#errors} in case all parts are invalid.
+      # Doesn't add {#errors} if any policy is valid.
+      #
+      # @example
+      #   first.valid?  # => true
+      #   second.valid? # => false
+      #
+      #   composition = Policy::Base::Or.new(first, second)
+      #   composition.valid?        # => true
+      #   composition.errors.empty? # => true
+      #
+      # @return [Boolean]
+      def valid?
+        super { return true if any_valid? }
+      end
+
+    end # class Or
+
+  end # module Base
+
+end # module Policy

data/lib/policy/base/xor.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+module Policy
+
+  module Base
+
+    # Composition of two policies
+    #
+    # The policy is valid if one of its parts is valid, while another is not.
+    # {#valid?} method picks errors from its parts in case both are invalid.
+    #
+    # @example (see #valid?)
+    #
+    # @api private
+    class Xor < Node
+
+      # Checks if there is both valid and invalid parts are present
+      #
+      # Mutates the policy by adding {#errors} if all parts are invalid.
+      # Doesn't add {#errors} if any part is valid.
+      #
+      # @example
+      #   first.valid?  # => false
+      #   second.valid? # => false
+      #
+      #   composition = Policy::Base::Xor.new(first, second)
+      #   composition.valid?        # => false
+      #   composition.errors.empty? # => false
+      #
+      # @return [Boolean]
+      def valid?
+        super { return true if any_valid? && any_invalid? }
+      end
+
+    end # class Xor
+
+  end # module Base
+
+end # module Policy

data/lib/policy/cli.rb

@@ -1,9 +1,14 @@
 # encoding: utf-8
+
 require "hexx-cli"
 
+require_relative "cli/attribute"
+
 module Policy
 
   # Scaffolds a policy with a specification and translations
+  #
+  # @api private
   class CLI < Hexx::CLI::Base
 
     # @private
@@ -24,9 +29,9 @@ module Policy
     class_option(
       :attributes,
       aliases: %w(-a),
-      banner: " debet credit",
+      banner: " debet{Transaction} credit{Transaction}",
       default: %w(),
-      desc: "The list of attributes of the policy (the order is essential).",
+      desc: "The list of policy object's attributes.",
       type: :array
     )
 
@@ -77,7 +82,7 @@ module Policy
     end
 
     def attributes
-      @attributes ||= options[:attributes].map(&:downcase)
+      @attributes ||= options[:attributes].map(&Attribute.method(:new))
     end
 
     def locales

data/lib/policy/cli/attribute.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+module Policy
+
+  class CLI < Hexx::CLI::Base
+
+    # Decorates the string with #name and #type methods for described attribute
+    #
+    # @api private
+    class Attribute
+
+      # @!scope class
+      # @!method new(source)
+      # Creates the decorator
+      #
+      # @param [String] source
+      #
+      # @return [Policy::CLI::Attribute]
+
+      # @private
+      def initialize(source)
+        @source = source
+      end
+
+      # The name of the attribute
+      #
+      # @return [String]
+      def name
+        @type ||= begin
+          value = @source[/^\w+/]
+          value ? value.snake_case : "@todo"
+        end
+      end
+
+      # The type of the attribute
+      #
+      # @return [String]
+      def type
+        @type ||= begin
+          value = @source[/(?<=\{)(.+)(?=\})/]
+          value ? Hexx::CLI::Name.new(value).type : "@todo"
+        end
+      end
+
+    end # class Attribute
+
+  end # class CLI
+
+end # module Policy