canql 1.3.0

data/lib/canql/grammars/test_result.treetop

@@ -0,0 +1,19 @@
+module Canql
+  grammar TestResult
+    rule test_results
+      and_keyword? existance_modifier:test_result_no_keyword? natal_period:test_result_natal_period? test_results_keyword <Nodes::TestResult::Exists>
+    end
+
+    rule test_result_no_keyword
+      space ('no' / 'some') word_break
+    end
+
+    rule test_result_natal_period
+      (prenatal_keyword / postnatal_keyword)
+    end
+
+    rule test_results_keyword
+      space 'tests' word_break
+    end
+  end
+end

data/lib/canql/nodes.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+# These file contain custom mixins for treetop
+# nodes that enable them to generate meta_data_items, etc.
+
+# Treetop documentation seems to be out of date;
+# it says to create subclasses of nodes. However,
+# treetop 1.4.10 expects to extend the node with
+# the specified <MODULE> from the grammar.
+require 'canql/treetop/extensions'
+require 'canql/constants'
+
+require 'canql/nodes/age'
+require 'canql/nodes/dates'
+require 'canql/nodes/e_base_records'
+require 'canql/nodes/batch_types'
+require 'canql/nodes/anomaly'
+require 'canql/nodes/test_result'
+require 'canql/nodes/patient'
+require 'canql/nodes/main'
+require 'canql/nodes/registry'

