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

data/lib/bcdice/arithmetic_evaluator.rb

@@ -1,167 +1,16 @@
 module BCDice
-  #
-  # 四則演算を評価するクラス
-  #
-  class ArithmeticEvaluator
+  module ArithmeticEvaluator
     class << self
       # 四則演算を評価する
-      # @param expr [String] 評価する式
+      # @deprecated +Arithmetic.#eval+ を利用してください。
+      # @param expr [String, nil] 評価する式
       # @param round_type [Symbol] 端数処理の種類
       # @return [Integer] 評価結果を返す。不正な式の場合には0を返す。
       def eval(expr, round_type: RoundType::FLOOR)
-        ArithmeticEvaluator.new(expr, round_type: round_type).eval()
-      end
-    end
-
-    # @param [String, nil] expr 評価する式
-    # @param [Symbol] round_type 端数処理の種類
-    def initialize(expr, round_type: RoundType::FLOOR)
-      @expr = expr
-      @round_type = round_type
-
-      @error = false
-    end
-
-    # @return [Boolean] 式の評価時にエラーが発生したか
-    def error?
-      @error
-    end
-
-    # 四則演算を評価する
-    # 同一インスタンスでevalを二回以上実行した場合の挙動は未定義とする
-    #
-    # @return [Integer] 評価結果を返す。不正な式の場合には0を返す。
-    def eval
-      if @expr.nil?
-        return 0
-      end
-
-      unless @expr.is_a?(String)
-        raise TypeError, "expr must be String, not #{@expr.class}"
-      end
-
-      @tokens = tokenize(@expr)
-      @idx = 0
-      @error = false
-
-      ret = expr()
-      if @error
-        return 0
-      else
-        return ret
-      end
-    end
-
-    private
-
-    def tokenize(expr)
-      expr.gsub(%r{[\(\)\+\-\*/]}) { |e| " #{e} " }.split(" ")
-    end
-
-    def add
-      ret = mul()
-
-      loop do
-        if consume("+")
-          ret += mul()
-        elsif consume("-")
-          ret -= mul()
-        else
-          break
-        end
-      end
-
-      return ret
-    end
-    alias expr add
-
-    def mul
-      ret = unary()
-
-      loop do
-        if consume("*")
-          ret *= unary()
-        elsif consume("/")
-          ret = div(ret, unary())
-        else
-          break
-        end
-      end
-
-      return ret
-    end
+        return 0 unless expr
 
-    def div(left, right)
-      if right.zero?
-        @error = true
-        return 0
+        Arithmetic.eval(expr, round_type) || 0
       end
-
-      case @round_type
-      when RoundType::CEIL
-        return (left.to_f / right).ceil
-      when RoundType::ROUND
-        return (left.to_f / right).round
-      when RoundType::FLOOR
-        return left / right
-      else
-        raise ArgumentError, "unknown round type: #{@round_type.inspect}"
-      end
-    end
-
-    def unary
-      if consume("+")
-        unary()
-      elsif consume("-")
-        -unary()
-      else
-        term()
-      end
-    end
-
-    def term
-      if consume("(")
-        ret = expr()
-        expect(")")
-        return ret
-      else
-        return expect_number()
-      end
-    end
-
-    def consume(str)
-      if @tokens[@idx] != str
-        return false
-      end
-
-      @idx += 1
-      return true
-    end
-
-    def expect(str)
-      if @tokens[@idx] != str
-        @error = true
-      end
-
-      @idx += 1
-    end
-
-    def expect_number()
-      unless integer?(@tokens[@idx])
-        @error = true
-        @idx += 1
-        return 0
-      end
-
-      ret = @tokens[@idx].to_i
-      @idx += 1
-      return ret
-    end
-
-    def integer?(str)
-      # Ruby 1.9 以降では Kernel.#Integer を使うべき
-      # Ruby 1.8 にもあるが、基数を指定できない問題がある
-      !/^\d+$/.match(str).nil?
     end
   end
 end

data/lib/bcdice/base.rb

@@ -7,7 +7,7 @@ require "bcdice/dice_table"
 require "bcdice/enum"
 require "bcdice/translate"
 require "bcdice/result"
-require "bcdice/command_parser"
+require "bcdice/command/parser"
 require "bcdice/deprecated/checker"
 
 module BCDice
