attestor 0.0.1

data/config/metrics/churn.yml

@@ -0,0 +1,6 @@
+---
+ignore_files:
+- spec
+- config
+minimum_churn_count: 0
+start_date: "1 year ago"

data/config/metrics/flay.yml

@@ -0,0 +1,2 @@
+---
+minimum_score: 10

data/config/metrics/metric_fu.yml

@@ -0,0 +1,15 @@
+---
+folders: # The list of folders to be used by any metric.
+- lib
+- app
+metrics: # The list of allowed metrics. The other metrics are disabled.
+- cane
+- churn
+- flay
+- flog
+- reek
+- roodi
+- saikuro
+format: html
+output: tmp/metric_fu
+verbose: false

data/config/metrics/reek.yml

@@ -0,0 +1 @@
+---

data/config/metrics/roodi.yml

@@ -0,0 +1,24 @@
+---
+AssignmentInConditionalCheck:
+CaseMissingElseCheck:
+ClassLineCountCheck:
+  line_count: 300
+ClassNameCheck:
+  pattern: !ruby/regexp /^[A-Z][a-zA-Z0-9]*$/
+ClassVariableCheck:
+CyclomaticComplexityBlockCheck:
+  complexity: 4
+CyclomaticComplexityMethodCheck:
+  complexity: 8
+EmptyRescueBodyCheck:
+ForLoopCheck:
+MethodLineCountCheck:
+  line_count: 20
+MethodNameCheck:
+  pattern: !ruby/regexp /^[\||\^|\&|\!]$|^[_a-z<>=\[|+-\/\*`]+[_a-z0-9_<>=~@\[\]]*[=!\?]?$/
+ModuleLineCountCheck:
+  line_count: 300
+ModuleNameCheck:
+  pattern: !ruby/regexp /^[A-Z][a-zA-Z0-9]*$/
+ParameterNumberCheck:
+  parameter_count: 5

data/config/metrics/rubocop.yml

@@ -0,0 +1,75 @@
+---
+# settings added by the 'hexx-suit' module
+# output: "tmp/rubocop"
+# format: "html"
+
+AllCops:
+  Exclude:
+    - '**/db/schema.rb'
+
+Lint/HandleExceptions:
+  Exclude:
+    - '**/*_spec.rb'
+
+Lint/RescueException:
+  Exclude:
+    - '**/*_spec.rb'
+
+Style/AccessorMethodName:
+  Exclude:
+    - '**/*_spec.rb'
+
+Style/AsciiComments:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  Exclude:
+    - '**/*_spec.rb'
+
+Style/Documentation:
+  Exclude:
+    - '**/version.rb'
+    - '**/*_spec.rb'
+
+Style/EmptyLinesAroundBlockBody:
+  Enabled: false
+
+Style/EmptyLinesAroundClassBody:
+  Enabled: false
+
+Style/EmptyLinesAroundMethodBody:
+  Enabled: false
+
+Style/EmptyLinesAroundModuleBody:
+  Enabled: false
+
+Style/EmptyLineBetweenDefs:
+  Enabled: false
+
+Style/FileName:
+  Enabled: false
+
+Style/RaiseArgs:
+  EnforcedStyle: compact
+
+Style/SingleLineMethods:
+  Exclude:
+    - '**/*_spec.rb'
+
+Style/SingleSpaceBeforeFirstArg:
+  Enabled: false
+
+Style/SpecialGlobalVars:
+  Exclude:
+    - '**/Gemfile'
+    - '**/*.gemspec'
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Style/TrivialAccessors:
+  Exclude:
+    - '**/*_spec.rb'

data/config/metrics/saikuro.yml

@@ -0,0 +1,3 @@
+---
+warn_cyclo:  4
+error_cyclo: 6

data/config/metrics/simplecov.yml

@@ -0,0 +1,6 @@
+---
+output: tmp/coverage
+filters: # The list of paths to be excluded from coverage checkup
+- "spec/"
+- "config/"
+groups: []

data/config/metrics/yardstick.yml

@@ -0,0 +1,37 @@
+---
+# Settings added by the 'hexx-suit' gem
+output: "tmp/yardstick/output.log"
+path: "lib/**/*.rb"
+rules:
+  ApiTag::Presence:
+    enabled: true
+    exclude: []
+  ApiTag::Inclusion:
+    enabled: true
+    exclude: []
+  ApiTag::ProtectedMethod:
+    enabled: true
+    exclude: []
+  ApiTag::PrivateMethod:
+    enabled: false
+    exclude: []
+  ExampleTag:
+    enabled: true
+    exclude: []
+  ReturnTag:
+    enabled: true
+    exclude: []
+  Summary::Presence:
+    enabled: true
+    exclude: []
+  Summary::Length:
+    enabled: true
+    exclude: []
+  Summary::Delimiter:
+    enabled: true
+    exclude: []
+  Summary::SingleLine:
+    enabled: true
+    exclude: []
+threshold: 100
+verbose: false

data/lib/attestor/invalid_error.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+module Attestor
+
+  # The exception to be raised when a validation fails
+  class InvalidError < RuntimeError
+
+    # @!scope class
+    # @!method new(object, validations: nil, messages: [], context: :all)
+    # Creates an exception for given object
+    #
+    # @param  [Object] object
+    #   The invalid object
+    # @option [Array<String>] :messages
+    #   The list of validation error messages
+    # @option [Symbol] :context
+    #   The list of context for validation
+    # @option [Array<Symbol>] :validations
+    #   The list of all validations that was checked out
+    #
+    # @return [Attestor::InvalidError]
+
+    # @private
+    def initialize(object, messages = [])
+      @object   = object
+      @messages = messages.dup.freeze
+      freeze
+    end
+
+    # @!attribute [r] object
+    # The invalid object
+    #
+    # @return [Object]
+    attr_reader :object
+
+    # @!attribute [r] messages
+    # The list of validation error messages
+    #
+    # @return [Array<String>]
+    attr_reader :messages
+
+  end # class InvalidError
+
+end # module Attestor

data/lib/attestor/policy/and.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+module Attestor
+
+  module Policy
+
+    # AND-concatenation of several policies (branches)
+    #
+    # The policy is valid if all its branches are valid.
+    #
+    # @example (see #validate)
+    #
+    # @api private
+    class And < Node
+
+      # Checks whether every policy is valid
+      #
+      # @example
+      #   first.valid?  # => true
+      #   second.valid? # => false
+      #
+      #   composition = Attestor::Policy::And.new(first, second)
+      #   composition.validate
+      #   # => Policy::InvalidError
+      #
+      # @return [undefined]
+      def validate
+        return unless any_invalid?
+        super
+      end
+
+    end # class And
+
+  end # module Base
+
+end # module Policy

data/lib/attestor/policy/factory.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+
+module Attestor
+
+  module Policy
+
+    # The collection of factory methods for creating complex policies
+    module Factory
+
+      # Builds the AND composition of policy with other policies
+      #
+      # @param [Attestor::Policy] policy
+      #
+      # @overload and(policy, *others)
+      #   Combines a policy with others
+      #
+      #   @param [Attestor::Policy, Array<Attestor::Policy>] others
+      #
+      #   @return [Attestor::Policy::And]
+      #
+      # @overload and(policy)
+      #   Creates a negator object, awaiting fot #not method call
+      #
+      #   @return [Attestor::Policy::Negator]
+      def and(policy, *others)
+        __factory_method__(And, policy, others)
+      end
+
+      # Builds the OR composition of policy with other policies
+      #
+      # @param [Attestor::Policy] policy
+      #
+      # @overload or(policy, *others)
+      #   Combines a policy with others
+      #
+      #   @param [Attestor::Policy, Array<Attestor::Policy>] others
+      #
+      #   @return [Attestor::Policy::Or]
+      #
+      # @overload or(policy)
+      #   Creates a negator object, awaiting fot #not method call
+      #
+      #   @return [Attestor::Policy::Negator]
+      def or(policy, *others)
+        __factory_method__(Or, policy, others)
+      end
+
+      # Builds the XOR composition of policy with other policies
+      #
+      # @param [Attestor::Policy] policy
+      #
+      # @overload xor(policy, *others)
+      #   Combines a policy with others
+      #
+      #   @param [Attestor::Policy, Array<Attestor::Policy>] others
+      #
+      #   @return [Attestor::Policy::Xor]
+      #
+      # @overload xor(policy)
+      #   Creates a negator object, awaiting fot #not method call
+      #
+      #   @return [Attestor::Policy::Negator]
+      def xor(policy, *others)
+        __factory_method__(Xor, policy, others)
+      end
+
+      # Builds the negation of given policy
+      #
+      # @param [Attestor::Policy] policy
+      #
+      # @return [Attestor::Policy::Not]
+      def not(policy)
+        Not.new(policy)
+      end
+
+      private
+
+      def __factory_method__(composer, policy, others)
+        policies = others.flatten
+        return composer.new(policy, policies) if policies.any?
+        Negator.new(composer, policy)
+      end
+
+    end # module Factory
+
+  end # module Policy
+
+end # module Attestor

data/lib/attestor/policy/negator.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+module Attestor
+
+  module Policy
+
+    # 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(composer, policy)
+        @policy   = policy
+        @composer = composer
+        freeze
+      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 Policy
+
+end # module Attestor

data/lib/attestor/policy/node.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+module Attestor
+
+  module Policy
+
+    # The base class for composite policies
+    #
+    # @api private
+    class Node
+      include Attestor::Policy
+
+      # @!scope class
+      # @!method new(*branches)
+      # Creates the node with branches
+      #
+      # @param [<Attestor::Policy>, Array<Attestor::Policy>] branches
+      #
+      # @return [Policy::Base::Node]
+
+      # @private
+      def initialize(*branches)
+        @branches = branches.flatten
+        freeze
+      end
+
+      # @!attribute [r] branches
+      # The branches of the node
+      #
+      # @return [Array<Policy::Base>]
+      attr_reader :branches
+
+      # Validates the policy as invalid
+      #
+      # To be reloaded by subclasses (And, Or, Xor, Not)
+      #
+      # @raise [Policy::InvalidError]
+      #
+      # @return [undefined]
+      def validate
+        invalid :base
+      end
+
+      private
+
+      def any_valid?
+        branches.detect(&:valid?)
+      end
+
+      def any_invalid?
+        branches.detect(&:invalid?)
+      end
+
+    end # class Node
+
+  end # module Base
+
+end # module Policy

data/lib/attestor/policy/not.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+module Attestor
+
+  module Policy
+
+    # Negation of a single policy
+    #
+    # The policy is valid if its only branch is invalid
+    #
+    # @example (see #validate)
+    #
+    # @api private
+    class Not < Node
+
+      # @!scope class
+      # @!method new(policy)
+      # Creates the policy negation
+      #
+      # @param [Array<Policy::Base>] policy
+      #
+      # @return [Policy::Base::Node]
+
+      # @private
+      def initialize(_)
+        super
+      end
+
+      # Checks whether every policy is valid
+      #
+      # @example
+      #   policy.valid? # => true
+      #
+      #   composition = Attestor::Policy::Not.new(policy)
+      #   composition.validate
+      #   # => Policy::InvalidError
+      #
+      # @return [undefined]
+      def validate
+        return unless any_valid?
+        super
+      end
+
+    end # class And
+
+  end # module Base
+
+end # module Policy

data/lib/attestor/policy/or.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+module Attestor
+
+  module Policy
+
+    # OR-concatenation of several policies (branches)
+    #
+    # The policy is valid unless all its branches are invalid.
+    #
+    # @example (see #validate)
+    #
+    # @api private
+    class Or < Node
+
+      # Checks whether any policy is valid
+      #
+      # @example
+      #   first.valid?  # => false
+      #   second.valid? # => false
+      #
+      #   composition = Attestor::Policy::Or.new(first, second)
+      #   composition.validate
+      #   # => Policy::InvalidError
+      #
+      # @return [undefined]
+      def validate
+        return if any_valid?
+        super
+      end
+
+    end # class Or
+
+  end # module Base
+
+end # module Policy

data/lib/attestor/policy/xor.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+module Attestor
+
+  module Policy
+
+    # XOR-concatenation of several policies (branches)
+    #
+    # The policy is valid when it has both valid and invalid branches.
+    #
+    # @example (see #validate)
+    #
+    # @api private
+    class Xor < Node
+
+      # Checks whether both valid and invalid branches are present
+      #
+      # @example
+      #   first.valid?  # => true
+      #   second.valid? # => true
+      #
+      #   composition = Attestor::Policy::Xor.new(first, second)
+      #   composition.validate
+      #   # => Policy::InvalidError
+      #
+      # @return [undefined]
+      def validate
+        return if any_valid? && any_invalid?
+        super
+      end
+
+    end # class Xor
+
+  end # module Base
+
+end # module Policy

data/lib/attestor/policy.rb

@@ -0,0 +1,121 @@
+# encoding: utf-8
+
+module Attestor
+
+  # API for policies that validates another objects
+  module Policy
+    # @!parse include Attestor::Validations
+    # @!parse extend Attestor::Validations::ClassMethods
+    # @!parse extend Attestor::Policy::Factory
+
+    # @private
+    def self.included(klass)
+      klass.instance_eval do
+        include Validations
+        extend Factory
+      end
+    end
+
+    # Checks whether the policy is valid
+    #
+    # @return [Boolean]
+    def valid?
+      validate
+    rescue InvalidError
+      false
+    else
+      true
+    end
+
+    # Checks whether the policy is invalid
+    #
+    # @return [Boolean]
+    def invalid?
+      !valid?
+    end
+
+    # Negates the current policy
+    #
+    # @return [Attestor::Policy::Not]
+    def not
+      self.class.not(self)
+    end
+
+    # Builds the AND composition of current policy with other policies
+    #
+    # @overload and(policy, *others)
+    #   Combines the policy with the others
+    #
+    #   The combination is valid if all policies are valid
+    #
+    #   @param [Attestor::Policy, Array<Attestor::Policy>] others
+    #
+    #   @return [Attestor::Policy::And]
+    #
+    # @overload and(policy)
+    #   Creates a negator object, awaiting fot #not method call
+    #
+    #   @example
+    #     policy.and.not(one, two)
+    #
+    #     # this is equal to combination with negation of other policies:
+    #     policy.and(one.not, two.not)
+    #
+    #   @return [Attestor::Policy::Negator]
+    def and(*others)
+      self.class.and(self, *others)
+    end
+
+    # Builds the OR composition of current policy with other policies
+    #
+    # @overload or(policy, *others)
+    #   Combines the policy with the others
+    #
+    #   The combination is valid unless all the policies are invalid
+    #
+    #   @param [Attestor::Policy, Array<Attestor::Policy>] others
+    #
+    #   @return [Attestor::Policy::And]
+    #
+    # @overload or(policy)
+    #   Creates a negator object, awaiting fot #not method call
+    #
+    #   @example
+    #     policy.or.not(one, two)
+    #
+    #     # this is equal to combination with negation of other policies:
+    #     policy.or(one.not, two.not)
+    #
+    #   @return [Attestor::Policy::Negator]
+    def or(*others)
+      self.class.or(self, *others)
+    end
+
+    # Builds the XOR composition of current policy with other policies
+    #
+    # @overload xor(policy, *others)
+    #   Combines the policy with the others
+    #
+    #   The combination is valid if both valid and invalid policies are present
+    #
+    #   @param [Attestor::Policy, Array<Attestor::Policy>] others
+    #
+    #   @return [Attestor::Policy::And]
+    #
+    # @overload xor(policy)
+    #   Creates a negator object, awaiting fot #not method call
+    #
+    #   @example
+    #     policy.xor.not(one, two)
+    #
+    #     # this is equal to combination with negation of other policies:
+    #     policy.xor(one.not, two.not)
+    #
+    #   @return [Attestor::Policy::Negator]
+    def xor(*others)
+      self.class.xor(self, *others)
+    end
+
+  end # module Policy
+
+end # module Attestor