RubyGems - drgdsl - Versions diffs - 1.0.0 → 1.1.0 - Mend

drgdsl 1.0.0 → 1.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

checksums.yaml +4 -4
data/.rubocop.yml +133 -0
data/Gemfile.lock +1 -1
data/bin/html +56 -0
data/exe/drgdsl +31 -8
data/lib/drgdsl/ast.rb +7 -1
data/lib/drgdsl/ast_builder.rb +6 -4
data/lib/drgdsl/core_extensions.rb +49 -0
data/lib/drgdsl/paren_cleaner.rb +58 -0
data/lib/drgdsl/parser.rb +17 -13
data/lib/drgdsl/pretty_printer.rb +208 -0
data/lib/drgdsl/version.rb +1 -1
data/lib/drgdsl/visitor.rb +86 -6
data/lib/drgdsl.rb +56 -2
metadata +7 -2

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c17114e6f5723fac59d6acf342e6038be2a74a6b1d31cc300cc83e8c77a1ae2b
-  data.tar.gz: 820f8aea9f44b5e911f6112bef704cb3b8a198ac551038819364840e1cefbe4b
+  metadata.gz: a9715079e711fd5f608888b4b6433221db58145b85d58562e5419170496201c1
+  data.tar.gz: 7c83b0126a22e86431e5d8ededa65b75cb982d8fdd8b1dd2db726308c94e5b25
 SHA512:
-  metadata.gz: 26aba3e5db76bf2e10899f1c007fb3463736ab3d3bc05f7883b5250992ad6fb8b755319aab3446c61f269a4688e317b46b219f46f190ea5360f4a59ce36e3bd8
-  data.tar.gz: 473c59b7476fc637493742ae50814d76a9cb63f58f45921b60fa3a51880c11b4e564312556eadf2c8f0134d49ba966d0b71c69f90cda4d6c074c5a66eded7853
+  metadata.gz: 8051b841182ad48e4e13f57bd06bfe999f694321c1abd3c88d16065a6149d0c80d357d6a6e75fd0d56f96356bc16fabaf85f321da6a7deb66d7510e8cb8695a9
+  data.tar.gz: af4454d07118b2966da5074332d7549fda5b9ffc3fafae56dd151f86d40342ae23be3d089967d68e0ddcf6d8c6a7c1d388fba19b6aa61718d72ad9d1dc9f4b29

data/.rubocop.yml ADDED Viewed

@@ -0,0 +1,133 @@
+# https://github.com/bbatsov/rubocop/blob/master/config/default.yml
+AllCops:
+  DisplayCopNames: true
+  DisplayStyleGuide: true
+  TargetRubyVersion: 2.5
+  Include:
+    - Rakefile
+LineLength:
+  Max: 80
+  Exclude:
+    - test/**/**
+    - lib/drgdsl/parser.rb
+    - lib/drgdsl/ast_builer.rb
+Layout/SpaceInsideStringInterpolation:
+  Enabled: false
+Layout/EmptyLinesAroundBlockBody:
+  Enabled: false
+Layout/EmptyLinesAroundClassBody:
+  Enabled: false
+Layout/EmptyLinesAroundModuleBody:
+  Enabled: false
+Layout/EmptyLineBetweenDefs:
+  NumberOfEmptyLines: [1, 2]
+Layout/MultilineOperationIndentation:
+  EnforcedStyle: indented
+Layout/AlignParameters:
+  EnforcedStyle: with_first_parameter
+Layout/DotPosition:
+  Enabled: false
+Style/PercentLiteralDelimiters:
+  Enabled: false
+Style/StringLiterals:
+  Enabled: false
+Style/StringLiteralsInInterpolation:
+  Enabled: false
+Style/SingleLineBlockParams:
+  Enabled: false
+Style/TrivialAccessors:
+  AllowPredicates: true
+Style/Semicolon:
+  AllowAsExpressionSeparator: true
+Style/PerlBackrefs:
+  Enabled: false
+Style/SingleLineMethods:
+  Enabled: false
+Style/Documentation:
+  Enabled: false
+Style/RegexpLiteral:
+  Enabled: false
+Style/CommandLiteral:
+  Enabled: false
+Style/FormatString:
+  Enabled: false
+Style/AsciiComments:
+  Enabled: false
+Style/SymbolProc:
+  AutoCorrect: false
+Style/EmptyMethod:
+  Enabled: false
+Style/MultilineTernaryOperator:
+  Enabled: false
+Style/DoubleNegation:
+  Enabled: false
+Metrics/ClassLength:
+  Enabled: false
+Metrics/ModuleLength:
+  Enabled: false
+Metrics/MethodLength:
+  Enabled: false
+Metrics/CyclomaticComplexity:
+  Enabled: false
+Metrics/PerceivedComplexity:
+  Enabled: false
+Metrics/AbcSize:
+  Enabled: false
+Metrics/ParameterLists:
+  CountKeywordArgs: false
+Metrics/BlockLength:
+  Enabled: false
+Naming/HeredocDelimiterNaming:
+  Enabled: false
+Naming/PredicateName:
+  Enabled: false
+Naming/MethodName:
+  Enabled: false
+Naming/UncommunicativeMethodParamName:
+  Enabled: false
+Performance/RedundantBlockCall:
+  Enabled: false
+Lint/UnusedMethodArgument:
+  Enabled: true
+  AutoCorrect: false

