drgdsl 1.0.0

data/lib/drgdsl/ast_builder.rb

@@ -0,0 +1,269 @@
+require 'pp'
+
+module DrgDSL
+  class UnknownCstError < StandardError
+    attr_reader :cst, :result
+
+    # @param cst [Hash] CST obtained by parser
+    # @param result [Object] whatever the AstBuilder was able to generate
+    def initialize(cst, result)
+      @cst = cst
+      @result = result
+    end
+
+    def message
+      <<~EOM
+      Don't know how to build AST from this CST:
+
+        #{pretty cst}
+
+      Intermediate result:
+
+        #{pretty result}
+      EOM
+    end
+
+    private
+
+    # @return [String] nicely formatted string for enhanced readability.
+    def pretty(object)
+      PP.pp object, ''
+    end
+  end
+
+  class AstBuilder < Parslet::Transform
+
+    # @param cst [Hash] CST-ish hash obtained from DrgParser.
+    # @return [Node] AST
+    # @raise [UnknownCstError] when CST could not be converted to a correct
+    #   AST.
+    def self.build(cst)
+      ast = new.apply(cst)
+      raise UnknownCstError.new(cst, ast) if broken_ast?(ast)
+      ast
+    end
+
+    # Did we manage to build a correct AST?
+    #
+    # @return [Boolean]
+    def self.broken_ast?(ast)
+      !ast.is_a?(Ast::Node)
+    end
+
+    # Parslet transformation rules that transform a nested CST-ish hash
+    # generated by DrgParser into a AST.
+    #
+    # Check out https://kschiess.github.io/parslet/transform.html for more
+    # details on transformations.
+
+    # Only one and-expression means there's no RHS of an "oder" expression, so
+    # we just go downwards.
+    rule(exp: subtree(:and_exp)) { and_exp }
+
+    # Two or more and-expressions will be joined with an "oder". So and has
+    # higher precedence.
+    rule(exp: sequence(:and_exp)) do
+      Ast::Expression.new(and_exp)
+    end
+
+    # In case of no RHS we simply go downwards.
+    rule(and_exp: subtree(:simple)) do
+      simple
+    end
+
+    rule(and_exp: sequence(:simple)) do
+      Ast::AndExpression.new(simple)
+    end
+
+    rule(simple: subtree(:simple)) { simple }
+
+    rule(paren_exp: subtree(:exp)) do
+      Ast::ParenExpression.new(exp)
+    end
+
+    # "NOT ( ... )" -> "nicht [...]"
+    rule(not_exp: subtree(:exp)) do
+      Ast::NotExpression.new(exp)
+    end
+
+    # "EMPTY()" -> "leer"
+    rule(empty: simple(:empty)) do
+      Ast::Empty.new
+    end
+
+    # "NOT IN TABLE ... -> "nicht in Tabelle ...""
+    rule(
+      unary_condition: {
+        keyword: simple(:keyword),
+        condition: subtree(:condition)
+      }
+    ) do
+      Ast::UnaryCondition.new(op: keyword, condition: condition)
+    end
+
+    rule(
+      variable: subtree(:inner_variable)
+    ) do
+      inner_variable
+    end
+
+    # "AGEYEARS" --> "Alter"
+    rule(inner_variable: subtree(:variable)) do
+      Ast::Variable.new(variable)
+    end
+
+    # "42" -> "42"
+    rule(constant: simple(:constant)) do
+      Ast::Constant.new(constant)
+    end
+
+    # "DRG (F89)" -> "Definition der DRG (F98)"
+    rule(
+      basic_or_drg_link: {
+        variable: subtree(:var),
+        drg_link: {
+          drg: simple(:drg)
+        }
+      }
+    ) do
+      Ast::DrgLink.new(name: drg, variable: var)
+    end
+
+    # "PDX IN TABLE ..." -> "Hauptdiagnose in Tabelle ..."
+    rule(
+      basic_or_drg_link: {
+        variable: subtree(:var),
+        condition: subtree(:condition)
+      }
+    ) do
+      Ast::BasicExpression.new(variable: var, condition: condition)
+    end
+
+    # Go down to in-table, in-tables or all-in-tables condition.
+    rule(table_condition: subtree(:table_condition)) { table_condition }
+
+    # "in table (<reftable>)" -> "in Tabelle <external table name>"
+    rule(in_table: simple(:table)) do
+      Ast::TableCondition.new(
+        op: Ast::TableCondition::IN_TABLE,
+        tables: table
+      )
+    end
+
+    # Multi-tables expression is deliberately mapped to one external table for
+    # enhanced readability.
+    #
+    # "in tables (<ref1>, <ref2>, ...)" -> "in Tabelle <external table name>"
+    rule(
+      in_tables: {
+        tables: sequence(:tables)
+      }
+    ) do
+      Ast::TableCondition.new(
+        op: Ast::TableCondition::IN_TABLES,
+        tables: tables
+      )
+    end
+
+    rule(
+      comparison: subtree(:comparison)
+    ) do
+      comparison
+    end
+
+    rule(
+      op: simple(:op),
+      value: subtree(:value),
+      table_condition: subtree(:table_condition)
+    ) do
+      Ast::Comparison.new(
+        op: op,
+        value: value,
+        table_condition: table_condition
+      )
+    end
+
+    # Handle dangling comparison after table expressions.
+    rule(
+      in_table: {
+        table: simple(:table),
+        comparison: subtree(:comparison)
+      }
+    ) do
+      Ast::TableCondition.new(
+        op: Ast::TableCondition::IN_TABLE,
+        tables: table,
+        comparison: comparison
+      )
+    end
+
+    rule(
+      in_tables: {
+        tables: sequence(:tables),
+        comparison: subtree(:comparison)
+      }
+    ) do
+      Ast::TableCondition.new(
+        op: Ast::TableCondition::IN_TABLES,
+        tables: tables,
+        comparison: comparison
+      )
+    end
+
+    rule(table: simple(:table)) { table.to_s.strip }
+
+    # "SRGLRB IN TABLE( CO3021ORS   )" -> "Beidseitige Prozedur in Tabelle CO3021ORS"
+    rule(
+      srglrb_table_condition: {
+        variable: subtree(:var),
+        condition: subtree(:condition)
+      }
+    ) do
+      Ast::SrglrbTableCondition.new(variable: var, condition: condition)
+    end
+
+    # "OPD2 in (SRG in table ...) > 0" -> "Mindestens zwei Behandlungen, die mindestens einen Tag auseinander liegen in [Prozedur in Tabelle ...]" ¯\_(ツ)_/¯
+    rule(
+      date_exp: {
+        opd: simple(:opd),
+        variable: subtree(:left_var),
+        left_table_condition: subtree(:left_table_condition),
+        and_table_condition: {
+          variable: subtree(:right_var),
+          right_table_condition: subtree(:right_table_condition)
+        },
+        comparison: subtree(:comparison)
+      }
+    ) do
+      Ast::DateExpression.new(
+        left_variable: left_var,
+        right_variable: right_var,
+        left_condition: left_table_condition,
+        right_condition: right_table_condition,
+        comparison: comparison,
+        opd: opd
+      )
+    end
+
+    rule(
+      date_exp: {
+        opd: simple(:opd),
+        variable: subtree(:left_var),
+        left_table_condition: subtree(:left_table_condition),
+        comparison: subtree(:comparison)
+      }
+    ) do
+      Ast::DateExpression.new(
+        left_variable: left_var,
+        left_condition: left_table_condition,
+        comparison: comparison,
+        opd: opd
+      )
+    end
+
+    # "Vierzeitige_bestimmte_OR" -> "Vierzeitige bestimmte OR-Prozeduren"
+    rule(function_call: simple(:fname)) do
+      Ast::FunctionCall.new(fname)
+    end
+  end
+end

