bcdice 3.0.0.pre.alpha.2 → 3.0.0.pre.rc.1

data/lib/bcdice/command_parser.rb

@@ -1,242 +0,0 @@
-require "bcdice/arithmetic_evaluator"
-require "bcdice/normalize"
-require "bcdice/format"
-
-module BCDice
-  # よくある形式のコマンドのパースを補助するクラス
-  #
-  # @example Literal by String
-  #   parser = CommandParser.new("MC")
-  #   parsed = parser.parse("MC+2*3@30<=10/2-3") #=> <CommandParser::Parsed>
-  #
-  #   parsed.command #=> "MC"
-  #   parsed.modify_number #=> 6
-  #   parsed.critical #=> 30
-  #   parsed.cmp_op #=> #>=
-  #   parsed.target_number #=> 2
-  #
-  # @example Literal by Regexp
-  #   parser = CommandParser.new(/^RE\d+$/)
-  #   parsed = parser.parse("RE44+20") #=> <CommandParser::Parsed>
-  #
-  #   parsed.command #=> "RE44"
-  #   parsed.modify_number #=> 20
-  class CommandParser < ArithmeticEvaluator
-    # @param literals [Array<String, Regexp>]
-    def initialize(*literals)
-      @literals = literals
-      @round_type = RoundType::FLOOR
-      @allowed_cmp_op = nil
-
-      @enabled_question_target = false
-    end
-
-    # パース結果
-    class Parsed
-      # @return [String]
-      attr_accessor :command
-
-      # @return [Integer, nil]
-      attr_accessor :critical
-
-      # @return [Integer, nil]
-      attr_accessor :fumble
-
-      # @return [Integer, nil]
-      attr_accessor :dollar
-
-      # @return [Integer]
-      attr_accessor :modify_number
-
-      # @return [Symbol, nil]
-      attr_accessor :cmp_op
-
-      # @return [Integer, nil]
-      attr_accessor :target_number
-
-      # @param value [Boolean]
-      # @return [Boolean]
-      attr_writer :question_target
-
-      def initialize
-        @critical = nil
-        @fumble = nil
-        @dollar = nil
-        @cmp_op = nil
-        @target_number = nil
-        @question_target = false
-      end
-
-      # @return [Boolean]
-      def question_target?
-        @question_target
-      end
-
-      # @param suffix_position [Symbol] クリティカルなどの表示位置
-      # @return [String]
-      def to_s(suffix_position = :after_command)
-        c = @critical ? "@#{@critical}" : nil
-        f = @fumble ? "##{@fumble}" : nil
-        d = @dollar ? "$#{@dollar}" : nil
-        m = Format.modifier(@modify_number)
-        target = @question_target ? "?" : @target_number
-
-        case suffix_position
-        when :after_command
-          [@command, c, f, d, m, @cmp_op, target].join()
-        when :after_modify_number
-          [@command, m, c, f, d, @cmp_op, target].join()
-        when :after_target_number
-          [@command, m, @cmp_op, target, c, f, d].join()
-        end
-      end
-    end
-
-    # 特定の比較演算子のみ許可するようにする。
-    # 比較演算子なしを許可する場合には nil を指定してください。
-    #
-    # @param cmp_op [Array<Symbol, nil>] 許可する比較演算子の一覧
-    # @return [self]
-    def allow_cmp_op(*cmp_op)
-      @allowed_cmp_op = cmp_op
-      self
-    end
-
-    # 目標値 "?" を許容する
-    #
-    # @return [self]
-    def enable_question_target
-      @enabled_question_target = true
-      self
-    end
-
-    # 式をパースする
-    #
-    # @param expr [String]
-    # @param round_type [Symbol]
-    # @return [CommandParser::Parsed, nil]
-    def parse(expr, round_type = RoundType::FLOOR)
-      @tokens = tokenize(expr)
-      @idx = 0
-      @error = false
-      @round_type = round_type
-
-      @parsed = Parsed.new()
-
-      lhs()
-      if @error
-        return nil
-      end
-
-      @parsed.cmp_op = take_cmp_op()
-      rhs() if @parsed.cmp_op
-
-      if @idx < @tokens.size || @error
-        return nil
-      end
-
-      return @parsed
-    end
-
-    private
-
-    # @return [Array<String>]
-    def tokenize(expr)
-      expr.gsub(%r{[\(\)\+\-*/@#\$]|[<>!=]+}) { |e| " #{e} " }.split(" ")
-    end
-
-    def lhs
-      command = take()
-      unless literal?(command)
-        @error = true
-        return
-      end
-
-      command_suffix()
-
-      ret = 0
-      loop do
-        if consume("+")
-          ret += mul()
-        elsif consume("-")
-          ret -= mul()
-        else
-          break
-        end
-      end
-
-      command_suffix()
-
-      @parsed.command = command
-      @parsed.modify_number = ret
-    end
-
-    def command_suffix
-      loop do
-        if consume("@")
-          if @parsed.critical
-            @error = true
-          end
-          @parsed.critical = unary()
-        elsif consume("#")
-          if @parsed.fumble
-            @error = true
-          end
-          @parsed.fumble = unary()
-        elsif consume("$")
-          if @parsed.dollar
-            @error = true
-          end
-          @parsed.dollar = unary()
-        else
-          break
-        end
-      end
-    end
-
-    def rhs
-      if @enabled_question_target && consume("?")
-        @parsed.question_target = true
-        @parsed.target_number = 0
-      else
-        @parsed.question_target = false
-        @parsed.target_number = expr()
-      end
-    end
-
-    def literal?(command)
-      @literals.each do |lit|
-        case lit
-        when String
-          return true if command == lit
-        when Regexp
-          return true if command =~ lit
-        end
-      end
-
-      return false
-    end
-
-    def take
-      ret = @tokens[@idx]
-      @idx += 1
-
-      return ret
-    end
-
-    def take_cmp_op
-      cmp_op = Normalize.comparison_operator(take())
-      @error ||= denied_cmp_op?(cmp_op)
-
-      return cmp_op
-    end
-
-    def denied_cmp_op?(cmp_op)
-      if @allowed_cmp_op.nil?
-        false
-      else
-        !@allowed_cmp_op.include?(cmp_op)
-      end
-    end
-  end
-end

data/lib/bcdice/common_command/add_dice/parser.y

@@ -1,153 +0,0 @@
-class BCDice::CommonCommand::AddDice::Parser
-token NUMBER CMP_OP S D K H L U R PLUS MINUS ASTERISK SLASH PARENL PARENR QUESTION
-
-rule
-  command: secret add
-         {
-           secret, lhs = val
-           raise ParseError unless lhs.include_dice?
-
-           result = Node::Command.new(secret, lhs)
-         }
-         | secret add CMP_OP target
-         {
-           secret, lhs, cmp_op, rhs = val
-           raise ParseError if !lhs.include_dice? || rhs.include_dice? || cmp_op.nil?
-
-           result = Node::Command.new(secret, lhs, cmp_op, rhs)
-         }
-
-  secret: /* none */
-        { result = false }
-        | S
-        { result = true }
-
-  target: add
-        | QUESTION
-        { result = Node::UndecidedTarget.instance }
-
-  add: add PLUS mul
-     {
-      lhs = val[0]
-      op, rhs = expand_negate(:+, val[2])
-      result = Node::BinaryOp.new(lhs, op, rhs)
-     }
-     | add MINUS mul
-     {
-      lhs = val[0]
-      op, rhs = expand_negate(:-, val[2])
-      result = Node::BinaryOp.new(lhs, op, rhs)
-     }
-     | mul
-
-  mul: mul ASTERISK unary
-     {
-      lhs = val[0]
-      rhs = val[2]
-      result = Node::BinaryOp.new(lhs, :*, rhs)
-     }
-     | mul SLASH unary round_type
-     {
-       lhs = val[0]
-       rhs = val[2]
-       divied_class = val[3]
-       result = divied_class.new(lhs, rhs)
-     }
-     | unary
-
-  round_type: /* none */
-            { result = Node::DivideWithRoundingDown }
-            | U
-            { result = Node::DivideWithRoundingUp }
-            | R
-            { result = Node::DivideWithRoundingOff }
-
-  unary: PLUS unary
-       { result = val[1] }
-       | MINUS unary
-       {
-         body = val[1]
-         result = body.is_a?(Node::Negate) ? body.body : Node::Negate.new(body)
-       }
-       | dice
-
-  dice: term D term
-      {
-        times = val[0]
-        sides = val[2]
-        raise ParseError if times.include_dice? || sides.include_dice?
-
-        result = Node::DiceRoll.new(times, sides)
-      }
-      | term D
-      {
-        times = val[0]
-        sides = Node::Number.new(6)
-        raise ParseError if times.include_dice?
-
-        result = Node::DiceRoll.new(times, sides)
-      }
-      | term D term filter_type term
-      {
-        times = val[0]
-        sides = val[2]
-        filter = val[3]
-        n_filtering = val[4]
-        raise ParseError if times.include_dice? || sides.include_dice? || n_filtering.include_dice?
-
-        result = Node::DiceRollWithFilter.new(times, sides, n_filtering, filter)
-      }
-      | term
-
-  filter_type: K H
-             { result = Node::DiceRollWithFilter::KEEP_HIGHEST }
-             | K L
-             { result = Node::DiceRollWithFilter::KEEP_LOWEST }
-             | D H
-             { result = Node::DiceRollWithFilter::DROP_HIGHEST }
-             | D L
-             { result = Node::DiceRollWithFilter::DROP_LOWEST }
-
-  term: PARENL add PARENR
-      { result = Node::Parenthesis.new(val[1]) }
-      | NUMBER
-      { result = Node::Number.new(val[0]) }
-end
-
----- header
-
-require "bcdice/common_command/lexer"
-require "bcdice/common_command/add_dice/node"
-
----- inner
-
-def self.parse(source)
-  new.parse(source)
-end
-
-def parse(source)
-  @lexer = Lexer.new(source)
-  do_parse()
-rescue ParseError
-  nil
-end
-
-private
-
-def next_token
-  @lexer.next_token
-end
-
-# 加減算の右辺が負数である場合に加減算を逆転させる
-def expand_negate(op, rhs)
-  if rhs.is_a?(Node::Negate)
-    if op == :+
-      return [:-, rhs.body]
-    elsif op == :-
-      return [:+, rhs.body]
-    end
-  end
-
-  [op, rhs]
-end
-

data/lib/bcdice/common_command/barabara_dice/parser.y

@@ -1,107 +0,0 @@
-class BCDice::CommonCommand::BarabaraDice::Parser
-  token NUMBER B R U C F S PLUS MINUS ASTERISK SLASH PARENL PARENR BRACKETL BRACKETR LESS GREATER EQUAL NOT AT CMP_OP
-
-  rule
-    expr: secret notations target
-        {
-          result = Node::Command.new(
-            secret: val[0],
-            notations: val[1],
-            cmp_op: val[2][:cmp_op],
-            target_number: val[2][:target]
-          )
-        }
-
-    secret: /* none */
-          { result = false }
-          | S
-          { result = true }
-
-    target: /* none */
-          { result = {} }
-          | CMP_OP add
-          {
-            cmp_op, target = val
-            raise ParseError unless cmp_op
-
-            result = {cmp_op: cmp_op, target: target}
-          }
-
-    notations: notations PLUS dice
-             {
-               notations = val[0]
-               notations.push(val[2])
-               result = notations
-             }
-             | dice
-             { result = [val[0]] }
-
-    dice: term B term
-        {
-          times = val[0]
-          sides = val[2]
-          result = Node::Notation.new(times, sides)
-        }
-
-    add: add PLUS mul
-       { result = Arithmetic::Node::BinaryOp.new(val[0], :+, val[2]) }
-       | add MINUS mul
-       { result = Arithmetic::Node::BinaryOp.new(val[0], :-, val[2]) }
-       | mul
-
-    mul: mul ASTERISK unary
-       { result = Arithmetic::Node::BinaryOp.new(val[0], :*, val[2]) }
-       | mul SLASH unary round_type
-       {
-         divied_class = val[3]
-         result = divied_class.new(val[0], val[2])
-       }
-       | unary
-
-    round_type: /* none */
-              { result = Arithmetic::Node::DivideWithGameSystemDefault }
-              | U
-              { result = Arithmetic::Node::DivideWithCeil }
-              | C
-              { result = Arithmetic::Node::DivideWithCeil }
-              | R
-              { result = Arithmetic::Node::DivideWithRound }
-              | F
-              { result = Arithmetic::Node::DivideWithFloor }
-
-    unary: PLUS unary
-         { result = val[1] }
-         | MINUS unary
-         { result = Arithmetic::Node::Negative.new(val[1]) }
-         | term
-
-    term: PARENL add PARENR
-        { result = val[1] }
-        | NUMBER
-        { result = Arithmetic::Node::Number.new(val[0]) }
-end
-
----- header
-
-require "bcdice/common_command/lexer"
-require "bcdice/common_command/reroll_dice/node"
-require "bcdice/arithmetic/node"
-
----- inner
-
-def self.parse(source)
-  new.parse(source)
-end
-
-def parse(source)
-  @lexer = Lexer.new(source)
-  do_parse()
-rescue ParseError
-  nil
-end
-
-private
-
-def next_token
-  @lexer.next_token
-end