yes 0.0.1

data/README.rdoc

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

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

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

data/data/yes/yes.yes

@@ -0,0 +1,21 @@
+---
+/*:
+  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.rb

@@ -0,0 +1,38 @@
+module YES
+
+  # Simple validatily check.
+  #
+  # @return [Boolean]
+  def self.valid?(schema, yaml)
+    yes = YES::Lint.new(@schema)
+    yes.validate(@yaml).empty? 
+  end
+
+end
+
+#
+require 'yaml'
+
+require 'yes/constraints/abstract_constraint'
+require 'yes/constraints/node_constraint'
+require 'yes/constraints/tree_constraint'
+
+require 'yes/constraints/range'
+require 'yes/constraints/regexp'
+require 'yes/constraints/fnmatch'
+
+require 'yes/constraints/tag'
+require 'yes/constraints/type'
+
+require 'yes/constraints/count'
+require 'yes/constraints/length'
+require 'yes/constraints/requires'
+require 'yes/constraints/inclusive'
+require 'yes/constraints/exclusive'
+
+require 'yes/constraints/value'
+require 'yes/constraints/key'
+
+require 'yes/logical_and'
+require 'yes/lint'
+

data/lib/yes/cli.rb

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

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

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

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

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