activefacts-cql 1.9.3 → 1.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b7b7e191eaad678aeb89be0ca8743eb90dfe8d5b
-  data.tar.gz: 3a777616625aa25805d2f50ae25cf7633e3a0099
+  metadata.gz: 0b7e982dad70afb43fd9171c3c6cc198dd98fd06
+  data.tar.gz: af7013320edfcd4de82ad25ef640539da87b8198
 SHA512:
-  metadata.gz: 88ac4c71766457a0995f1bbddf00a650187fae4eacfe9e3c87ef9648737c72db756e80fab41097980fa70cffb583ccc1211d1bcea9b34fabcee18cab07af18cc
-  data.tar.gz: e1c94deab6e96e52a0a4ec88568f3549181855de3e04fec9a06dc62e318a4317339128e70f7067e6361c701864146d6afb34ed90fc82687c44744ee564f6f6d6
+  metadata.gz: 4ac31ed75cd632ec21c464b802db0ea4a9b5a06bffef119bf9736163bad1b55d67ec7be5fd03fa03cec6fd3bd1defd3ab22c1e378229c1e4127c6f109d3f5201
+  data.tar.gz: f7d592f347a8c5e556ab1107597f2db6751ac466083f9ac07100b0701e32b4805c9edc187af0a05924e561c08437303d8afa311503f5f30cf4f167896f4a7f47

data/activefacts-cql.gemspec

@@ -24,7 +24,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.3"
 
-  spec.add_runtime_dependency "activefacts-metamodel", "~> 1", ">= 1.9.20"
-  spec.add_runtime_dependency "treetop", [">= 1.4.14", "~> 1.4"]
+  spec.add_runtime_dependency "activefacts-metamodel", "~> 1", ">= 1.9.21"
+  spec.add_runtime_dependency "treetop", ["~> 1.6", ">= 1.6.9"]
 end
-

data/lib/activefacts/cql/compiler.rb

@@ -134,7 +134,7 @@ module ActiveFacts
               start_line = @string.line_of(node.interval.first)
               end_line = @string.line_of(node.interval.last-1)
               lines = start_line != end_line ? "s #{start_line}-#{end_line}" : " #{start_line.to_s}"
-              ne = StandardError.new("at line#{lines} #{e.message.strip}")
+              ne = StandardError.new("at line#{lines}, #{e.message.strip}")
               ne.set_backtrace(e.backtrace)
               raise ne
             end

data/lib/activefacts/cql/compiler/constraint.rb

@@ -518,16 +518,6 @@ module ActiveFacts
           @regular_expression = ast[:regular_expression]
         end
 
-        def assert_value(val)
-          if val.is_a?(String)
-            @constellation.Value(eval(val), true, nil)
-          elsif val
-            @constellation.Value(val.to_s, false , nil)
-          else
-            nil
-          end
-        end
-
         def compile
           @constraint = @constellation.ValueConstraint(:new)
           raise "Units on value constraints are not yet processed (at line #{'REVISIT'})" if @units
@@ -537,8 +527,8 @@ module ActiveFacts
             @value_ranges.each do |range|
               min, max = Array === range ? range : [range, range]
               v_range = @constellation.ValueRange(
-                min && @constellation.Bound(:value => assert_value(min), :is_inclusive => true),
-                max && @constellation.Bound(:value => assert_value(max), :is_inclusive => true))
+                min && @constellation.Bound(:value => assert_literal_value(min), :is_inclusive => true),
+                max && @constellation.Bound(:value => assert_literal_value(max), :is_inclusive => true))
               ar = @constellation.AllowedRange(@constraint, v_range)
             end
           else

data/lib/activefacts/cql/compiler/query.rb

@@ -39,13 +39,16 @@ module ActiveFacts
         def build_step query, clause, roles_by_binding = {}, parent_variable = nil
           return unless clause.refs.size > 0  # Empty clause... really?
 