data/lib/drgdsl/parser.rb

@@ -0,0 +1,256 @@
+module DrgDSL
+  class ParserError < StandardError
+    attr_reader :parslet_error, :input
+
+    def initialize(parslet_error:, input:)
+      @parslet_error = parslet_error
+      @input = input
+    end
+
+    def message
+      %{Failed to parse "#{input}"\nParslet::ParseFailed: #{parslet_error}}
+    end
+  end
+
+  # Used to parse logic expressions in flowchart decision tree. Based on the
+  # Grouper's DRG parser[0], only difference being that this parser doesn't
+  # know about statements, since they do not occur in the decision nodes.
+  #
+  # To learn more about Parslet see the parser[1] and transform[2] docs.
+  #
+  # The full syntax of the logic is described in
+  # documents/Spec-Handbuch_v2.2.3.pdf in chapter 5.5.
+  #
+  # [0] https://github.com/swissdrg/grouper/blob/master/src/main/common/org/swissdrg/grouper/parser/DrgParser.jj
+  # [1] https://kschiess.github.io/parslet/parser.html
+  # [2] https://kschiess.github.io/parslet/transform.html
+  class Parser < Parslet::Parser
+
+    # @param expression [String]
+    # @return [Ast::Node]
+    def self.parse(expression)
+      AstBuilder.build new.parse(expression.to_s.strip)
+    rescue Parslet::ParseFailed => e
+      raise ParserError.new(parslet_error: e, input: expression)
+    end
+
+    # Case-insensitive string matching
+    #
+    # https://kschiess.github.io/parslet/tricks.html
+    def stri(str)
+      key_chars = str.split(//)
+      key_chars.map { |c| match["#{c.upcase}#{c.downcase}"] }.inject(:>>)
+    end
+
+    # Tokens
+    rule(:star)          { str('*') >> sp? }
+    rule(:k_or)          { stri('or') }
+    rule(:k_and)         { stri('and') }
+    rule(:k_not)         { stri('not') }
+    rule(:k_different)   { stri('different') }
+    rule(:k_empty)       { stri('empty') }
+    rule(:k_in)          { stri('in') }
+    rule(:mdc)           { stri('mdc') }
+    rule(:in_table)      { stri('in table') }
+    rule(:in_tables)     { stri('in tables') }
+    rule(:all_in_table)  { stri('all in table') }
+    rule(:lpar)          { str('(') >> sp? }
+    rule(:rpar)          { sp? >> str(')') }
+    rule(:underscore)    { str('_') }
+    rule(:comma)         { str(',') }
+    rule(:quote)         { str("'") }
+    rule(:assign)        { str(':=') }
+    rule(:letter)        { match('[a-zA-Z]') }
+    rule(:digit)         { match('[0-9]') }
+    rule(:number)        { digit.repeat(1) }
+
+    rule(:comparison_operator) do
+      stri(">=") |
+      stri(">") |
+      stri("<=") |
+      stri("<") |
+      stri("=")
+    end
+
+    #   name
+    #     ::= letter (letter | number | underscore)*
+    rule(:name)          { letter >> (letter | number | underscore).repeat }
+
+    rule(:variable_name) do
+      stri("PDX") |
+        stri("SDX") >> number.maybe |
+        stri("DDX") >> number.maybe |
+        stri("SRG") >> number.maybe |
+        stri("SRGB") >> number.maybe |
+        stri("SRGR") >> number.maybe |
+        stri("SRGL") >> number.maybe |
+        stri("SRGN") >> number.maybe |
+        stri("SRGU") >> number.maybe |
+        stri("AGEYEARS") |
+        stri("AGEDAYS") |
+        stri("SEX") |
+        stri("ADM_WT") |
+        stri("HMV") |
+        stri("MDC") |
+        stri("DRG") |
+        stri("ADRG") |
+        stri("GST") |
+        stri("LOS") |
+        stri("PCCL") |
+        stri("SEP") |
+        stri("ENTRY") |
+        stri("ADM_MODE") |
+        stri("VOID") |
+        stri("GESTAGE")
+    end
+
+    #   srglrb
+    #     ::= 'SRGLRB' number{0,1}
+    rule(:srglrb)  { stri('SRGLRB') >> number.maybe }
+
+    #   opd
+    #     ::= 'OPD' number{0,1}
+    rule(:opd)  { stri('OPD') >> number.maybe }
+
+    # By "double nesting" the variable, the AST builder (a parslet transformer)
+    # can use subtree(:variable) to retrieve a variable node, given there's a
+    # rule for inner_variable that creates said node.
+    #
+    #   variable
+    #     ::= variable_name
+    rule(:variable) { (star.maybe >> variable_name).as(:inner_variable).as(:variable) }
+
+    #   constant
+    #     ::= quote{0,1} (number | name) name{0,1} quote{0,1}
+    rule(:constant) do
+      (quote.maybe >> ((number | name) >> name.maybe) >> quote.maybe).as(:constant)
+    end
+
+    #   value
+    #     ::= variable | constant
+    rule(:value) { (variable | constant).as(:value) }
+
+    #   function_call
+    #     ::= name
+    rule(:function_call) do
+      name.as(:function_call)
+    end
+
+    #   empty
+    #     ::= empty '()'
+    rule(:empty) do
+      k_empty >> sp? >> (lpar >> rpar).maybe
+    end
+
+    #   table_condition
+    #     ::= (in_table '(' name ')' comparison{0,1})
+    #       | in_tables '(' name (comma name)* ')' comparison{0,1}
+    #       | all_in_table '(' name ')'
+    rule(:table_condition) do
+      (in_table >> sp? >> lpar >> name.as(:table) >> rpar >> sp? >> comparison.as(:comparison).maybe).as(:in_table) |
+        (in_tables >> sp? >> lpar >> (name.as(:table) >> (sp? >> comma >> sp? >> name.as(:table)).repeat).as(:tables) >> rpar >> sp? >> comparison.as(:comparison).maybe).as(:in_tables) |
+        (all_in_table >> sp? >> lpar >> name.as(:table) >> rpar).as(:all_in_table)
+    end
+
+    #   comparison
+    #     ::= comparison_operator value table_condition{0,1}
+    rule(:comparison) do
+      comparison_operator.as(:op) >> sp? >>
+        value >> sp? >> table_condition.maybe.as(:table_condition)
+    end
+
+    #   unary_condition
+    #     ::= (not | different) condition
+    rule(:unary_condition) do
+      (k_not | k_different).as(:keyword) >> sp? >> condition.as(:condition)
+    end
+
+    #   condition
+    #     ::= comparison
+    #       | unary_operator
+    #       | empty
+    #       | table_condition
+    rule(:condition) do
+      comparison.as(:comparison) | unary_condition.as(:unary_condition) | empty.as(:empty) | table_condition.as(:table_condition)
+    end
+
+    #   expression
+    #     ::= and_expression (or and_expression)*
+    rule(:expression) do
+      (sp? >> and_expression.as(:and_exp) >> (sp? >> k_or >> sp? >> and_expression.as(:and_exp)).repeat >> sp?).as(:exp)
+    end
+
+    #   and_expression
+    #     ::= simple_expression (and simple_expression)*
+    rule(:and_expression) do
+      simple_expression.as(:simple) >> (sp? >> k_and >> sp? >> simple_expression.as(:simple)).repeat
+    end
+
+    #   simple_expression
+    #     ::= '(' expression ')'
+    #       | basic_or_drg_link
+    #       | srglrb_table_condition
+    #       | date_expression
+    #       | not_expression
+    #       | function_call
+    rule(:simple_expression) do
+      (lpar >> expression >> rpar).as(:paren_exp) |
+        basic_or_drg_link |
+        srglrb_table_condition |
+        date_expression |
+        not_expression |
+        function_call
+    end
+
+    #   date_expression
+    #     ::= opd in '(' variable table_condition (and variable table_ondition){0,1} ')' comparison
+    rule(:date_expression) do
+      (opd.as(:opd) >> sp? >> k_in >> sp? >> lpar >> variable >> sp? >> table_condition.as(:left_table_condition) >> (sp? >> k_and >> sp? >> variable >> sp? >> table_condition.as(:right_table_condition)).as(:and_table_condition).maybe >> rpar >> sp? >> comparison.as(:comparison)).as(:date_exp)
+    end
+
+    #   srglrb_table_condition
+    #     ::= star{0,1} srglrb condition
+    rule(:srglrb_table_condition) do
+      ((star.maybe >> srglrb).as(:inner_variable).as(:variable) >> sp? >> condition.as(:condition)).as(:srglrb_table_condition)
+    end
+
+    #   not_expression
+    #     ::= not '(' expression ')'
+    rule(:not_expression) do
+      (k_not >> sp? >> lpar >> expression >> rpar).as(:not_exp)
+    end
+
+    #   basic_or_drg_link
+    #     ::= variable (basic_expression | drg_link)
+    rule(:basic_or_drg_link) do
+      (variable >> sp? >> (basic_expression | drg_link)).as(:basic_or_drg_link)
+    end
+
+    #   basic_expression
+    #     ::= condition
+    rule(:basic_expression) do
+      condition.as(:condition)
+    end
+
+    #   drg_link
+    #     ::= '(' name ')'
+    rule(:drg_link) do
+      (lpar >> name.as(:drg) >> rpar).as(:drg_link)
+    end
+
+    rule(:comment) do
+      str('/*') >> (str('*/').absent? >> any).repeat >> str('*/')
+    end
+
+    rule(:sp) do
+      (match("[ \t\r\n]") | comment).repeat(1)
+    end
+
+    # Optional whitespace rule. Unfortunately, skipping whitespace can't be
+    # automated:
+    # https://github.com/kschiess/parslet/issues/4://github.com/kschiess/parslet/issues/49
+    rule(:sp?) { sp.repeat }
+
+    rule(:root) { expression }
+  end
+end

data/lib/drgdsl/version.rb

@@ -0,0 +1,3 @@
+module DrgDSL
+  VERSION = "1.0.0"
+end

data/lib/drgdsl/visitor.rb

@@ -0,0 +1,17 @@
+module DrgDSL
+  module Visitor
+    def visit(n)
+      send("visit_#{n.type}", n)
+    end
+
+    Ast::Node.node_classes.each do |node_class|
+      define_method("visit_#{Ast::Node.type(node_class)}") do |n|
+        default_value
+      end
+    end
+
+    # @return [Object] what the visit_<node_class> methods return by default.
+    def default_value
+    end
+  end
+end

data/lib/drgdsl.rb

@@ -0,0 +1,23 @@
+require 'oj'
+require 'parslet'
+
+require_relative "./drgdsl/version"
+require_relative "./drgdsl/ast"
+require_relative "./drgdsl/ast_builder"
+require_relative "./drgdsl/parser"
+require_relative "./drgdsl/visitor"
+
+module DrgDSL
+
+  # @param input [String]
+  # @return [Ast::Node]
+  def self.parse(input)
+    Parser.parse(input)
+  end
+
+  # @param input [String]
+  # @return [String]
+  def self.json(input)
+    Oj.dump parse(input).to_hash, mode: :compat
+  end
+end