data/Gemfile.lock CHANGED Viewed

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    drgdsl (1.0.0)
+    drgdsl (1.1.0)
       oj (~> 3.5.0)
       parslet (~> 1.8.2)

data/bin/html ADDED Viewed

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+# Generates highlighted html snippets for a bunch of expressions for
+# visualization purposes.
+require "bundler/setup"
+require "drgdsl"
+logics = []
+File.read('./test/expressions.txt', encoding: 'utf-8').split("\n\n").each_with_index do |exp, i|
+  html = DrgDSL.pretty_print(exp, output_format: :html)
+  logics << html
+end
+puts <<~HTML
+  <html>
+  <head>
+    <style>
+      .drgdsl-keyword {
+        color: blue;
+      }
+      .drgdsl-function {
+        color: green;
+      }
+      .drgdsl-op {
+        color: grey;
+      }
+      .drgdsl-table {
+        color: pink;
+      }
+      .drgdsl-variable {
+        color: black;
+      }
+      .drgdsl-constant {
+        color: purple;
+      }
+      .drgdsl-drg, .drgdsl-adrg {
+        color: black;
+      }
+    </style>
+  </head>
+  <body>
+  #{logics.join("\n")}
+  </body>
+  </html>
+HTML

data/exe/drgdsl CHANGED Viewed

@@ -9,6 +9,14 @@ option_parser = OptionParser.new do |opts|
     $options[:compact] = true
   end
+  opts.on('-o', '--output [OUTPUT]', %i[json html]) do |output|
+    $options[:output] = output
+  end
+  opts.on('--clean-parens', 'Remove redundant parentheses') do
+    $options[:clean_parens] = true
+  end
   opts.on_tail('-h', '--help', 'Show this message') do
     puts opts
     exit
@@ -25,15 +33,30 @@ input = if (arg = ARGV.first).is_a? String
         end
 begin
-  json = DrgDSL.json(input)
+  case $options[:output]
+  when :json
+    json = DrgDSL.json(input)
+    if $options[:compact]
+      puts json
+    else
+      # Forgive me Matz for I have sinned
+      system %{echo '#{json}' | python -m json.tool}
+    end
+  when :html
+    puts DrgDSL.pretty_print(
+      input,
+      output_format: :html,
+      remove_redundant_parens: $options[:clean_parens]
+    )
+  else
+    puts DrgDSL.pretty_print(
+      input,
+      output_format: :bash,
+      remove_redundant_parens: $options[:clean_parens]
+    )
+  end
 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 CHANGED Viewed

@@ -45,6 +45,12 @@ module DrgDSL
       def to_hash
         raise NotImplementedError
       end
+      def pretty_print(**pretty_printer_options)
+        accept PrettyPrinter.new(**pretty_printer_options)
+      end
+      alias to_s pretty_print
     end
     # Represents a list of expressions joined with an "OR",
@@ -314,7 +320,7 @@ module DrgDSL
         @left_condition = left_condition
         @right_condition = right_condition
         @comparison = comparison
-        @opd = opd
+        @opd = opd.to_s.strip.upcase
       end
       def to_hash