-          step = @constellation.Step(
-              query, query.all_step.size,
-              :fact_type => clause.fact_type,
-              :alternative_set => nil,
-              :is_disallowed => clause.certainty == false,
-              :is_optional => clause.certainty == nil
-            )
+          # A bare object type is a valid clause, but it contains no fact type hence no step
+          if clause.fact_type
+            step = @constellation.Step(
+                query, query.all_step.size,
+                :fact_type => clause.fact_type,
+                :alternative_set => nil,
+                :is_disallowed => clause.certainty == false,
+                :is_optional => clause.certainty == nil
+              )
+          end
 
           trace :query, "Creating Plays for #{clause.inspect} with #{clause.refs.size} refs" do
             is_input = true

data/lib/activefacts/cql/compiler/shared.rb

@@ -108,6 +108,16 @@ module ActiveFacts
         def source
           @tree.text_value
         end
+
+        def assert_literal_value(val)
+          if val.is_a?(String)
+            @constellation.Value(eval(val), true, nil)
+          elsif val
+            @constellation.Value(val.to_s, false , nil)
+          else
+            nil
+          end
+        end
       end
 
       class Vocabulary < Definition

data/lib/activefacts/cql/compiler/value_type.rb

@@ -99,27 +99,44 @@ module ActiveFacts
         end
 
         def compile
-          length, scale = *@parameters
+          ordered_parameters, named_parameters = @parameters.partition{|p| Integer === p}
+          length, scale = *ordered_parameters
 
           # Create the base type unless it already exists:
           base_type = nil
           if (@base_type_name != @name)
             unless base_type = @vocabulary.valid_value_type_name(@base_type_name)
               base_type = @constellation.ValueType(@vocabulary, @base_type_name, :concept => :new)
-              return base_type if @base_type_name == @name
             end
           end
 
           # Create and initialise the ValueType:
           vt = @vocabulary.valid_value_type_name(@name) ||
             @constellation.ValueType(@vocabulary, @name, :concept => :new)
+
+          # Apply independence:
           vt.is_independent = true if @pragmas.delete('independent')
+
+          # Apply pragmas:
           @pragmas.each do |p|
             @constellation.ConceptAnnotation(:concept => vt.concept, :mapping_annotation => p)
           end if @pragmas
-          vt.supertype = base_type if base_type
-          vt.length = length if length
-          vt.scale = scale if scale
+
+          # Apply supertype
+          if base_type and base_type != vt
+            raise "You may not change the supertype of #{vt.name} from #{vt.supertype.name} to #{base_type.name}" if vt.supertype && vt.supertype != base_type
+            vt.supertype = base_type
+          end
+
+          # Apply ordered parameters:
+          if length
+            raise "You may not change the length of #{vt.name} from #{vt.length} to #{length}" if vt.length && vt.length != length
+            vt.length = length
+          end
+          if scale
+            raise "You may not change the scale of #{vt.name} from #{vt.scale} to #{scale}" if vt.scale && vt.scale != scale
+            vt.scale = scale
+          end
           vt.transaction_phase = @auto_assigned_at
 
           unless @unit.empty?
@@ -140,18 +157,110 @@ module ActiveFacts
                 @constellation.Derivation(unit, base_unit).exponent = exponent
               end
             end
+            raise "You may not change the units of #{vt.name} from #{vt.unit.describe} to #{unit.describe}" if vt.unit && vt.unit != unit
             vt.unit = unit
           end
 
+          # Apply a value constraint:
           if @value_constraint
-            @value_constraint.constellation = @constellation
+            @value_constraint.constellation = @constellation  # Pass constellation to the value_constraint compiler
+            raise "#{vt.name} is already constrained to #{vt.value_constraint.describe} so you can't change it to #{@value_constraint.describe}" if vt.value_constraint && vt.value_constraint != value_constraint
             vt.value_constraint = @value_constraint.compile
           end
 
+          # Apply a context note:
           if @context_note
             @context_note.compile(@constellation, vt)
           end
 
