yes 0.0.1

data/lib/yes/constraints/fnmatch.rb

@@ -0,0 +1,42 @@
+module YES
+
+  module Constraints
+
+    # Validate file glob match. This uess standard unix-style file matching,
+    # primarily '*` and `?`, to detrmine a mathing node value.
+    # All values are converted to strings (using #to_s) for comparison.
+    #--
+    # TODO: better name then `FNMatch`?
+    #++
+    class FNMatch < NodeConstraint
+
+      #
+      # @return [Array<Constraint>]
+      def self.checklist(spec, tree, nodes)
+        return [] unless applicable?(spec)
+        nodes.map do |node|
+          new(spec, tree, node)
+        end
+      end
+
+      # Only applicable if `fnmatch` field is in spec.
+      def self.applicable?(spec)
+        spec['fnmatch']
+      end
+
+      # Validate file glob match. This uess standard unix-style file matching,
+      # primarily '*` and `?`, to detrmine a mathing node value.
+      # All values are converted to strings (using #to_s) for comparison.
+      #
+      # @return [Boolean] validity
+      def validate(spec)
+        fnmatch = spec['fnmatch']
+
+        File.fnmatch(fnmatch, node.value)
+      end
+
+    end
+
+  end
+
+end

data/lib/yes/constraints/inclusive.rb

@@ -0,0 +1,50 @@
+module YES
+
+  module Constraints
+
+    # Inclusion can either be a boolean expression in
+    # which case it validates that there is at least one matching
+    # node. Otherwise, the value is taken to be a ypath and validates
+    # that there are matching paths if the main selection is present.
+    #--
+    # TODO: Provide $parent$ path substitution ?
+    #++
+    class Inclusive < TreeConstraint
+
+      #
+      # @return [Array<Constraint>]
+      def self.checklist(spec, tree, nodes)
+        return [] unless applicable?(spec)
+        [new(spec, tree, nodes)]
+      end
+
+      # Only applicable if `inclusive` field in in the spec.
+      def self.applicable?(spec)
+        spec['inclusive']
+      end
+
+      # Validate inclusion - This can either be a boolean expression in
+      # which case it validates that there is at least one matching
+      # node. Otherwise, the value is taken to be a ypath and validates
+      # that there are matching paths if the main selection is present.
+      #
+      # @return [Boolean] validity
+      def valid?
+        return true unless applicable?
+
+        inclusive = spec['inclusive']
+
+        case inclusive
+        when true, false
+          nodes.size > 0
+        else
+          in_nodes = tree.select(inclusive)
+          nodes.size == 0 or in_nodes.size > 0
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/yes/constraints/key.rb

@@ -0,0 +1,55 @@
+module YES
+
+  module Constraints
+
+    # Validate if a mapping node's _keys_ conforms to a constraint.
+    #
+    #   //authors:
+    #     type: map
+    #     key:
+    #       type: str
+    #
+    class Key < NodeConstraint
+
+      # For key constraint, the work is all handled by the
+      # checklist method.
+      #
+      # @return [Array<Constraint>]
+      def self.checklist(spec, tree, nodes)
+        return [] unless applicable?(spec)
+
+        key_spec = spec['key']
+        list     = []
+
+        nodes.each do |node|
+          case node.kind
+          when :map
+            YES.constraints.each do |c|
+              list.concat(c.checklist(key_spec, tree, node.value.keys))
+            end
+          else
+            raise "key constraint applies only to mappings"
+          end
+        end
+
+        list
+      end
+
+      #
+      #
+      def self.applicable?(spec)
+        spec['key']
+      end
+
+      #
+      # no-op
+      #
+      # @return [Boolean] validity
+      def validate(spec)
+      end
+
+    end
+
+  end
+
+end

data/lib/yes/constraints/kind.rb