data/lib/drgdsl/ast_builder.rb CHANGED Viewed

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
 require 'pp'
 module DrgDSL
@@ -13,13 +15,13 @@ module DrgDSL
     def message
       <<~EOM
-      Don't know how to build AST from this CST:
+        Don't know how to build AST from this CST:
-        #{pretty cst}
+          #{pretty cst}
-      Intermediate result:
+        Intermediate result:
-        #{pretty result}
+          #{pretty result}
       EOM
     end

data/lib/drgdsl/core_extensions.rb ADDED Viewed

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+module DrgDSL
+  # Add core extensions here as refinements. Only load them when necessary, so
+  # that we don't monkeypatch applications that load DrgDSL.
+  #
+  # @example Loading the core extensions to the current lexical scope
+  #
+  #   module MyScope
+  #     using DrgDSL::CoreExtensions
+  #
+  #     # Extensions exist here
+  #
+  #   end
+  #
+  #   # Extensions no longer exist here
+  #
+  module CoreExtensions
+    refine String do
+      def colorize(color_code)
+        "\e[#{color_code}m#{self}\e[0m"
+      end
+      def magenta
+        colorize 35
+      end
+      def cyan
+        colorize 36
+      end
+      def red
+        colorize 31
+      end
+      def yellow
+        colorize 33
+      end
+      def green
+        colorize 32
+      end
+      def blue
+        colorize 34
+      end
+    end
+  end
+end

data/lib/drgdsl/paren_cleaner.rb ADDED Viewed

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+module DrgDSL
+  class ParenCleaner
+    include Visitor
+    # @param expression [String]
+    # @return [String] pretty printed expression without any redundant
+    #   parentheses.
+    def self.remove_redundant_parens(expression)
+      ast = Parser.parse(expression)
+      reduced_ast = clean(ast)
+      reduced_ast.to_s
+    end
+    # @param ast [Node]
+    # @return [Node] ast without redundant ParenExpressions
+    def self.clean(ast, remove_outer_parens: true)
+      # If the whole expression is wrapped in parentheses, we can start
+      # visiting the first child.
+      if ast.type == 'ParenExpression' && remove_outer_parens
+        ast = ast.expression
+      end
+      ast.accept(new)
+    end
+    private
+    def visit_Expression(n)
+      Ast::Expression.new(n.expressions.map { |e| visit(e) })
+    end
+    def visit_AndExpression(n)
+      Ast::AndExpression.new(n.expressions.map { |e| visit(e) })
+    end
+    def visit_ParenExpression(n)
+      types = %w(
+        ParenExpression
+        DrgLink
+        BasicExpression
+        AndExpression
+        NotExpression
+        FunctionCall
+        Empty
+        TableCondition
+      )
+      return visit(n.expression) if types.include?(n.expression.type)
+      if n.expression.type == 'Expression'
+        return Ast::ParenExpression.new(visit(n.expression))
+      end
+      n
+    end
+  end
+end

data/lib/drgdsl/parser.rb CHANGED Viewed

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
 module DrgDSL
   class ParserError < StandardError
     attr_reader :parslet_error, :input