+          # Apply named parameter (definitions, restrictions, and settings):
+          trace :vtp, "Applying named parameters for #{@name}" do
+            named_parameters.each do |(kind, vtp_name, *rest)|
+              # Look up an existing definition of the parameter:
+              vtp = nil
+              vt.supertypes_transitive.detect do |st|
+                vtp = st.all_value_type_parameter.detect{|evtp| evtp.name == vtp_name}
+              end
+
+              trace :vtp, "Applying #{kind} of named parameter #{vtp_name}" do
+                restrictions = nil
+                case kind
+                when :definition
+                  raise "You may not redefine parameter #{vtp_name} of #{vt.name}" if vtp
+                  trace :vtp, "Defining parameter #{vtp_name} for #{vt.name}" do
+                    parameter_value_type_name = rest.shift.term
+                    parameter_value_type = @vocabulary.valid_value_type_name(parameter_value_type_name)
+                    raise "Type #{parameter_value_type_name} for parameter #{vtp_name} of #{vt.name} is not defined" unless parameter_value_type
+                    vtp = @constellation.ValueTypeParameter(value_type: vt, name: vtp_name, parameter_value_type: parameter_value_type)
+                    restrictions = rest[0]
+                  end
+
+                when :restriction
+                  raise "parameter #{vtp_name} of #{vt.name} is not defined" unless vtp
+                  trace :vtp, "Restricting parameter #{vtp_name} for #{vt.name} to #{rest[0].inspect}"
+                  restrictions = rest[0]
+
+                when :setting
+                  raise "parameter #{vtp_name} of #{vt.name} is not defined" unless vtp
+                  # A Setting is a single-valued restriction
+                  trace :vtp, "Setting parameter #{vtp_name} for #{vt.name} to #{[rest[0]].inspect}"
+                  restrictions = [rest[0]]
+                else
+                  raise "AST error: unknown valuetype parameter #{kind}"
+                end
+
+                if restrictions && restrictions[0] == :value
+                  # This is a value restriction which perhaps sets the RestrictionStyle
+                  value = restrictions[1]
+                  vtp.restriction_style = restrictions[2]
+                  case restrictions[2]
+                  when '', nil
+                    restrictions = [[value, value]]
+                  when 'min'
+                    restrictions = [[value, nil]]
+                  when 'max'
+                    restrictions = [[nil, value]]   # Or should it be [0, value]? But we can get that using a range...
+                  end
+                  trace :vtp, "Setting value for parameter #{vtp_name} for #{vt.name} to #{value.inspect} with style #{vtp.restriction_style.inspect}"
+                end
+
+                if restrictions
+                  # Find all ValueTypeParameterRestrictions for this parameter in this type's closest restricted supertype
+                  vtprs = nil
+                  restricted_supertype = nil
+                  vt.supertypes_transitive.detect do |st|
+                    vtprs = st.all_value_type_parameter_restriction.select{|evtpr| evtpr.value_type_parameter == vtp}
+                    vtprs = nil if vtprs.empty?
+                    restricted_supertype = st
+                    trace :vtp, "Existing #{vtp_name} restriction on #{st.name} allows #{vt.name} to use #{vtprs.map(&:value_range).inspect}" if vtprs
+                    vtprs
+                  end
+
+                  if vtprs && vt == restricted_supertype
+                    raise "You can't change the existing restrictions on parameter #{vtp_name} of #{vt.name}"
+                  end
+
+                  trace :vtp, "Restricting parameter #{vtp_name}#{vt != vtp.value_type ? " (of #{vtp.value_type.name})" : ''} for #{vt.name} to #{restrictions.inspect}" do
+                    restrictions.each do |restriction|
+
+                      min, max = Array === restriction ? restriction : [restriction, restriction]
+                      value_range = @constellation.ValueRange(
+                        min && @constellation.Bound(:value => assert_literal_value(min), :is_inclusive => true),
+                        max && @constellation.Bound(:value => assert_literal_value(max), :is_inclusive => true)
+                      )
+
+                      # This restriction may not widen the supertype's restriction:
+                      if vtprs && !vtprs.detect{|r| r.value_range.includes?(value_range)}
+                        raise "#{vtp_name} of #{@name} may not be set to #{restriction} because #{vtprs[0].value_type.name} restricts it to #{vtprs.map(&:value_range).map(&:inspect)*', '}"
+                      end
+                      @constellation.ValueTypeParameterRestriction(value_type: vt, value_type_parameter: vtp, value_range: value_range)
+                    end
+                  end
+                end
+              end
+            end
+          end
+
           vt
         end
 

data/lib/activefacts/cql/parser.rb

@@ -258,7 +258,7 @@ module ActiveFacts
         begin
           node = parse(InputProxy.new(input, context, self), :index => @index)
           unless node 
-            raise failure_reason unless @index == input.size
+            raise failure_reason || "not all input was understood" unless @index == input.size
             return nil  # No input, or no more input
           end
           if @block

data/lib/activefacts/cql/parser/CQLParser.treetop

@@ -54,7 +54,8 @@ module ActiveFacts
       rule definition_body
         vocabulary_definition
         / import_definition
-        / prescan           # Always fails, but its side-effects are needed in the following
+       # Magic here to avoid a Treetop bug with sem-preds, which require a sequence (this doesn't need to make a sequence)
+        / '' &{|s| _nt_prescan; false }           # Always fails, but its side-effects are needed in the following
         / constraint
         / unit_definition   # REVISIT: Move this above the prescan?
         / object_type
@@ -160,23 +161,34 @@ module ActiveFacts
 
       rule informal_description
         informally s ',' s
-          subject:(
-            signifier:each S term         # Informal definition of an object type
-            /
-            signifier:when S reading:phrase+ s ','       # or a fact type
-          ) s
-          text:(!(!. / '.' [ \t\r]* "\n") (string / .))*  # Allow . inside a string
-          (!. / '.' [ \t\r]* "\n")          # The description terminates in a fullstop at the end of a line, or EOF
+	  subject:informal_description_subject s
+          informal_description_body
+          informal_description_closer
         {
           def ast
             kind = subject.signifier.text_value.to_sym
             subject_name = (kind == :each ? subject.term.text_value : subject.reading.text_value)
             phrases = subject.reading.elements.map(&:ast) if kind == :when
-            Compiler::InformalDefinition.new(kind, subject_name, phrases, text.text_value)
+            Compiler::InformalDefinition.new(kind, subject_name, phrases, informal_description_body.text_value)
           end
         }
       end
 
+      rule informal_description_subject
+	signifier:each S term         # Informal definition of an object type
+	/
+	signifier:when S reading:phrase+ s ','       # or a fact type
+      end
+
+      rule informal_description_body
+	(!informal_description_closer (string / .))*  # Allow . inside a string
+      end
+
+      # The description terminates in a fullstop at the end of a line, or EOF
+      rule informal_description_closer
+	(!. / '.' [ \t\r]* "\n")
+      end
+
       rule constraint
         subset_constraint /
         equality_constraint /

data/lib/activefacts/cql/parser/Language/English.treetop

@@ -225,7 +225,7 @@ module ActiveFacts
 
       rule agg_of of end
       rule agg_in in end
-      rule restricted_to 'restricted' s 'to' s !alphanumeric end
+      rule restricted_to restricted s 'to' s !alphanumeric end
       # any is optionally used in an identifying role_list
       rule any one / a end
 
@@ -254,6 +254,7 @@ module ActiveFacts
       rule some 'some' !alphanumeric end
 
       # >>>>>>>>>>>>>>>>>>>> External vocabulary <<<<<<<<<<<<<<<<<<<<
+      rule accepts 'accepts' !alphanumeric end
       rule according_to 'according' S to end
       rule acyclic 'acyclic' !alphanumeric end
       rule alias 'alias' !alphanumeric end
@@ -284,7 +285,9 @@ module ActiveFacts
       rule it 'it' !alphanumeric end
       rule its 'its' !alphanumeric end
       rule masculine 'masculine' !alphanumeric end
+      rule max 'max' !alphanumeric end
       rule maybe 'maybe' !alphanumeric end
+      rule min 'min' !alphanumeric end
       rule only 'only' !alphanumeric end
       rule or 'or' !alphanumeric end
       rule of 'of' !alphanumeric end
@@ -294,6 +297,8 @@ module ActiveFacts
       rule personal 'personal' !alphanumeric end
       rule radix_point '.' end
       rule reflexive 'reflexive' !alphanumeric end
+      rule restricted 'restricted' !alphanumeric end
+      rule restricts 'restricts' !alphanumeric end
       rule returning 'returning' !alphanumeric end
       rule schema 'schema' !alphanumeric end
       rule separate 'separate' !alphanumeric end
@@ -312,11 +317,12 @@ module ActiveFacts
       rule true 'true' !alphanumeric end
       rule version 'version' !alphanumeric end
       rule vocabulary 'vocabulary' !alphanumeric end
+      rule was 'was' !alphanumeric end
       rule when 'when' !alphanumeric end
       rule where 'where' !alphanumeric end
       rule which 'which' !alphanumeric end
-      rule was 'was' !alphanumeric end
       rule who 'who' !alphanumeric end
+      rule with 'with' !alphanumeric end
 
     end
   end

data/lib/activefacts/cql/parser/Language/French.treetop

@@ -256,6 +256,7 @@ module ActiveFacts
       rule according_to 'selon' !alphanumeric end 
       rule acyclic 'acyclique' !alphanumeric end
       rule alias 'alias' !alphanumeric end 
+      rule accepts 'accepte' !alphanumeric end
       rule and 'et' !alphanumeric end
       rule antisymmetric 'antisymmetric' !alphanumeric end
       rule approximately 'environ' !alphanumeric end            # REVISIT: google translate
@@ -282,7 +283,9 @@ module ActiveFacts
       rule is est end                   # Called from ObjectTypes.treetop in "is identified by"
       rule its ('sa' / 'son') !alphanumeric end
       rule masculine 'masculin' !alphanumeric end 
+      rule max 'max' !alphanumeric end
       rule maybe 'peut-être' !alphanumeric end                  # REVISIT: eventuellement = possibly?
+      rule min 'min' !alphanumeric end
       rule only 'que' !alphanumeric end                 # REVISIT: Used in constraints
       rule or 'ou' !alphanumeric end 
       rule ordering_prefix by s (ascending/descending)? s end
@@ -291,6 +294,8 @@ module ActiveFacts
       rule personal 'personelle' !alphanumeric end 
       rule radix_point ',' end
       rule reflexive 'réflexive' !alphanumeric end
+      rule restricted 'limité' !alphanumeric s end
+      rule restricts 'limit' [ée] !alphanumeric s end
       rule returning 'retour' !alphanumeric end
       rule separate 'distincte' !alphanumeric end
       rule schema 'schema' !alphanumeric end
@@ -312,6 +317,7 @@ module ActiveFacts
       rule vocabulary 'vocabulaire' !alphanumeric end 
       rule where 'où' !alphanumeric end 
       rule who 'qui' !alphanumeric end 
+      rule with 'avec' !alphanumeric end 
 
     end
   end

data/lib/activefacts/cql/parser/Terms.treetop

@@ -31,6 +31,8 @@ module ActiveFacts
       end
 
       rule prescan
+        informally_prescan
+        /
         s each?
         s (
           term_definition_name mapping_pragmas entity_prefix
@@ -50,14 +52,27 @@ module ActiveFacts
         prescan_rest
         &{|s|
           # Wipe any terminal failures that were added:
-          @terminal_failures = []
-          @max_terminal_failure_index = start_index
+          forget_failures_to_here
 
           # puts "========== prescan is complete on #{(s.map{|e|e.text_value}*" ").inspect} =========="
           false
         }
       end
 
+      rule informally_prescan
+        informally s ',' s
+          informal_description_subject_prescan s
+          informal_description_body
+          informal_description_closer
+      end
+
+      rule informal_description_subject_prescan
+        each S term_definition_name       # Informal definition of an object type
+        /
+        when S phrase+ s ','              # or a fact type; we can't forward-reference these
+                                          # This could memoize a bad parse for 'phrase'!!!
+      end
+
       # Do a first-pass mainly lexical analysis, looking for role name definitions and adjectives,
       # for use in detecting terms later.
       rule prescan_rest
@@ -74,9 +89,8 @@ module ActiveFacts
           / id
           # / literal # REVISIT: Literals might contain "(as Foo)" and mess things up
           / range                           # Covers all numbers and strings
-          / comparator                      # handle two-character operators
           / S                               # White space and comments, must precede / and *
-          / [-+{}\[\].,:^/%*()]             # All other punctuation and operators
+          / [^;]                            # Skip anything else, we want the prescan to finish
         )* [?;] s
       end
 

data/lib/activefacts/cql/parser/ValueTypes.treetop

@@ -62,12 +62,51 @@ module ActiveFacts
       end
 
       rule type_parameter_list
-        head:number s tail:( ',' s number s )*
-        {
+        head:parameter s tail:( ',' s parameter s)*
+	{
           def values
-            [head.value, *tail.elements.map{|i| i.number.value}]
+            [head.value, *tail.elements.map{|i| i.parameter.value}]
           end
-        }
+	}
+      end
+
+      rule parameter
+	number / named_parameter
+      end
+
+      rule ordered_parameter
+        number
+      end
+
+      rule named_parameter
+        (	# Set the value for a parameter
+          with s parameter_name as s literal:parameter_literal
+          /
+          parameter_name ':' s literal:parameter_literal
+        ) <Parser::ValueTypeParameterSetting>
+        /	# Define a new parameter
+        accepts s parameter_name as value_type:term s vr:(restricted s to s parameter_restriction)? <Parser::ValueTypeParameterDefinition>
+        /	# Restrict values for a parameter
+        restricts s parameter_name to s parameter_restriction <Parser::ValueTypeParameterRestriction>
+      end
+
+      rule parameter_name
+        !(with/accepts/restricts/as/term) id s
+        { def value; id.text_value; end }
+      end
+
+      rule parameter_literal
+	number
+	/   # We need the text_value of a string here, not the result of parsing it
+	string { def value; text_value; end }
+      end
+
+      rule parameter_restriction
+	range_list s
+	  { def values; range_list.ranges; end}
+	/
+	parameter_literal s direction:(min / max)? s
+	  { def values; [:value, parameter_literal.value, direction.text_value]; end}
       end
 
       rule unit_definition

data/lib/activefacts/cql/parser/nodes.rb

@@ -44,6 +44,24 @@ module ActiveFacts
           :term
         end
       end
+
+      module ValueTypeParameterSetting
+        def value
+          [:setting, parameter_name.value, literal.value]
+        end
+      end
+
+      module ValueTypeParameterDefinition
+        def value
+          [:definition, parameter_name.value, value_type.ast, vr.empty? ? nil : vr.parameter_restriction.values]
+        end
+      end
+
+      module ValueTypeParameterRestriction
+        def value
+          [:restriction, parameter_name.value, parameter_restriction.values]
+        end
+      end
     end
   end
 end

data/lib/activefacts/cql/version.rb

@@ -1,5 +1,5 @@
 module ActiveFacts
   module CQL
-    VERSION = "1.9.3"
+    VERSION = "1.9.4"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activefacts-cql
 version: !ruby/object:Gem::Version
-  version: 1.9.3
+  version: 1.9.4
 platform: ruby
 authors:
 - Clifford Heath
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-11-10 00:00:00.000000000 Z
+date: 2018-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -61,7 +61,7 @@ dependencies:
         version: '1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.9.20
+        version: 1.9.21
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -71,27 +71,27 @@ dependencies:
         version: '1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.9.20
+        version: 1.9.21
 - !ruby/object:Gem::Dependency
   name: treetop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.4.14
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '1.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.4.14
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '1.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.9
 description: Compiler for the Constellation Query Language, part of the ActiveFacts
   suite for Fact Modeling
 email: