nokogiri_schematron_builder 0.1.0

data/lib/nokogiri/xml/schematron/namespace.rb

@@ -0,0 +1,42 @@
+require "nokogiri/xml/schematron/base"
+
+module Nokogiri
+  module XML
+    module Schematron
+      # The internal representation of the +<sch:ns>+ XML element.
+      #
+      # For example:
+      #
+      #   namespace = Nokogiri::XML::Schematron::Namespace.new(nil, prefix: "ex", uri: "http://example.com/ns#")
+      #   # => #<Nokogiri::XML::Schematron::Namespace:0x00007f8486acd4f8 @parent=nil, @children=[], @options={:prefix=>"ex", :uri=>"http://example.com/ns#"}>
+      #   namespace.to_builder.to_xml
+      #   # => "<?xml version=\"1.0\"?>\n<sch:ns xmlns:sch=\"http://purl.oclc.org/dsdl/schematron\" prefix=\"ex\" uri=\"http://example.com/ns#\"/>\n"
+      #
+      class Namespace < Nokogiri::XML::Schematron::Base
+        # @!attribute [rw] prefix
+        #   @return [String] the value of the +@prefix+ XML attribute.
+        attribute :prefix
+
+        # @!attribute [rw] uri
+        #   @return [String] the value of the +@uri+ XML attribute.
+        attribute :uri
+
+        protected
+
+        def build!(xml)
+          xml["sch"].send(:ns, %w(prefix uri).inject(xmlns) { |acc, method_name|
+            unless (s = send(method_name.to_sym)).nil?
+              acc[method_name.to_s] = s
+            end
+
+            acc
+          }) do
+            super(xml)
+          end
+
+          return
+        end
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/schematron/nodes/base.rb

@@ -0,0 +1,189 @@
+require "nokogiri/xml/schematron/base"
+
+module Nokogiri
+  module XML
+    module Schematron
+      module Nodes
+        # The base class for internal representations of abstract syntax tree
+        # (AST) nodes, where the tree is denested and then used to build a
+        # sequence of zero or more +<sch:rule>+ elements.
+        # @abstract
+        class Base < Nokogiri::XML::Schematron::Base
+          # @return [Hash<String, Nokogiri::XML::Schematron::Nodes::Base>] the hash of child nodes by XPaths.
+          attr_reader :child_node_by_context
+
+          # @return [String] the XPath.
+          attr_accessor :context
+
+          # Create a new +Nodes::Base+ object.
+          #
+          # @param parent [Nokogiri::XML::Schematron::Base] the parent object.
+          # @param context [String] the XPath.
+          # @param options [Hash<Symbol, Object>] the options.
+          # @yieldparam node [Nokogiri::XML::Schematron::Nodes::Base] the +Nodes::Base+ object.
+          # @yieldreturn [void]
+          # @raise [ArgumentError] if the XPath is +nil+.
+          def initialize(parent, context, **options, &block)
+            @child_node_by_context = {}
+
+            if context.nil?
+              raise ::ArgumentError
+            else
+              @context = context
+            end
+
+            super(parent, **options, &block)
+          end
+
+          # Create a new +Nodes::Permit+ object.
+          #
+          # @param context [String] the XPath.
+          # @param options [Hash<Symbol, Object>] the options.
+          # @yieldparam node [Nokogiri::XML::Schematron::Nodes::Permit] the +Nodes::Permit+ object.
+          # @yieldreturn [void]
+          # @return [Nokogiri::XML::Schematron::Nodes::Permit] the +Nodes::Permit+ object.
+          # @raise [ArgumentError] if the XPath is +nil+.
+          def permit(context, **options, &block)
+            node = Nokogiri::XML::Schematron::Nodes::Permit.new(self, context, **options, &block)
+            @child_node_by_context[context] = node
+            node
+          end
+
+          # Create a new +Nodes::Reject+ object.
+          #
+          # @param context [String] the XPath.
+          # @param options [Hash<Symbol, Object>] the options.
+          # @yieldparam node [Nokogiri::XML::Schematron::Nodes::Reject] the +Nodes::Reject+ object.
+          # @yieldreturn [void]
+          # @return [Nokogiri::XML::Schematron::Nodes::Reject] the +Nodes::Reject+ object.
+          # @raise [ArgumentError] if the XPath is +nil+.
+          def reject(context, **options, &block)
+            node = Nokogiri::XML::Schematron::Nodes::Reject.new(self, context, **options, &block)
+            @child_node_by_context[context] = node
+            node
+          end
+
+          # Create a new +Nodes::Require+ object.
+          #
+          # @param context [String] the XPath.
+          # @param options [Hash<Symbol, Object>] the options.
+          # @yieldparam node [Nokogiri::XML::Schematron::Nodes::Require] the +Nodes::Require+ object.
+          # @yieldreturn [void]
+          # @return [Nokogiri::XML::Schematron::Nodes::Require] the +Nodes::Require+ object.
+          # @raise [ArgumentError] if the XPath is +nil+.
+          def require(context, **options, &block)
+            node = Nokogiri::XML::Schematron::Nodes::Require.new(self, context, **options, &block)
+            @child_node_by_context[context] = node
+            node
+          end
+
+          # Create a new +Nodes::Validations::Exclusion+ object.
+          #
+          # @param context [String] the XPath.
+          # @param options [Hash<Symbol, Object>] the options.
+          # @option options [Array<String>] :in ([]) the array of available items.
+          # @yieldparam node [Nokogiri::XML::Schematron::Nodes::Validations::Exclusion] the +Nodes::Validations::Exclusion+ object.
+          # @yieldreturn [void]
+          # @return [Nokogiri::XML::Schematron::Nodes::Validations::Exclusion] the +Nodes::Validations::Exclusion+ object.
+          def validates_exclusion_of(context, **options, &block)
+            node = Nokogiri::XML::Schematron::Nodes::Validations::Exclusion.new(self, context, **options, &block)
+            @child_node_by_context[context] = node
+            node
+          end
+
+          # Create a new +Nodes::Validations::Inclusion+ object.
+          #
+          # @param context [String] the XPath.
+          # @param options [Hash<Symbol, Object>] the options.
+          # @option options [Array<String>] :in ([]) the array of available items.
+          # @yieldparam node [Nokogiri::XML::Schematron::Nodes::Validations::Inclusion] the +Nodes::Validations::Inclusion+ object.
+          # @yieldreturn [void]
+          # @return [Nokogiri::XML::Schematron::Nodes::Validations::Inclusion] the +Nodes::Validations::Inclusion+ object.
+          def validates_inclusion_of(context, **options, &block)
+            node = Nokogiri::XML::Schematron::Nodes::Validations::Inclusion.new(self, context, **options, &block)
+            @child_node_by_context[context] = node
+            node
+          end
+
+          # Create a new +Nodes::Validations::Numericality+ object.
+          #
+          # @param context [String] the XPath.
+          # @param options [Hash<Symbol, Object>] the options.
+          # @option options [Boolean] :even (false) Specifies the value must be an even number.
+          # @option options [Integer, Float] :equal_to (nil) Specifies the value must be equal to the supplied value.
+          # @option options [Integer, Float] :greater_than (nil) Specifies the value must be greater than the supplied value.
+          # @option options [Integer, Float] :greater_than_or_equal_to (nil) Specifies the value must be greater than or equal the supplied value.
+          # @option options [Integer, Float] :less_than (nil) Specifies the value must be less than the supplied value.
+          # @option options [Integer, Float] :less_than_or_equal_to (nil) Specifies the value must be less than or equal the supplied value.
+          # @option options [Boolean] :odd (false) Specifies the value must be an odd number.
+          # @option options [Integer, Float] :other_than (nil) Specifies the value must be other than the supplied value.
+          # @yieldparam node [Nokogiri::XML::Schematron::Nodes::Validations::Numericality] the +Nodes::Validations::Numericality+ object.
+          # @yieldreturn [void]
+          # @return [Nokogiri::XML::Schematron::Nodes::Validations::Numericality] the +Nodes::Validations::Numericality+ object.
+          def validates_numericality_of(context, **options, &block)
+            node = Nokogiri::XML::Schematron::Nodes::Validations::Numericality.new(self, context, **options, &block)
+            @child_node_by_context[context] = node
+            node
+          end
+
+          protected
+
+          def build!(xml)
+            if @child_node_by_context.any?
+              xml["sch"].send(:rule, xmlns.merge({
+                "context" => send(:absolute_context),
+              })) do
+                @child_node_by_context.each_pair.sort_by { |pair| pair[0] }.each do |pair|
+                  pair[1].send(:build_assertion!, xml)
+                end
+
+                super(xml)
+              end
+
+              @child_node_by_context.each_pair.sort_by { |pair| pair[0] }.each do |pair|
+                pair[1].send(:build!, xml)
+              end
+            end
+
+            return
+          end
+
+          # Build the XML representation of the +<sch:assert>+ XML element.
+          #
+          # @param xml [Nokogiri::XML::Builder] the XML builder.
+          # @return [void]
+          def build_assertion!(xml)
+            return
+          end
+
+          private
+
+          # @return [String] the absolute XPath with respect to the abstract syntax tree.
+          def absolute_context
+            return @context unless @parent.is_a?(Nokogiri::XML::Schematron::Nodes::Base)
+
+            prefix = @parent.send(:absolute_context)
+
+            separator = \
+              case prefix
+                when "/" then ""
+                else "/"
+              end
+
+            [
+              prefix,
+              @context,
+            ].join(separator)
+          end
+        end
+      end
+    end
+  end
+end
+
+require "nokogiri/xml/schematron/nodes/permit"
+require "nokogiri/xml/schematron/nodes/reject"
+require "nokogiri/xml/schematron/nodes/require"
+require "nokogiri/xml/schematron/nodes/validations/exclusion"
+require "nokogiri/xml/schematron/nodes/validations/inclusion"
+require "nokogiri/xml/schematron/nodes/validations/numericality"

