gds-data-validation 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0f56c000f3ef005f609da4a062006914e0e851ba
+  data.tar.gz: e3fe4d0e6c382a06f3a859bd7b3d00d49e08285e
+SHA512:
+  metadata.gz: 1ec8377a3978dd16fedc947ea370c7402a182338c3e0d997063ee071935b150727f058377280eb0cb95cc4e770f82bb5f4686023217b102af3bf3a110a2743c3
+  data.tar.gz: 20d7ffb1c4087fba7306f0c1ca2491ef7a7d975e9fca7c78b6b2dae97e28bb50bbf2078389e65afd2fc4a568ec0122a514b58338582e4f54f63b65a0dcb10a3d

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# CHANGELOG
+
+### 0.1.0 - (2019-07-11)
+
+* Initial release

data/MIT-LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2019 Ulrich Ramminger
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,85 @@
+gds-data-validation
+===================
+
+A data validation library providing a rule-based schema definition language.    
+For checking (incoming) data against a specified schema definition.    
+GDS stands for General Data Structure.    
+
+Installation
+============
+
+~~~
+gem install gds-data-validation
+~~~
+
+An Example
+==========
+
+~~~ruby
+require "gds-data-validation"
+
+dataValidation = GdsDataValidation.create( <<-EOS )
+company = :name        : @t_string,
+          :address     : address,
+          :ceo         : person,
+          :employees   : person*
+person =  :firstname   : @t_string,
+          :lastname    : @t_string,
+          :yearOfBirth : @t_int,
+          :address     : address
+address = :street      : @t_string,
+          :zipcode     : @t_int,
+          :city        : @t_string
+EOS
+
+dataValidation.check( nil )   # => false
+dataValidation.check(
+  { name: 'My Company', address: { street: 'Broadway 300', zipcode: 22222, city: 'New York' },
+    ceo: { firstname: 'John', lastname: 'McArthur', yearOfBirth: 1959,
+           address: { street: 'Rosedale Dr. 40', zipcode: 34003, city: 'Los Angeles' } },
+    employees: [
+      { firstname: 'Berry', lastname: 'Miller', yearOfBirth: 1989,
+        address: { street: 'South St. 12', zipcode: 48333, city: 'Chicago' } },
+      { firstname: 'Jane', lastname: 'Smith', yearOfBirth: 1993,
+        address: { street: 'Mainstreet 4', zipcode: 62883, city: 'Seattle' } } ] }
+)   # => true
+~~~
+
+Introduction
+============
+
+The original idea was to create a library for the validation of data structures which have been created
+by the [GDS (General Data Structure)](https://urasepandia.de/gds.html) language.
+
+Synonyms and related terms are data validation, validation checker, schema validation, schema validator, schema checker.
+
+Ruby Gem
+========
+
+You can find it on RubyGems.org:  
+
+[rubygems.org/gems/gds-data-validation](https://rubygems.org/gems/gds-data-validation)
+
+Source Code
+===========
+
+You can find the source code on GitHub:  
+
+[github.com/uliramminger/gds-data-validation](https://github.com/uliramminger/gds-data-validation)
+
+Further Information
+===================
+
+You will find detailed information here:  [urasepandia.de/gds-data-validation.html](https://urasepandia.de/gds-data-validation.html)
+
+Maintainer
+==========
+
+Uli Ramminger <uli@urasepandia.de>
+
+Copyright
+=========
+
+Copyright (c) 2019 Ulrich Ramminger
+
+See MIT-LICENSE for further details.

data/Rakefile

@@ -0,0 +1,15 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs = [ 'test' ]
+  t.test_files = FileList['test/test*.rb']
+  t.verbose = true
+end
+
+desc "Gem build"
+task :gembuild do
+  puts `gem build gds-data-validation.gemspec`
+end
+
+desc "Run tests"
+task :default => :test

data/lib/gds-data-validation.rb

@@ -0,0 +1,45 @@
+# gds-data-validation.rb
+
+# You will find further information here:  https://urasepandia.de/gds-data-validation.html
+
+require_relative 'gds-data-validation/version.rb'
+require_relative 'gds-data-validation/lng_gds_check.rb'
+require_relative 'gds-data-validation/validation_generator.rb'
+
+class GdsDataValidation
+
+  class << self
+
+    # create an data validation class which is checking incoming data against a specified schema definition
+    #
+    # @param schema_definition [String] the schema definition to be used for data validation
+    #
+    # @return [Class] anonymous class for data validation
+    #
+    # @example
+    #   require 'gds-data-validaion'
+    #
+    #   dataValidation = GdsDataValidation.create( <<-EOS )
+    #   schema = @t_int
+    #   EOS
+    #
+    #   dataValidation.check( 10 )    # => true
+    #   dataValidation.check( "a" )   # => false
+    def create( schema_definition )
+      vcg = ValidationCheckerGenerator.new
+      vcg.generate( LDLgeneratedLanguage::Language_gds_check.parse( schema_definition ) )
+    end
+
+    # create an data validation class which is checking incoming data against a specified schema definition stored in a file
+    #
+    # @param file_name [String] file name, this file contains the schema definition
+    #
+    # @return [Class] anonymous class for data validation
+    def create_from_file( file_name )
+      vcg = ValidationCheckerGenerator.new
+      vcg.generate( LDLgeneratedLanguage::Language_gds_check.parse( File.read( file_name ) ) )
+    end
+
+  end
+
+end

data/lib/gds-data-validation/lng_gds_check.rb

@@ -0,0 +1,40 @@
+# lng_gds_check.rb
+
+module LDLgeneratedLanguage
+
+  class Language_gds_check
+    require 'treetop'
+
+    class SyntaxError < ::StandardError
+    end
+
+    def self.parse( s )
+      @parserClass ||= begin
+        Treetop.load_from_string GrammarDef
+        instance_eval( 'Language_gds_check_05Parser' )
+      end
+      parser = @parserClass.new
+
+      parseTree = parser.parse( s + "\n" )
+
+      unless parseTree
+        lineOfFailure   = parser.failure_line
+        columnOfFailure = parser.failure_column
+
+        s = "LANGUAGE_GDS_CHECK: Error happend, while parsing the definition: line #{lineOfFailure}, column #{columnOfFailure}" + "\n"
+        s += parser.failure_reason + "\n"  if parser.failure_reason
+        s += "--->" + "\n"
+        s += parser.input.lines[((lineOfFailure-1-5)>0 ? (lineOfFailure-1-5) : 0)..(lineOfFailure-1)].join.chomp + "\n"
+        s += ' '*((parser.failure_column) -1) + '^' + "\n"
+        s += "<---" + "\n"
+
+        raise SyntaxError, s
+      end
+
+      parseTree.ast
+    end
+
+    GrammarDef = "grammar Language_gds_check_05\n\n  rule top\n    defs ''\n    {\n      def ast\n        defs.ast\n      end\n    }\n  end\n\n  rule defs\n    wscommnl2 productionrule_l:(productionrule*)  wscommnl2\n    {\n      def ast\n        r = []\n        productionrule_l.elements.each do |e|\n          r << e.ast\n        end\n        r\n      end\n    }\n  end\n\n  rule productionrule\n    rulename wscommnl2 '=' wscommnl2 ruledefinition \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :name, rulename.ast ] )\n        r.merge!( Hash[ :ruledefinition, ruledefinition.ast ] )\n        r\n      end\n    }\n  end\n\n  rule rulename\n    identifier ''\n    {\n      def ast\n        identifier.ast\n      end\n    }\n  end\n\n  rule ruledefinition\n    alternatives ''\n    {\n      def ast\n        alternatives.ast\n      end\n    }\n  end\n\n  rule alternatives\n    alternative_mb wscommnl2 '/' wscommnl2 alternatives \n    {\n      def ast\n        r = []\n        r << alternative_mb.ast\n        r2 = alternatives.ast\n        if r2.is_a?(Array); r.concat( r2 ); else r << r2; end\n        r\n      end\n    }\n    /\n    alternative_mb '' \n    {\n      def ast\n        r = []\n        r << alternative_mb.ast\n        r\n      end\n    }\n  end\n\n  rule alternative_mb\n    mb:maybe? wscommnl2 alternative \n    {\n      def ast\n        r = {}\n        r.merge!( alternative.ast )\n        r.merge!( Hash[ :maybe, mb.ast ] )  unless mb.empty?\n        r\n      end\n    }\n  end\n\n  rule alternative\n    hashdef wscommnl2 \n    {\n      def ast\n        hashdef.ast\n      end\n    }\n    /\n    structuraldef wscommnl2 \n    {\n      def ast\n        structuraldef.ast\n      end\n    }\n  end\n\n  rule hashdef\n    sk:strictkeys? wscommnl2 keyvaluedefs \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :hashdef, keyvaluedefs.ast ] )\n        r.merge!( Hash[ :strict, sk.ast ] )  unless sk.empty?\n        r\n      end\n    }\n  end\n\n  rule arraydef\n    rulename sizespec \n    {\n      def ast\n        r = {}\n        r1 = {}\n        r1.merge!( Hash[ :rulename, rulename.ast ] )\n        r1.merge!( Hash[ :sizespec, sizespec.ast ] )\n        r.merge!( Hash[ :arraydef, r1 ] )\n        r\n      end\n    }\n  end\n\n  rule subruledef\n    rulename '' \n    {\n      def ast\n        r = {}\n        r1 = {}\n        r1.merge!( Hash[ :rulename, rulename.ast ] )\n        r.merge!( Hash[ :subruledef, r1 ] )\n        r\n      end\n    }\n  end\n\n  rule strictkeys\n    '@strict' \n    {\n      def ast\n        :strict\n      end\n    }\n  end\n\n  rule keyvaluedefs\n    keyvaluedef wscommnl2 ',' wscommnl2 keyvaluedefs \n    {\n      def ast\n        r = []\n        r << keyvaluedef.ast\n        r2 = keyvaluedefs.ast\n        if r2.is_a?(Array); r.concat( r2 ); else r << r2; end\n        r\n      end\n    }\n    /\n    keyvaluedef '' \n    {\n      def ast\n        r = []\n        r << keyvaluedef.ast\n        r\n      end\n    }\n  end\n\n  rule keyvaluedef\n    keydef wscommnl2 ':?' wscommnl2 structuraldef_mb \n    {\n      def ast\n        r = {}\n        r1 = {}\n        r1.merge!( Hash[ :key, keydef.ast ] )\n        r1.merge!( Hash[ :value, structuraldef_mb.ast ] )\n        r1.merge!( Hash[ :optional, :optional ] )\n        r.merge!( Hash[ :keyvaluedef, r1 ] )\n        r\n      end\n    }\n    /\n    keydef wscommnl2 ':' wscommnl2 structuraldef_mb \n    {\n      def ast\n        r = {}\n        r1 = {}\n        r1.merge!( Hash[ :key, keydef.ast ] )\n        r1.merge!( Hash[ :value, structuraldef_mb.ast ] )\n        r.merge!( Hash[ :keyvaluedef, r1 ] )\n        r\n      end\n    }\n  end\n\n  rule keydef\n    wscommnl2 ':' identifier \n    {\n      def ast\n        identifier.ast\n      end\n    }\n  end\n\n  rule structuraldef_mb\n    mb:maybe? wscommnl2 structuraldef \n    {\n      def ast\n        r = {}\n        r.merge!( structuraldef.ast )\n        r.merge!( Hash[ :maybe, mb.ast ] )  unless mb.empty?\n        r\n      end\n    }\n  end\n\n  rule structuraldef\n    no:notop? wscommnl2 '(' wscommnl2 typevaldef_disjunction wscommnl2 ')' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :valdefdisjunct, typevaldef_disjunction.ast ] )\n        r.merge!( Hash[ :notop, no.ast ] )  unless no.empty?\n        r\n      end\n    }\n    /\n    typevaldef_disjunction '' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :valdefdisjunct, typevaldef_disjunction.ast ] )\n        r\n      end\n    }\n    /\n    no:notop? wscommnl2 typedef \n    {\n      def ast\n        r = {}\n        r1 = {}\n        r1.merge!( typedef.ast )\n        r1.merge!( Hash[ :notop, no.ast ] )  unless no.empty?\n        r.merge!( Hash[ :typedef, r1 ] )\n        r\n      end\n    }\n    /\n    basicvaldef '' \n    {\n      def ast\n        basicvaldef.ast\n      end\n    }\n    /\n    arraydef '' \n    {\n      def ast\n        r = {}\n        r.merge!( arraydef.ast )\n        r\n      end\n    }\n    /\n    subruledef '' \n    {\n      def ast\n        r = {}\n        r.merge!( subruledef.ast )\n        r\n      end\n    }\n  end\n\n  rule basicvaldef\n    rubysymbol '' \n    {\n      def ast\n        r = {}\n        r1 = {}\n        r1.merge!( Hash[ :type, :t_symbol ] )\n        r1.merge!( Hash[ :value, rubysymbol.ast ] )\n        r.merge!( Hash[ :basicvaluedef, r1 ] )\n        r\n      end\n    }\n    /\n    string '' \n    {\n      def ast\n        r = {}\n        r1 = {}\n        r1.merge!( Hash[ :type, :t_string ] )\n        r1.merge!( Hash[ :value, string.ast ] )\n        r.merge!( Hash[ :basicvaluedef, r1 ] )\n        r\n      end\n    }\n    /\n    number_float '' \n    {\n      def ast\n        r = {}\n        r1 = {}\n        r1.merge!( Hash[ :type, :t_float ] )\n        r1.merge!( Hash[ :value, number_float.ast ] )\n        r.merge!( Hash[ :basicvaluedef, r1 ] )\n        r\n      end\n    }\n    /\n    number_int '' \n    {\n      def ast\n        r = {}\n        r1 = {}\n        r1.merge!( Hash[ :type, :t_int ] )\n        r1.merge!( Hash[ :value, number_int.ast ] )\n        r.merge!( Hash[ :basicvaluedef, r1 ] )\n        r\n      end\n    }\n    /\n    keyword_literal '' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :basicvaluedef, keyword_literal.ast ] )\n        r\n      end\n    }\n  end\n\n  rule typevaldef_disjunction\n    tvclause wscommnl2 '|' wscommnl2 tvclauses \n    {\n      def ast\n        r = []\n        r << tvclause.ast\n        r2 = tvclauses.ast\n        if r2.is_a?(Array); r.concat( r2 ); else r << r2; end\n        r\n      end\n    }\n  end\n\n  rule tvclauses\n    tvclause wscommnl2 '|' wscommnl2 tvclauses \n    {\n      def ast\n        r = []\n        r << tvclause.ast\n        r2 = tvclauses.ast\n        if r2.is_a?(Array); r.concat( r2 ); else r << r2; end\n        r\n      end\n    }\n    /\n    tvclause '' \n    {\n      def ast\n        r = []\n        r << tvclause.ast\n        r\n      end\n    }\n  end\n\n  rule tvclause\n    no:notop? wscommnl2 typedef \n    {\n      def ast\n        r = {}\n        r1 = {}\n        r1.merge!( typedef.ast )\n        r1.merge!( Hash[ :notop, no.ast ] )  unless no.empty?\n        r.merge!( Hash[ :typedef, r1 ] )\n        r\n      end\n    }\n    /\n    basicvaldef '' \n    {\n      def ast\n        basicvaldef.ast\n      end\n    }\n  end\n\n  rule sizespec\n    '+'\n    {\n      def ast\n        text_value.to_sym\n      end\n    }\n    /\n    '*'\n    {\n      def ast\n        text_value.to_sym\n      end\n    }\n    /\n    '(' wscommnl2 '..' wscommnl2 number_int wscommnl2 ')' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :max, number_int.ast ] )\n        r\n      end\n    }\n    /\n    '(' wscommnl2 a:number_int wscommnl2 '..' wscommnl2 b:number_int wscommnl2 ')' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :min, a.ast ] )\n        r.merge!( Hash[ :max, b.ast ] )\n        r\n      end\n    }\n    /\n    '(' wscommnl2 number_int wscommnl2 '..' wscommnl2 ')' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :min, number_int.ast ] )\n        r\n      end\n    }\n    /\n    '(' wscommnl2 number_int wscommnl2 ')' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :min, number_int.ast ] )\n        r.merge!( Hash[ :max, number_int.ast ] )\n        r\n      end\n    }\n  end\n\n  rule typedef\n    typedef_string ''\n    {\n      def ast\n        typedef_string.ast\n      end\n    }\n    /\n    typedef_int ''\n    {\n      def ast\n        typedef_int.ast\n      end\n    }\n    /\n    typedef_float ''\n    {\n      def ast\n        typedef_float.ast\n      end\n    }\n    /\n    '@t_numeric' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :type, :t_numeric ] )\n        r\n      end\n    }\n    /\n    '@t_nil' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :type, :t_nil ] )\n        r\n      end\n    }\n    /\n    '@t_bool' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :type, :t_bool ] )\n        r\n      end\n    }\n    /\n    '@t_true' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :type, :t_true ] )\n        r\n      end\n    }\n    /\n    '@t_false' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :type, :t_false ] )\n        r\n      end\n    }\n    /\n    typedef_symbol ''\n    {\n      def ast\n        typedef_symbol.ast\n      end\n    }\n    /\n    '@t_any' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :type, :t_any ] )\n        r\n      end\n    }\n  end\n\n  rule typedef_int\n    wscommnl2 '@t_int' wscommnl2 ivs:intvaluespecs? \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :type, :t_int ] )\n        r.merge!( Hash[ :valuespecs, ivs.ast ] )  unless ivs.empty?\n        r\n      end\n    }\n  end\n\n  rule maybe\n    '@maybe' \n    {\n      def ast\n        :maybe\n      end\n    }\n  end\n\n  rule intvaluespecs\n    intvaluespec_with_not* \n    {\n      def ast\n        r = []\n        elements.each do |e|\n          r << e.ast\n        end\n        r\n      end\n    }\n  end\n\n  rule intvaluespec_with_not\n    no:notop? wscommnl2 intvaluespec wscommnl2 \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :notop, no.ast ] )  unless no.empty?\n        r.merge!( intvaluespec.ast )\n        r\n      end\n    }\n  end\n\n  rule intvaluespec\n    wscommnl2 '!=' wscommnl2 number_int \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :spec, :neql ] )\n        r.merge!( Hash[ :val, number_int.ast ] )\n        r\n      end\n    }\n    /\n    wscommnl2 '==' wscommnl2 number_int \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :spec, :eql ] )\n        r.merge!( Hash[ :val, number_int.ast ] )\n        r\n      end\n    }\n    /\n    intvaluespec_keywords '' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :spec, intvaluespec_keywords.ast ] )\n        r\n      end\n    }\n    /\n    intminmaxspec ''\n    {\n      def ast\n        intminmaxspec.ast\n      end\n    }\n    /\n    intvaluelist '' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :valuelist, intvaluelist.ast ] )\n        r\n      end\n    }\n  end\n\n  rule intvaluespec_keywords\n    'odd'\n    {\n      def ast\n        text_value.to_sym\n      end\n    }\n    /\n    'even'\n    {\n      def ast\n        text_value.to_sym\n      end\n    }\n  end\n\n  rule intvaluelist\n    wscommnl2 '[' wscommnl2 intvalues_comma wscommnl2 ']'\n    {\n      def ast\n        intvalues_comma.ast\n      end\n    }\n    /\n    wscommnl2 '%(' wscommnl2 intvalues_nocomma wscommnl2 ')'\n    {\n      def ast\n        intvalues_nocomma.ast\n      end\n    }\n  end\n\n  rule intvalues_comma\n    number_int wscommnl2 onemorenumint_comma_l:(onemorenumint_comma*) \n    {\n      def ast\n        r = []\n        r << number_int.ast\n        r1 = []\n        onemorenumint_comma_l.elements.each do |e|\n          r1 << e.ast\n        end\n        r.concat( r1 )\n        r\n      end\n    }\n  end\n\n  rule onemorenumint_comma\n    wscommnl2 ',' wscommnl2 number_int\n    {\n      def ast\n        number_int.ast\n      end\n    }\n  end\n\n  rule intvalues_nocomma\n    number_int wscommnl2 onemorenumint_nocomma_l:(onemorenumint_nocomma*) \n    {\n      def ast\n        r = []\n        r << number_int.ast\n        r1 = []\n        onemorenumint_nocomma_l.elements.each do |e|\n          r1 << e.ast\n        end\n        r.concat( r1 )\n        r\n      end\n    }\n  end\n\n  rule onemorenumint_nocomma\n    ws number_int\n    {\n      def ast\n        number_int.ast\n      end\n    }\n  end\n\n  rule typedef_string\n    wscommnl2 '@t_string' wscommnl2 svs:stringvaluespecs? \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :type, :t_string ] )\n        r.merge!( Hash[ :valuespecs, svs.ast ] )  unless svs.empty?\n        r\n      end\n    }\n  end\n\n  rule stringvaluespecs\n    stringvaluespec_with_not* \n    {\n      def ast\n        r = []\n        elements.each do |e|\n          r << e.ast\n        end\n        r\n      end\n    }\n  end\n\n  rule stringvaluespec_with_not\n    no:notop? wscommnl2 stringvaluespec wscommnl2 \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :notop, no.ast ] )  unless no.empty?\n        r.merge!( stringvaluespec.ast )\n        r\n      end\n    }\n  end\n\n  rule stringvaluespec\n    wscommnl2 '!=' wscommnl2 string \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :spec, :neql ] )\n        r.merge!( Hash[ :val, string.ast ] )\n        r\n      end\n    }\n    /\n    wscommnl2 '==' wscommnl2 string \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :spec, :eql ] )\n        r.merge!( Hash[ :val, string.ast ] )\n        r\n      end\n    }\n    /\n    stringvaluespec_keywords '' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :spec, stringvaluespec_keywords.ast ] )\n        r\n      end\n    }\n    /\n    lengthspec ''\n    {\n      def ast\n        lengthspec.ast\n      end\n    }\n    /\n    stringvaluelist '' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :valuelist, stringvaluelist.ast ] )\n        r\n      end\n    }\n    /\n    regexp '' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :spec, :regexp ] )\n        r.merge!( regexp.ast )\n        r\n      end\n    }\n  end\n\n  rule stringvaluespec_keywords\n    'blank'\n    {\n      def ast\n        text_value.to_sym\n      end\n    }\n    /\n    'empty'\n    {\n      def ast\n        text_value.to_sym\n      end\n    }\n    /\n    'present'\n    {\n      def ast\n        text_value.to_sym\n      end\n    }\n    /\n    'something'\n    {\n      def ast\n        text_value.to_sym\n      end\n    }\n  end\n\n  rule stringvaluelist\n    wscommnl2 '[' wscommnl2 stringvalues_comma wscommnl2 ']'\n    {\n      def ast\n        stringvalues_comma.ast\n      end\n    }\n    /\n    wscommnl2 '%(' wscommnl2 stringvalues_nocomma wscommnl2 ')'\n    {\n      def ast\n        stringvalues_nocomma.ast\n      end\n    }\n  end\n\n  rule stringvalues_comma\n    string wscommnl2 onemorestring_comma_l:(onemorestring_comma*) \n    {\n      def ast\n        r = []\n        r << string.ast\n        r1 = []\n        onemorestring_comma_l.elements.each do |e|\n          r1 << e.ast\n        end\n        r.concat( r1 )\n        r\n      end\n    }\n  end\n\n  rule onemorestring_comma\n    wscommnl2 ',' wscommnl2 string\n    {\n      def ast\n        string.ast\n      end\n    }\n  end\n\n  rule stringvalues_nocomma\n    stringnoblank wscommnl2 onemorestring_nocomma_l:(onemorestring_nocomma*) \n    {\n      def ast\n        r = []\n        r << stringnoblank.ast\n        r1 = []\n        onemorestring_nocomma_l.elements.each do |e|\n          r1 << e.ast\n        end\n        r.concat( r1 )\n        r\n      end\n    }\n  end\n\n  rule onemorestring_nocomma\n    ws stringnoblank\n    {\n      def ast\n        stringnoblank.ast\n      end\n    }\n  end\n\n  rule typedef_float\n    wscommnl2 '@t_float' wscommnl2 vs:floatvaluespecs? \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :type, :t_float ] )\n        r.merge!( Hash[ :valuespecs, vs.ast ] )  unless vs.empty?\n        r\n      end\n    }\n  end\n\n  rule floatvaluespecs\n    floatvaluespec_with_not* \n    {\n      def ast\n        r = []\n        elements.each do |e|\n          r << e.ast\n        end\n        r\n      end\n    }\n  end\n\n  rule floatvaluespec_with_not\n    no:notop? wscommnl2 floatvaluespec wscommnl2 \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :notop, no.ast ] )  unless no.empty?\n        r.merge!( floatvaluespec.ast )\n        r\n      end\n    }\n  end\n\n  rule floatvaluespec\n    wscommnl2 '!=' wscommnl2 number_float \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :spec, :neql ] )\n        r.merge!( Hash[ :val, number_float.ast ] )\n        r\n      end\n    }\n    /\n    wscommnl2 '==' wscommnl2 number_float \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :spec, :eql ] )\n        r.merge!( Hash[ :val, number_float.ast ] )\n        r\n      end\n    }\n    /\n    floatminmaxspec ''\n    {\n      def ast\n        floatminmaxspec.ast\n      end\n    }\n    /\n    floatvaluelist '' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :valuelist, floatvaluelist.ast ] )\n        r\n      end\n    }\n  end\n\n  rule floatminmaxspec\n    min wscommnl2 a:number_float wscommnl2 max wscommnl2 b:number_float \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :minspec, min.ast ] )\n        r.merge!( Hash[ :min, a.ast ] )\n        r.merge!( Hash[ :maxspec, max.ast ] )\n        r.merge!( Hash[ :max, b.ast ] )\n        r\n      end\n    }\n    /\n    max wscommnl2 a:number_float wscommnl2 min wscommnl2 b:number_float \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :maxspec, max.ast ] )\n        r.merge!( Hash[ :max, a.ast ] )\n        r.merge!( Hash[ :minspec, min.ast ] )\n        r.merge!( Hash[ :min, b.ast ] )\n        r\n      end\n    }\n    /\n    min wscommnl2 number_float \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :minspec, min.ast ] )\n        r.merge!( Hash[ :min, number_float.ast ] )\n        r\n      end\n    }\n    /\n    max wscommnl2 number_float \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :maxspec, max.ast ] )\n        r.merge!( Hash[ :max, number_float.ast ] )\n        r\n      end\n    }\n    /\n    wscommnl2 '(' wscommnl2 a:number_float wscommnl2 '..' wscommnl2 b:number_float wscommnl2 ')' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :min, a.ast ] )\n        r.merge!( Hash[ :max, b.ast ] )\n        r\n      end\n    }\n    /\n    wscommnl2 '(' wscommnl2 number_float wscommnl2 '..' wscommnl2 ')' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :min, number_float.ast ] )\n        r\n      end\n    }\n    /\n    wscommnl2 '(' wscommnl2 '..' wscommnl2 number_float wscommnl2 ')' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :max, number_float.ast ] )\n        r\n      end\n    }\n  end\n\n  rule floatvaluelist\n    wscommnl2 '[' wscommnl2 floatvalues_comma wscommnl2 ']'\n    {\n      def ast\n        floatvalues_comma.ast\n      end\n    }\n    /\n    wscommnl2 '%(' wscommnl2 floatvalues_nocomma wscommnl2 ')'\n    {\n      def ast\n        floatvalues_nocomma.ast\n      end\n    }\n  end\n\n  rule floatvalues_comma\n    number_float wscommnl2 onemorenumfloat_comma_l:(onemorenumfloat_comma*) \n    {\n      def ast\n        r = []\n        r << number_float.ast\n        r1 = []\n        onemorenumfloat_comma_l.elements.each do |e|\n          r1 << e.ast\n        end\n        r.concat( r1 )\n        r\n      end\n    }\n  end\n\n  rule onemorenumfloat_comma\n    wscommnl2 ',' wscommnl2 number_float\n    {\n      def ast\n        number_float.ast\n      end\n    }\n  end\n\n  rule floatvalues_nocomma\n    number_float wscommnl2 onemorenumfloat_nocomma_l:(onemorenumfloat_nocomma*) \n    {\n      def ast\n        r = []\n        r << number_float.ast\n        r1 = []\n        onemorenumfloat_nocomma_l.elements.each do |e|\n          r1 << e.ast\n        end\n        r.concat( r1 )\n        r\n      end\n    }\n  end\n\n  rule onemorenumfloat_nocomma\n    ws number_float\n    {\n      def ast\n        number_float.ast\n      end\n    }\n  end\n\n  rule typedef_symbol\n    wscommnl2 '@t_symbol' wscommnl2 vs:symbolvaluespecs? \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :type, :t_symbol ] )\n        r.merge!( Hash[ :valuespecs, vs.ast ] )  unless vs.empty?\n        r\n      end\n    }\n  end\n\n  rule symbolvaluespecs\n    symbolvaluespec_with_not* \n    {\n      def ast\n        r = []\n        elements.each do |e|\n          r << e.ast\n        end\n        r\n      end\n    }\n  end\n\n  rule symbolvaluespec_with_not\n    no:notop? wscommnl2 symbolvaluespec wscommnl2 \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :notop, no.ast ] )  unless no.empty?\n        r.merge!( symbolvaluespec.ast )\n        r\n      end\n    }\n  end\n\n  rule symbolvaluespec\n    wscommnl2 '!=' wscommnl2 rubysymbol \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :spec, :neql ] )\n        r.merge!( Hash[ :val, rubysymbol.ast ] )\n        r\n      end\n    }\n    /\n    wscommnl2 '==' wscommnl2 rubysymbol \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :spec, :eql ] )\n        r.merge!( Hash[ :val, rubysymbol.ast ] )\n        r\n      end\n    }\n    /\n    lengthspec ''\n    {\n      def ast\n        lengthspec.ast\n      end\n    }\n    /\n    symbolvaluelist '' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :valuelist, symbolvaluelist.ast ] )\n        r\n      end\n    }\n    /\n    regexp '' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :spec, :regexp ] )\n        r.merge!( regexp.ast )\n        r\n      end\n    }\n  end\n\n  rule symbolvaluelist\n    wscommnl2 '[' wscommnl2 symbolvalues_comma wscommnl2 ']'\n    {\n      def ast\n        symbolvalues_comma.ast\n      end\n    }\n    /\n    wscommnl2 '%(' wscommnl2 symbolvalues_nocomma wscommnl2 ')'\n    {\n      def ast\n        symbolvalues_nocomma.ast\n      end\n    }\n  end\n\n  rule symbolvalues_comma\n    rubysymbol wscommnl2 onemoresymbol_comma_l:(onemoresymbol_comma*) \n    {\n      def ast\n        r = []\n        r << rubysymbol.ast\n        r1 = []\n        onemoresymbol_comma_l.elements.each do |e|\n          r1 << e.ast\n        end\n        r.concat( r1 )\n        r\n      end\n    }\n  end\n\n  rule onemoresymbol_comma\n    wscommnl2 ',' wscommnl2 rubysymbol\n    {\n      def ast\n        rubysymbol.ast\n      end\n    }\n  end\n\n  rule symbolvalues_nocomma\n    rubysymbolcontent wscommnl2 onemoresymbol_nocomma_l:(onemoresymbol_nocomma*) \n    {\n      def ast\n        r = []\n        r << rubysymbolcontent.ast\n        r1 = []\n        onemoresymbol_nocomma_l.elements.each do |e|\n          r1 << e.ast\n        end\n        r.concat( r1 )\n        r\n      end\n    }\n  end\n\n  rule onemoresymbol_nocomma\n    ws rubysymbolcontent\n    {\n      def ast\n        rubysymbolcontent.ast\n      end\n    }\n  end\n\n  rule notop\n    !'!=' '!'  \n    {\n      def ast\n        :notop\n      end\n    }\n  end\n\n  rule intminmaxspec\n    min wscommnl2 a:number_int wscommnl2 max wscommnl2 b:number_int \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :minspec, min.ast ] )\n        r.merge!( Hash[ :min, a.ast ] )\n        r.merge!( Hash[ :maxspec, max.ast ] )\n        r.merge!( Hash[ :max, b.ast ] )\n        r\n      end\n    }\n    /\n    max wscommnl2 a:number_int wscommnl2 min wscommnl2 b:number_int \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :maxspec, max.ast ] )\n        r.merge!( Hash[ :max, a.ast ] )\n        r.merge!( Hash[ :minspec, min.ast ] )\n        r.merge!( Hash[ :min, b.ast ] )\n        r\n      end\n    }\n    /\n    min wscommnl2 number_int \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :minspec, min.ast ] )\n        r.merge!( Hash[ :min, number_int.ast ] )\n        r\n      end\n    }\n    /\n    max wscommnl2 number_int \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :maxspec, max.ast ] )\n        r.merge!( Hash[ :max, number_int.ast ] )\n        r\n      end\n    }\n    /\n    wscommnl2 '(' wscommnl2 a:number_int wscommnl2 '..' wscommnl2 b:number_int wscommnl2 ')' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :min, a.ast ] )\n        r.merge!( Hash[ :max, b.ast ] )\n        r\n      end\n    }\n    /\n    wscommnl2 '(' wscommnl2 number_int wscommnl2 '..' wscommnl2 ')' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :min, number_int.ast ] )\n        r\n      end\n    }\n    /\n    wscommnl2 '(' wscommnl2 '..' wscommnl2 number_int wscommnl2 ')' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :max, number_int.ast ] )\n        r\n      end\n    }\n  end\n\n  rule min\n    '>=' \n    {\n      def ast\n        :gte\n      end\n    }\n    /\n    '>' \n    {\n      def ast\n        :gt\n      end\n    }\n  end\n\n  rule max\n    '<=' \n    {\n      def ast\n        :lte\n      end\n    }\n    /\n    '<' \n    {\n      def ast\n        :lt\n      end\n    }\n  end\n\n  rule lengthspec\n    wscommnl2 'length' wscommnl2 '==' wscommnl2 number_int \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :spec, :length ] )\n        r.merge!( Hash[ :relop, :eql ] )\n        r.merge!( Hash[ :val, number_int.ast ] )\n        r\n      end\n    }\n    /\n    wscommnl2 'length' wscommnl2 '!=' wscommnl2 number_int \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :spec, :length ] )\n        r.merge!( Hash[ :relop, :neql ] )\n        r.merge!( Hash[ :val, number_int.ast ] )\n        r\n      end\n    }\n    /\n    wscommnl2 'length' wscommnl2 intminmaxspec \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :spec, :length ] )\n        r.merge!( intminmaxspec.ast )\n        r\n      end\n    }\n  end\n\n  rule keyword_literal\n    'true' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :type, :t_true ] )\n        r.merge!( Hash[ :value, :true ] )\n        r\n      end\n    }\n    /\n    'false' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :type, :t_false ] )\n        r.merge!( Hash[ :value, :false ] )\n        r\n      end\n    }\n    /\n    'nil' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :type, :t_nil ] )\n        r.merge!( Hash[ :value, :nil ] )\n        r\n      end\n    }\n    /\n    'null' \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :type, :t_nil ] )\n        r.merge!( Hash[ :value, :nil ] )\n        r\n      end\n    }\n  end\n\n  rule rubysymbol\n    wscommnl2 ':' rubysymbolcontent \n    {\n      def ast\n        rubysymbolcontent.ast\n      end\n    }\n  end\n\n  rule rubysymbolcontent\n    wscommnl2 '\"' rubysymbol_in_double_quotes '\"' \n    {\n      def ast\n        rubysymbol_in_double_quotes.ast\n      end\n    }\n    /\n    wscommnl2 '\\'' rubysymbol_in_single_quotes '\\'' \n    {\n      def ast\n        rubysymbol_in_single_quotes.ast\n      end\n    }\n    /\n    ( !'(' !')' !'}' !' ' !',' !']' !'#' !'/*' !'*/' !\"\\n\" .)+ \n    {\n      def ast\n        text_value.to_sym\n      end\n    }\n  end\n\n  rule rubysymbol_in_double_quotes\n    ('\\\"' / !'\"' !\"\\n\" .)+ \n    {\n      def ast\n        text_value.to_sym\n      end\n    }\n  end\n\n  rule rubysymbol_in_single_quotes\n    ('\\\\\\'' / !'\\'' !\"\\n\" .)+ \n    {\n      def ast\n        text_value.to_sym\n      end\n    }\n  end\n\n  rule string\n    string_with_doublequotes ''\n    {\n      def ast\n        string_with_doublequotes.ast\n      end\n    }\n  end\n\n  rule string_with_doublequotes\n    wscommnl2 '\"' string_double_q '\"'\n    {\n      def ast\n        string_double_q.ast\n      end\n    }\n  end\n\n  rule string_double_q\n    ('\\\\\\\\' / '\\\"' / !'\"' .)* \n    {\n      def ast\n        \n        text_value.gsub(/(\\\\\\\\)|(\\\\n)|(\\\\\")/, '\\\\\\\\'=>'\\\\', \"\\\\n\"=>\"\\n\", '\\\\\"'=>'\"')\n      \n      end\n    }\n  end\n\n  rule stringnoblank\n    (!' ' !'(' !')' .)+ \n    {\n      def ast\n         text_value \n      end\n    }\n  end\n\n  rule regexp\n    wscommnl2 '/' wscommnl2 regexp_inner wscommnl2 '/' regexp_options \n    {\n      def ast\n        r = {}\n        r.merge!( Hash[ :regexp, regexp_inner.ast ] )\n        r.merge!( Hash[ :options, regexp_options.ast ] )\n        r\n      end\n    }\n  end\n\n  rule regexp_options\n    regexp_option* \n    {\n      def ast\n        r = []\n        elements.each do |e|\n          r << e.ast\n        end\n        r\n      end\n    }\n  end\n\n  rule regexp_option\n    'i'\n    {\n      def ast\n        text_value.to_sym\n      end\n    }\n  end\n\n  rule regexp_inner\n    ('\\\\\\\\' / '\\/' / !'/' .)* \n    {\n      def ast\n        \n    #text_value.gsub(/(\\\\\\\\)|(\\\\n)|(\\\\\")/, '\\\\\\\\'=>'\\\\', \"\\\\n\"=>\"\\n\", '\\\\\"'=>'\"')\n    text_value # .gsub(/(\\\\\\\\)|(\\\\n)|(\\\\\")/, '\\\\\\\\'=>'\\\\', \"\\\\n\"=>\"\\n\", '\\\\\"'=>'\"')\n  \n      end\n    }\n  end\n\n  rule number_int\n    ('-'/'+')? ([1-9]) ([0-9])*  \n    {\n      def ast\n        text_value.to_i\n      end\n    }\n    /\n    [0]  \n    {\n      def ast\n        text_value.to_i\n      end\n    }\n  end\n\n  rule number_float\n    [+-]? ( [0-9] / '_' [0-9] )* [.] [0-9] ( [0-9] / '_' [0-9] )* (('e'/'E') [+-]? [0-9] ( [0-9] / '_' [0-9] )* )?  \n    {\n      def ast\n        text_value.to_f\n      end\n    }\n  end\n\n  rule wsc\n    [ \\t] \n    {\n    }\n  end\n\n  rule identifier\n    ([a-zA-Z_] [a-zA-Z0-9_]*)\n    {\n      def ast\n        text_value.to_sym\n      end\n    }\n  end\n\n  rule string_no_space\n    [a-zA-Z0-9_/.:]+\n    {\n      def ast\n        text_value\n      end\n    }\n  end\n\n  rule indentation\n    ' '*\n  end\n\n  rule ws\n    wsc*\n  end\n\n  rule icomm\n    '#'\n  end\n\n  rule wscommnl\n    ws ( icomm ( !\"\\n\" . )* )? \"\\n\"\n  end\n\n  rule wscommnl2\n    ( icomm ( !\"\\n\" . )* \"\\n\" / \"\\n\" / wsc )*\n  end\n\nend\n"
+
+  end
+end

data/lib/gds-data-validation/validation_generator.rb

@@ -0,0 +1,1420 @@
+# validation_generator.rb
+
+# ATTENTION: this file is generated
+
+require 'forwardable'
+
+class GdsDataValidation
+
+  class ValidationCheckerGenerator
+
+    class SourceGenerator
+
+      def initialize
+        @resultString = ""
+        @indentLevel = 0
+      end
+
+      def indent
+        @indentLevel += 1
+      end
+
+      def unindent
+        @indentLevel -= 1  if @indentLevel > 0
+      end
+
+      def add( str )
+        @resultString << str
+      end
+
+      def add_line( str )
+        @resultString << " "*(@indentLevel * 2) + str << "\n"
+      end
+
+      def begin_line( str )
+        @resultString << " "*(@indentLevel * 2) + str
+      end
+
+      def end_line( str )
+        @resultString << str << "\n"
+      end
+
+      def new_line
+        @resultString << "\n"
+      end
+
+      def result
+        @resultString
+      end
+
+      def reset
+        @resultString = ""
+      end
+
+    end
+
+    extend Forwardable
+    def_delegators :@scgen, :add, :add_line, :begin_line, :end_line, :new_line, :indent, :unindent, :result, :reset
+
+    def initialize
+      @scgen = SourceGenerator.new
+    end
+
+    def generate( appliedGrammar )
+      reset
+      _gen_main( appliedGrammar )
+
+      create_class
+    end
+
+    private
+
+    def create_class
+      Class.new.tap{ |x| x.class_eval( result ) }
+    end
+
+
+    def _gen_main( struct, label = nil, params = nil )
+      if struct.is_a?( Array )
+        if label
+          case label
+          when "before"
+            indent
+            add_line "class << self"
+            new_line
+            indent
+          when "after"
+            unindent
+            new_line
+            add_line "end"
+            unindent
+          when "check_method"
+            add_line "def check( value )"
+            indent
+            _gen_ruledefinition( struct.first, "callfirstrule" )
+            unindent
+            add_line "end"
+          end
+        else
+          unless label || params
+            _gen_main( struct, "before" )
+            _gen_main( struct, "check_method" )
+            struct.each do |subval|
+              _gen_ruledefinition( subval, nil, nil )
+            end
+            _gen_main( struct, "after" )
+          end
+        end
+      end
+    end
+
+    def _gen_ruledefinition( struct, label = nil, params = nil )
+      if ( struct.is_a?( Hash ) && struct.has_key?( :name ) && struct.has_key?( :ruledefinition ) )
+        if label
+          case label
+          when "callfirstrule"
+            add_line "check_#{struct[:name]}( value )"
+          end
+        else
+          unless label || params
+            new_line
+            add_line "def check_#{struct[:name]}( value )"
+            indent
+            _gen_alternatives( struct[:ruledefinition], nil, nil )
+            unindent
+            add_line "end"
+          end
+        end
+      end
+    end
+
+    def _gen_alternatives( struct, label = nil, params = nil )
+      if struct.is_a?( Array ) && struct.length() == 1
+        unless label || params
+          struct.each do |subval|
+            _gen_alternative( subval, nil, nil )
+          end
+        end
+      elsif struct.is_a?( Array ) && struct.length() >= 2
+        unless label || params
+          add_line "clauseRule = false"
+          struct.each do |subval|
+            _gen_alternative_clause( subval, nil, nil )
+          end
+          begin_line ""
+          add "unless"
+          end_line( " clauseRule" )
+          indent
+          add_line "return false"
+          unindent
+          add_line "end"
+          add_line "return true"
+        end
+      end
+    end
+
+    def _gen_alternative_clause( struct, label = nil, params = nil )
+      if true #  :name
+        unless label || params
+          add_line "unless clauseRule"
+          indent
+          add_line "clauseRule = lambda do"
+          indent
+          _gen_alternative( struct, nil, nil )
+          unindent
+          add_line "end.()"
+          unindent
+          add_line "end"
+        end
+      end
+    end
+
+    def _gen_alternative( struct, label = nil, params = nil )
+      if ( struct.is_a?( Hash ) && struct.has_key?( :hashdef ) && struct.has_key?( :strict ) && struct[:strict] == :strict )
+        unless label || params
+          _gen_maybe3( struct, nil, ["value"] )
+          add_line "unless ( value.is_a?( Hash ) )"
+          indent
+          add_line "return false"
+          unindent
+          add_line "end"
+          begin_line "unless ( value.keys - %i( "
+          struct[:hashdef].each do |subval|
+            _gen_keyvaluedef( subval, "output_key" )
+          end
+          end_line( ") ).empty?" )
+          indent
+          add_line "return false"
+          unindent
+          add_line "end"
+          struct[:hashdef].each do |subval|
+            _gen_keyvaluedef( subval, nil, nil )
+          end
+          add_line "return true"
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :hashdef ) )
+        unless label || params
+          _gen_maybe3( struct, nil, ["value"] )
+          add_line "unless ( value.is_a?( Hash ) )"
+          indent
+          add_line "return false"
+          unindent
+          add_line "end"
+          struct[:hashdef].each do |subval|
+            _gen_keyvaluedef( subval, nil, nil )
+          end
+          add_line "return true"
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :arraydef ) )
+        unless label || params
+          _gen_maybe3( struct, nil, ["value"] )
+          add_line "unless value.is_a?( Array )"
+          indent
+          add_line "return false"
+          unindent
+          add_line "end"
+          _gen_arraydef( struct[:arraydef], nil, ["value"] )
+          add_line "return true"
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :subruledef ) )
+        unless label || params
+          _gen_maybe3( struct, nil, ["value"] )
+          begin_line "unless check_"
+          _gen_subruledef( struct[:subruledef], "therulename", nil )
+          end_line( "( value )" )
+          indent
+          add_line "return false"
+          unindent
+          add_line "end"
+          add_line "return true"
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :typedef ) )
+        unless label || params
+          _gen_maybe3( struct, nil, ["value"] )
+          begin_line ""
+          _gen_notop( struct[:typedef], nil, nil )
+          add " ( "
+          _gen_typedef( struct[:typedef], "typecheck", ["value"] )
+          end_line( " )" )
+          indent
+          add_line "return false"
+          unindent
+          add_line "end"
+          _gen_maybe2( struct[:typedef], nil, ["value"] )
+          add_line "return true"
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :basicvaluedef ) )
+        unless label || params
+          _gen_maybe3( struct, nil, ["value"] )
+          _gen_basicvaluedef( struct[:basicvaluedef], nil, ["value"] )
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :valdefdisjunct ) )
+        unless label || params
+          _gen_maybe3( struct, nil, ["value"] )
+          add_line "clause = false"
+          struct[:valdefdisjunct].each do |subval|
+            _gen_disjunction( subval, nil, ["value"] )
+          end
+          begin_line ""
+          _gen_notop( struct, nil, nil )
+          end_line( " clause" )
+          indent
+          add_line "return false"
+          unindent
+          add_line "end"
+          add_line "return true"
+        end
+      end
+    end
+
+    def _gen_basicvaluedef( struct, label = nil, params = nil )
+      if ( struct.is_a?( Hash ) && struct.has_key?( :type ) && struct[:type] == :t_true && struct.has_key?( :value ) )
+        if label
+          case label
+          when "thevalue"
+            add "true"
+          end
+        elsif params
+          if params.length == 1
+            add_line "unless #{params[0]} == true"
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+            add_line "return true"
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :type ) && struct[:type] == :t_false && struct.has_key?( :value ) )
+        if label
+          case label
+          when "thevalue"
+            add "false"
+          end
+        elsif params
+          if params.length == 1
+            add_line "unless #{params[0]} == false"
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+            add_line "return true"
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :type ) && struct[:type] == :t_nil && struct.has_key?( :value ) )
+        if label
+          case label
+          when "thevalue"
+            add "nil"
+          end
+        elsif params
+          if params.length == 1
+            add_line "unless #{params[0]} == nil"
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+            add_line "return true"
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :value ) )
+        if label
+          case label
+          when "thevalue"
+            add "#{struct[:value].inspect}"
+          end
+        elsif params
+          if params.length == 1
+            add_line "unless #{params[0]} == #{struct[:value].inspect}"
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+            add_line "return true"
+          end
+        end
+      end
+    end
+
+    def _gen_maybe( struct, label = nil, params = nil )
+      if ( struct.is_a?( Hash ) && struct.has_key?( :maybe ) && struct[:maybe] == :maybe )
+        if params
+          if params.length == 1
+            add "#{params[0]}.nil? || "
+          end
+        end
+      end
+    end
+
+    def _gen_maybe2( struct, label = nil, params = nil )
+      if ( struct.is_a?( Hash ) && struct.has_key?( :maybe ) && struct[:maybe] == :maybe )
+        if params
+          if params.length == 1
+            add_line "unless #{params[0]}.nil?"
+            indent
+            _gen_typedef( struct, nil, ["value"] )
+            unindent
+            add_line "end"
+          end
+        end
+      elsif true
+        if params
+          if params.length == 1
+            _gen_typedef( struct, nil, ["value"] )
+          end
+        end
+      end
+    end
+
+    def _gen_maybe3( struct, label = nil, params = nil )
+      if ( struct.is_a?( Hash ) && struct.has_key?( :maybe ) && struct[:maybe] == :maybe )
+        if label
+          case label
+          when "condition"
+            if params
+              if params.length == 1
+                add "#{params[0]}.nil? || "
+              end
+            end
+          when "only_begin"
+            if params
+              if params.length == 1
+                add_line "unless #{params[0]}.nil?"
+                indent
+              end
+            end
+          when "only_end"
+            unindent
+            add_line "end"
+          when "disjunct"
+            if params
+              if params.length == 1
+                add_line "clause = #{params[0]}.nil?"
+              end
+            end
+          end
+        elsif params
+          if params.length == 1
+            add_line "if #{params[0]}.nil?"
+            indent
+            add_line "return true"
+            unindent
+            add_line "end"
+          end
+        end
+      end
+    end
+
+    def _gen_disjunction( struct, label = nil, params = nil )
+      if ( struct.is_a?( Hash ) && struct.has_key?( :typedef ) )
+        if params
+          if params.length == 1
+            add_line "unless clause"
+            indent
+            add_line "clause = lambda do"
+            indent
+            begin_line ""
+            _gen_notop( struct[:typedef], nil, nil )
+            add " ( "
+            _gen_typedef( struct[:typedef], "typecheck", ["#{params[0]}"] )
+            end_line( " )" )
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+            _gen_typedef( struct[:typedef], nil, ["#{params[0]}"] )
+            add_line "return true"
+            unindent
+            add_line "end.()"
+            unindent
+            add_line "end"
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :basicvaluedef ) )
+        if params
+          if params.length == 1
+            add_line "unless clause"
+            indent
+            add_line "clause = lambda do"
+            indent
+            _gen_maybe3( struct, nil, ["#{params[0]}"] )
+            _gen_basicvaluedef( struct[:basicvaluedef], nil, ["#{params[0]}"] )
+            unindent
+            add_line "end.()"
+            unindent
+            add_line "end"
+          end
+        end
+      end
+    end
+
+    def _gen_keyvaluedef( struct, label = nil, params = nil )
+      if ( struct.is_a?( Hash ) && struct.has_key?( :keyvaluedef ) )
+        if label
+          case label
+          when "output_key"
+            _gen_keyvaluedef1( struct[:keyvaluedef], "output_key", nil )
+          end
+        else
+          unless label || params
+            _gen_keyvaluedef1( struct[:keyvaluedef], nil, nil )
+          end
+        end
+      end
+    end
+
+    def _gen_arraydef( struct, label = nil, params = nil )
+      if ( struct.is_a?( Hash ) && struct.has_key?( :rulename ) && struct.has_key?( :sizespec ) )
+        if params
+          if params.length == 1
+            _gen_sizespec( struct[:sizespec], nil, ["#{params[0]}"] )
+            add_line "unless #{params[0]}.all? { |e| check_#{struct[:rulename]}( e ) }"
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+          end
+        end
+      end
+    end
+
+    def _gen_keyvaluedef1( struct, label = nil, params = nil )
+      if ( struct.is_a?( Hash ) && struct.has_key?( :key ) && struct.has_key?( :value ) && struct.has_key?( :optional ) && struct[:optional] == :optional )
+        if label
+          case label
+          when "output_key"
+            add "#{struct[:key]} "
+          end
+        else
+          unless label || params
+            add_line "if value.has_key?( #{struct[:key].inspect} )"
+            indent
+            add_line "v = value.fetch( #{struct[:key].inspect} )"
+            _gen_valuedef( struct[:value], nil, nil )
+            unindent
+            add_line "end"
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :key ) && struct.has_key?( :value ) )
+        if label
+          case label
+          when "output_key"
+            add "#{struct[:key]} "
+          end
+        else
+          unless label || params
+            add_line "unless value.has_key?( #{struct[:key].inspect} )"
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+            add_line "v = value.fetch( #{struct[:key].inspect} )"
+            _gen_valuedef( struct[:value], nil, nil )
+          end
+        end
+      end
+    end
+
+    def _gen_valuedef( struct, label = nil, params = nil )
+      if ( struct.is_a?( Hash ) && struct.has_key?( :basicvaluedef ) )
+        unless label || params
+          begin_line "unless "
+          _gen_maybe3( struct, "condition", ["v"] )
+          add "v == "
+          _gen_basicvaluedef( struct[:basicvaluedef], "thevalue", nil )
+          end_line( "" )
+          indent
+          add_line "return false"
+          unindent
+          add_line "end"
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :typedef ) )
+        unless label || params
+          begin_line "unless "
+          _gen_maybe3( struct, "condition", ["v"] )
+          _gen_notop( struct[:typedef], "boolop", nil )
+          add "( "
+          _gen_typedef( struct[:typedef], "typecheck", ["v"] )
+          end_line( " )" )
+          indent
+          add_line "return false"
+          unindent
+          add_line "end"
+          _gen_maybe3( struct, "only_begin", ["v"] )
+          _gen_typedef( struct[:typedef], nil, ["v"] )
+          _gen_maybe3( struct, "only_end", nil )
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :arraydef ) )
+        unless label || params
+          begin_line "unless "
+          _gen_maybe3( struct, "condition", ["v"] )
+          end_line( "v.is_a?( Array )" )
+          indent
+          add_line "return false"
+          unindent
+          add_line "end"
+          _gen_maybe3( struct, "only_begin", ["v"] )
+          _gen_arraydef( struct[:arraydef], nil, ["v"] )
+          _gen_maybe3( struct, "only_end", nil )
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :subruledef ) )
+        unless label || params
+          begin_line "unless "
+          _gen_maybe3( struct, "condition", ["v"] )
+          add "check_"
+          _gen_subruledef( struct[:subruledef], "therulename", nil )
+          end_line( "( v )" )
+          indent
+          add_line "return false"
+          unindent
+          add_line "end"
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :valdefdisjunct ) )
+        unless label || params
+          add_line "clause = false"
+          _gen_maybe3( struct, "disjunct", ["v"] )
+          struct[:valdefdisjunct].each do |subval|
+            _gen_disjunction( subval, nil, ["v"] )
+          end
+          _gen_maybe3( struct, "only_begin", ["v"] )
+          begin_line ""
+          _gen_notop( struct, nil, nil )
+          end_line( " clause" )
+          indent
+          add_line "return false"
+          unindent
+          add_line "end"
+          _gen_maybe3( struct, "only_end", nil )
+        end
+      end
+    end
+
+    def _gen_sizespec( struct, label = nil, params = nil )
+      if ( struct.is_a?( Symbol ) && struct == :* )
+        if params
+          if params.length == 1
+          end
+        end
+      elsif ( struct.is_a?( Symbol ) && struct == :+ )
+        if params
+          if params.length == 1
+            add_line "unless #{params[0]}.size() >= 1"
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+          end
+        end
+      elsif true
+        if params
+          if params.length == 1
+            _gen_minmaxspec( struct, nil, ["#{params[0]}"".size()"] )
+          end
+        end
+      end
+    end
+
+    def _gen_subruledef( struct, label = nil, params = nil )
+      if ( struct.is_a?( Hash ) && struct.has_key?( :rulename ) )
+        if label
+          case label
+          when "therulename"
+            add "#{struct[:rulename]}"
+          end
+        end
+      end
+    end
+
+    def _gen_typedef( struct, label = nil, params = nil )
+      if ( struct.is_a?( Hash ) && struct.has_key?( :type ) && struct[:type] == :t_string && struct.has_key?( :valuespecs ) )
+        if label
+          case label
+          when "thetype"
+            unless params
+              add "String"
+            end
+            if params
+              if params.length == 1
+                add "String # #{params[0]}"
+              end
+              if params.length == 2
+                add "String # #{params[0]} and #{params[1]}"
+              end
+            end
+          when "typecheck"
+            if params
+              if params.length == 1
+                add "#{params[0]}.is_a?( "
+                _gen_typedef( struct, "thetype" )
+                add " )"
+              end
+            end
+          end
+        elsif params
+          if params.length == 1
+            struct[:valuespecs].each do |subval|
+              _gen_stringvaluespec( subval, nil, ["#{params[0]}"] )
+            end
+          end
+          if params.length == 2
+            struct[:valuespecs].each do |subval|
+              _gen_stringvaluespec( subval, nil, ["#{params[1]}"" - ""#{params[0]}"] )
+            end
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :type ) && struct[:type] == :t_string )
+        if label
+          case label
+          when "thetype"
+            add "String"
+          when "typecheck"
+            if params
+              if params.length == 1
+                add "#{params[0]}.is_a?( "
+                _gen_typedef( struct, "thetype" )
+                add " )"
+              end
+            end
+          end
+        else
+          unless label || params
+            add ""
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :type ) && struct[:type] == :t_int && struct.has_key?( :valuespecs ) )
+        if label
+          case label
+          when "thetype"
+            add "Integer"
+          when "typecheck"
+            if params
+              if params.length == 1
+                add "#{params[0]}.is_a?( "
+                _gen_typedef( struct, "thetype" )
+                add " )"
+              end
+            end
+          end
+        elsif params
+          if params.length == 1
+            _gen_intvaluespecs( struct[:valuespecs], nil, ["#{params[0]}"] )
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :type ) && struct[:type] == :t_int )
+        if label
+          case label
+          when "thetype"
+            add "Integer"
+          when "typecheck"
+            if params
+              if params.length == 1
+                add "#{params[0]}.is_a?( "
+                _gen_typedef( struct, "thetype" )
+                add " )"
+              end
+            end
+          end
+        else
+          unless label || params
+            add ""
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :type ) && struct[:type] == :t_float && struct.has_key?( :valuespecs ) )
+        if label
+          case label
+          when "thetype"
+            add "Float"
+          when "typecheck"
+            if params
+              if params.length == 1
+                add "#{params[0]}.is_a?( "
+                _gen_typedef( struct, "thetype" )
+                add " )"
+              end
+            end
+          end
+        elsif params
+          if params.length == 1
+            _gen_floatvaluespecs( struct[:valuespecs], nil, ["#{params[0]}"] )
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :type ) && struct[:type] == :t_float )
+        if label
+          case label
+          when "thetype"
+            add "Float"
+          when "typecheck"
+            if params
+              if params.length == 1
+                add "#{params[0]}.is_a?( "
+                _gen_typedef( struct, "thetype" )
+                add " )"
+              end
+            end
+          end
+        else
+          unless label || params
+            add ""
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :type ) && struct[:type] == :t_nil )
+        if label
+          case label
+          when "thetype"
+            add "NilClass"
+          when "typecheck"
+            if params
+              if params.length == 1
+                add "#{params[0]}.is_a?( "
+                _gen_typedef( struct, "thetype" )
+                add " )"
+              end
+            end
+          end
+        else
+          unless label || params
+            add ""
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :type ) && struct[:type] == :t_numeric )
+        if label
+          case label
+          when "thetype"
+            add "Numeric"
+          when "typecheck"
+            if params
+              if params.length == 1
+                add "#{params[0]}.is_a?( "
+                _gen_typedef( struct, "thetype" )
+                add " )"
+              end
+            end
+          end
+        else
+          unless label || params
+            add ""
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :type ) && struct[:type] == :t_symbol && struct.has_key?( :valuespecs ) )
+        if label
+          case label
+          when "thetype"
+            add "Symbol"
+          when "typecheck"
+            if params
+              if params.length == 1
+                add "#{params[0]}.is_a?( "
+                _gen_typedef( struct, "thetype" )
+                add " )"
+              end
+            end
+          end
+        elsif params
+          if params.length == 1
+            _gen_symbolvaluespecs( struct[:valuespecs], nil, ["#{params[0]}"] )
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :type ) && struct[:type] == :t_symbol )
+        if label
+          case label
+          when "thetype"
+            add "Symbol"
+          when "typecheck"
+            if params
+              if params.length == 1
+                add "#{params[0]}.is_a?( "
+                _gen_typedef( struct, "thetype" )
+                add " )"
+              end
+            end
+          end
+        else
+          unless label || params
+            add ""
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :type ) && struct[:type] == :t_true )
+        if label
+          case label
+          when "thetype"
+            add "TrueClass"
+          when "typecheck"
+            if params
+              if params.length == 1
+                add "#{params[0]}.is_a?( "
+                _gen_typedef( struct, "thetype" )
+                add " )"
+              end
+            end
+          end
+        else
+          unless label || params
+            add ""
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :type ) && struct[:type] == :t_false )
+        if label
+          case label
+          when "thetype"
+            add "FalseClass"
+          when "typecheck"
+            if params
+              if params.length == 1
+                add "#{params[0]}.is_a?( "
+                _gen_typedef( struct, "thetype" )
+                add " )"
+              end
+            end
+          end
+        else
+          unless label || params
+            add ""
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :type ) && struct[:type] == :t_bool )
+        if label
+          case label
+          when "typecheck"
+            if params
+              if params.length == 1
+                add "#{params[0]}.is_a?( TrueClass ) || #{params[0]}.is_a?( FalseClass )"
+              end
+            end
+          end
+        else
+          unless label || params
+            add ""
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :type ) && struct[:type] == :t_any )
+        if label
+          case label
+          when "thetype"
+            add "Object"
+          when "typecheck"
+            if params
+              if params.length == 1
+                add "#{params[0]}.is_a?( "
+                _gen_typedef( struct, "thetype" )
+                add " )"
+              end
+            end
+          end
+        else
+          unless label || params
+            add ""
+          end
+        end
+      end
+    end
+
+    def _gen_intvaluespecs( struct, label = nil, params = nil )
+      if struct.is_a?( Array )
+        if params
+          if params.length == 1
+            struct.each do |subval|
+              _gen_intvaluespec( subval, nil, ["#{params[0]}"] )
+            end
+          end
+        end
+      end
+    end
+
+    def _gen_intvaluespec( struct, label = nil, params = nil )
+      if ( struct.is_a?( Hash ) && struct.has_key?( :spec ) && struct[:spec] == :even )
+        if params
+          if params.length == 1
+            begin_line ""
+            _gen_notop( struct, nil, nil )
+            end_line( " #{params[0]}.even?" )
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+            _gen_minmaxspec( struct, nil, ["#{params[0]}"] )
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :spec ) && struct[:spec] == :odd )
+        if params
+          if params.length == 1
+            begin_line ""
+            _gen_notop( struct, nil, nil )
+            end_line( " #{params[0]}.odd?" )
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+            _gen_minmaxspec( struct, nil, ["#{params[0]}"] )
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :spec ) && struct[:spec] == :eql && struct.has_key?( :val ) )
+        if params
+          if params.length == 1
+            begin_line ""
+            _gen_notop( struct, nil, nil )
+            end_line( " #{params[0]} == #{struct[:val]}" )
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :spec ) && struct[:spec] == :neql && struct.has_key?( :val ) )
+        if params
+          if params.length == 1
+            begin_line ""
+            _gen_notop( struct, nil, nil )
+            end_line( " #{params[0]} != #{struct[:val]}" )
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :valuelist ) )
+        if params
+          if params.length == 1
+            begin_line ""
+            _gen_notop( struct, nil, nil )
+            end_line( " #{struct[:valuelist].inspect}.include?( #{params[0]} )" )
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+          end
+        end
+      elsif true
+        if params
+          if params.length == 1
+            _gen_minmaxspec( struct, nil, ["#{params[0]}"] )
+          end
+        end
+      end
+    end
+
+    def _gen_stringvaluespecs( struct, label = nil, params = nil )
+      if struct.is_a?( Array )
+        if params
+          if params.length == 1
+            struct.each do |subval|
+              _gen_stringvaluespec( subval, nil, ["#{params[0]}"] )
+            end
+          end
+        end
+      end
+    end
+
+    def _gen_stringvaluespec( struct, label = nil, params = nil )
+      if ( struct.is_a?( Hash ) && struct.has_key?( :spec ) && struct[:spec] == :eql && struct.has_key?( :val ) )
+        if params
+          if params.length == 1
+            begin_line ""
+            _gen_notop( struct, nil, nil )
+            end_line( " #{params[0]} == #{struct[:val].inspect}" )
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :spec ) && struct[:spec] == :neql && struct.has_key?( :val ) )
+        if params
+          if params.length == 1
+            begin_line ""
+            _gen_notop( struct, nil, nil )
+            end_line( " #{params[0]} != #{struct[:val].inspect}" )
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :valuelist ) )
+        if params
+          if params.length == 1
+            begin_line ""
+            _gen_notop( struct, nil, nil )
+            end_line( " #{struct[:valuelist].inspect}.include?( #{params[0]} )" )
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :spec ) && struct[:spec] == :empty )
+        if params
+          if params.length == 1
+            begin_line ""
+            _gen_notop( struct, nil, nil )
+            end_line( " #{params[0]}.empty?" )
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :spec ) && struct[:spec] == :something )
+        if params
+          if params.length == 1
+            begin_line ""
+            _gen_notop( struct, nil, nil )
+            end_line( " ! #{params[0]}.empty?" )
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :spec ) && struct[:spec] == :blank )
+        if params
+          if params.length == 1
+            begin_line ""
+            _gen_notop( struct, nil, nil )
+            end_line( " #{params[0]}.empty? || #{params[0]}.match( /\\A[[:space:]]*\\z/ )" )
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :spec ) && struct[:spec] == :present )
+        if params
+          if params.length == 1
+            begin_line ""
+            _gen_notop( struct, nil, nil )
+            end_line( " ! ( #{params[0]}.empty? || #{params[0]}.match( /\\A[[:space:]]*\\z/ ) )" )
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :spec ) && struct[:spec] == :length )
+        if params
+          if params.length == 1
+            add_line "l = #{params[0]}.length"
+            _gen_minmaxspec( struct, nil, ["l"] )
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :spec ) && struct[:spec] == :regexp && struct.has_key?( :regexp ) && struct.has_key?( :options ) )
+        if params
+          if params.length == 1
+            begin_line ""
+            _gen_notop( struct, nil, nil )
+            add " #{params[0]}.match( /#{struct[:regexp]}/"
+            _gen_regexp_options( struct[:options], nil, nil )
+            end_line( " )" )
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+          end
+        end
+      end
+    end
+
+    def _gen_regexp_options( struct, label = nil, params = nil )
+      if struct.is_a?( Array )
+        unless label || params
+          struct.each do |subval|
+            _gen_regexp_option( subval, nil, nil )
+          end
+        end
+      end
+    end
+
+    def _gen_regexp_option( struct, label = nil, params = nil )
+      if ( struct.is_a?( Symbol ) && struct == :i )
+        unless label || params
+          add "i"
+        end
+      end
+    end
+
+    def _gen_floatvaluespecs( struct, label = nil, params = nil )
+      if struct.is_a?( Array )
+        if params
+          if params.length == 1
+            struct.each do |subval|
+              _gen_floatvaluespec( subval, nil, ["#{params[0]}"] )
+            end
+          end
+        end
+      end
+    end
+
+    def _gen_floatvaluespec( struct, label = nil, params = nil )
+      if ( struct.is_a?( Hash ) && struct.has_key?( :spec ) && struct[:spec] == :eql && struct.has_key?( :val ) )
+        if params
+          if params.length == 1
+            begin_line ""
+            _gen_notop( struct, nil, nil )
+            end_line( " #{params[0]} == #{struct[:val]}" )
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :spec ) && struct[:spec] == :neql && struct.has_key?( :val ) )
+        if params
+          if params.length == 1
+            begin_line ""
+            _gen_notop( struct, nil, nil )
+            end_line( " #{params[0]} != #{struct[:val]}" )
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :valuelist ) )
+        if params
+          if params.length == 1
+            begin_line ""
+            _gen_notop( struct, nil, nil )
+            end_line( " #{struct[:valuelist].inspect}.include?( #{params[0]} )" )
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+          end
+        end
+      elsif true
+        if params
+          if params.length == 1
+            _gen_minmaxspec( struct, nil, ["#{params[0]}"] )
+          end
+        end
+      end
+    end
+
+    def _gen_symbolvaluespecs( struct, label = nil, params = nil )
+      if struct.is_a?( Array )
+        if params
+          if params.length == 1
+            struct.each do |subval|
+              _gen_symbolvaluespec( subval, nil, ["#{params[0]}"] )
+            end
+          end
+        end
+      end
+    end
+
+    def _gen_symbolvaluespec( struct, label = nil, params = nil )
+      if ( struct.is_a?( Hash ) && struct.has_key?( :spec ) && struct[:spec] == :eql && struct.has_key?( :val ) )
+        if params
+          if params.length == 1
+            begin_line ""
+            _gen_notop( struct, nil, nil )
+            end_line( " #{params[0]} == #{struct[:val].inspect}" )
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :spec ) && struct[:spec] == :neql && struct.has_key?( :val ) )
+        if params
+          if params.length == 1
+            begin_line ""
+            _gen_notop( struct, nil, nil )
+            end_line( " #{params[0]} != #{struct[:val].inspect}" )
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :valuelist ) )
+        if params
+          if params.length == 1
+            begin_line ""
+            _gen_notop( struct, nil, nil )
+            end_line( " #{struct[:valuelist].inspect}.include?( #{params[0]} )" )
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :spec ) && struct[:spec] == :length )
+        if params
+          if params.length == 1
+            add_line "l = #{params[0]}.length"
+            _gen_minmaxspec( struct, nil, ["l"] )
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :spec ) && struct[:spec] == :regexp && struct.has_key?( :regexp ) && struct.has_key?( :options ) )
+        if params
+          if params.length == 1
+            begin_line ""
+            _gen_notop( struct, nil, nil )
+            add " #{params[0]}.match( /#{struct[:regexp]}/"
+            _gen_regexp_options( struct[:options], nil, nil )
+            end_line( " )" )
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+          end
+        end
+      end
+    end
+
+    def _gen_minmaxspec( struct, label = nil, params = nil )
+      if ( struct.is_a?( Hash ) && struct.has_key?( :relop ) && struct[:relop] == :eql && struct.has_key?( :val ) )
+        if params
+          if params.length == 1
+            begin_line ""
+            _gen_notop( struct, nil, nil )
+            end_line( " #{params[0]} == #{struct[:val]}" )
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :relop ) && struct[:relop] == :neql && struct.has_key?( :val ) )
+        if params
+          if params.length == 1
+            begin_line ""
+            _gen_notop( struct, nil, nil )
+            end_line( " #{params[0]} != #{struct[:val]}" )
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :minspec ) && struct.has_key?( :maxspec ) && struct.has_key?( :min ) && struct.has_key?( :max ) )
+        if params
+          if params.length == 1
+            begin_line ""
+            _gen_notop( struct, nil, nil )
+            add " #{params[0]} "
+            _gen_relationalop( struct[:minspec], nil, nil )
+            add " #{struct[:min]} && #{params[0]} "
+            _gen_relationalop( struct[:maxspec], nil, nil )
+            end_line( " #{struct[:max]}" )
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :minspec ) && struct.has_key?( :min ) )
+        if params
+          if params.length == 1
+            begin_line ""
+            _gen_notop( struct, nil, nil )
+            add " #{params[0]} "
+            _gen_relationalop( struct[:minspec], nil, nil )
+            end_line( " #{struct[:min]}" )
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :maxspec ) && struct.has_key?( :max ) )
+        if params
+          if params.length == 1
+            begin_line ""
+            _gen_notop( struct, nil, nil )
+            add " #{params[0]} "
+            _gen_relationalop( struct[:maxspec], nil, nil )
+            end_line( " #{struct[:max]}" )
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :min ) && struct.has_key?( :max ) )
+        if params
+          if params.length == 1
+            begin_line ""
+            _gen_notop( struct, nil, nil )
+            end_line( " #{params[0]} >= #{struct[:min]} && #{params[0]} <= #{struct[:max]}" )
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :min ) )
+        if params
+          if params.length == 1
+            begin_line ""
+            _gen_notop( struct, nil, nil )
+            end_line( " #{params[0]} >= #{struct[:min]}" )
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+          end
+        end
+      elsif ( struct.is_a?( Hash ) && struct.has_key?( :max ) )
+        if params
+          if params.length == 1
+            begin_line ""
+            _gen_notop( struct, nil, nil )
+            end_line( " #{params[0]} <= #{struct[:max]}" )
+            indent
+            add_line "return false"
+            unindent
+            add_line "end"
+          end
+        end
+      end
+    end
+
+    def _gen_notop( struct, label = nil, params = nil )
+      if ( struct.is_a?( Hash ) && struct.has_key?( :notop ) && struct[:notop] == :notop )
+        if label
+          case label
+          when "boolop"
+            add "! "
+          end
+        else
+          unless label || params
+            add "if"
+          end
+        end
+      elsif true
+        if label
+          case label
+          when "boolop"
+            add ""
+          end
+        else
+          unless label || params
+            add "unless"
+          end
+        end
+      end
+    end
+
+    def _gen_relationalop( struct, label = nil, params = nil )
+      if ( struct.is_a?( Symbol ) && struct == :gt )
+        unless label || params
+          add ">"
+        end
+      elsif ( struct.is_a?( Symbol ) && struct == :gte )
+        unless label || params
+          add ">="
+        end
+      elsif ( struct.is_a?( Symbol ) && struct == :lt )
+        unless label || params
+          add "<"
+        end
+      elsif ( struct.is_a?( Symbol ) && struct == :lte )
+        unless label || params
+          add "<="
+        end
+      end
+    end
+
+  end
+
+end