drgdsl 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c17114e6f5723fac59d6acf342e6038be2a74a6b1d31cc300cc83e8c77a1ae2b
+  data.tar.gz: 820f8aea9f44b5e911f6112bef704cb3b8a198ac551038819364840e1cefbe4b
+SHA512:
+  metadata.gz: 26aba3e5db76bf2e10899f1c007fb3463736ab3d3bc05f7883b5250992ad6fb8b755319aab3446c61f269a4688e317b46b219f46f190ea5360f4a59ce36e3bd8
+  data.tar.gz: 473c59b7476fc637493742ae50814d76a9cb63f58f45921b60fa3a51880c11b4e564312556eadf2c8f0134d49ba966d0b71c69f90cda4d6c074c5a66eded7853

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.5.0
+before_install: gem install bundler -v 1.16.1

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in drgdsl.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,42 @@
+PATH
+  remote: .
+  specs:
+    drgdsl (1.0.0)
+      oj (~> 3.5.0)
+      parslet (~> 1.8.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    byebug (10.0.2)
+    coderay (1.1.2)
+    method_source (0.9.0)
+    minitest (5.11.3)
+    oj (3.5.1)
+    parslet (1.8.2)
+    pry (0.11.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    pry-byebug (3.6.0)
+      byebug (~> 10.0)
+      pry (~> 0.10)
+    pry-doc (0.13.4)
+      pry (~> 0.11)
+      yard (~> 0.9.11)
+    rake (12.3.1)
+    yard (0.9.12)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  drgdsl!
+  minitest
+  pry
+  pry-byebug
+  pry-doc
+  rake
+
+BUNDLED WITH
+   1.16.1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Rathesan Iyadurai
+
+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 OR COPYRIGHT HOLDERS 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,69 @@
+# DrgDSL
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'drgdsl', git: 'git@192.168.145.133:gems/drgdsl.git'
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+## Usage
+
+From Ruby
+
+```ruby
+# Use .parse to get an AST Object
+DrgDSL.parse("PDX IN TABLES( A0801PXA, A0802PXA, A0803PXA, A0804PXA  )")
+# => #<DrgDSL::Ast::BasicExpression:0x00007f9ad8e29558 @condition=#<DrgDSL::Ast::TableCondition:0x00007f9ad8e2ae58 @comparison=nil, @op="in tables", @tables=["A0801PXA", "A0802PXA", "A0803PXA", "A0804PXA"]>, @variable=#<DrgDSL::Ast::Variable:0x00007f9ad8e30010 @name="PDX">>
+
+# Use .json to get a JSON representation of the AST
+DrgDSL.json("PDX IN TABLES( A0801PXA, A0802PXA, A0803PXA, A0804PXA  )")
+# => "{\"basic\":{\"var\":{\"name\":\"PDX\"},\"condition\":{\"table_condition\":{\"op\":\"in tables\",\"tables\":[\"A0801PXA\",\"A0802PXA\",\"A0803PXA\",\"A0804PXA\"],\"comparison\":null}}}}"
+```
+
+From the CLI
+
+```
+$ drgdsl "PDX IN TABLES( A0801PXA, A0802PXA, A0803PXA, A0804PXA  )"
+
+{
+    "basic": {
+        "condition": {
+            "table_condition": {
+                "comparison": null,
+                "op": "in tables",
+                "tables": [
+                    "A0801PXA",
+                    "A0802PXA",
+                    "A0803PXA",
+                    "A0804PXA"
+                ]
+            }
+        },
+        "var": {
+            "name": "PDX"
+        }
+    }
+}
+```
+
+### Traversing the AST
+
+DrgDSL comes with a mixin that provides AST visit hooks. See `DrgDSL::Visitor`.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "drgdsl"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "pry"
+Pry.start(DrgDSL)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/drgdsl.gemspec

@@ -0,0 +1,41 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "drgdsl/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "drgdsl"
+  spec.version       = DrgDSL::VERSION
+  spec.authors       = ["SwissDRG AG"]
+  spec.email         = ["rathesan.iyadurai@swissdrg.org"]
+
+  spec.summary       = %q{DrgDSL}
+  spec.homepage      = "https://www.swissdrg.org"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against " \
+  #     "public gem pushes."
+  # end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'parslet', '~> 1.8.2'
+  spec.add_dependency 'oj', '~> 3.5.0'
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-byebug"
+  spec.add_development_dependency "pry-doc"
+end

data/exe/drgdsl

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require_relative '../lib/drgdsl'
+
+$options = {}
+option_parser = OptionParser.new do |opts|
+  opts.on('--compact') do
+    $options[:compact] = true
+  end
+
+  opts.on_tail('-h', '--help', 'Show this message') do
+    puts opts
+    exit
+  end
+end
+
+HELP = option_parser.help
+option_parser.parse!
+
+input = if (arg = ARGV.first).is_a? String
+          arg
+        else
+          ARGF.read
+        end
+
+begin
+  json = DrgDSL.json(input)
+rescue => e
+  puts e.message
+  exit(1)
+end
+
+if $options[:compact]
+  puts json
+else
+  # Forgive me Matz for I have sinned
+  system %{echo '#{json}' | python -m json.tool}
+end

data/lib/drgdsl/ast.rb

@@ -0,0 +1,368 @@
+module DrgDSL
+
+  # Nodes in DRG logic AST.
+  #
+  # @see AstBuilder
+  module Ast
+    module Node
+      class << self
+        def node_classes
+          @node_classes ||= []
+        end
+
+        def included(node_class)
+          node_classes << node_class
+        end
+
+        def type(node_class)
+          node_class.to_s[/\w+$/]
+        end
+      end
+
+      def accept(visitor)
+        visitor.visit(self)
+      end
+
+      # Class name of the concrete node without the module name. Do not
+      # override. Used by Visitor to determine which method to call.
+      def type
+        Node.type(self.class)
+      end
+
+      # @return [Boolean] whether this node represents a MDC equality check,
+      #   e.g. "MDC = '01'"
+      def mdc_equality?
+        false
+      end
+
+      # @return [Boolean] whether this node represents a SEP equality check,
+      #   e.g. "SEP = '07'"
+      def sep_equality?
+        false
+      end
+
+      # @return [Hash] Hash representation of the node
+      def to_hash
+        raise NotImplementedError
+      end
+    end
+
+    # Represents a list of expressions joined with an "OR",
+    # e.g., "exp1 or exp2 or exp3 ..."
+    class Expression
+      include Node
+
+      attr_reader :expressions
+
+      def initialize(expressions)
+        @expressions = expressions
+      end
+
+      # @return [Boolean] whether this expression only contains SEP equality
+      #   checks.
+      def only_sep_equality_nodes?
+        expressions.all?(&:sep_equality?)
+      end
+
+      # @return [Boolean] whether this expression only contains MDC equality
+      #   checks.
+      def only_mdc_equality_nodes?
+        expressions.all?(&:mdc_equality?)
+      end
+
+      def to_hash
+        { or: [expressions.map(&:to_hash)] }
+      end
+    end
+
+    # Represents a list of expressions joined with an "AND",
+    # e.g., "exp1 and exp2 and exp3 ..."
+    class AndExpression
+      include Node
+
+      attr_reader :expressions
+
+      def initialize(expressions)
+        @expressions = expressions
+      end
+
+      def to_hash
+        { and: [ expressions.map(&:to_hash) ] }
+      end
+    end
+
+    # One expression surrounded by parentheses, e.g., "(exp)"
+    class ParenExpression
+      include Node
+
+      attr_reader :expression
+
+      def initialize(expression)
+        @expression = expression
+      end
+
+      def to_hash
+        { paren: expression.to_hash }
+      end
+    end
+
+    # A NotExpression is a logic text of the form
+    #   "not (expression)"
+    class NotExpression
+      include Node
+
+      attr_reader :expression
+
+      def initialize(expression)
+        @expression = expression
+      end
+
+      def to_hash
+        { not: expression.to_hash }
+      end
+    end
+
+    # "Komplizierende_Prozeduren", "Dialyse", ...
+    class FunctionCall
+      include Node
+
+      attr_reader :name
+
+      def initialize(name)
+        @name = name.to_s.strip
+      end
+
+      def to_hash
+        { function_call: name }
+      end
+    end
+
+    # A drg link originates from the grammar rule basic_or_drg_link
+    # This rule is of the form "variable (basic_expression | drg_link)"
+    # therefore a DrgLink has a variable and a name
+    class DrgLink
+      include Node
+
+      attr_reader :variable, :name
+
+      # @param name [String] either a drg or adrg name
+      def initialize(name:, variable:)
+        @name = name.to_s.strip.upcase
+        @variable = variable
+      end
+
+      def to_hash
+        { drg_link: { var: variable.to_hash, name: name } }
+      end
+    end
+
+    # A BasicExpression consists of a variable and a condition
+    # (because every variant of condition has a variable)
+    class BasicExpression
+      include Node
+
+      attr_reader :variable, :condition
+
+      # @param variable [Variable]
+      # @param condition [Comparison|UnaryCondition|TableCondition|Empty]
+      def initialize(variable:, condition:)
+        @variable = variable
+        @condition = condition
+      end
+
+      def mdc_equality?
+        variable.name == "MDC" && condition.op == "="
+      end
+
+      def sep_equality?
+        variable.name == "SEP" && condition.op == "="
+      end
+
+      def to_hash
+        { basic: { var: variable.to_hash, condition: condition.to_hash } }
+      end
+    end
+
+    # A comparison is either from a table_condition, a condition or a date_expression
+    class Comparison
+      include Node
+
+      attr_reader :op, :value, :table_condition
+
+      def initialize(op:, value:, table_condition: nil)
+        @op = op.to_s.strip
+        @value = value
+        @table_condition = table_condition
+      end
+
+      def to_hash
+        {
+          comparison: {
+            op: op,
+            value: value.to_hash,
+            table_condition: table_condition&.to_hash
+          }
+        }
+      end
+    end
+
+    # Has a certain operator (i.e. not / different) and a condition
+    #
+    # "not < 3"
+    class UnaryCondition
+      include Node
+
+      attr_reader :op, :condition
+
+      # @param op [String]
+      def initialize(op:, condition:)
+        @op = op.to_s.downcase
+        @condition = condition
+      end
+
+      def to_hash
+        { 
+          unary_condition: {
+            op: op,
+            condition: condition.to_hash
+          }
+        }
+      end
+    end
+
+    class Empty
+      include Node
+
+      def to_hash
+        { empty: nil }
+      end
+    end
+
+    # There are 3 variants of table conditions (in_table, in_tables, all_in_table)
+    # A table condition can have an optional comparison.
+    # Tables refers to the table names (the internal names)
+    class TableCondition
+      IN_TABLE     = 'in table'.freeze
+      IN_TABLES    = 'in tables'.freeze
+      ALL_IN_TABLE = 'all in table'.freeze
+
+      include Node
+
+      attr_reader :op, :tables, :comparison
+
+      # @param op [String] IN_TABLE, IN_TABLES or ALL_IN_TABLE
+      # @param tables [Array<String>] one or more table names
+      def initialize(op:, tables:, comparison: nil)
+        @op = op
+        @tables = Array(tables).map(&:to_s)
+        @comparison = comparison
+      end
+
+      def to_hash
+        {
+          table_condition: {
+            op: op,
+            tables: tables,
+            comparison: comparison&.to_hash
+          }
+        }
+      end
+    end
+
+    # INFO: srg (prozedur) l (links) r (rechts) b(beidseitig)
+    class SrglrbTableCondition
+      include Node
+
+      attr_reader :variable, :condition
+
+      def initialize(variable:, condition:)
+        @variable = variable
+        @condition = condition
+      end
+
+      def to_hash
+        {
+          srglrb_table_condition: {
+            var: variable.to_hash,
+            condition: condition.to_hash
+          }
+        }
+      end
+    end
+
+    class DateExpression
+      include Node
+
+      attr_reader :left_variable,
+        :right_variable,
+        :left_condition,
+        :right_condition,
+        :comparison,
+        :opd
+
+      # @param opd [String] E.g. "opd4" => "mind. 4 erfüllen" query
+      def initialize(left_variable:,
+                     right_variable: nil,
+                     left_condition:,
+                     right_condition: nil,
+                     comparison:,
+                     opd:
+                    )
+
+        @left_variable = left_variable
+        @right_variable = right_variable
+        @left_condition = left_condition
+        @right_condition = right_condition
+        @comparison = comparison
+        @opd = opd
+      end
+
+      def to_hash
+        {
+          opd: {
+            var: opd,
+            left_var: left_variable.to_hash,
+            left_condition: left_condition.to_hash,
+            right_var: right_variable&.to_hash,
+            right_condition: right_condition&.to_hash,
+            comparison: comparison.to_hash
+          }
+        }
+      end
+    end
+
+    # "PDX", "AGEYEARS", ...
+    class Variable
+      include Node
+
+      attr_reader :name
+
+      def initialize(name)
+        @name = name.to_s.strip
+      end
+
+      def to_hash
+        { name: name }
+      end
+    end
+
+    # "3", "'MDC'", ...
+    class Constant
+      include Node
+
+      attr_reader :value
+
+      def initialize(value)
+        @value = value.to_s.strip.tr("'", '')
+      end
+
+      def to_s
+        value.to_s
+      end
+
+      def to_hash
+        { constant: { value: value } }
+      end
+    end
+  end
+end