data/lib/nokogiri/xml/schematron/nodes/context.rb

@@ -0,0 +1,13 @@
+require "nokogiri/xml/schematron/nodes/base"
+
+module Nokogiri
+  module XML
+    module Schematron
+      module Nodes
+        # The abstract syntax tree node whose +@context+ XML attribute is the root.
+        class Context < Nokogiri::XML::Schematron::Nodes::Base
+        end
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/schematron/nodes/permit.rb

@@ -0,0 +1,24 @@
+require "nokogiri/xml/schematron/nodes/base"
+
+module Nokogiri
+  module XML
+    module Schematron
+      module Nodes
+        # The abstract syntax tree node whose +@context+ XML attribute is OPTIONAL.
+        class Permit < Nokogiri::XML::Schematron::Nodes::Base
+          protected
+
+          def build_assertion!(xml)
+            xml["sch"].send(:assert, xmlns.merge({
+              "test" => "count(#{@context}) >= 0",
+            })) do
+              xml.text("element \"#{@context}\" is OPTIONAL")
+            end
+
+            return
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/schematron/nodes/reject.rb

@@ -0,0 +1,24 @@
+require "nokogiri/xml/schematron/nodes/base"
+
+module Nokogiri
+  module XML
+    module Schematron
+      module Nodes
+        # The abstract syntax tree node whose +@context+ XML attribute is NOT RECOMMENDED.
+        class Reject < Nokogiri::XML::Schematron::Nodes::Base
+          protected
+
+          def build_assertion!(xml)
+            xml["sch"].send(:assert, xmlns.merge({
+              "test" => "not(#{@context})",
+            })) do
+              xml.text("element \"#{@context}\" is NOT RECOMMENDED")
+            end
+
+            return
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/schematron/nodes/require.rb

@@ -0,0 +1,24 @@
+require "nokogiri/xml/schematron/nodes/base"
+
+module Nokogiri
+  module XML
+    module Schematron
+      module Nodes
+        # The abstract syntax tree node whose +@context+ XML attribute is REQUIRED.
+        class Require < Nokogiri::XML::Schematron::Nodes::Base
+          protected
+
+          def build_assertion!(xml)
+            xml["sch"].send(:assert, xmlns.merge({
+              "test" => "count(#{@context}) >= 1",
+            })) do
+              xml.text("element \"#{@context}\" is REQUIRED")
+            end
+
+            return
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/schematron/nodes/validations/exclusion.rb