@@ -83,6 +83,8 @@ module BCDice
 
       @round_type = RoundType::FLOOR # 割り算をした時の端数の扱い (FLOOR: 切り捨て, CEIL: 切り上げ, ROUND: 四捨五入)
 
+      @sides_implicit_d = 6 # 1D のようにダイスの面数が指定されていない場合に何面ダイスにするか
+
       @upper_dice_reroll_threshold = nil # UpperDiceで振り足しをする出目の閾値 nilの場合デフォルト設定なし
       @reroll_dice_reroll_threshold = nil # RerollDiceで振り足しをする出目の閾値 nilの場合デフォルト設定なし
 
@@ -109,6 +111,11 @@ module BCDice
     # @return [Symbol]
     attr_reader :round_type
 
+    # ダイスの面数が指定されていない場合に何面ダイスにするか
+    #
+    # @return [Integer]
+    attr_reader :sides_implicit_d
+
     # UpperDiceで振り足しをする出目の閾値
     #
     # @return [Integer, nil]

data/lib/bcdice/command/lexer.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "strscan"
+require "bcdice/normalize"
+
+module BCDice
+  module Command
+    class Lexer
+      SYMBOLS = {
+        "+" => :PLUS,
+        "-" => :MINUS,
+        "*" => :ASTERISK,
+        "/" => :SLASH,
+        "(" => :PARENL,
+        ")" => :PARENR,
+        "?" => :QUESTION,
+        "@" => :AT,
+        "#" => :SHARP,
+        "$" => :DOLLAR,
+      }.freeze
+
+      def initialize(source, notations)
+        # sourceが空文字だとString#splitが空になる
+        source = source&.split(" ", 2)&.first || ""
+        @scanner = StringScanner.new(source)
+        @notations = notations.map do |n|
+          n.is_a?(String) ? Regexp.new(n) : n
+        end
+      end
+
+      def next_token
+        return [false, "$"] if @scanner.eos?
+
+        @notations.each do |n|
+          token = @scanner.scan(n)
+          return [:NOTATION, token] if token
+        end
+
+        if (number = @scanner.scan(/\d+/))
+          [:NUMBER, number.to_i]
+        elsif (cmp_op = @scanner.scan(/[<>!=]+/))
+          cmp_op = Normalize.comparison_operator(cmp_op)
+          type = cmp_op ? :CMP_OP : :ILLEGAL
+          [type, cmp_op]
+        else
+          char = @scanner.getch.upcase
+          type = SYMBOLS[char] || char.to_sym
+          [type, char]
+        end
+      end
+
+      def source
+        @scanner.string
+      end
+    end
+  end
+end

data/lib/bcdice/command/parsed.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module BCDice
+  module Command
+    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
+  end
+end

data/lib/bcdice/command/parser.rb