data/lib/canql/nodes/age.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+module Canql #:nodoc: all
+  module Nodes
+    module Age
+      module BirthDateNode
+        def meta_data_item
+          subject = reverse_scan_for_marker(:subject) == 'mother' ? 'mother' : 'patient'
+          range = fuzzy_date.to_daterange
+          {
+            "#{subject}.birthdate" => {
+              Canql::LIMITS => [
+                range.date1.try(:to_date).try(:iso8601), range.date2.try(:to_date).try(:iso8601)
+              ]
+            }
+          }
+        end
+      end
+
+      module DeathDateNode
+        def meta_data_item
+          subject = reverse_scan_for_marker(:subject) == 'mother' ? 'mother' : 'patient'
+          range = fuzzy_date.to_daterange
+          {
+            "#{subject}.deathdate" => {
+              Canql::LIMITS => [
+                range.date1.try(:to_date).try(:iso8601), range.date2.try(:to_date).try(:iso8601)
+              ]
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/canql/nodes/anomaly.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+module Canql #:nodoc: all
+  module Nodes
+    module Anomaly
+      module Exists
+        def anomaly_type
+          text_value = natal_period.text_value.strip
+          return '' if '' == text_value
+
+          ".#{text_value}"
+        end
+
+        def meta_data_item
+          {
+            "anomaly#{anomaly_type}.exists" => {
+              Canql::EQUALS => existance_modifier.text_value.strip != 'no'
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/canql/nodes/batch_types.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+module Canql #:nodoc: all
+  module Nodes
+    module BatchTypeNode
+      def to_type
+        string = respond_to?(:normalise) ? normalise : text_value
+        string.upcase
+      end
+    end
+
+    module PaediatricNode
+      def normalise
+        'paediatric'
+      end
+    end
+  end
+end

data/lib/canql/nodes/dates.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+require 'chronic'
+require 'ndr_support/daterange'
+
+module Canql #:nodoc: all
+  module Nodes
+    module FuzzyDateNode
+      delegate :to_daterange, to: :date
+    end
+
+    module SpecificDateNode
+      delegate :to_daterange, to: :date_fragment
+    end
+
+    module FragmentedDateRangeNode
+      def to_daterange
+        d1 = start.to_daterange.date1
+        d2 = finish.to_daterange.date2
+
+        Daterange.new(d1, d2)
+      end
+    end
+
+    module YearQuarterNode
+      def to_daterange
+        quarter = text_value[0..1]
+        year = text_value[3..-1]
+        quarters = {
+          'q1': "01-04-#{year}",
+          'q2': "01-07-#{year}",
+          'q3': "01-10-#{year}",
+          'q4': "01-01-#{year.to_i + 1}"
+        }
+        Daterange.new(quarters[quarter.to_sym].to_date,
+                      quarters[quarter.to_sym].to_date + 3.months - 1.day)
+      end
+    end
+
+    module DateFragmentNode
+      delegate :to_daterange, to: :fragment
+    end
+
+    module DateRangeNode
+      def to_daterange
+        Daterange.new(text_value.to_s)
+      end
+    end
+
+    module ChronicDateNode
+      def to_daterange
+        chronic = Chronic.parse(text_value.to_s, context: :past, guess: false)
+        if chronic.instance_of?(Chronic::Span)
+          Daterange.new(chronic.begin, chronic.end - 1.day)
+        else
+          Daterange.new(chronic)
+        end
+      end
+    end
+  end
+end

data/lib/canql/nodes/e_base_records.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+module Canql #:nodoc: all
+  module Nodes
+    module EBaseRecordsNode
+      def meta_data_item
+        filter =
+          if types.empty?
+            { Canql::ALL => true }
+          else
+            { Canql::EQUALS => types.to_list }
+          end
+        { 'unprocessed_records.sources' => filter }
+      end
+    end
+
+    module BatchTypesNode
+      delegate :to_list, to: :allowed_types
+    end
+
+    module AllowedTypesNode
+      def to_list
+        list = [batch_type.to_type]
+        list.concat types.elements.map(&:extract_type)
+      end
+    end
+
+    module MoreTypesNode
+      def extract_type
+        batch_type.to_type
+      end
+    end
+
+    module ActionsNode
+      def meta_data_item
+        { 'action.actioninitiated' => { Canql::EQUALS => action_type.text_value.upcase.strip } }
+      end
+    end
+
+    module ActionProviderCodeNode
+      def meta_data_item
+        # default to provider
+        key = 'providercode'
+        { "action.#{key}" => { Canql::EQUALS => code.text_value.upcase } }
+      end
+    end
+
+    module ActionProviderNameNode
+      def meta_data_item
+        # default to provider
+        key = provider_type.text_value == 'cancer network' ? 'cn_ukacrname' : 'providername'
+        {
+          "action.#{key}" => {
+            Canql::BEGINS => short_desc.text_value.upcase,
+            :interval => interval
+          }
+        }
+      end
+    end
+  end
+end

data/lib/canql/nodes/main.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+# require 'active_support/core_ext/object/blank'
+
+module Canql #:nodoc: all
+  module Nodes
+    module RecordCountNode
+      def meta_data_item
+        { 'limit' => { Canql::EQUALS => number.text_value.to_i } }
+      end
+    end
+  end
+end

data/lib/canql/nodes/patient.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+module Canql #:nodoc: all
+  module Nodes
+    module Patient
+      module GenderNode
+        def meta_data_item
+          { 'patient.sex' => { Canql::EQUALS => gender.text_value == 'male' ? '1' : '2' } }
+        end
+      end
+
+      module OutcomeNode
+        def meta_data_item
+          { 'patient.outcome' => { Canql::EQUALS => outcome.text_value } }
+        end
+      end
+
+      module FieldExists
+        FIELDS = {
+          'date of birth':        { patient: 'birthdate', mother: 'birthdate' },
+          'dob':                  { patient: 'birthdate', mother: 'birthdate' },
+          'postcode':             { patient: 'postcode',  mother: 'postcode'  },
+          'nhs number':           { patient: 'nhsnumber', mother: 'nhsnumber' },
+          'birth weight':         { patient: 'weight' },
+          'place of delivery':    { patient: 'placeofdelivery' },
+          'sex':                  { patient: 'sex' },
+          'outcome':              { patient: 'outcome' }
+        }.freeze
+
+        def meta_data_item
+          subject = reverse_scan_for_marker(:subject) == 'mother' ? 'mother' : 'patient'
+          field_names = actual_field_names(
+            patient_field_list.text_values_for_marker(:patient_field_name), subject.to_sym
+          )
+          modifer = field_existance_modifier.text_value.strip
+          existance = modifer != 'missing' ? 'fields_populated' : 'fields_missing'
+          { "#{subject}.#{existance}" => { Canql::EQUALS => field_names } }
+        end
+
+        def actual_field_names(fields, subject)
+          actual_fields = []
+          fields.each do |f|
+            f = f.downcase.to_sym
+            actual_fields << FIELDS[f][subject] unless FIELDS[f].nil? || FIELDS[f][subject].nil?
+          end
+          actual_fields
+        end
+      end
+
+      module ExpectedDateRangeNode
+        def meta_data_item
+          range = fuzzy_date.to_daterange
+          {
+            'patient.expecteddeliverydate' => {
+              Canql::LIMITS => [
+                range.date1.try(:to_date).try(:iso8601),
+                range.date2.try(:to_date).try(:iso8601)
+              ]
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/canql/nodes/registry.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module Canql #:nodoc: all
+  module Nodes
+    module RegistryNode
+      def meta_data_item
+        { 'patient.registry' => { Canql::EQUALS => registry.to_registrycode } }
+      end
+    end
+
+    module RegistryCodeNode
+      def to_registrycode
+        text_value.upcase
+      end
+    end
+  end
+end

data/lib/canql/nodes/test_result.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module Canql #:nodoc: all
+  module Nodes
+    module TestResult
+      module Exists
+        def test_result_type
+          text_value = natal_period.text_value.strip
+          return '' if '' == text_value
+
+          ".#{text_value}"
+        end
+
+        def meta_data_item
+          { "testresults#{test_result_type}.exists" => {
+            Canql::EQUALS => existance_modifier.text_value.strip != 'no'
+          } }
+        end
+      end
+    end
+  end
+end

data/lib/canql/parser.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+require 'canql/nodes'
+require 'canql/grammars'
+
+module Canql
+  # This class simplifies CANQL queries by wrapping them in a little syntactic sugar.
+  class Parser
+    attr_reader :parser
+
+    def initialize(query)
+      raise ArgumentError unless query.is_a?(String)
+
+      @parser = CanqlParser.new
+      @result = @parser.parse(query.downcase)
+
+      return if valid?
+      # FIXME: should log "Parser failed parsing \"#{query}\": #{@parser.failure_reason} " \
+      #                   "(line: #{@parser.failure_line}, column: #{@parser.failure_column})"
+    end
+
+    def valid?
+      !@result.nil?
+    end
+
+    def failure_reason
+      valid? ? nil : @parser.failure_reason
+    end
+
+    def failure_line
+      valid? ? nil : @parser.failure_line
+    end
+
+    def failure_column
+      valid? ? nil : @parser.failure_column
+    end
+
+    def meta_data
+      valid? ? @result.meta_data : {}
+    end
+  end
+end

data/lib/canql/treetop/extensions.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+module Treetop
+  module Runtime
+    # We extend the SyntaxNode class to include a hash of meta data.
+    # Individual rules can define meta_data_item method that must return
+    # a hash that is merged with the hash data for the entire query.
+    class SyntaxNode
+      def meta_data(hash = {})
+        hash.merge!(meta_data_item) if respond_to?(:meta_data_item)
+
+        if nonterminal?
+          elements.each do |element|
+            element.meta_data(hash)
+          end
+        end
+
+        hash
+      end
+
+      def text_values_for_marker(marker)
+        list = []
+        text_values_for_marker_scanner(self, marker, list)
+        list
+      end
+
+      def reverse_scan_for_marker(marker)
+        marker_value = reverse_marker_scanner(self, marker)
+        return if marker_value.nil? || marker_value.empty?
+        marker_value
+      end
+
+      private
+
+      def text_values_for_marker_scanner(root, marker, list)
+        return if root.elements.nil?
+        root.elements.each do |e|
+          list << e.send(marker).text_value if e.respond_to?(marker)
+          text_values_for_marker_scanner(e, marker, list)
+        end
+        list
+      end
+
+      def reverse_marker_scanner(root, marker)
+        return if root.nil? || root.elements.nil?
+        marker_value = root.send(marker).text_value if root.respond_to?(marker)
+        if marker_value.nil? || marker_value.empty?
+          marker_value = reverse_marker_scanner(root.parent, marker)
+        end
+        marker_value
+      end
+    end
+  end
+end