@@ -0,0 +1,51 @@
+require "nokogiri/xml/schematron/internal/core_ext/array"
+require "nokogiri/xml/schematron/nodes/base"
+
+module Nokogiri
+  module XML
+    module Schematron
+      module Nodes
+        module Validations
+          # The abstract syntax tree node that uses the +contains(haystack, needle)+
+          # XPath function, where +haystack+ and +needle+ are strings, to test
+          # if the +@context+ XML attribute is not included in an array of
+          # available items.
+          #
+          # For the supplied array of available items
+          #
+          #   ["a", "b", "c"]
+          #
+          # and context
+          #
+          #   "/x/y/z/text()"
+          #
+          # this abstract syntax tree node is equivalent to the XPath:
+          #
+          #   "not(contains('_a_ _b_ _c_', concat('_', /x/y/z/text(), '_')))"
+          #
+          class Exclusion < Nokogiri::XML::Schematron::Nodes::Base
+            # @!attribute [rw] in
+            #   @return [Array<String>] the array of available items.
+            attribute :in
+
+            protected
+
+            def build_assertion!(xml)
+              xml["sch"].send(:assert, xmlns.merge({
+                "test" => "not(contains('#{(send(:in) || []).collect { |s| "_#{s.gsub("'", "\\'")}_" }.join(" ")}', concat('_', #{@context}, '_')))",
+              })) do
+                xml.text("text \"")
+                xml["sch"].send(:"value-of", {
+                  "select" => @context,
+                })
+                xml.text("\": element \"#{@context}\" MUST NOT be #{Nokogiri::XML::Schematron::Internal::CoreExt::Array.to_sentence((send(:in) || []).collect { |s| "\"#{s.gsub("\"", "\\\"")}\"" }, last_word_connector: ", or ", two_words_connector: " or ", words_connector: ", ")}")
+              end
+
+              return
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/schematron/nodes/validations/inclusion.rb

@@ -0,0 +1,51 @@
+require "nokogiri/xml/schematron/internal/core_ext/array"
+require "nokogiri/xml/schematron/nodes/base"
+
+module Nokogiri
+  module XML
+    module Schematron
+      module Nodes
+        module Validations
+          # The abstract syntax tree node that uses the +contains(haystack, needle)+
+          # XPath function, where +haystack+ and +needle+ are strings, to test
+          # if the +@context+ XML attribute is included in an array of available
+          # items.
+          #
+          # For the supplied array of available items
+          #
+          #   ["a", "b", "c"]
+          #
+          # and context
+          #
+          #   "/x/y/z/text()"
+          #
+          # this abstract syntax tree node is equivalent to the XPath:
+          #
+          #   "contains('_a_ _b_ _c_', concat('_', /x/y/z/text(), '_'))"
+          #
+          class Inclusion < Nokogiri::XML::Schematron::Nodes::Base
+            # @!attribute [rw] in
+            #   @return [Array<String>] the array of available items.
+            attribute :in
+
+            protected
+
+            def build_assertion!(xml)
+              xml["sch"].send(:assert, xmlns.merge({
+                "test" => "contains('#{(send(:in) || []).collect { |s| "_#{s.gsub("'", "\\'")}_" }.join(" ")}', concat('_', #{@context}, '_'))",
+              })) do
+                xml.text("text \"")
+                xml["sch"].send(:"value-of", {
+                  "select" => @context,
+                })
+                xml.text("\": element \"#{@context}\" MUST be #{Nokogiri::XML::Schematron::Internal::CoreExt::Array.to_sentence((send(:in) || []).collect { |s| "\"#{s.gsub("\"", "\\\"")}\"" }, last_word_connector: ", or ", two_words_connector: " or ", words_connector: ", ")}")
+              end
+
+              return
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/schematron/nodes/validations/numericality.rb

@@ -0,0 +1,142 @@
+require "nokogiri/xml/schematron/internal/core_ext/array"
+require "nokogiri/xml/schematron/nodes/base"
+
+module Nokogiri
+  module XML
+    module Schematron
+      module Nodes
+        module Validations
+          # The abstract syntax tree node that uses the +number(any)+
+          # XPath function, where +any+ is any value, to test if the +@context+
+          # XML attribute is numeric.
+          class Numericality < Nokogiri::XML::Schematron::Nodes::Base
+            # @!attribute [rw] even
+            #   @return [Boolean] the value must be an even number.
+            attribute :even
+
+            # @!attribute [rw] equal_to
+            #   @return [Integer, Float] the value must be equal to the supplied value.
+            attribute :equal_to
+
+            # @!attribute [rw] greater_than
+            #   @return [Integer, Float] the value must be greater than the supplied value.
+            attribute :greater_than
+
+            # @!attribute [rw] greater_than_or_equal_to
+            #   @return [Integer, Float] the value must be greater than or equal the supplied value.
+            attribute :greater_than_or_equal_to
+
+            # @!attribute [rw] less_than
+            #   @return [Integer, Float] the value must be less than the supplied value.
+            attribute :less_than
+
+            # @!attribute [rw] less_than_or_equal_to
+            #   @return [Integer, Float] the value must be less than or equal the supplied value.
+            attribute :less_than_or_equal_to
+
+            # @!attribute [rw] odd
+            #   @return [Boolean] the value must be an odd number.
+            attribute :odd
+
+            # @!attribute [rw] other_than
+            #   @return [Integer, Float] the value must be other than the supplied value.
+            attribute :other_than
+
+            protected
+
+            def build_assertion!(xml)
+              tests = [
+                "number(#{@context}) = #{@context}",
+              ]
+
+              messages = [
+                "MUST be a number",
+              ]
+
+              PROC_BY_METHOD_NAME.each do |method_name, block|
+                unless (orig_value = send(method_name.to_sym)).nil? || (pair = block.call(orig_value)).nil?
+                  tests << pair[0]
+                  messages << pair[1]
+                end
+              end
+
+              xml["sch"].send(:assert, xmlns.merge({
+                "test" => tests.collect { |s| "(#{s})" }.join(" and "),
+              })) do
+                xml.text("text \"")
+                xml["sch"].send(:"value-of", {
+                  "select" => @context,
+                })
+                xml.text("\": element \"#{@context}\" #{Nokogiri::XML::Schematron::Internal::CoreExt::Array.to_sentence(messages, last_word_connector: ", and ", two_words_connector: " and ", words_connector: ", ")}")
+              end
+
+              return
+            end
+
+            private
+
+            # @return [Hash<Symbol, Proc>] the hash of blocks by method name.
+            PROC_BY_METHOD_NAME = {
+              even: ::Proc.new { |bool|
+                if bool == true
+                  [
+                    "number(#{@context}) mod 2 = 0",
+                    "MUST be even",
+                  ]
+                else
+                  nil
+                end
+              },
+              equal_to: ::Proc.new { |number|
+                [
+                  "number(#{@context}) = #{number}",
+                  "MUST be equal to #{number}",
+                ]
+              },
+              greater_than: ::Proc.new { |number|
+                [
+                  "number(#{@context}) > #{number}",
+                  "MUST be greater than #{number}",
+                ]
+              },
+              greater_than_or_equal_to: ::Proc.new { |number|
+                [
+                  "number(#{@context}) >= #{number}",
+                  "MUST be greater than or equal to #{number}",
+                ]
+              },
+              less_than: ::Proc.new { |number|
+                [
+                  "number(#{@context}) < #{number}",
+                  "MUST be less than #{number}",
+                ]
+              },
+              less_than_or_equal_to: ::Proc.new { |number|
+                [
+                  "number(#{@context}) <= #{number}",
+                  "MUST be less than or equal to #{number}",
+                ]
+              },
+              odd: ::Proc.new { |bool|
+                if bool == true
+                  [
+                    "number(#{@context}) mod 2 = 1",
+                    "MUST be odd",
+                  ]
+                else
+                  nil
+                end
+              },
+              other_than: ::Proc.new { |number|
+                [
+                  "number(#{@context}) != #{number}",
+                  "MUST NOT be equal to #{number}",
+                ]
+              },
+            }
+          end
+        end
+      end
+    end
+  end
+end