yes 0.0.1 → 1.3.0

data/README.rdoc

@@ -1,144 +0,0 @@
-= YES - YAML Easy Schema
-
-Author:: Thomas Sawyer
-License:: BSD-2-Clause
-Copyright:: (c) 2011 Thomas Sawyer, Rubyworks
-
-
-== SALES PITCH
-
-It doesn't get any easier than this!
-
-YES is a schema system for YAML that is intuitive and extremely powerful.
-
-YES Schemas are also YAML documents, so they eat there own dog food.
-
-
-== HOW IT WORKS
-
-The design of YeS is as simple as it is powerful. A YeS schema is composed
-of YPath selectors mapped to document constraints. YPath is a syntax
-for selecting *nodes* from a YAML document.
-
-When validating a YAML document against a YeS schema a "lint" program
-simply collects all matching nodes with their applicable constraints into
-a collection of *unit-validations*. Then this collection is filtered of 
-all *passing* validations. All that is left are the failures. If the filtered
-list is empty the document is completely valid. If not empty, the lint
-program can provide a detailed *editorial* list of the failures.
-
-Constraints are given as a mappings of validation type to validation
-parameters.
-
-Lets take an example:
-
-    people/*/name:
-      regexp: '[^/n]'
-
-This simple schema selects all nodes under a `people` sequence of
-mappings with a name key, the value of which cannot contain newlines.
-In other words:
-
-    --
-    people:
-      - name: Charlie Adams
-      - name: Julie Ann Rose
-
-Would satisfy the schema. But,
-
-    --
-    people:
-      - name: |
-          Charlie
-          Adams
-
-Would not.
-
-TODO: Better Examples!!!
-
-Sometimes multiple constraints of the same type need to be applied to 
-a set of nodes. This can be done by expressing the same YPath with 
-different constraints, for example:
-
-    people/*/name:
-      regexp: '[^/t]'
-    people/*/name:
-      regexp: '[^/n]'
-
-But to make the intent more succinct a sequence of constraints can be give
-along with the *logical-and* tag , `!!and`.
-
-    people/*/name: !!and
-      - regexp: '[^/t]'
-      - regexp: '[^/n]'
-
-If the `!!and` tag is not given, then the default operator is used, 
-*logical-or*, which can also be explicitly stated as `!!or`:
-
-    people/*/name: !!or
-      - regexp: '[^/t]'
-      - regexp: '[^/n]'
-
-In this way logical relationships of constraints can be created.
-
-    people/*/name: !!or
-      - !!and
-        - regexp: '[^/t]'
-        - regexp: '[^/n]'
-      - !!and
-        - regexp: '[^/t]'
-        - regexp: '[^/n]'
-
-
-== COMMAND LINE
-
-To use on the command line *lint* tool. Say we have a `schema.yes` file:
-
-    ---
-    name:
-      type: str
-      regexp: '[^\n]'
-      required: true
-    age:
-      type: int
-    birth:
-      type: date
-
-Try it on `sample.yaml`.
-
-    ---
-    name: Thomas T. Thomas
-    age: 42
-    birth: 1976-07-04
-
-Using the executable.
-
-    $ yes-lint schema.yes sample.yaml
-
-In code that is:
-
-    require 'yes'
-
-    lint = YES::Lint.new(File.new('schema.yes'))
-
-    lint.validate(File.new('sample.yaml'))
-
-
-== CONTRIBUTE
-
-Come on folks! Let's get YAML up to snuff. A good Schema could really
-help YAML go the distance and penetrate some of those "Enterprisey" worlds.
-
-* Please read, write and comment on issues[https://github.com/rubyworks/yes/issues].
-* Please critique the code.
-* Please fork and submit patches in topic branches.
-
-And please contribute to {Rubyworks Ruby Development Fund}[http://rubyworks.github.org]
-so us poor Ruby OSS developers can eat :)
-
-
-== COPYRIGHT
-
-(BSD-2 license)
-
-Copyright (c) 2011 Rubyworks, Thomas Sawyer

data/THANKS.rdoc

@@ -1,10 +0,0 @@
-= SPECIAL THANKS
-
-== Kwaify
-
-Copyright:: (c) 2005-2010 Kuwata Lab. All rights reserved.
-License:: MIT
-Website:: http://www.kuwata-lab.com/kwalify
-
-Although no Kwalify code was actually used to build YES, it provided
-inspiration for some of the design choices.

data/bin/yes-lint

@@ -1,4 +0,0 @@
-#!/usr/bin/env ruby
-require 'yes/cli'
-YES.cli(*ARGV)
-

data/data/yes/yes.yes

@@ -1,21 +0,0 @@
----
-/*:
-  type: map
-
-/*/type:
-  type: str
-
-/*/required:
-  type: bool
-  required: false
-
-/*/range:
-  type: str
-  pattern: '^\d+\.\.(\d+|n)$'
-
-/*/pattern:
-  type: str
-
-/*/fnmatch:
-  type: str
-

data/lib/yes/cli.rb

@@ -1,20 +0,0 @@
-require 'yes'
-
-module YES
-
-  def self.cli(*argv)
-    schema_file = argv[0]
-    target_file = argv[1]
-
-    lint = Lint.new(File.new(schema_file))
-    edit = lint.validate(File.new(target_file))
-
-    if edit.size == 0
-      #$stderr.puts "valid: #{target_file}"
-    else
-      $stderr.puts edit.to_yaml
-      exit -1
-    end
-  end
-
-end

data/lib/yes/constraints/abstract_constraint.rb

@@ -1,121 +0,0 @@
-module YES
-
-  #
-  def self.constraints
-    @constraints ||= []
-  end
-
-  #
-  module Constraints
-
-    # AbstractConstraint serves as the base class for
-    # all other constraints.
-    class AbstractConstraint
-
-      #
-      def self.inherited(base)
-        YES.constraints << base
-      end
-
-      # noop
-      def self.checklist(spec, tree, nodes)
-        []
-      end
-
-      #
-      def initialize(spec, tree, nodes)
-        @spec  = spec
-        @tree  = tree
-        @nodes = nodes
-      end
-
-    public
-
-      #
-      attr :nodes
-
-      # 
-      attr :spec
-
-      #
-      attr :tree
-
-      # MUST OVERRIDE THIS METHOD IN SUBCLASSES
-      #
-      def validate(spec)
-        raise "undefined method -- `validate'"
-      end
-
-      # MUST OVERRIDE THIS METHOD IN SUBCLASSES
-      #
-      def self.applicable?(spec)
-        raise "undefined class method -- `applicable?'"
-      end
-
-      #
-      def valid? 
-        return true unless applicable?
-        recurse_valid?(spec)
-      end
-
-      #
-      def applicable?
-        self.class.applicable?(spec)
-      end
-
-    private
-
-      #
-      def recurse_valid?(spec=nil)
-        spec ||= self.spec
-        case spec
-        when Array  # logical-or
-          spec.any?{ |sub_spec| recurse_valid?(sub_spec) }
-        else
-          validate(spec)
-        end
-      end
-
-      # Range matching is used by a couple of validators.
-      #
-      # @param range [Array, String]
-      #   The range representation.
-      #
-      # @example
-      #   1..1  =~ 1
-      #   1...2 =~ 1
-      #   [1,1] =~ 1
-      #   [1,2) =~ 1
-      #   (1,2] =~ 2
-      #   (1,3) =~ 2
-      #
-      def match_delta(range, value)
-        case range
-        when Array  # array can do string comparisons
-          value > range.first && value < range.last
-        when /^(.*)\.\.\.(n|N)$/
-          value >= $1.to_f
-        when /^(.*)\.\.(n|N)$/
-          value >= $1.to_f
-        when /^(.*)\.\.\.(.*)$/
-          value >= $1.to_f && value < $2.to_f
-        when /^(.*)\.\.(.*)$/
-          value >= $1.to_f && value <= $2.to_f
-        when /^\[(.*)\,(.*)\]$/
-          value >= $1.to_f && value <= $2.to_f
-        when /^\[(.*)\,(.*)\)$/
-          value >= $1.to_f && value < $2.to_f
-        when /^\((.*)\,(.*)\]$/
-          value > $1.to_f && value <= $2.to_f
-        when /^\((.*)\,(.*)\)$/
-          value > $1.to_f && value < $2.to_f
-        else # assume range is just a number
-          range.to_f == value.to_f
-        end
-      end
-
-    end
-
-  end
-
-end

data/lib/yes/constraints/choice.rb

@@ -1,39 +0,0 @@
-module YES
-
-  module Constraints
-
-    # Validate from a selction of choices.
-    #
-    #   choice: [M,F]
-    #
-    class Choice < 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 `choice` field is in spec.
-      def self.applicable?(spec)
-        spec['choice']
-      end
-
-      # Validate that a node's value is amoung a provided
-      # list of values.
-      #
-      # @return [Boolean] validity
-      def validate(spec)
-        choice = Array(spec['choice'])
-        choice.include?(node.transform)
-      end
-
-    end
-
-  end
-
-end
-

data/lib/yes/constraints/count.rb

@@ -1,38 +0,0 @@
-module YES
-
-  module Constraints
-
-    # Count validation ensures there are a limited number of matching
-    # nodes in a document.
-    #
-    #   //gold:
-    #     count: 1..4
-    #
-    # Would mean the `gold` mapping key could only appear 1 to 4 times
-    # in the entire document.
-    class Count < TreeConstraint
-
-      #
-      # @return [Array<Constraint>]
-      def self.checklist(spec, tree, nodes)
-        return [] unless applicable?(spec)
-        [new(spec, tree, nodes)]
-      end
-
-      # Only applicable if `count` entry is in the spec.
-      def self.applicable?(spec)
-        spec['count']
-      end
-
-      # Validate count ensure there is a minimum and/or maximum
-      # number of matching nodes.
-      def validate(spec)
-        count = spec['count']
-        match_delta(count, nodes.size)
-      end
-
-    end
-
-  end
-
-end

data/lib/yes/constraints/exclusive.rb

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

data/lib/yes/constraints/fnmatch.rb

@@ -1,42 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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