@@ -0,0 +1,34 @@
+module YES
+
+  module Constraints
+
+    # Validate the <i>kind of node</i>. There are only three kinds
+    # of nodes: `scalar`, `map` and `seq`.
+    # 
+    class Kind < NodeConstraint
+
+      #
+      # @return [Array<Constraint>]
+      def self.checklist(spec, tree, nodes)
+        return [] unless applicable?(spec)
+        nodes.map do |node|
+          new(spec, tree, node)
+        end
+      end  
+
+      #
+      def self.applicable?(spec)
+        spec['kind']
+      end
+
+      # Validate type.
+      #
+      def validate(spec)
+        node.kind.to_s == spec['kind']
+      end
+
+    end
+
+  end
+
+end

data/lib/yes/constraints/length.rb

@@ -0,0 +1,46 @@
+module YES
+
+  module Constraints
+
+    # Validate if a node's value is within a certain length.
+    # The value is converted to a string using #to_s for the
+    # comparison.
+    #
+    #   //code:
+    #     length: 3
+    #
+    # A valid code value could then have no more than three characters.
+    class Length < NodeConstraint
+
+      #
+      #
+      # @return [Array<Constraint>]
+      def self.checklist(spec, tree, nodes)
+        return [] unless applicable?(spec)
+        nodes.map do |node|
+          new(spec, tree, node)
+        end
+      end
+
+      #
+      #
+      def self.applicable?(spec)
+        spec['length']
+      end
+
+      #
+      # Validate if a node value is within a certain length.
+      # The value is converted to a string using #to_s for the
+      # comparison.
+      #
+      # @return [Boolean] validity
+      def validate(spec)
+        length = spec['length']
+        match_delta(length, node.value.to_s.size)
+      end
+
+    end
+
+  end
+
+end

data/lib/yes/constraints/node_constraint.rb

@@ -0,0 +1,55 @@
+module YES
+
+  module Constraints
+
+    # The NodeConstraint class is an abstract class
+    # and used for create constraint subclasses that
+    # apply constraints on a sigle node.
+    #
+    class NodeConstraint < AbstractConstraint
+
+      # Like {Abstract#initialize} but takes a `node` qas well.
+      def initialize(spec, tree, node)
+        super(spec, tree, [node])
+        @node = node
+      end
+
+    public
+
+      # YAML Node.
+      attr :node
+
+      # Get the applicable node's tag.
+      def tag
+        node.type_id
+      end
+
+      # Get the applicable node's value.
+      def value
+        node.value
+      end
+
+#    # Covert a YAML node (Syck) node into a generic representation.
+#    #
+#    # TODO: Should `style` be part of this? Also, is `kind` the proper term?
+#    def catholic_node(node)
+#      n = {}
+#      n['tag']   = node.type_id 
+#      #n['type'] = #base_type_id(node)
+#      n['kind']  = node.kind.to_s
+#      n['value'] = node.value
+#      n['style'] = node.instance_variable_get('@style').to_s
+#      n
+#    end
+
+      #
+      #
+      def self.applicable?(spec)
+        false
+      end
+
+    end
+
+  end
+
+end

data/lib/yes/constraints/range.rb

@@ -0,0 +1,43 @@
+module YES
+
+  module Constraints
+
+    # Validate the a nodes value is within a certain range.
+    # Primarily this works for numeric values, but it can
+    # also work for string in ASCII/UTF-8 order, by using 
+    # a 2-element array for comparison.
+    #
+    #   //note:
+    #     range: ['A','G']
+    #
+    # Valid values for are then only A, B, C, D, E, F and G.
+    class Range < NodeConstraint
+
+      #
+      # @return [Array<Validaiton>]
+      def self.checklist(spec, tree, nodes)
+        return [] unless applicable?(spec)
+        nodes.map do |node|
+          new(spec, tree, node)
+        end
+      end
+
+      #
+      def self.applicable?(spec)
+        spec['range']
+      end
+
+      # Validate if a node is the only one of it's value in a sequence
+      # or mapping.
+      #
+      # @return [Boolean] validity
+      def validate(spec)
+        range = spec['range']
+        match_delta(range, node.transform) ? true : false
+      end
+
+    end
+
+  end
+
+end