@@ -39,7 +41,9 @@ module DrgDSL
     # https://kschiess.github.io/parslet/tricks.html
     def stri(str)
       key_chars = str.split(//)
-      key_chars.map { |c| match["#{c.upcase}#{c.downcase}"] }.inject(:>>)
+      key_chars
+        .map { |c| match["#{c.upcase}#{c.downcase}".squeeze] }
+        .inject(:>>)
     end
     # Tokens
@@ -51,9 +55,9 @@ module DrgDSL
     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(:in_table)      { stri('in') >> sp? >> stri('table') }
+    rule(:in_tables)     { stri('in') >> sp? >> stri('tables') }
+    rule(:all_in_table)  { stri('all') >> sp? >> stri('in') >> sp? >> stri('table') }
     rule(:lpar)          { str('(') >> sp? }
     rule(:rpar)          { sp? >> str(')') }
     rule(:underscore)    { str('_') }
@@ -65,11 +69,11 @@ module DrgDSL
     rule(:number)        { digit.repeat(1) }
     rule(:comparison_operator) do
-      stri(">=") |
-      stri(">") |
-      stri("<=") |
-      stri("<") |
-      stri("=")
+      str(">=")   |
+        str(">")  |
+        str("<=") |
+        str("<")  |
+        str("=")
     end
     #   name
@@ -106,11 +110,11 @@ module DrgDSL
     #   srglrb
     #     ::= 'SRGLRB' number{0,1}
-    rule(:srglrb)  { stri('SRGLRB') >> number.maybe }
+    rule(:srglrb) { stri('SRGLRB') >> number.maybe }
     #   opd
     #     ::= 'OPD' number{0,1}
-    rule(:opd)  { stri('OPD') >> number.maybe }
+    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
@@ -243,12 +247,12 @@ module DrgDSL
     end
     rule(:sp) do
-      (match("[ \t\r\n]") | comment).repeat(1)
+      (match("[ \t\r\n\f]") | 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
+    # https://github.com/kschiess/parslet/issues/49
     rule(:sp?) { sp.repeat }
     rule(:root) { expression }

data/lib/drgdsl/pretty_printer.rb ADDED Viewed

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+require 'cgi'
+module DrgDSL
+  class PrettyPrinter
+    using CoreExtensions
+    include Visitor
+    OUTPUT_FORMATS = %i[string html bash].freeze
+    OUTPUT_FORMATS.each do |format|
+      define_method "output_#{format}?" do
+        @output_format == format
+      end
+    end
+    attr_reader :indentation_level, :indentation_string, :output_format
+    # @param expression [String]
+    # @return [String]
+    def self.pretty_print(expression, **options)
+      ast = Parser.parse(expression)
+      ast = ParenCleaner.clean(ast) if options.delete(:remove_redundant_parens)
+      output = ast.accept(new(**options))
+      output_format = options[:output_format]
+      return "<pre>#{output}</pre>" if output_format == :html
+      output
+    end
+    # @param output_format [Symbol]
+    # @param multiline [Boolean]
+    def initialize(output_format: :string,
+                   multiline: true)
+      @indentation_level = 0
+      @indentation_string = '  '
+      unless OUTPUT_FORMATS.include?(output_format)
+        raise "Unknown output format: #{output_format.inspect}"
+      end
+      @output_format = output_format
+      @multiline = multiline
+    end
+    def multiline?
+      @multiline
+    end
+    def visit_nil
+      ''
+    end
+    private
+    def visit_Expression(n)
+      keyword = wrap('OR', type: :keyword)
+      separator = " #{keyword} "
+      separator = "\n#{f(keyword)} " if multiline?
+      n.expressions.map { |e| visit(e) }.join(separator)
+    end
+    def visit_AndExpression(n)
+      keyword = wrap('AND', type: :keyword)
+      separator = " #{keyword} "
+      separator = "\n#{f(keyword)} " if multiline?
+      n.expressions.map { |e| visit(e) }.join(separator)
+    end
+    def visit_ParenExpression(n)
+      return "(#{visit(n.expression)})" unless multiline?
+      str = +"(\n"
+      indented do
+        str << f(visit(n.expression))
+      end
+      str << "\n"
+      str << f(')')
+    end
+    def visit_NotExpression(n)
+      "#{wrap('NOT', type: :keyword)} (#{visit(n.expression)})"
+    end
+    def visit_FunctionCall(n)
+      wrap(n.name, type: :function)
+    end
+    def visit_DrgLink(n)
+      "#{visit(n.variable)} (#{wrap(n.name, type: n.variable.name.downcase)})"
+    end
+    def visit_BasicExpression(n)
+      "#{visit(n.variable)} #{visit(n.condition)}"
+    end
+    def visit_Comparison(n)
+      "#{wrap(n.op, type: :op)} #{visit(n.value)} #{visit(n.table_condition)}".strip
+    end
+    def visit_UnaryCondition(n)
+      "#{wrap(n.op.upcase, type: :keyword)} #{visit(n.condition)}"
+    end
+    def visit_Empty(_)
+      wrap('EMPTY', type: :keyword)
+    end
+    def visit_TableCondition(n)
+      str = +"#{wrap(n.op.upcase, type: :keyword)} "
+      if multiline? && n.tables.count > 4
+        str << "(\n"
+        indented do
+          str << n.tables.map { |t| f(wrap(t.upcase, type: :table)) }.join(",\n")
+        end
+        str << "\n"
+        str << f(')')
+      else
+        str << "(#{n.tables.map { |t| wrap(t.upcase, type: :table) }.join(', ')})"
+      end
+      str
+    end
+    def visit_SrglrbTableCondition(n)
+      "#{visit(n.variable)} #{visit(n.condition)}"
+    end
+    def visit_DateExpression(n)
+      "#{wrap(n.opd, type: :variable)} IN (#{visit(n.left_variable)} #{visit(n.left_condition)}#{n.right_variable && " AND #{visit(n.right_variable)} #{visit(n.right_condition)}"}) #{visit(n.comparison)}".strip
+    end
+    def visit_Variable(n)
+      wrap(n.name.upcase, type: :variable)
+    end
+    def visit_Constant(n)
+      wrap(n.value, type: :constant)
+    end
+    def indented
+      indent!
+      yield
+      deindent!
+    end
+    def indent!
+      @indentation_level += 1
+    end
+    def deindent!
+      @indentation_level -= 1
+    end
+    def indentation
+      return '' unless multiline?
+      @indentation_string * @indentation_level
+    end
+    # @param str [String]
+    # @return [String] indented string
+    def f(str)
+      "#{indentation}#{str}"
+    end
+    def wrap(str, **options)
+      return str if output_string?
+      return span(str, type: options[:type]) if output_html?
+      return ansi_colored(str, type: options[:type]) if output_bash?
+    end
+    def span(str, type:)
+      class_name = "drgdsl-#{type}"
+      %{<span class="#{class_name}">#{escape_html(str)}</span>}
+    end
+    def escape_html(str)
+      CGI.escapeHTML(str)
+    end
+    def ansi_colored(str, type:)
+      case type.to_sym
+      when :keyword
+        str.blue
+      when :function
+        str.green
+      when :op
+        str.blue
+      when :table
+        str.magenta
+      when :variable
+        str.cyan
+      when :constant
+        str.red
+      when :drg, :adrg
+        str.yellow
+      else
+        str
+      end
+    end
+  end
+end

data/lib/drgdsl/version.rb CHANGED Viewed

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

data/lib/drgdsl/visitor.rb CHANGED Viewed

@@ -1,17 +1,97 @@
+# frozen_string_literal: true
 module DrgDSL
+  # Mixin for Ast::Node visitors. Visits all child nodes and returns the
+  # visited node by default.
   module Visitor
     def visit(n)
+      return visit_nil if n.nil?
       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
+    # Override to define what should happen when one calls #visit with nil (can
+    # occur on optional AST branches).
+    #
+    # Does nothing by default. A string visitor might want to return an empty
+    # string here.
+    def visit_nil
+    end
+    def visit_Expression(n)
+      n.expressions.map { |e| visit(e) }
+      n
+    end
+    def visit_AndExpression(n)
+      n.expressions.map { |e| visit(e) }
+      n
+    end
+    def visit_ParenExpression(n)
+      visit(n.expression)
+      n
+    end
+    def visit_NotExpression(n)
+      visit(n.expression)
+      n
+    end
+    def visit_FunctionCall(n)
+      n
+    end
+    def visit_DrgLink(n)
+      visit(n.variable)
+      n
+    end
+    def visit_BasicExpression(n)
+      visit(n.variable)
+      visit(n.condition)
+      n
+    end
+    def visit_Comparison(n)
+      visit(n.value)
+      visit(n.table_condition)
+      n
+    end
+    def visit_UnaryCondition(n)
+      visit(n.condition)
+      n
+    end
+    def visit_Empty(n)
+      n
+    end
+    def visit_TableCondition(n)
+      visit(n.comparison)
+      n
+    end
+    def visit_SrglrbTableCondition(n)
+      visit(n.condition)
+      n
+    end
+    def visit_DateExpression(n)
+      visit(n.left_variable)
+      visit(n.left_condition)
+      visit(n.right_variable)
+      visit(n.right_condition)
+      visit(n.comparison)
+      n
+    end
+    def visit_Variable(n)
+      n
     end
-    # @return [Object] what the visit_<node_class> methods return by default.
-    def default_value
+    def visit_Constant(n)
+      n
     end
   end
 end

data/lib/drgdsl.rb CHANGED Viewed

@@ -1,14 +1,18 @@
+# frozen_string_literal: true
 require 'oj'
 require 'parslet'
 require_relative "./drgdsl/version"
+require_relative "./drgdsl/core_extensions"
 require_relative "./drgdsl/ast"
 require_relative "./drgdsl/ast_builder"
 require_relative "./drgdsl/parser"
 require_relative "./drgdsl/visitor"
+require_relative "./drgdsl/pretty_printer"
+require_relative "./drgdsl/paren_cleaner"
 module DrgDSL
   # @param input [String]
   # @return [Ast::Node]
   def self.parse(input)
@@ -16,8 +20,58 @@ module DrgDSL
   end
   # @param input [String]
-  # @return [String]
+  # @return [String] JSON representation of the AST
   def self.json(input)
     Oj.dump parse(input).to_hash, mode: :compat
   end
+  # @param input [String]
+  # @param remove_redundant_parens [Boolean] (false)
+  # @param multiline [Boolean] (true) pass false to print the expression
+  #   without any newlines.
+  # @param output_format [Symbol] (:string) also supports :html and :bash.
+  #
+  # @return [String] pretty printed DrgDSL expression
+  #
+  # @example Pretty printing with various options
+  #   input = "(pdx in table (a  )) and (drg (f46) or (drg (g22) and los < 3))"
+  #   DrgDSL.pretty_print(input)
+  #   # =>
+  #   #     (
+  #   #       PDX IN TABLE (A)
+  #   #     )
+  #   #     AND (
+  #   #       DRG (F46)
+  #   #       OR (
+  #   #         DRG (G22)
+  #   #         AND LOS < 3
+  #   #       )
+  #   #     )
+  #
+  #   DrgDSL.pretty_print(input, remove_redundant_parens: true)
+  #   # =>
+  #   #     PDX IN TABLE (A)
+  #   #     AND (
+  #   #       DRG (F46)
+  #   #       OR DRG (G22)
+  #   #       AND LOS < 3
+  #   #     )
+  #
+  #   DrgDSL.pretty_print(input, remove_redundant_parens: true, multiline: false)
+  #   # => PDX IN TABLE (A) AND (DRG (F46) OR DRG (G22) AND LOS < 3)
+  #
+  #   DrgDSL.pretty_print(input, remove_redundant_parens: true, output_format: html)
+  #   # =>
+  #   #     <pre>
+  #   #     <span class="drgdsl-variable">PDX</span> <span class="drgdsl-keyword">IN TABLE</span> (<span class="drgdsl-table">A</span>)
+  #   #     <span class="drgdsl-keyword">AND</span> (
+  #   #       <span class="drgdsl-variable">DRG</span> (<span class="drgdsl-drg">F46</span>)
+  #   #       <span class="drgdsl-keyword">OR</span> <span class="drgdsl-variable">DRG</span> (<span class="drgdsl-drg">G22</span>)
+  #   #       <span class="drgdsl-keyword">AND</span> <span class="drgdsl-variable">LOS</span> <span class="drgdsl-op">&lt;</span> <span class="drgdsl-constant">3</span>
+  #   #     )
+  #   #     </pre>
+  #
+  def self.pretty_print(input, **options)
+    PrettyPrinter.pretty_print(input, **options)
+  end
 end

metadata CHANGED Viewed

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: drgdsl
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - SwissDRG AG
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2018-04-18 00:00:00.000000000 Z
+date: 2018-07-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
@@ -131,6 +131,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rubocop.yml"
 - ".travis.yml"
 - Gemfile
 - Gemfile.lock
@@ -138,13 +139,17 @@ files:
 - README.md
 - Rakefile
 - bin/console
+- bin/html
 - bin/setup
 - drgdsl.gemspec
 - exe/drgdsl
 - lib/drgdsl.rb
 - lib/drgdsl/ast.rb
 - lib/drgdsl/ast_builder.rb
+- lib/drgdsl/core_extensions.rb
+- lib/drgdsl/paren_cleaner.rb
 - lib/drgdsl/parser.rb
+- lib/drgdsl/pretty_printer.rb
 - lib/drgdsl/version.rb
 - lib/drgdsl/visitor.rb
 homepage: https://www.swissdrg.org