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

drgdsl 1.0.0 → 1.1.0

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