@@ -0,0 +1,489 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.5.1
+# from Racc grammar file "".
+#
+
+require 'racc/parser.rb'
+
+
+require "bcdice/arithmetic/node"
+require "bcdice/command/lexer"
+require "bcdice/command/parsed"
+
+# よくある形式のコマンドのパースを補助するクラス
+#
+# @example Literal by String
+#   parser = Command::Parser.new("MC", round_type: BCDice::RoundType::FLOOR)
+#                           .enable_critical
+#   parsed = parser.parse("MC+2*3@30<=10/2-3") #=> <Command::Parsed>
+#
+#   parsed.command #=> "MC"
+#   parsed.modify_number #=> 6
+#   parsed.critical #=> 30
+#   parsed.cmp_op #=> #>=
+#   parsed.target_number #=> 2
+#
+# @example Literal by Regexp
+#   parser = Command::Parser.new(/RE\d+/)
+#   parsed = parser.parse("RE44+20") #=> <Command::Parsed>
+#
+#   parsed.command #=> "RE44"
+#   parsed.modify_number #=> 20
+class BCDice::Command::Parser < Racc::Parser; end
+
+module BCDice
+  module Command
+    class Parser < Racc::Parser
+
+
+def initialize(*notations, round_type:)
+  super()
+  @notations = notations
+  @round_type = round_type
+  @modifier = true
+  @critical = false
+  @fumble = false
+  @dollar = false
+  @allowed_cmp_op = [nil, :>=, :>, :<=, :<, :==, :!=]
+  @question_target = false
+end
+
+# 修正値は受け付けないようにする
+# @return [BCDice::Command::Parser]
+def disable_modifier
+  @modifier = false
+  self
+end
+
+# +@+によるクリティカル値の指定を許可する
+# @return [BCDice::Command::Parser]
+def enable_critical
+  @critical = true
+  self
+end
+
+# +#+によるファンブル値の指定を許可する
+# @return [BCDice::Command::Parser]
+def enable_fumble
+  @fumble = true
+  self
+end
+
+# +$+による値の指定を許可する
+# @return [BCDice::Command::Parser]
+def enable_dollar
+  @dollar = true
+  self
+end
+
+# 使用できる比較演算子を制限する。
+# 目標値未入力を許可する場合には+nil+を指定する。
+# @param ops [Array<nil, Symbol>] 許可する比較演算子の一覧
+# @return [BCDice::Command::Parser]
+def restrict_cmp_op_to(*ops)
+  @allowed_cmp_op = ops
+  self
+end
+
+# 目標値"?"の指定を許可する
+# @return [BCDice::Command::Parser]
+def enable_question_target
+  @question_target = true
+  self
+end
+
+# @param source [String]
+# @return [BCDice::Command::Parsed, nil]
+def parse(source)
+  @lexer = Lexer.new(source, @notations)
+  do_parse()
+rescue ParseError, ZeroDivisionError
+  nil
+end
+
+private
+
+def parsed(notation, option, modifier, target)
+  Parsed.new.tap do |p|
+    p.command = notation
+    p.critical = option[:critical]&.eval(@round_type)
+    p.fumble = option[:fumble]&.eval(@round_type)
+    p.dollar = option[:dollar]&.eval(@round_type)
+    p.modify_number = modifier.eval(@round_type)
+    p.cmp_op = target[:cmp_op]
+    if target[:target] == "?"
+      p.question_target = true
+      p.target_number = 0
+    else
+      p.question_target = false
+      p.target_number = target[:target]&.eval(@round_type)
+    end
+  end
+end
+
+def next_token
+  @lexer.next_token
+end
+##### State transition tables begin ###
+
+racc_action_table = [
+    24,     6,     7,    16,    17,    20,    21,    16,    17,    23,
+     6,     7,    14,    36,    37,    31,    11,    12,    13,    14,
+    24,     2,    24,    36,    37,    20,    21,    20,    21,    23,
+    24,    23,    24,    41,    42,    20,    21,    20,    21,    23,
+    24,    23,    24,    36,    37,    20,    21,    20,    21,    23,
+    24,    23,    24,    36,    37,    20,    21,    20,    21,    23,
+    24,    23,    24,    36,    37,    20,    21,    20,    21,    23,
+    24,    23,    24,    36,    37,    20,    21,    20,    21,    23,
+    24,    23,    24,    36,    37,    20,    21,    20,    21,    23,
+     3,    23,    41,    42,     8,   nil,   nil,    45,    11,    12,
+    13,    14,    51,    49,    50,    52 ]
+
+racc_action_check = [
+    14,     2,     2,     9,     9,    14,    14,     5,     5,    14,
+     4,     4,     9,    18,    18,    14,     4,     4,     4,     4,
+     6,     0,     7,    25,    25,     6,     6,     7,     7,     6,
+    11,     7,    12,    30,    30,    11,    11,    12,    12,    11,
+    13,    12,    16,    32,    32,    13,    13,    16,    16,    13,
+    17,    16,    20,    34,    34,    17,    17,    20,    20,    17,
+    21,    20,    23,    35,    35,    21,    21,    23,    23,    21,
+    36,    23,    37,    46,    46,    36,    36,    37,    37,    36,
+    41,    37,    42,    47,    47,    41,    41,    42,    42,    41,
+     1,    42,    40,    40,     3,   nil,   nil,    40,    15,    15,
+    15,    15,    44,    44,    44,    44 ]
+
+racc_action_pointer = [
+     3,    90,    -6,    94,     3,     0,    18,    20,   nil,    -4,
+   nil,    28,    30,    38,    -2,    85,    40,    48,     4,   nil,
+    50,    58,   nil,    60,   nil,    14,   nil,   nil,   nil,   nil,
+    26,   nil,    34,   nil,    44,    54,    68,    70,   nil,   nil,
+    85,    78,    80,   nil,    99,   nil,    64,    74,   nil,   nil,
+   nil,   nil,   nil ]
+
+racc_action_default = [
+   -31,   -31,    -4,   -31,   -12,    -4,   -31,   -31,    53,   -12,
+    -3,   -31,   -31,   -31,   -31,   -12,   -31,   -31,    -8,   -20,
+   -31,   -31,   -28,   -31,   -30,    -9,    -1,    -5,    -6,    -7,
+   -13,   -14,   -17,    -2,   -10,   -11,   -31,   -31,   -26,   -27,
+   -31,   -31,   -31,   -18,   -21,   -29,   -15,   -16,   -19,   -22,
+   -23,   -24,   -25 ]
+
+racc_goto_table = [
+    18,    25,     1,    27,    28,    29,    30,    48,   nil,    10,
+    34,    35,    38,    39,    26,    40,     4,   nil,   nil,    15,
+    33,     5,   nil,     9,   nil,   nil,   nil,   nil,    43,    44,
+   nil,   nil,   nil,   nil,   nil,    46,    47 ]
+
+racc_goto_check = [
+     6,     6,     1,     5,     5,     5,     7,     8,   nil,     4,
+     6,     6,     5,     5,     4,     7,     2,   nil,   nil,     2,
+     4,     3,   nil,     3,   nil,   nil,   nil,   nil,     5,     5,
+   nil,   nil,   nil,   nil,   nil,     6,     6 ]
+
+racc_goto_pointer = [
+   nil,     2,    14,    19,     5,    -8,    -6,    -8,   -37,   nil ]
+
+racc_goto_default = [
+   nil,   nil,   nil,   nil,   nil,    19,    32,   nil,   nil,    22 ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  4, 20, :_reduce_1,
+  4, 20, :_reduce_2,
+  3, 20, :_reduce_3,
+  0, 21, :_reduce_4,
+  3, 21, :_reduce_5,
+  3, 21, :_reduce_6,
+  3, 21, :_reduce_7,
+  2, 22, :_reduce_8,
+  2, 22, :_reduce_9,
+  3, 22, :_reduce_10,
+  3, 22, :_reduce_11,
+  0, 23, :_reduce_12,
+  2, 23, :_reduce_13,
+  2, 23, :_reduce_14,
+  3, 26, :_reduce_15,
+  3, 26, :_reduce_16,
+  1, 26, :_reduce_none,
+  3, 25, :_reduce_18,
+  4, 25, :_reduce_19,
+  1, 25, :_reduce_none,
+  0, 27, :_reduce_21,
+  1, 27, :_reduce_22,
+  1, 27, :_reduce_23,
+  1, 27, :_reduce_24,
+  1, 27, :_reduce_25,
+  2, 24, :_reduce_26,
+  2, 24, :_reduce_27,
+  1, 24, :_reduce_none,
+  3, 28, :_reduce_29,
+  1, 28, :_reduce_30 ]
+
+racc_reduce_n = 31
+
+racc_shift_n = 53
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :NUMBER => 2,
+  :R => 3,
+  :U => 4,
+  :C => 5,
+  :F => 6,
+  :PLUS => 7,
+  :MINUS => 8,
+  :ASTERISK => 9,
+  :SLASH => 10,
+  :PARENL => 11,
+  :PARENR => 12,
+  :AT => 13,
+  :SHARP => 14,
+  :DOLLAR => 15,
+  :CMP_OP => 16,
+  :QUESTION => 17,
+  :NOTATION => 18 }
+
+racc_nt_base = 19
+
+racc_use_result_var = true
+
+Racc_arg = [
+  racc_action_table,
+  racc_action_check,
+  racc_action_default,
+  racc_action_pointer,
+  racc_goto_table,
+  racc_goto_check,
+  racc_goto_default,
+  racc_goto_pointer,
+  racc_nt_base,
+  racc_reduce_table,
+  racc_token_table,
+  racc_shift_n,
+  racc_reduce_n,
+  racc_use_result_var ]
+
+Racc_token_to_s_table = [
+  "$end",
+  "error",
+  "NUMBER",
+  "R",
+  "U",
+  "C",
+  "F",
+  "PLUS",
+  "MINUS",
+  "ASTERISK",
+  "SLASH",
+  "PARENL",
+  "PARENR",
+  "AT",
+  "SHARP",
+  "DOLLAR",
+  "CMP_OP",
+  "QUESTION",
+  "NOTATION",
+  "$start",
+  "expr",
+  "option",
+  "modifier",
+  "target",
+  "unary",
+  "mul",
+  "add",
+  "round_type",
+  "term" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+def _reduce_1(val, _values, result)
+          raise ParseError unless @modifier
+          notation, option, modifier, target = val
+          result = parsed(notation, option, modifier, target)
+
+    result
+end
+
+def _reduce_2(val, _values, result)
+          raise ParseError unless @modifier
+          notation, modifier, option, target = val
+          result = parsed(notation, option, modifier, target)
+
+    result
+end
+
+def _reduce_3(val, _values, result)
+          notation, option, target = val
+          result = parsed(notation, option,  Arithmetic::Node::Number.new(0), target)
+
+    result
+end
+
+def _reduce_4(val, _values, result)
+            result = {}
+
+    result
+end
+
+def _reduce_5(val, _values, result)
+            option, _, term = val
+            raise ParseError unless @critical && option[:critical].nil?
+
+            option[:critical] = term
+            result = option
+
+    result
+end
+
+def _reduce_6(val, _values, result)
+            option, _, term = val
+            raise ParseError unless @fumble && option[:fumble].nil?
+
+            option[:fumble] = term
+            result = option
+
+    result
+end
+
+def _reduce_7(val, _values, result)
+            option, _, term = val
+            raise ParseError unless @dollar && option[:dollar].nil?
+
+            option[:dollar] = term
+            result = option
+
+    result
+end
+
+def _reduce_8(val, _values, result)
+ result = val[1]
+    result
+end
+
+def _reduce_9(val, _values, result)
+ result = Arithmetic::Node::Negative.new(val[1])
+    result
+end
+
+def _reduce_10(val, _values, result)
+ result = Arithmetic::Node::BinaryOp.new(val[0], :+, val[2])
+    result
+end
+
+def _reduce_11(val, _values, result)
+ result = Arithmetic::Node::BinaryOp.new(val[0], :-, val[2])
+    result
+end
+
+def _reduce_12(val, _values, result)
+            raise ParseError unless @allowed_cmp_op.include?(nil)
+            result = {}
+
+    result
+end
+
+def _reduce_13(val, _values, result)
+            cmp_op, target = val
+            raise ParseError unless @allowed_cmp_op.include?(cmp_op)
+
+            result = {cmp_op: cmp_op, target: target}
+
+    result
+end
+
+def _reduce_14(val, _values, result)
+            cmp_op = val[0]
+            raise ParseError unless @question_target
+            raise ParseError unless @allowed_cmp_op.include?(cmp_op)
+
+            result = {cmp_op: cmp_op, target: "?"}
+
+    result
+end
+
+def _reduce_15(val, _values, result)
+ result = Arithmetic::Node::BinaryOp.new(val[0], :+, val[2])
+    result
+end
+
+def _reduce_16(val, _values, result)
+ result = Arithmetic::Node::BinaryOp.new(val[0], :-, val[2])
+    result
+end
+
+# reduce 17 omitted
+
+def _reduce_18(val, _values, result)
+ result = Arithmetic::Node::BinaryOp.new(val[0], :*, val[2])
+    result
+end
+
+def _reduce_19(val, _values, result)
+         divied_class = val[3]
+         result = divied_class.new(val[0], val[2])
+
+    result
+end
+
+# reduce 20 omitted
+
+def _reduce_21(val, _values, result)
+ result = Arithmetic::Node::DivideWithGameSystemDefault
+    result
+end
+
+def _reduce_22(val, _values, result)
+ result = Arithmetic::Node::DivideWithCeil
+    result
+end
+
+def _reduce_23(val, _values, result)
+ result = Arithmetic::Node::DivideWithCeil
+    result
+end
+
+def _reduce_24(val, _values, result)
+ result = Arithmetic::Node::DivideWithRound
+    result
+end
+
+def _reduce_25(val, _values, result)
+ result = Arithmetic::Node::DivideWithFloor
+    result
+end
+
+def _reduce_26(val, _values, result)
+ result = val[1]
+    result
+end
+
+def _reduce_27(val, _values, result)
+ result = Arithmetic::Node::Negative.new(val[1])
+    result
+end
+
+# reduce 28 omitted
+
+def _reduce_29(val, _values, result)
+ result = val[1]
+    result
+end
+
+def _reduce_30(val, _values, result)
+ result = Arithmetic::Node::Number.new(val[0])
+    result
+end
+
+def _reduce_none(val, _values, result)
+  val[0]
+end
+
+    end   # class Parser
+  end   # module Command
+end   # module BCDice