poe-css 0.0.1

data/lib/poe-css/generator.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module POECSS
+  module Generator
+    class << self
+      def generate_poe_rules(clauses)
+        clauses.map { |clause|
+          visibility_command_clauses, nonvisibility_command_clauses = [
+            clause.command_clauses
+          ].flatten.partition { |c| c.command_key == 'show' || c.command_key == 'hide' }
+          visibility_command_clause = visibility_command_clauses.first
+          if visibility_command_clause.nil?
+            raise ArgumentError, "Each generated clause must have a Show or Hide command.\n\n#{clause}"
+          end
+
+          visibility_header = visibility_command_clause.command_key.capitalize
+
+          match_rules = clause.match_clauses.map { |c|
+            args = c.match_arguments
+            arguments =
+              case c.match_key
+              when 'itemlevel'
+                [ 'ItemLevel', args[:operator], args[:level] ]
+              when 'droplevel'
+                [ 'DropLevel', args[:operator], args[:level] ]
+              when 'quality'
+                [ 'Quality', args[:operator], args[:quality] ]
+              when 'rarity'
+                [ 'Rarity', args[:operator], args[:rarity] ]
+              when 'class'
+                [ 'Class', args[:substrings].sort.map(&:inspect) ]
+              when 'basetype'
+                [ 'BaseType', args[:substrings].sort.map(&:inspect) ]
+              when 'corrupted'
+                [ 'Corrupted', bool(args[:corrupted]) ]
+              when 'elderitem'
+                [ 'ElderItem', bool(args[:elder_item]) ]
+              when 'height'
+                [ 'Height', args[:operator], args[:height] ]
+              when 'identified'
+                [ 'Identified', bool(args[:identified]) ]
+              when 'linkedsockets'
+                [ 'LinkedSockets', args[:operator], args[:sockets] ]
+              when 'shapedmap'
+                [ 'ShapedMap', bool(args[:shaped_map]) ]
+              when 'shaperitem'
+                [ 'ShaperItem', bool(args[:shaper_item]) ]
+              when 'socketgroup'
+                [ 'SocketGroup', args[:sub_socket_groups].sort_by { |s| [ -s.length, s ] }.map(&:inspect) ]
+              when 'sockets'
+                [ 'Sockets', args[:operator], args[:sockets] ]
+              when 'width'
+                [ 'Width', args[:operator], args[:width] ]
+              else
+                raise ArgumentError, c.match_key
+              end
+
+            arguments.flatten.join(' ')
+          }
+
+          nonvisibility_commands = nonvisibility_command_clauses.map { |c|
+            arg = c.command_argument
+            arguments =
+              case c.command_key
+              when 'setbordercolor'
+                [ 'SetBorderColor', color_from_spec(arg[:color]) ]
+              when 'settextcolor'
+                [ 'SetTextColor', color_from_spec(arg[:color]) ]
+              when 'setbackgroundcolor'
+                [ 'SetBackgroundColor', color_from_spec(arg[:color]) ]
+              when 'playalertsound'
+                [ 'PlayAlertSound', arg[:sound_id], arg[:volume] ]
+              when 'playalertsoundpositional'
+                [ 'PlayAlertSoundPositional', arg[:sound_id], arg[:volume] ]
+              when 'setfontsize'
+                [ 'SetFontSize', arg[:font_size] ]
+              else
+                raise ArgumentError, c.command_key
+              end
+
+            arguments.flatten.compact.join(' ')
+          }
+
+          [
+            visibility_header.to_s,
+            match_rules.sort.map { |r| "  #{r}" }.join("\n"),
+            nonvisibility_commands.sort.map { |r| "  #{r}" }.join("\n")
+          ].reject(&:empty?).join("\n") + "\n"
+        }.join("\n")
+      end
+
+      private
+
+      def color_from_spec(spec)
+        case spec
+        when RGBColorSpec
+          (%i[r g b].map { |c| spec[c] } + [ spec.a || 255 ]).join(' ')
+        else
+          raise ArgumentError, spec
+        end
+      end
+
+      def bool(b)
+        (!b.nil? ? b : true).to_s.capitalize
+      end
+    end
+  end
+end