data/lib/yes/constraints/regexp.rb

@@ -0,0 +1,52 @@
+module YES
+
+  module Constraints
+
+    # Validate matching values against a regular expression.
+    # All values are converted to strings (using #to_s) for comparison.
+    #
+    #   //pin:
+    #     regexp: /^\d\s\d\d$/
+    #
+    class Regexp < NodeConstraint
+
+      #
+      # @return [Array<Validaiton>]
+      def self.checklist(spec, tree, nodes)
+        return [] unless applicable?(spec)
+        nodes.map do |node|
+          new(spec, tree, node)
+        end
+      end
+
+      #
+      def self.applicable?(spec)
+        spec['regexp']
+      end
+
+      # Validate matching values against a regular expression.
+      # All values are converted to strings (using #to_s) for comparison.
+      #
+      # @return [Boolean] validity
+      def validate(spec)
+        regexp = parse_regexp(spec['regexp'])
+        regexp =~ node.value ? true : false
+      end
+
+      # The regular expression from `spec`.
+      #
+      # @return [Regexp] spec's regular expression
+      def parse_regexp(re)
+        case re
+        when /^\/(.*?)\/(\w*)$/
+          ::Regexp.new($1)  # TODO: modifiers
+        else
+          ::Regexp.new(re)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/yes/constraints/required.rb

@@ -0,0 +1,45 @@
+module YES
+
+  module Constraints
+
+    #
+    # TODO: For the moment this is the same as Inclusive.
+    #       It was originall inteded to work like {RequiresValidation}
+    #       but it rpoved hard to work out the validation procedure
+    #       when matching to the subfield. If we can fix it maybe we will
+    #       keep, but for now THIS IS NOT USED.
+    #
+    class Required < TreeConstraint
+
+      #
+      # @return [Array<Constraint>]
+      def self.checklist(spec, tree, nodes)
+        return [] unless applicable?(spec)
+        [new(spec, tree, nodes)]
+      end
+
+      # Only applicable if `required` field appears in spec.
+      def self.applicable?(spec)
+        spec['required']
+      end
+
+      # Validates whether a matching node must be present within it's parent.
+      #
+      # @return [Boolean] validity
+      def validate(spec)
+        required = spec['required']
+
+        case required
+        when true, false
+          nodes.size > 0
+        else
+          in_nodes = tree.select(required)
+          nodes.size == 0 or in_nodes.size > 0
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/yes/constraints/requires.rb

@@ -0,0 +1,57 @@
+module YES
+
+  module Constraints
+
+    # Takes a list of relative YPaths and ensures they are present.
+    # This is most useful for ensuring the existance of mapping fields.
+    #
+    #     foo:
+    #       requires:
+    #         - bar
+    #
+    # A valid document would be:
+    #
+    #     foo:
+    #       bar: true
+    #
+    # The literal meaing of this example is "if `foo` exists, the make sure
+    # `foo/bar` also exists.
+    class Requires < NodeConstraint
+
+      #
+      # @return [Array<Constraint>]
+      def self.checklist(spec, tree, nodes)
+        return [] unless applicable?(spec)
+        nodes.map do |node|
+          new(spec, tree, node)
+        end
+      end
+
+      #
+      def self.applicable?(spec)
+        spec['requires']
+      end
+
+      # Validates whether a matching node must be present within it's parent.
+      #
+      # @return [Boolen] validity
+      def validate(spec)
+        requires = Array(spec['requires'])
+
+        requires.each do |rq|
+          case rq
+          when /^\// # absolute path
+            rq_nodes = tree.select(rq)
+          else
+            rq_nodes = node.select(rq)
+          end
+          return false unless rq_nodes.size > 0
+        end
+
+      end
+
+    end
+
+  end
+
+end