data/lib/poe-css/parser.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module POECSS
+  module Parser
+    module_function
+
+    def parse_input(s)
+      input = s.strip
+      tree = Parser.new.parse(input, reporter: Parslet::ErrorReporter::Deepest.new)
+      Transformer.new.apply(tree)
+    rescue Parslet::ParseFailed => error
+      raise ParseError.new(:parser, error.parse_failure_cause)
+    end
+
+    class Parser < Parslet::Parser
+      def stri(str)
+        str.split('').map { |char| match["#{char.upcase}#{char.downcase}"] }.reduce(:>>)
+      end
+
+      rule(:newline) { match("\n").repeat(1) }
+      rule(:space) { match('\s').repeat(1) }
+      rule(:space?) { space.maybe }
+      rule(:comma) { str(',') >> space? }
+      rule(:pipe) { str('|') >> space? }
+      rule(:open_brace) { str('{') >> space? }
+      rule(:close_brace) { str('}') >> space? }
+
+      rule(:operator) { (str('>=') | str('<=') | str('>') | str('<') | str('=')).as(:operator) >> space? }
+
+      rule(:integer) { match('[0-9]').repeat(1).as(:integer) >> space? }
+      rule(:rarity) { (stri('Normal') | stri('Magic') | stri('Rare') | stri('Unique')).as(:rarity) >> space? }
+      rule(:string) {
+        ((str('"') >> match(%([a-zA-Z0-9' ])).repeat(1).as(:string) >> str('"')) | match(%([a-zA-Z0-9'])).repeat(1).as(:string)) >> space?
+      }
+      rule(:strings) { string.repeat(1).as(:strings) }
+      rule(:rgb_color_spec) {
+        stri('RGB') >> stri('A').maybe >> str('(') >> space? >>
+          integer.as(:r) >> comma >>
+          integer.as(:g) >> comma >>
+          integer.as(:b) >>
+          (comma >> integer.as(:a)).maybe >>
+          str(')') >> space?
+      }
+      rule(:color_spec) {
+        rgb_color_spec.as(:rgb)
+      }
+      rule(:sound_spec) {
+        integer.as(:sound_id) >> integer.as(:volume).maybe
+      }
+      rule(:boolean) { (stri('true') | stri('false')).as(:boolean) >> space? }
+
+      rule(:match_item_level) {
+        stri('ItemLevel').as(:match_key) >> space? >> (operator.maybe.as(:operator) >> integer.as(:level)).as(:match_arguments)
+      }
+      rule(:match_drop_level) {
+        stri('DropLevel').as(:match_key) >> space? >> (operator.maybe.as(:operator) >> integer.as(:level)).as(:match_arguments)
+      }
+      rule(:match_quality) {
+        stri('Quality').as(:match_key) >> space? >> (operator.maybe.as(:operator) >> integer.as(:quality)).as(:match_arguments)
+      }
+      rule(:match_rarity) {
+        stri('Rarity').as(:match_key) >> space? >> (operator.maybe.as(:operator) >> rarity.as(:rarity)).as(:match_arguments)
+      }
+      rule(:match_class) {
+        stri('Class').as(:match_key) >> space? >> strings.as(:substrings).as(:match_arguments)
+      }
+      rule(:match_base_type) {
+        stri('BaseType').as(:match_key) >> space? >> strings.as(:substrings).as(:match_arguments)
+      }
+      rule(:match_sockets) {
+        stri('Sockets').as(:match_key) >> space? >> (operator.maybe.as(:operator) >> integer.as(:sockets)).as(:match_arguments)
+      }
+      rule(:match_linked_sockets) {
+        stri('LinkedSockets').as(:match_key) >> space? >> (operator.maybe.as(:operator) >> integer.as(:sockets)).as(:match_arguments)
+      }
+      rule(:match_socket_group) {
+        stri('SocketGroup').as(:match_key) >> space? >> strings.as(:sub_socket_groups).as(:match_arguments)
+      }
+      rule(:match_height) {
+        stri('Height').as(:match_key) >> space? >> (operator.maybe.as(:operator) >> integer.as(:height)).as(:match_arguments)
+      }
+      rule(:match_width) {
+        stri('Width').as(:match_key) >> space? >> (operator.maybe.as(:operator) >> integer.as(:width)).as(:match_arguments)
+      }
+      rule(:match_identified) {
+        stri('Identified').as(:match_key) >> space? >> boolean.maybe.as(:identified).as(:match_arguments)
+      }
+      rule(:match_corrupted) {
+        stri('Corrupted').as(:match_key) >> space? >> boolean.maybe.as(:corrupted).as(:match_arguments)
+      }
+      rule(:match_elder_item) {
+        stri('ElderItem').as(:match_key) >> space? >> boolean.maybe.as(:elder_item).as(:match_arguments)
+      }
+      rule(:match_shaped_map) {
+        stri('ShapedMap').as(:match_key) >> space? >> boolean.maybe.as(:shaped_map).as(:match_arguments)
+      }
+      rule(:match_shaper_item) {
+        stri('ShaperItem').as(:match_key) >> space? >> boolean.maybe.as(:shaper_item).as(:match_arguments)
+      }
+
+      rule(:match_clause) {
+        (
+          match_item_level |
+          match_drop_level |
+          match_quality |
+          match_rarity |
+          match_class |
+          match_base_type |
+          match_sockets |
+          match_linked_sockets |
+          match_socket_group |
+          match_height |
+          match_width |
+          match_identified |
+          match_corrupted |
+          match_elder_item |
+          match_shaped_map |
+          match_shaper_item
+        )
+      }
+
+      rule(:command_set_border_color) { stri('SetBorderColor').as(:command_key) >> space? >> color_spec.as(:color).as(:command_argument) }
+      rule(:command_set_text_color) { stri('SetTextColor').as(:command_key) >> space? >> color_spec.as(:color).as(:command_argument) }
+      rule(:command_set_bg_color) { stri('SetBackgroundColor').as(:command_key) >> space? >> color_spec.as(:color).as(:command_argument) }
+      rule(:command_play_alert_sound) { stri('PlayAlertSound').as(:command_key) >> space? >> sound_spec.as(:command_argument) }
+      rule(:command_play_alert_sound_positional) { stri('PlayAlertSoundPositional').as(:command_key) >> space? >> sound_spec.as(:command_argument) }
+      rule(:command_set_font_size) { stri('SetFontSize').as(:command_key) >> space? >> integer.as(:font_size).as(:command_argument) }
+
+      rule(:command_clause) {
+        (
+          (stri('Show').as(:command_key) >> space?) |
+          (stri('Hide').as(:command_key) >> space?) |
+          command_set_border_color |
+          command_set_text_color |
+          command_set_bg_color |
+          command_play_alert_sound |
+          command_play_alert_sound_positional |
+          command_set_font_size
+        )
+      }
+
+      rule(:match_alternation) {
+        ((match_clause >> comma).repeat(0) >> match_clause).as(:match_clauses)
+      }
+
+      rule(:clause) {
+        ((match_alternation >> pipe).repeat(0) >> match_alternation).as(:match_alternations) >> open_brace >>
+          (command_clause | clause).repeat(1).as(:inner_clauses) >> close_brace
+      }
+      rule(:clauses) { clause.repeat(0) }
+      root(:clauses)
+    end
+
+    class Transformer < Parslet::Transform
+      rule(integer: simple(:i)) { Integer(i) }
+      rule(operator: simple(:o)) { o.to_s }
+      rule(rarity: simple(:o)) { o.to_s }
+      rule(string: simple(:s)) { s.to_s }
+      rule(strings: sequence(:s)) { s }
+      rule(boolean: simple(:b)) { b.to_s.downcase == 'true'.downcase }
+      rule(sockets: simple(:g)) { g.to_s.upcase }
+      rule(rgb: { r: simple(:r), g: simple(:g), b: simple(:b), a: simple(:a) }) { RGBColorSpec.new(r, g, b, a) }
+      rule(rgb: { r: simple(:r), g: simple(:g), b: simple(:b) }) { RGBColorSpec.new(r, g, b, nil) }
+
+      rule(sub_socket_groups: sequence(:groups)) {
+        { sub_socket_groups: groups.map(&:upcase) }
+      }
+
+      rule(match_key: simple(:k), match_arguments: subtree(:a)) { MatchClause.new(k.to_s.downcase, a) }
+      rule(command_key: simple(:k), command_argument: subtree(:a)) { CommandClause.new(k.to_s.downcase, a) }
+      rule(command_key: simple(:k)) { CommandClause.new(k.to_s.downcase, nil) }
+      rule(match_alternations: subtree(:alternations), inner_clauses: subtree(:inner_clauses)) {
+        Clause.new([ alternations ].flatten.map { |match_clauses| [ match_clauses[:match_clauses] ].flatten }, inner_clauses)
+      }
+    end
+  end
+end

data/lib/poe-css/preprocessor.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module POECSS
+  module Preprocessor
+    IDENTIFIER_CHAR_REGEX = '[0-9a-zA-Z\-_]'
+
+    class DefinitionParser < Parslet::Parser
+      rule(:newline) { str("\n").repeat(1) }
+      rule(:space) { match('\s').repeat(1) }
+      rule(:space?) { space.maybe }
+      rule(:comma) { str(',') >> space? }
+      rule(:open_brace) { str('{') >> space? }
+      rule(:close_brace) { str('}') >> space? }
+      rule(:open_paren) { str('(') >> space? }
+      rule(:close_paren) { str(')') >> space? }
+
+      rule(:identifier) { str('@') >> match(IDENTIFIER_CHAR_REGEX.to_s).repeat >> space? }
+
+      rule(:macro_prototype) {
+        (
+          identifier.as(:macro_name) >> open_paren >>
+            ((identifier.as(:argument) >> comma).repeat >> identifier.as(:argument)).repeat(0, 1).as(:argument_list) >>
+          close_paren
+        ).as(:macro_prototype)
+      }
+      rule(:block_in_macro) { open_brace >> (block_in_macro | match('[^{}]')).repeat(0) >> close_brace }
+      rule(:macro_definition) { (macro_prototype >> block_in_macro.as(:macro_replacement)).as(:macro) }
+
+      rule(:constant_definition) {
+        (identifier.as(:identifier) >> str(':') >> space? >> match('[^\n]').repeat(1).as(:replacement)).as(:constant_definition)
+      }
+
+      rule(:non_newline_char) { match('[^\n]') }
+      rule(:nonmacro_line) { (non_newline_char.repeat(0) >> newline | non_newline_char.repeat(1)) }
+      rule(:program) {
+        (match('\s').repeat(0) >> (constant_definition | macro_definition | nonmacro_line.as(:nonmacro_line))).repeat(0)
+      }
+
+      root(:program)
+    end
+
+    ConstantDefinition = Struct.new(:identifier, :replacement)
+    ArgumentList = Struct.new(:arguments)
+    MacroDefinition = Struct.new(:identifier, :argument_list, :replacement)
+
+    class DefinitionTransformer < Parslet::Transform
+      rule(nonmacro_line: simple(:l)) { l.to_s }
+
+      rule(constant_definition: { identifier: simple(:i), replacement: simple(:r) }) { ConstantDefinition.new(i.to_s, r.to_s) }
+      rule(argument: simple(:a)) { a.to_s }
+      rule(macro: {
+        macro_prototype: {
+          macro_name: simple(:name),
+          argument_list: sequence(:args)
+        },
+        macro_replacement: simple(:r)
+      }) { MacroDefinition.new(name.to_s, ArgumentList.new(args), r.to_s.strip[1..-2]) }
+    end
+
+    class << self
+      def compile(input)
+        stripped_input = input.strip
+        return '' if stripped_input.empty?
+
+        r = parse_definition(stripped_input)
+        tree = DefinitionTransformer.new.apply(r)
+
+        constants = tree.select { |n| n.is_a?(ConstantDefinition) }
+        macros = tree.select { |n| n.is_a?(MacroDefinition) }
+        strings = tree.select { |n| n.is_a?(String) }
+
+        constants_by_id =
+          begin
+            grouping = constants.group_by(&:identifier)
+            if (id, = grouping.find { |_, defs| defs.length > 1 })
+              raise ArgumentError, "Multiple definitions of #{id} found."
+            end
+
+            grouping.transform_values(&:first).to_h
+          end
+
+        macros_by_id =
+          begin
+            grouping = macros.group_by(&:identifier)
+            if (id, = grouping.find { |_, defs| defs.length > 1 })
+              raise ArgumentError, "Multiple definitions of #{id} found."
+            end
+
+            grouping.transform_values(&:first).to_h
+          end
+
+        interpolate_macros(constants_by_id, macros_by_id, strings.join(''))
+      end
+
+      private
+
+      def parse_definition(input)
+        DefinitionParser.new.parse(input, reporter: Parslet::ErrorReporter::Deepest.new)
+      rescue Parslet::ParseFailed => error
+        raise ParseError.new(:preprocessor, error.parse_failure_cause)
+      end
+
+      class UsageParser < Parslet::Parser
+        rule(:comma) { str(',') }
+        rule(:open_paren) { str('(') }
+        rule(:close_paren) { str(')') }
+
+        rule(:identifier) { str('@') >> match(IDENTIFIER_CHAR_REGEX.to_s).repeat(1) }
+
+        rule(:argument) { match('[^,)]').repeat(1).as(:argument) }
+        rule(:macro_use) {
+          identifier.as(:macro_name) >> open_paren >>
+            ((argument >> comma).repeat >> argument).repeat(0, 1).as(:argument_list) >>
+            close_paren
+        }
+
+        rule(:program) {
+          (macro_use.as(:macro_use) | identifier.as(:constant_use) | match('.').as(:text)).repeat(0)
+        }
+
+        root(:program)
+      end
+
+      def interpolate_macros(constants_by_id, macros_by_id, input)
+        this = self
+
+        transform = Parslet::Transform.new do
+          rule(text: simple(:s)) { s.to_s }
+          rule(constant_use: simple(:s)) {
+            identifier = s.to_s.strip
+            constant = constants_by_id[identifier]
+            raise ArgumentError, "Unknown constant #{identifier}." unless constant
+            constant.replacement
+          }
+
+          rule(argument: simple(:a)) { a.to_s.strip }
+          rule(
+            macro_use: {
+              macro_name: simple(:name),
+              argument_list: sequence(:args)
+            }
+          ) {
+            identifier = name.to_s.strip
+            macro = macros_by_id[identifier]
+            raise ArgumentError, "Unknown macro #{identifier}." unless macro
+            if macro.argument_list.arguments.length != args.length
+              raise ArgumentError, "Got #{args.length} arguments to a #{macro.argument_list.arguments.length}-argument macro."
+            end
+
+            argument_bindings = macro.argument_list.arguments.zip(args)
+              .map { |argument_name, value| [ argument_name, ConstantDefinition.new(argument_name, value) ] }
+              .to_h
+            this.send(
+              :interpolate_macros,
+              constants_by_id.merge(argument_bindings),
+              macros_by_id,
+              macro.replacement
+            )
+          }
+        end
+
+        string = input
+
+        loop do
+          tree =
+            begin
+              UsageParser.new.parse(string, reporter: Parslet::ErrorReporter::Deepest.new)
+            rescue Parslet::ParseFailed => error
+              warn error.parse_failure_cause.ascii_tree
+              raise
+            end
+
+          new_string = transform.apply(tree).join('')
+
+          if new_string == string
+            break
+          end
+
+          string = new_string
+        end
+
+        string
+      end
+    end
+  end
+end