diff --git a/lib/unitsml/formula.rb b/lib/unitsml/formula.rb index 957e6a0..4ae16d5 100644 --- a/lib/unitsml/formula.rb +++ b/lib/unitsml/formula.rb @@ -35,9 +35,9 @@ def to_mathml(options = {}) math.ordered = true math.element_order ||= [] value.each { |instance| process_value(math, instance.to_mathml(options)) } - generated_math = math.to_xml.gsub(/&(.*?)(?=<\/)/, '&\1') reset_mml_models if plurimath_available? + generated_math else value.map { |obj| obj.to_mathml(options) } diff --git a/lib/unitsml/intermediate_exp_rules.rb b/lib/unitsml/intermediate_exp_rules.rb index dc64151..d8bbc95 100644 --- a/lib/unitsml/intermediate_exp_rules.rb +++ b/lib/unitsml/intermediate_exp_rules.rb @@ -3,33 +3,62 @@ module IntermediateExpRules include Parslet # Rules for slashed number - rule(:slashed_number_int_exp) { slashed_number | (str("(") >> slashed_number >> str(")")) } + rule(:slashed_number_int_exp) { slashed_number | (opening_paren >> slashed_number >> closing_paren) } # Rules for prefixes_units - rule(:prefixes_units_int_exp) { prefixes_units | (str("(") >> prefixes_units_named_exp.as(:intermediate_exp) >> str(")") >> extended_prefixed_units.maybe) } - rule(:extended_prefixed_units) { extender >> prefixes_units_int_exp.as(:sequence) } - rule(:prefixes_units_named_exp) do - prefixes_units | - ((str("(").as(:open_parenthesis) >> prefixes_units_int_exp.as(:int_exp) >> str(")").as(:close_parenthesis)).as(:intermediate_exp) >> extended_prefixed_units.maybe) + rule(:wrapper_prefixes_units_value) { int_exp_prefixes_units | prefixes_units_int_exp } + + rule(:extended_prefixed_units) { extender >> spaces? >> prefixes_units_int_exp.as(:sequence) } + + rule(:int_exp_prefixes_units) { opening_paren >> spaces? >> named_int_exp_prefixes_units.as(:int_exp) >> spaces? >> closing_paren } + + rule(:implicit_extended) do + prefixes_units.as(:first_set) >> spaces.as(:extender) >> prefixes_units.as(:second_set) | + int_exp_prefixes_units.as(:first_int_exp_set) >> spaces? >> int_exp_prefixes_units.as(:second_int_exp_set) | + prefixes_units.as(:first_set) >> spaces? >> int_exp_prefixes_units.as(:second_int_exp_set) | + int_exp_prefixes_units.as(:first_int_exp_set) >> spaces? >> prefixes_units.as(:second_set) + end + + rule(:prefixes_units_int_exp) do + implicit_extended.as(:implicit_extended) >> spaces? >> prefixes_units_int_exp.as(:sequence).maybe | + implicit_extended.as(:implicit_extended) >> spaces? >> extender >> spaces? >> prefixes_units_int_exp.as(:sequence).maybe | + int_exp_prefixes_units >> spaces? >> extender >> spaces? >> prefixes_units_int_exp.as(:sequence).maybe | + prefixes_units >> spaces? >> extender >> spaces? >> prefixes_units_int_exp.as(:sequence).maybe | + int_exp_prefixes_units >> prefixes_units_int_exp.as(:sequence).maybe | + prefixes_units >> prefixes_units_int_exp.as(:sequence).maybe + end + + rule(:prefixes_units_named_int_exp) do + opening_paren.as(:open_paren) >> spaces? >> wrapper_prefixes_units_value.as(:int_exp) >> spaces? >> closing_paren.as(:close_paren) + end + + rule(:named_int_exp_prefixes_units) do + prefixes_units_named_int_exp.as(:int_exp) >> (prefixes_units_int_exp | extended_prefixed_units).maybe | + prefixes_units_int_exp end # Rules for dimension_rules - rule(:dimension_rules_int_exp) { dimension_rules | (str("(") >> dimension_rules_named_exp.as(:intermediate_exp) >> str(")") >> extended_dimension_rules.maybe) } - rule(:extended_dimension_rules) { extender >> dimension_rules_int_exp.as(:sequence) } + rule(:dimension_rules_int_exp) do + dimension_rules.as(:first_set) >> spaces.as(:extender) >> dimension_rules.as(:second_set) >> dimension_rules_int_exp.maybe | + dimension_rules.as(:first_set) >> spaces? >> int_exp_dimension_rules.as(:second_int_exp_set) >> dimension_rules_int_exp.maybe | + int_exp_dimension_rules.as(:first_int_exp_set) >> spaces? >> dimension_rules.as(:second_set) >> dimension_rules_int_exp.maybe | + int_exp_dimension_rules.as(:first_int_exp_set) >> spaces? >> int_exp_dimension_rules.as(:second_int_exp_set) >> dimension_rules_int_exp.maybe | + int_exp_dimension_rules | + dimension_rules + end + + rule(:int_exp_dimension_rules) { opening_paren >> dimension_rules_named_exp.as(:int_exp) >> closing_paren >> extended_dimension_rules.maybe } + + rule(:extended_dimension_rules) { spaces? >> extender >> spaces? >> dimension_rules_int_exp.as(:sequence) } rule(:dimension_rules_named_exp) do - dimension_rules | - ((str("(").as(:open_parenthesis) >> dimension_rules_int_exp.as(:int_exp) >> str(")").as(:close_parenthesis)).as(:intermediate_exp) >> extended_dimension_rules.maybe) + ((opening_paren.as(:open_paren) >> dimension_rules_int_exp.as(:int_exp) >> closing_paren.as(:close_paren)).as(:int_exp) >> spaces? >> (dimension_rules_int_exp | extended_dimension_rules).as(:sequence).maybe) | + dimension_rules_int_exp end # Rules for dimensions - rule(:sqrt_dimensions) { str("sqrt(") >> dimensions_int_exp.as(:sqrt) >> str(")") } - rule(:powered_dimensions) { dimensions >> power.maybe } - rule(:dimensions_int_exp) { powered_dimensions | (str("(") >> dimensions_named_exp.as(:intermediate_exp) >> str(")")) } - rule(:dimensions_named_exp) { powered_dimensions | (str("(").as(:open_parenthesis) >> dimensions_int_exp.as(:int_exp) >> str(")").as(:close_parenthesis)) } + rule(:sqrt_dimensions) { sqrt >> opening_paren >> dimension_rules_int_exp.as(:sqrt) >> closing_paren } # Rules for sequence - rule(:sqrt_sequence) { str("sqrt(") >> sequence_int_exp.as(:sqrt) >> str(")") } - rule(:sequence_int_exp) { sequence | (str("(") >> sequence_named_exp.as(:intermediate_exp)>> str(")")) } - rule(:sequence_named_exp) { sequence | (str("(").as(:open_parenthesis) >> sequence_int_exp.as(:int_exp) >> str(")").as(:close_parenthesis)) } + rule(:sqrt_sequence) { sqrt >> opening_paren >> prefixes_units_int_exp.as(:sqrt) >> closing_paren } end end diff --git a/lib/unitsml/parse.rb b/lib/unitsml/parse.rb index fe875d7..fce3131 100644 --- a/lib/unitsml/parse.rb +++ b/lib/unitsml/parse.rb @@ -7,49 +7,51 @@ module Unitsml class Parse < Parslet::Parser include IntermediateExpRules - rule(:power) { str("^") >> slashed_number_int_exp } + rule(:sqrt) { str("sqrt") } + rule(:power) { str("^") >> slashed_number_int_exp } rule(:hyphen) { str("-") } rule(:number) { hyphen.maybe >> match(/[0-9]/).repeat(1) } + rule(:spaces) { match(/\s/).repeat(1) } + rule(:spaces?) { spaces.maybe } rule(:extender) { (forward_slashes | str("*")).as(:extender) } rule(:sequence) { single_letter_prefixes >> units | double_letter_prefixes >> units | units } + rule(:opening_paren) { str("(")} + rule(:closing_paren) { str(")")} rule(:unit_and_power) { units >> power.maybe } rule(:slashed_number) { (number >> (forward_slashes >> number).maybe).as(:integer) } rule(:forward_slashes) { str("//") | str("/") } + rule(:dimension_rules) { (sqrt_dimensions | powered_dimensions) >> extended_dimension_rules.maybe } + rule(:powered_dimensions) { dimensions >> power.maybe } rule(:units) do - @@filtered_units ||= arr_to_expression(Unitsdb.units.filtered, "units") + @@filtered_units ||= arr_to_expression(Unitsdb.units.filtered, "unit") end rule(:single_letter_prefixes) do - @@prefixes1 ||= arr_to_expression(Unitsdb.prefixes_by_size(1), "prefixes") + @@prefixes1 ||= arr_to_expression(Unitsdb.prefixes_by_size(1), "prefix") end rule(:double_letter_prefixes) do - @@prefixes2 ||= arr_to_expression(Unitsdb.prefixes_by_size(2), "prefixes") + @@prefixes2 ||= arr_to_expression(Unitsdb.prefixes_by_size(2), "prefix") end rule(:dimensions) do - @@dimensions ||= arr_to_expression(Unitsdb.dimensions.parsables.keys, "dimensions") + @@dimensions ||= arr_to_expression(Unitsdb.dimensions.parsables.keys, "dimension") end rule(:prefixes_units) do (sqrt_sequence >> extended_prefixed_units.maybe) | - (str("1").as(:units) >> extended_prefixed_units.maybe) | + (str("1").as(:unit) >> extended_prefixed_units.maybe) | (unit_and_power >> extended_prefixed_units) | - unit_and_power >> (str(")").present? | any.absent?) | + unit_and_power >> (any.absent? | (extender | opening_paren | closing_paren | spaces).present?) | (double_letter_prefixes >> unit_and_power >> extended_prefixed_units) | (double_letter_prefixes >> unit_and_power) | (single_letter_prefixes >> unit_and_power >> extended_prefixed_units) | (single_letter_prefixes >> unit_and_power) end - rule(:dimension_rules) do - (sqrt_dimensions >> extended_dimension_rules.maybe) | - (powered_dimensions >> extended_dimension_rules.maybe) - end - rule(:expression) do prefixes_units_int_exp | dimension_rules_int_exp | diff --git a/lib/unitsml/prefix.rb b/lib/unitsml/prefix.rb index 0353898..c15b5e1 100644 --- a/lib/unitsml/prefix.rb +++ b/lib/unitsml/prefix.rb @@ -16,7 +16,7 @@ def ==(object) end def prefix_instance - @prefix ||= Unitsdb.prefixes.find_by_symbol_name(prefix_name) + @prefix_instance ||= Unitsdb.prefixes.find_by_symbol_name(prefix_name) end def id diff --git a/lib/unitsml/transform.rb b/lib/unitsml/transform.rb index bd6e0d8..c6c900f 100644 --- a/lib/unitsml/transform.rb +++ b/lib/unitsml/transform.rb @@ -3,138 +3,190 @@ require "parslet" module Unitsml class Transform < Parslet::Transform - rule(sqrt: simple(:sqrt)) { Sqrt.new(sqrt) } - rule(units: simple(:unit)) { Unit.new(unit.to_s) } - rule(prefixes: simple(:prefix)) { Prefix.new(prefix.to_s) } - rule(dimensions: simple(:dimension)) { Dimension.new(dimension.to_s) } - rule(intermediate_exp: simple(:int_exp)) { int_exp } + rule(sqrt: simple(:sqrt)) { Sqrt.new(sqrt) } + rule(unit: simple(:unit)) { Unit.new(unit.to_s) } + rule(dimension: simple(:dimension)) { Dimension.new(dimension.to_s) } + rule(prefix: simple(:prefix)) { Prefix.new(prefix.to_s) } + rule(int_exp: simple(:int_exp)) { int_exp } + rule(implicit_extended: simple(:implicit_extended)) { implicit_extended } - rule(units: simple(:unit), - integer: simple(:integer)) do - Unit.new(unit.to_s, integer.to_s) + rule(int_exp: simple(:int_exp), + sequence: simple(:sequence)) do + Formula.new([int_exp, sequence]) end - rule(dimensions: simple(:dimension), - integer: simple(:integer)) do - Dimension.new(dimension.to_s, integer.to_s) + rule(first_int_exp_set: simple(:first_set), + second_set: simple(:second_set)) do + Formula.new([Utility.set_to_fence(first_set), second_set]) + end + + rule(first_int_exp_set: simple(:first_set), + second_int_exp_set: simple(:second_set)) do + Formula.new( + [Utility.set_to_fence(first_set), Utility.set_to_fence(second_set), + ] + ) end - rule(prefixes: simple(:prefix), - units: simple(:unit)) do + rule(first_set: simple(:first_set), + second_set: simple(:second_set)) do + Formula.new( + [ + first_set, + second_set, + ] + ) + end + + rule(first_set: simple(:first_set), + second_int_exp_set: simple(:second_set)) do + Formula.new( + [ + first_set, + Utility.set_to_fence(second_set), + ] + ) + end + + rule(prefix: simple(:prefix), + unit: simple(:unit)) do Unit.new(unit.to_s, prefix: Prefix.new(prefix.to_s)) end - rule(prefixes: simple(:prefix), - units: simple(:unit), + rule(unit: simple(:unit), integer: simple(:integer)) do - prefix_obj = Prefix.new(prefix.to_s) - Unit.new(unit.to_s, integer.to_s, prefix: prefix_obj) + Unit.new(unit.to_s, integer) end - rule(open_parenthesis: simple(:open_paren), - int_exp: simple(:exp), - close_parenthesis: simple(:close_paren)) do - Fenced.new(open_paren.to_s, exp, close_paren.to_s) + rule(dimension: simple(:dimension), + integer: simple(:integer)) do + Dimension.new(dimension.to_s, integer) + end + + rule(prefix: simple(:prefix), + unit: simple(:unit), + integer: simple(:integer)) do + Unit.new(unit.to_s, integer.to_s, prefix: Prefix.new(prefix.to_s)) end - rule(open_parenthesis: simple(:open_paren), - int_exp: simple(:exp), - close_parenthesis: simple(:close_paren), - sequence: sequence(:sequence)) do + rule(first_set: simple(:first_set), + extender: simple(:extender), + second_set: simple(:second_set)) do Formula.new( [ - Fenced.new(open_paren.to_s, exp, close_paren.to_s), - sequence, - ], + first_set, + Extender.new(extender.to_s), + second_set, + ] ) end - rule(intermediate_exp: simple(:intermediate_exp), + rule(implicit_extended: simple(:implicit_extended), extender: simple(:extender), sequence: simple(:sequence)) do Formula.new( [ - intermediate_exp, + implicit_extended, Extender.new(extender.to_s), sequence, - ], + ] ) end - rule(prefixes: simple(:prefix), - units: simple(:unit), - integer: simple(:integer), + rule(int_exp: simple(:int_exp), extender: simple(:extender), - sequence: simple(:sequence),) do - prefix_obj = Prefix.new(prefix.to_s) - unit_object = Unit.new(unit.to_s, integer.to_s, prefix: prefix_obj) + sequence: simple(:sequence)) do Formula.new( [ - unit_object, + int_exp, Extender.new(extender.to_s), sequence, - ], + ] ) end - rule(prefixes: simple(:prefix), - units: simple(:unit), + rule(unit: simple(:unit), extender: simple(:extender), sequence: simple(:sequence)) do Formula.new( [ - Unit.new(unit.to_s, prefix: Prefix.new(prefix.to_s)), + Unit.new(unit.to_s), Extender.new(extender.to_s), sequence, - ], + ] ) end - rule(units: simple(:unit), + rule(dimension: simple(:dimension), extender: simple(:extender), sequence: simple(:sequence)) do Formula.new( [ - Unit.new(unit.to_s), + Dimension.new(dimension.to_s), Extender.new(extender.to_s), sequence, + ] + ) + end + + rule(open_paren: simple(:open_paren), + int_exp: simple(:int_exp), + close_paren: simple(:close_paren)) do + Fenced.new( + open_paren.to_s, + int_exp, + close_paren.to_s, + ) + end + + rule(unit: simple(:unit), + integer: simple(:int), + extender: simple(:ext), + sequence: simple(:sequence)) do + Formula.new( + [ + Unit.new(unit.to_s, int.to_s), + Extender.new(ext.to_s), + sequence, ], ) end - rule(units: simple(:unit), - integer: simple(:integer), - extender: simple(:extender), + rule(dimension: simple(:dimension), + integer: simple(:int), + extender: simple(:ext), sequence: simple(:sequence)) do Formula.new( [ - Unit.new(unit.to_s, integer.to_s), - Extender.new(extender.to_s), + Dimension.new(dimension.to_s, int.to_s), + Extender.new(ext.to_s), sequence, ], ) end - rule(dimensions: simple(:dimension), - extender: simple(:extender), + rule(prefix: simple(:prefix), + unit: simple(:unit), + extender: simple(:ext), sequence: simple(:sequence)) do Formula.new( [ - Dimension.new(dimension.to_s), - Extender.new(extender.to_s), + Unit.new(unit.to_s, prefix: Prefix.new(prefix.to_s)), + Extender.new(ext.to_s), sequence, ], ) end - rule(dimensions: simple(:dimension), + rule(prefix: simple(:prefix), + unit: simple(:unit), integer: simple(:integer), - extender: simple(:extender), + extender: simple(:ext), sequence: simple(:sequence)) do Formula.new( [ - Dimension.new(dimension.to_s, integer.to_s), - Extender.new(extender.to_s), + Unit.new(unit.to_s, integer.to_s, prefix: Prefix.new(prefix.to_s)), + Extender.new(ext.to_s), sequence, ], ) diff --git a/lib/unitsml/utility.rb b/lib/unitsml/utility.rb index ec4fdeb..f537e3a 100644 --- a/lib/unitsml/utility.rb +++ b/lib/unitsml/utility.rb @@ -303,6 +303,12 @@ def html_entity_to_unicode(string) def underscore(str) str.gsub(/([a-z])([A-Z])/, '\1_\2').downcase end + + def set_to_fence(set) + return set if set.is_a?(Fenced) + + Fenced.new("(", set, ")") + end end end end diff --git a/spec/unitsml/conv/asciimath_spec.rb b/spec/unitsml/conv/asciimath_spec.rb index 6f2bbe3..437aeb3 100644 --- a/spec/unitsml/conv/asciimath_spec.rb +++ b/spec/unitsml/conv/asciimath_spec.rb @@ -260,4 +260,141 @@ expect(formula).to eq(expected_value) end end + + describe "implicit extender" do + context "implicit extender example #1 from issue#53" do + let(:exp) { "unitsml(J(kg*K))" } + let(:expected_value) { "J(kg*K)" } + + it "matches the UnitsML to AsciiMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #2 from issue#53" do + let(:exp) { "unitsml(J kg^-1 * K^-1)" } + let(:expected_value) { "J kg^-1*K^-1" } + + it "matches the UnitsML to AsciiMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #3 from issue#53" do + let(:exp) { "unitsml(J/mol * K)" } + let(:expected_value) { "J/mol^-1*K^-1" } + + it "matches the UnitsML to AsciiMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #4 from issue#53" do + let(:exp) { "unitsml(J/(mol * K))" } + let(:expected_value) { "J/mol^-1*K^-1" } + + it "matches the UnitsML to AsciiMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #5" do + let(:exp) { "unitsml((mol * K)J)" } + let(:expected_value) { "(mol*K)J" } + + it "matches the UnitsML to AsciiMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #6" do + let(:exp) { "unitsml((mol * K) J)" } + let(:expected_value) { "(mol*K)J" } + + it "matches the UnitsML to AsciiMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #7" do + let(:exp) { "unitsml((mol * K)(J))" } + let(:expected_value) { "(mol*K)(J)" } + + it "matches the UnitsML to AsciiMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #8" do + let(:exp) { "unitsml((mol * K)(J*K))" } + let(:expected_value) { "(mol*K)(J*K)" } + + it "matches the UnitsML to AsciiMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #9" do + let(:exp) { "unitsml(E_erlang(mm)*kg)" } + let(:expected_value) { "E(mm)*kg" } + + it "matches the UnitsML to AsciiMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #10" do + let(:exp) { "unitsml(dim_Theta(dim_phi))" } + let(:expected_value) { "Theta(phi)" } + + it "matches the UnitsML to AsciiMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #11" do + let(:exp) { "unitsml((dim_Theta)dim_L)" } + let(:expected_value) { "(Theta)L" } + + it "matches the UnitsML to AsciiMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #12" do + let(:exp) { "unitsml(dim_Theta dim_L)" } + let(:expected_value) { "Theta L" } + + it "matches the UnitsML to AsciiMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #13" do + let(:exp) { "unitsml(dim_phi (dim_Theta dim_L))" } + let(:expected_value) { "phi(Theta L)" } + + it "matches the UnitsML to AsciiMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #14" do + let(:exp) { "unitsml((dim_phi(dim_I)) ((dim_Theta) dim_L))" } + let(:expected_value) { "(phi(I))((Theta)L)" } + + it "matches the UnitsML to AsciiMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #15" do + let(:exp) { "unitsml(sqrt(dim_phi(dim_I)) ((dim_Theta) dim_L))" } + let(:expected_value) { "phi(I)((Theta)L)" } + + it "matches the UnitsML to AsciiMath converted value" do + expect(formula).to eq(expected_value) + end + end + end end diff --git a/spec/unitsml/conv/html_spec.rb b/spec/unitsml/conv/html_spec.rb index 7df6e72..7bae447 100644 --- a/spec/unitsml/conv/html_spec.rb +++ b/spec/unitsml/conv/html_spec.rb @@ -287,4 +287,141 @@ expect(formula).to be_equivalent_to(expected_value) end end + + describe "implicit extender" do + context "implicit extender example #1 from issue#53" do + let(:exp) { "unitsml(J(kg*K))" } + let(:expected_value) { "J(kg⋅K)" } + + it "matches the UnitsML to HTML converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #2 from issue#53" do + let(:exp) { "unitsml(J kg^-1 * K^-1)" } + let(:expected_value) { "J⋅kg−1⋅K−1" } + + it "matches the UnitsML to HTML converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #3 from issue#53" do + let(:exp) { "unitsml(J/mol * K)" } + let(:expected_value) { "J⋅mol−1⋅K−1" } + + it "matches the UnitsML to HTML converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #4 from issue#53" do + let(:exp) { "unitsml(J/(mol * K))" } + let(:expected_value) { "J⋅mol−1⋅K−1" } + + it "matches the UnitsML to HTML converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #5" do + let(:exp) { "unitsml((mol * K)J)" } + let(:expected_value) { "(mol⋅K)J" } + + it "matches the UnitsML to HTML converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #6" do + let(:exp) { "unitsml((mol * K) J)" } + let(:expected_value) { "(mol⋅K)J" } + + it "matches the UnitsML to HTML converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #7" do + let(:exp) { "unitsml((mol * K)(J))" } + let(:expected_value) { "(mol⋅K)(J)" } + + it "matches the UnitsML to HTML converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #8" do + let(:exp) { "unitsml((mol * K)(J*K))" } + let(:expected_value) { "(mol⋅K)(J⋅K)" } + + it "matches the UnitsML to HTML converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #9" do + let(:exp) { "unitsml(E_erlang(mm)*kg)" } + let(:expected_value) { "E(mm)⋅kg" } + + it "matches the UnitsML to HTML converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #10" do + let(:exp) { "unitsml(dim_Theta(dim_phi))" } + let(:expected_value) { "𝝠(𝞅)" } + + it "matches the UnitsML to HTML converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #11" do + let(:exp) { "unitsml((dim_Theta)dim_L)" } + let(:expected_value) { "(𝝠)𝖫" } + + it "matches the UnitsML to HTML converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #12" do + let(:exp) { "unitsml(dim_Theta dim_L)" } + let(:expected_value) { "𝝠⋅𝖫" } + + it "matches the UnitsML to HTML converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #13" do + let(:exp) { "unitsml(dim_phi (dim_Theta dim_L))" } + let(:expected_value) { "𝞅(𝝠⋅𝖫)" } + + it "matches the UnitsML to HTML converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #14" do + let(:exp) { "unitsml((dim_phi(dim_I)) ((dim_Theta) dim_L))" } + let(:expected_value) { "(𝞅(𝖨))((𝝠)𝖫)" } + + it "matches the UnitsML to HTML converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #15" do + let(:exp) { "unitsml(sqrt(dim_phi(dim_I)) ((dim_Theta) dim_L))" } + let(:expected_value) { "𝞅(𝖨)((𝝠)𝖫)" } + + it "matches the UnitsML to HTML converted value" do + expect(formula).to eq(expected_value) + end + end + end end diff --git a/spec/unitsml/conv/latex_spec.rb b/spec/unitsml/conv/latex_spec.rb index 395cea2..b128061 100644 --- a/spec/unitsml/conv/latex_spec.rb +++ b/spec/unitsml/conv/latex_spec.rb @@ -287,4 +287,141 @@ expect(formula).to be_equivalent_to(expected_value) end end + + describe "implicit extender" do + context "implicit extender example #1 from issue#53" do + let(:exp) { "unitsml(J(kg*K))" } + let(:expected_value) { "\\ensuremath{\\mathrm{J}}(k\\ensuremath{\\mathrm{g}}/\\ensuremath{\\mathrm{K}})" } + + it "matches the UnitsML to LaTeX converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #2 from issue#53" do + let(:exp) { "unitsml(J kg^-1 * K^-1)" } + let(:expected_value) { "\\ensuremath{\\mathrm{J}}/k\\ensuremath{\\mathrm{g}}^-1/\\ensuremath{\\mathrm{K}}^-1" } + + it "matches the UnitsML to LaTeX converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #3 from issue#53" do + let(:exp) { "unitsml(J/mol * K)" } + let(:expected_value) { "\\ensuremath{\\mathrm{J}}/\\ensuremath{\\mathrm{mol}}^-1/\\ensuremath{\\mathrm{K}}^-1" } + + it "matches the UnitsML to LaTeX converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #4 from issue#53" do + let(:exp) { "unitsml(J/(mol * K))" } + let(:expected_value) { "\\ensuremath{\\mathrm{J}}/\\ensuremath{\\mathrm{mol}}^-1/\\ensuremath{\\mathrm{K}}^-1" } + + it "matches the UnitsML to LaTeX converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #5" do + let(:exp) { "unitsml((mol * K)J)" } + let(:expected_value) { "(\\ensuremath{\\mathrm{mol}}/\\ensuremath{\\mathrm{K}})\\ensuremath{\\mathrm{J}}" } + + it "matches the UnitsML to LaTeX converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #6" do + let(:exp) { "unitsml((mol * K) J)" } + let(:expected_value) { "(\\ensuremath{\\mathrm{mol}}/\\ensuremath{\\mathrm{K}})\\ensuremath{\\mathrm{J}}" } + + it "matches the UnitsML to LaTeX converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #7" do + let(:exp) { "unitsml((mol * K)(J))" } + let(:expected_value) { "(\\ensuremath{\\mathrm{mol}}/\\ensuremath{\\mathrm{K}})(\\ensuremath{\\mathrm{J}})" } + + it "matches the UnitsML to LaTeX converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #8" do + let(:exp) { "unitsml((mol * K)(J*K))" } + let(:expected_value) { "(\\ensuremath{\\mathrm{mol}}/\\ensuremath{\\mathrm{K}})(\\ensuremath{\\mathrm{J}}/\\ensuremath{\\mathrm{K}})" } + + it "matches the UnitsML to LaTeX converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #9" do + let(:exp) { "unitsml(E_erlang(mm)*kg)" } + let(:expected_value) { "\\ensuremath{\\mathrm{E}}(m\\ensuremath{\\mathrm{m}})/k\\ensuremath{\\mathrm{g}}" } + + it "matches the UnitsML to LaTeX converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #10" do + let(:exp) { "unitsml(dim_Theta(dim_phi))" } + let(:expected_value) { "\\ensuremath{\\mathsf{\\Theta}}(\\ensuremath{\\mathsf{\\phi}})" } + + it "matches the UnitsML to LaTeX converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #11" do + let(:exp) { "unitsml((dim_Theta)dim_L)" } + let(:expected_value) { "(\\ensuremath{\\mathsf{\\Theta}})\\ensuremath{\\mathsf{L}}" } + + it "matches the UnitsML to LaTeX converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #12" do + let(:exp) { "unitsml(dim_Theta dim_L)" } + let(:expected_value) { "\\ensuremath{\\mathsf{\\Theta}}/\\ensuremath{\\mathsf{L}}" } + + it "matches the UnitsML to LaTeX converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #13" do + let(:exp) { "unitsml(dim_phi (dim_Theta dim_L))" } + let(:expected_value) { "\\ensuremath{\\mathsf{\\phi}}(\\ensuremath{\\mathsf{\\Theta}}/\\ensuremath{\\mathsf{L}})" } + + it "matches the UnitsML to LaTeX converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #14" do + let(:exp) { "unitsml((dim_phi(dim_I)) ((dim_Theta) dim_L))" } + let(:expected_value) { "(\\ensuremath{\\mathsf{\\phi}}(\\ensuremath{\\mathsf{I}}))((\\ensuremath{\\mathsf{\\Theta}})\\ensuremath{\\mathsf{L}})" } + + it "matches the UnitsML to LaTeX converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #15" do + let(:exp) { "unitsml(sqrt(dim_phi(dim_I)) ((dim_Theta) dim_L))" } + let(:expected_value) { "\\ensuremath{\\mathsf{\\phi}}(\\ensuremath{\\mathsf{I}})((\\ensuremath{\\mathsf{\\Theta}})\\ensuremath{\\mathsf{L}})" } + + it "matches the UnitsML to LaTeX converted value" do + expect(formula).to eq(expected_value) + end + end + end end diff --git a/spec/unitsml/conv/mathml_spec.rb b/spec/unitsml/conv/mathml_spec.rb index f7b3848..4bdd634 100644 --- a/spec/unitsml/conv/mathml_spec.rb +++ b/spec/unitsml/conv/mathml_spec.rb @@ -676,4 +676,396 @@ expect(formula.to_mathml(multiplier: "X", explicit_parenthesis: false)).to be_equivalent_to(expected_value) end end + + describe "implicit extender" do + context "implicit extender example #1 from issue#53" do + let(:exp) { "unitsml(J(kg*K))" } + let(:expected_value) do + <<~MATHML + + J + + ( + kg + ) + K + ⋅ + + + MATHML + end + + it "matches the UnitsML to MathML converted value" do + expect(mathml).to be_equivalent_to(expected_value) + end + end + + context "implicit extender example #2 from issue#53" do + let(:exp) { "unitsml(J kg^-1 * K^-1)" } + let(:expected_value) do + <<~MATHML + + J + ⋅ + + + kg + + + − + 1 + + + ⋅ + + + K + + + − + 1 + + + + MATHML + end + + it "matches the UnitsML to MathML converted value" do + expect(mathml).to be_equivalent_to(expected_value) + end + end + + context "implicit extender example #3 from issue#53" do + let(:exp) { "unitsml(J/mol * K)" } + let(:expected_value) do + <<~MATHML + + J + ⋅ + + + mol + + + − + 1 + + + ⋅ + + + K + + + − + 1 + + + + MATHML + end + + it "matches the UnitsML to MathML converted value" do + expect(mathml).to be_equivalent_to(expected_value) + end + end + + context "implicit extender example #4 from issue#53" do + let(:exp) { "unitsml(J/(mol * K))" } + let(:expected_value) do + <<~MATHML + + J + ⋅ + + + mol + + + − + 1 + + + ⋅ + + + K + + + − + 1 + + + + MATHML + end + + it "matches the UnitsML to MathML converted value" do + expect(mathml).to be_equivalent_to(expected_value) + end + end + + context "implicit extender example #5" do + let(:exp) { "unitsml((mol * K)J)" } + let(:expected_value) do + <<~MATHML + + + ( + mol + ) + K + ⋅ + + J + + MATHML + end + + it "matches the UnitsML to MathML converted value" do + expect(mathml).to be_equivalent_to(expected_value) + end + end + + context "implicit extender example #6" do + let(:exp) { "unitsml((mol * K) J)" } + let(:expected_value) do + <<~MATHML + + + ( + mol + ) + K + ⋅ + + J + + MATHML + end + + it "matches the UnitsML to MathML converted value" do + expect(mathml).to be_equivalent_to(expected_value) + end + end + + context "implicit extender example #7" do + let(:exp) { "unitsml((mol * K)(J))" } + let(:expected_value) do + <<~MATHML + + + ( + mol + ) + K + ⋅ + + + ( + J + ) + + + MATHML + end + + it "matches the UnitsML to MathML converted value" do + expect(mathml).to be_equivalent_to(expected_value) + end + end + + context "implicit extender example #8" do + let(:exp) { "unitsml((mol * K)(J*K))" } + let(:expected_value) do + <<~MATHML + + + ( + mol + ) + K + ⋅ + + + ( + J + ) + K + ⋅ + + + MATHML + end + + it "matches the UnitsML to MathML converted value" do + expect(mathml).to be_equivalent_to(expected_value) + end + end + + context "implicit extender example #9" do + let(:exp) { "unitsml(E_erlang(mm)*kg)" } + let(:expected_value) do + <<~MATHML + + E + + ( + mm + ) + + ⋅ + kg + + MATHML + end + + it "matches the UnitsML to MathML converted value" do + expect(mathml).to be_equivalent_to(expected_value) + end + end + + context "implicit extender example #10" do + let(:exp) { "unitsml(dim_Theta(dim_phi))" } + let(:expected_value) do + <<~MATHML + + Θ + + ( + φ + ) + + + MATHML + end + + it "matches the UnitsML to MathML converted value" do + expect(mathml).to be_equivalent_to(expected_value) + end + end + + context "implicit extender example #11" do + let(:exp) { "unitsml((dim_Theta)dim_L)" } + let(:expected_value) do + <<~MATHML + + + ( + Θ + ) + + L + + MATHML + end + + it "matches the UnitsML to MathML converted value" do + expect(mathml).to be_equivalent_to(expected_value) + end + end + + context "implicit extender example #12" do + let(:exp) { "unitsml(dim_Theta dim_L)" } + let(:expected_value) do + <<~MATHML + + Θ + ⋅ + L + + MATHML + end + + it "matches the UnitsML to MathML converted value" do + expect(mathml).to be_equivalent_to(expected_value) + end + end + + context "implicit extender example #13" do + let(:exp) { "unitsml(dim_phi (dim_Theta dim_L))" } + let(:expected_value) do + <<~MATHML + + φ + + ( + Θ + ) + L + ⋅ + + + MATHML + end + + it "matches the UnitsML to MathML converted value" do + expect(mathml).to be_equivalent_to(expected_value) + end + end + + context "implicit extender example #14" do + let(:exp) { "unitsml((dim_phi(dim_I)) ((dim_Theta) dim_L))" } + let(:expected_value) do + <<~MATHML + + + ( + φ + + ( + I + ) + + ) + + + ( + + ( + Θ + ) + + L + ) + + + MATHML + end + + it "matches the UnitsML to MathML converted value" do + expect(mathml).to be_equivalent_to(expected_value) + end + end + + context "implicit extender example #15" do + let(:exp) { "unitsml(sqrt(dim_phi(dim_I)) ((dim_Theta) dim_L))" } + let(:expected_value) do + <<~MATHML + + φ + + ( + I + ) + + + ( + + ( + Θ + ) + + L + ) + + + MATHML + end + + it "matches the UnitsML to MathML converted value" do + expect(mathml).to be_equivalent_to(expected_value) + end + end + end end diff --git a/spec/unitsml/conv/plurimath_spec.rb b/spec/unitsml/conv/plurimath_spec.rb index 9a8de9f..47e2d17 100644 --- a/spec/unitsml/conv/plurimath_spec.rb +++ b/spec/unitsml/conv/plurimath_spec.rb @@ -201,4 +201,526 @@ expect(formula).to eq(expected_value) end end + + describe "implicit extender" do + context "implicit extender example #1 from issue#53" do + let(:exp) { "unitsml(J(kg*K))" } + let(:expected_value) do + Plurimath::Math::Formula.new([ + Plurimath::Math::Function::FontStyle::Normal.new( + Plurimath::Math::Symbols::Symbol.new("J"), + "normal", + ), + Plurimath::Math::Function::Fenced.new( + Plurimath::Math::Symbols::Paren::Lround.new, + [ + Plurimath::Math::Function::FontStyle::Normal.new( + Plurimath::Math::Symbols::Symbol.new("kg"), + "normal", + ), + Plurimath::Math::Symbols::Cdot.new, + Plurimath::Math::Function::FontStyle::Normal.new( + Plurimath::Math::Symbols::Symbol.new("K"), + "normal", + ) + ], + Plurimath::Math::Symbols::Paren::Rround.new, + ) + ]) + end + + it "matches the UnitsML to UnicodeMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #2 from issue#53" do + let(:exp) { "unitsml(J kg^-1 * K^-1)" } + let(:expected_value) do + Plurimath::Math::Formula.new([ + Plurimath::Math::Function::FontStyle::Normal.new( + Plurimath::Math::Symbols::Symbol.new("J"), + "normal", + ), + Plurimath::Math::Symbols::Cdot.new, + Plurimath::Math::Function::Power.new( + Plurimath::Math::Function::FontStyle::Normal.new( + Plurimath::Math::Symbols::Symbol.new("kg"), + "normal", + ), + Plurimath::Math::Formula.new([ + Plurimath::Math::Symbols::Minus.new, + Plurimath::Math::Number.new("1"), + ]) + ), + Plurimath::Math::Symbols::Cdot.new, + Plurimath::Math::Function::Power.new( + Plurimath::Math::Function::FontStyle::Normal.new( + Plurimath::Math::Symbols::Symbol.new("K"), + "normal", + ), + Plurimath::Math::Formula.new([ + Plurimath::Math::Symbols::Minus.new, + Plurimath::Math::Number.new("1"), + ]), + ) + ]) + end + + it "matches the UnitsML to UnicodeMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #3 from issue#53" do + let(:exp) { "unitsml(J/mol * K)" } + let(:expected_value) do + Plurimath::Math::Formula.new([ + Plurimath::Math::Function::FontStyle::Normal.new( + Plurimath::Math::Symbols::Symbol.new("J"), + "normal", + ), + Plurimath::Math::Symbols::Cdot.new, + Plurimath::Math::Function::Power.new( + Plurimath::Math::Function::FontStyle::Normal.new( + Plurimath::Math::Symbols::Symbol.new("mol"), + "normal", + ), + Plurimath::Math::Formula.new([ + Plurimath::Math::Symbols::Minus.new, + Plurimath::Math::Number.new("1"), + ]), + ), + Plurimath::Math::Symbols::Cdot.new, + Plurimath::Math::Function::Power.new( + Plurimath::Math::Function::FontStyle::Normal.new( + Plurimath::Math::Symbols::Symbol.new("K"), + "normal", + ), + Plurimath::Math::Formula.new([ + Plurimath::Math::Symbols::Minus.new, + Plurimath::Math::Number.new("1"), + ]), + ), + ]) + end + + it "matches the UnitsML to UnicodeMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #4 from issue#53" do + let(:exp) { "unitsml(J/(mol * K))" } + let(:expected_value) do + + Plurimath::Math::Formula.new([ + Plurimath::Math::Function::FontStyle::Normal.new( + Plurimath::Math::Symbols::Symbol.new("J"), + "normal", + ), + Plurimath::Math::Symbols::Cdot.new, + Plurimath::Math::Function::Power.new( + Plurimath::Math::Function::FontStyle::Normal.new( + Plurimath::Math::Symbols::Symbol.new("mol"), + "normal", + ), + Plurimath::Math::Formula.new([ + Plurimath::Math::Symbols::Minus.new, + Plurimath::Math::Number.new("1"), + ]), + ), + Plurimath::Math::Symbols::Cdot.new, + Plurimath::Math::Function::Power.new( + Plurimath::Math::Function::FontStyle::Normal.new( + Plurimath::Math::Symbols::Symbol.new("K"), + "normal", + ), + Plurimath::Math::Formula.new([ + Plurimath::Math::Symbols::Minus.new, + Plurimath::Math::Number.new("1"), + ]), + ), + ]) + end + + it "matches the UnitsML to UnicodeMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #5" do + let(:exp) { "unitsml((mol * K)J)" } + let(:expected_value) do + Plurimath::Math::Formula.new([ + Plurimath::Math::Function::Fenced.new( + Plurimath::Math::Symbols::Paren::Lround.new, + [ + Plurimath::Math::Function::FontStyle::Normal.new( + Plurimath::Math::Symbols::Symbol.new("mol"), + "normal", + ), + Plurimath::Math::Symbols::Cdot.new, + Plurimath::Math::Function::FontStyle::Normal.new( + Plurimath::Math::Symbols::Symbol.new("K"), + "normal", + ), + ], + Plurimath::Math::Symbols::Paren::Rround.new, + ), + Plurimath::Math::Function::FontStyle::Normal.new( + Plurimath::Math::Symbols::Symbol.new("J"), + "normal", + ), + ]) + end + + it "matches the UnitsML to UnicodeMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #6" do + let(:exp) { "unitsml((mol * K) J)" } + let(:expected_value) do + Plurimath::Math::Formula.new([ + Plurimath::Math::Function::Fenced.new( + Plurimath::Math::Symbols::Paren::Lround.new, + [ + Plurimath::Math::Function::FontStyle::Normal.new( + Plurimath::Math::Symbols::Symbol.new("mol"), + "normal", + ), + Plurimath::Math::Symbols::Cdot.new, + Plurimath::Math::Function::FontStyle::Normal.new( + Plurimath::Math::Symbols::Symbol.new("K"), + "normal", + ), + ], + Plurimath::Math::Symbols::Paren::Rround.new, + ), + Plurimath::Math::Function::FontStyle::Normal.new( + Plurimath::Math::Symbols::Symbol.new("J"), + "normal", + ), + ]) + end + + it "matches the UnitsML to UnicodeMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #7" do + let(:exp) { "unitsml((mol * K)(J))" } + let(:expected_value) do + Plurimath::Math::Formula.new([ + Plurimath::Math::Function::Fenced.new( + Plurimath::Math::Symbols::Paren::Lround.new, + [ + Plurimath::Math::Function::FontStyle::Normal.new( + Plurimath::Math::Symbols::Symbol.new("mol"), + "normal", + ), + Plurimath::Math::Symbols::Cdot.new, + Plurimath::Math::Function::FontStyle::Normal.new( + Plurimath::Math::Symbols::Symbol.new("K"), + "normal", + ), + ], + Plurimath::Math::Symbols::Paren::Rround.new, + ), + Plurimath::Math::Function::Fenced.new( + Plurimath::Math::Symbols::Paren::Lround.new, + [ + Plurimath::Math::Function::FontStyle::Normal.new( + Plurimath::Math::Symbols::Symbol.new("J"), + "normal", + ), + ], + Plurimath::Math::Symbols::Paren::Rround.new, + ), + ]) + end + + it "matches the UnitsML to UnicodeMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #8" do + let(:exp) { "unitsml((mol * K)(J*K))" } + let(:expected_value) do + Plurimath::Math::Formula.new([ + Plurimath::Math::Function::Fenced.new( + Plurimath::Math::Symbols::Paren::Lround.new, + [ + Plurimath::Math::Function::FontStyle::Normal.new( + Plurimath::Math::Symbols::Symbol.new("mol"), + "normal", + ), + Plurimath::Math::Symbols::Cdot.new, + Plurimath::Math::Function::FontStyle::Normal.new( + Plurimath::Math::Symbols::Symbol.new("K"), + "normal", + ), + ], + Plurimath::Math::Symbols::Paren::Rround.new, + ), + Plurimath::Math::Function::Fenced.new( + Plurimath::Math::Symbols::Paren::Lround.new, + [ + Plurimath::Math::Function::FontStyle::Normal.new( + Plurimath::Math::Symbols::Symbol.new("J"), + "normal", + ), + Plurimath::Math::Symbols::Cdot.new, + Plurimath::Math::Function::FontStyle::Normal.new( + Plurimath::Math::Symbols::Symbol.new("K"), + "normal", + ), + ], + Plurimath::Math::Symbols::Paren::Rround.new, + ), + ]) + end + + it "matches the UnitsML to UnicodeMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #9" do + let(:exp) { "unitsml(E_erlang(mm)*kg)" } + let(:expected_value) do + Plurimath::Math::Formula.new([ + Plurimath::Math::Function::FontStyle::Normal.new( + Plurimath::Math::Symbols::Symbol.new("E"), + "normal", + ), + Plurimath::Math::Function::Fenced.new( + Plurimath::Math::Symbols::Paren::Lround.new, + [ + Plurimath::Math::Function::FontStyle::Normal.new( + Plurimath::Math::Symbols::Symbol.new("mm"), + "normal", + ), + ], + Plurimath::Math::Symbols::Paren::Rround.new, + ), + Plurimath::Math::Symbols::Cdot.new, + Plurimath::Math::Function::FontStyle::Normal.new( + Plurimath::Math::Symbols::Symbol.new("kg"), + "normal", + ), + ]) + end + + it "matches the UnitsML to UnicodeMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #10" do + let(:exp) { "unitsml(dim_Theta(dim_phi))" } + let(:expected_value) do + Plurimath::Math::Formula.new([ + Plurimath::Math::Function::FontStyle::SansSerif.new( + Plurimath::Math::Symbols::UpcaseTheta.new, + "sans-serif", + ), + Plurimath::Math::Function::Fenced.new( + Plurimath::Math::Symbols::Paren::Lround.new, + [ + Plurimath::Math::Function::FontStyle::SansSerif.new( + Plurimath::Math::Symbols::Phi.new, + "sans-serif", + ), + ], + Plurimath::Math::Symbols::Paren::Rround.new, + ), + ]) + end + + it "matches the UnitsML to UnicodeMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #11" do + let(:exp) { "unitsml((dim_Theta)dim_L)" } + let(:expected_value) do + Plurimath::Math::Formula.new([ + Plurimath::Math::Function::Fenced.new( + Plurimath::Math::Symbols::Paren::Lround.new, + [ + Plurimath::Math::Function::FontStyle::SansSerif.new( + Plurimath::Math::Symbols::UpcaseTheta.new, + "sans-serif", + ), + ], + Plurimath::Math::Symbols::Paren::Rround.new, + ), + Plurimath::Math::Function::FontStyle::SansSerif.new( + Plurimath::Math::Symbols::Symbol.new("L"), + "sans-serif", + ), + ]) + end + + it "matches the UnitsML to UnicodeMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #12" do + let(:exp) { "unitsml(dim_Theta dim_L)" } + let(:expected_value) do + Plurimath::Math::Formula.new([ + Plurimath::Math::Function::FontStyle::SansSerif.new( + Plurimath::Math::Symbols::UpcaseTheta.new, + "sans-serif", + ), + Plurimath::Math::Symbols::Cdot.new, + Plurimath::Math::Function::FontStyle::SansSerif.new( + Plurimath::Math::Symbols::Symbol.new("L"), + "sans-serif", + ), + ]) + end + + it "matches the UnitsML to UnicodeMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #13" do + let(:exp) { "unitsml(dim_phi (dim_Theta dim_L))" } + let(:expected_value) do + Plurimath::Math::Formula.new([ + Plurimath::Math::Function::FontStyle::SansSerif.new( + Plurimath::Math::Symbols::Phi.new, + "sans-serif", + ), + Plurimath::Math::Function::Fenced.new( + Plurimath::Math::Symbols::Paren::Lround.new, + [ + Plurimath::Math::Function::FontStyle::SansSerif.new( + Plurimath::Math::Symbols::UpcaseTheta.new, + "sans-serif", + ), + Plurimath::Math::Symbols::Cdot.new, + Plurimath::Math::Function::FontStyle::SansSerif.new( + Plurimath::Math::Symbols::Symbol.new("L"), + "sans-serif", + ), + ], + Plurimath::Math::Symbols::Paren::Rround.new, + ), + ]) + end + + it "matches the UnitsML to UnicodeMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #14" do + let(:exp) { "unitsml((dim_phi(dim_I)) ((dim_Theta) dim_L))" } + let(:expected_value) do + Plurimath::Math::Formula.new([ + Plurimath::Math::Function::Fenced.new( + Plurimath::Math::Symbols::Paren::Lround.new, + [ + Plurimath::Math::Function::FontStyle::SansSerif.new( + Plurimath::Math::Symbols::Phi.new, + "sans-serif", + ), + Plurimath::Math::Function::Fenced.new( + Plurimath::Math::Symbols::Paren::Lround.new, + [ + Plurimath::Math::Function::FontStyle::SansSerif.new( + Plurimath::Math::Symbols::Symbol.new("I"), + "sans-serif", + ), + ], + Plurimath::Math::Symbols::Paren::Rround.new, + ), + ], + Plurimath::Math::Symbols::Paren::Rround.new, + ), + Plurimath::Math::Function::Fenced.new( + Plurimath::Math::Symbols::Paren::Lround.new, + [ + Plurimath::Math::Function::Fenced.new( + Plurimath::Math::Symbols::Paren::Lround.new, + [ + Plurimath::Math::Function::FontStyle::SansSerif.new( + Plurimath::Math::Symbols::UpcaseTheta.new, + "sans-serif", + ), + ], + Plurimath::Math::Symbols::Paren::Rround.new, + ), + Plurimath::Math::Function::FontStyle::SansSerif.new( + Plurimath::Math::Symbols::Symbol.new("L"), + "sans-serif", + ), + ], + Plurimath::Math::Symbols::Paren::Rround.new, + ), + ]) + end + + it "matches the UnitsML to UnicodeMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #15" do + let(:exp) { "unitsml(sqrt(dim_phi(dim_I)) ((dim_Theta) dim_L))" } + let(:expected_value) do + Plurimath::Math::Formula.new([ + Plurimath::Math::Function::FontStyle::SansSerif.new( + Plurimath::Math::Symbols::Phi.new, + "sans-serif", + ), + Plurimath::Math::Function::Fenced.new( + Plurimath::Math::Symbols::Paren::Lround.new, + [ + Plurimath::Math::Function::FontStyle::SansSerif.new( + Plurimath::Math::Symbols::Symbol.new("I"), + "sans-serif", + ), + ], + Plurimath::Math::Symbols::Paren::Rround.new, + ), + Plurimath::Math::Function::Fenced.new( + Plurimath::Math::Symbols::Paren::Lround.new, + [ + Plurimath::Math::Function::Fenced.new( + Plurimath::Math::Symbols::Paren::Lround.new, + [ + Plurimath::Math::Function::FontStyle::SansSerif.new( + Plurimath::Math::Symbols::UpcaseTheta.new, + "sans-serif", + ), + ], + Plurimath::Math::Symbols::Paren::Rround.new, + ), + Plurimath::Math::Function::FontStyle::SansSerif.new( + Plurimath::Math::Symbols::Symbol.new("L"), + "sans-serif", + ), + ], + Plurimath::Math::Symbols::Paren::Rround.new, + ), + ]) + end + + it "matches the UnitsML to UnicodeMath converted value" do + expect(formula).to eq(expected_value) + end + end + end end diff --git a/spec/unitsml/conv/unicode_spec.rb b/spec/unitsml/conv/unicode_spec.rb index e4cafe4..65ddd06 100644 --- a/spec/unitsml/conv/unicode_spec.rb +++ b/spec/unitsml/conv/unicode_spec.rb @@ -256,4 +256,141 @@ expect(formula).to be_equivalent_to(expected_value) end end + + describe "implicit extender" do + context "implicit extender example #1 from issue#53" do + let(:exp) { "unitsml(J(kg*K))" } + let(:expected_value) { "J(kg·K)" } + + it "matches the UnitsML to UnicodeMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #2 from issue#53" do + let(:exp) { "unitsml(J kg^-1 * K^-1)" } + let(:expected_value) { "J kg^-1·K^-1" } + + it "matches the UnitsML to UnicodeMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #3 from issue#53" do + let(:exp) { "unitsml(J/mol * K)" } + let(:expected_value) { "J/mol^-1·K^-1" } + + it "matches the UnitsML to UnicodeMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #4 from issue#53" do + let(:exp) { "unitsml(J/(mol * K))" } + let(:expected_value) { "J/mol^-1·K^-1" } + + it "matches the UnitsML to UnicodeMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #5" do + let(:exp) { "unitsml((mol * K)J)" } + let(:expected_value) { "(mol·K)J" } + + it "matches the UnitsML to UnicodeMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #6" do + let(:exp) { "unitsml((mol * K) J)" } + let(:expected_value) { "(mol·K)J" } + + it "matches the UnitsML to UnicodeMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #7" do + let(:exp) { "unitsml((mol * K)(J))" } + let(:expected_value) { "(mol·K)(J)" } + + it "matches the UnitsML to UnicodeMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #8" do + let(:exp) { "unitsml((mol * K)(J*K))" } + let(:expected_value) { "(mol·K)(J·K)" } + + it "matches the UnitsML to UnicodeMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #9" do + let(:exp) { "unitsml(E_erlang(mm)*kg)" } + let(:expected_value) { "E(mm)·kg" } + + it "matches the UnitsML to UnicodeMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #10" do + let(:exp) { "unitsml(dim_Theta(dim_phi))" } + let(:expected_value) { "𝝧(𝞅)" } + + it "matches the UnitsML to UnicodeMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #11" do + let(:exp) { "unitsml((dim_Theta)dim_L)" } + let(:expected_value) { "(𝝧)𝖫" } + + it "matches the UnitsML to UnicodeMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #12" do + let(:exp) { "unitsml(dim_Theta dim_L)" } + let(:expected_value) { "𝝧 𝖫" } + + it "matches the UnitsML to UnicodeMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #13" do + let(:exp) { "unitsml(dim_phi (dim_Theta dim_L))" } + let(:expected_value) { "𝞅(𝝧 𝖫)" } + + it "matches the UnitsML to UnicodeMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #14" do + let(:exp) { "unitsml((dim_phi(dim_I)) ((dim_Theta) dim_L))" } + let(:expected_value) { "(𝞅(𝖨))((𝝧)𝖫)" } + + it "matches the UnitsML to UnicodeMath converted value" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #15" do + let(:exp) { "unitsml(sqrt(dim_phi(dim_I)) ((dim_Theta) dim_L))" } + let(:expected_value) { "𝞅(𝖨)((𝝧)𝖫)" } + + it "matches the UnitsML to UnicodeMath converted value" do + expect(formula).to eq(expected_value) + end + end + end end diff --git a/spec/unitsml/parse_spec.rb b/spec/unitsml/parse_spec.rb index 3d5da39..808b8a1 100644 --- a/spec/unitsml/parse_spec.rb +++ b/spec/unitsml/parse_spec.rb @@ -8,10 +8,10 @@ let(:exp) { "unitsml(mm*s^-2)" } it "returns parslet tree of parsed Unitsml string" do - expect(formula[:prefixes]).to eq("m") - expect(formula[:units]).to eq("m") + expect(formula[:prefix]).to eq("m") + expect(formula[:unit]).to eq("m") expect(formula[:extender]).to eq("*") - expect(formula[:sequence][:units]).to eq("s") + expect(formula[:sequence][:unit]).to eq("s") expect(formula[:sequence][:integer]).to eq("-2") end end @@ -20,8 +20,8 @@ let(:exp) { "unitsml(um)" } it "returns parslet tree of parsed Unitsml string" do - expect(formula[:prefixes]).to eq("u") - expect(formula[:units]).to eq("m") + expect(formula[:prefix]).to eq("u") + expect(formula[:unit]).to eq("m") end end @@ -29,7 +29,7 @@ let(:exp) { "unitsml(degK)" } it "returns parslet tree of parsed Unitsml string" do - expect(formula[:units]).to eq("degK") + expect(formula[:unit]).to eq("degK") end end @@ -37,7 +37,7 @@ let(:exp) { "unitsml(prime)" } it "returns parslet tree of parsed Unitsml string" do - expect(formula[:units]).to eq("prime") + expect(formula[:unit]).to eq("prime") end end @@ -45,7 +45,7 @@ let(:exp) { "unitsml(rad)" } it "returns parslet tree of parsed Unitsml string" do - expect(formula[:units]).to eq("rad") + expect(formula[:unit]).to eq("rad") end end @@ -53,7 +53,7 @@ let(:exp) { "unitsml(Hz)" } it "returns parslet tree of parsed Unitsml string" do - expect(formula[:units]).to eq("Hz") + expect(formula[:unit]).to eq("Hz") end end @@ -61,8 +61,8 @@ let(:exp) { "unitsml(kg)" } it "returns parslet tree of parsed Unitsml string" do - expect(formula[:prefixes]).to eq("k") - expect(formula[:units]).to eq("g") + expect(formula[:prefix]).to eq("k") + expect(formula[:unit]).to eq("g") end end @@ -70,7 +70,7 @@ let(:exp) { "unitsml(m)" } it "returns parslet tree of parsed Unitsml string" do - expect(formula[:units]).to eq("m") + expect(formula[:unit]).to eq("m") end end @@ -78,7 +78,7 @@ let(:exp) { "unitsml(sqrt(Hz))" } it "returns parslet tree of parsed Unitsml string" do - expect(formula[:sqrt][:units]).to eq("Hz") + expect(formula[:sqrt][:unit]).to eq("Hz") end end @@ -86,8 +86,8 @@ let(:exp) { "unitsml(kg)" } it "returns parslet tree of parsed Unitsml string" do - expect(formula[:prefixes]).to eq("k") - expect(formula[:units]).to eq("g") + expect(formula[:prefix]).to eq("k") + expect(formula[:unit]).to eq("g") end end @@ -95,7 +95,7 @@ let(:exp) { "unitsml(g)" } it "returns parslet tree of parsed Unitsml string" do - expect(formula[:units]).to eq("g") + expect(formula[:unit]).to eq("g") end end @@ -103,7 +103,7 @@ let(:exp) { "unitsml(hp)" } it "returns parslet tree of parsed Unitsml string" do - expect(formula[:units]).to eq("hp") + expect(formula[:unit]).to eq("hp") end end @@ -113,10 +113,10 @@ it "returns parslet tree of parsed Unitsml string" do sequence = formula[:sequence] - expect(formula[:prefixes]).to eq("k") - expect(formula[:units]).to eq("g") + expect(formula[:prefix]).to eq("k") + expect(formula[:unit]).to eq("g") expect(formula[:extender]).to eq("*") - expect(sequence[:units]).to eq("s") + expect(sequence[:unit]).to eq("s") expect(sequence[:integer]).to eq("-2") end end @@ -125,7 +125,7 @@ let(:exp) { "unitsml(degK)" } it "returns parslet tree of parsed Unitsml string" do - expect(formula[:units]).to eq("degK") + expect(formula[:unit]).to eq("degK") end end @@ -133,8 +133,8 @@ let(:exp) { "unitsml(mbar)" } it "returns parslet tree of parsed Unitsml string" do - expect(formula[:prefixes]).to eq("m") - expect(formula[:units]).to eq("bar") + expect(formula[:prefix]).to eq("m") + expect(formula[:unit]).to eq("bar") end end @@ -142,7 +142,7 @@ let(:exp) { "unitsml(p-)" } it "returns parslet tree of parsed Unitsml string" do - expect(formula[:prefixes]).to eq("p") + expect(formula[:prefix]).to eq("p") end end @@ -150,7 +150,7 @@ let(:exp) { "unitsml(h-)" } it "returns parslet tree of parsed Unitsml string" do - expect(formula[:prefixes]).to eq("h") + expect(formula[:prefix]).to eq("h") end end @@ -158,7 +158,7 @@ let(:exp) { "unitsml(da-)" } it "returns parslet tree of parsed Unitsml string" do - expect(formula[:prefixes]).to eq("da") + expect(formula[:prefix]).to eq("da") end end @@ -166,7 +166,7 @@ let(:exp) { "unitsml(u-)" } it "returns parslet tree of parsed Unitsml string" do - expect(formula[:prefixes]).to eq("u") + expect(formula[:prefix]).to eq("u") end end @@ -176,9 +176,9 @@ it "returns parslet tree of parsed Unitsml string" do sequence = formula[:sequence] - expect(formula[:units]).to eq("A") + expect(formula[:unit]).to eq("A") expect(formula[:extender]).to eq("*") - expect(sequence[:units]).to eq("C") + expect(sequence[:unit]).to eq("C") expect(sequence[:integer]).to eq("3") end end @@ -189,9 +189,9 @@ it "returns parslet tree of parsed Unitsml string" do sequence = formula[:sequence] - expect(formula[:units]).to eq("A") + expect(formula[:unit]).to eq("A") expect(formula[:extender]).to eq("/") - expect(sequence[:units]).to eq("C") + expect(sequence[:unit]).to eq("C") expect(sequence[:integer]).to eq("-3") end end @@ -202,12 +202,12 @@ it "returns parslet tree of parsed Unitsml string" do sequence = formula[:sequence] - expect(formula[:units]).to eq("J") + expect(formula[:unit]).to eq("J") expect(formula[:extender]).to eq("/") - expect(sequence[:prefixes]).to eq("k") - expect(sequence[:units]).to eq("g") + expect(sequence[:prefix]).to eq("k") + expect(sequence[:unit]).to eq("g") expect(sequence[:extender]).to eq("*") - expect(sequence[:sequence][:units]).to eq("K") + expect(sequence[:sequence][:unit]).to eq("K") end end @@ -215,8 +215,8 @@ let(:exp) { "unitsml(kg^-2)" } it "returns parslet tree of parsed Unitsml string" do - expect(formula[:prefixes]).to eq("k") - expect(formula[:units]).to eq("g") + expect(formula[:prefix]).to eq("k") + expect(formula[:unit]).to eq("g") expect(formula[:integer]).to eq("-2") end end @@ -235,10 +235,10 @@ it "returns parslet tree of parsed Unitsml string" do sequence = formula[:sequence] - expect(formula[:prefixes]).to eq("k") - expect(formula[:units]).to eq("g") + expect(formula[:prefix]).to eq("k") + expect(formula[:unit]).to eq("g") expect(formula[:extender]).to eq("*") - expect(sequence[:units]).to eq("s") + expect(sequence[:unit]).to eq("s") expect(sequence[:integer]).to eq("-2") end end @@ -249,11 +249,11 @@ it "returns parslet tree of parsed Unitsml string" do sequence = formula[:sequence] - expect(formula[:prefixes]).to eq("m") - expect(formula[:units]).to eq("W") + expect(formula[:prefix]).to eq("m") + expect(formula[:unit]).to eq("W") expect(formula[:extender]).to eq("*") - expect(sequence[:prefixes]).to eq("c") - expect(sequence[:units]).to eq("m") + expect(sequence[:prefix]).to eq("c") + expect(sequence[:unit]).to eq("m") expect(sequence[:integer]).to eq("-2") end end @@ -264,9 +264,9 @@ it "returns parslet tree of parsed Unitsml string" do sequence = formula[:sequence] - expect(formula[:dimensions]).to eq("dim_Theta") + expect(formula[:dimension]).to eq("dim_Theta") expect(formula[:extender]).to eq("*") - expect(sequence[:dimensions]).to eq("dim_L") + expect(sequence[:dimension]).to eq("dim_L") expect(sequence[:integer]).to eq("2") end end @@ -277,10 +277,10 @@ it "returns parslet tree of parsed Unitsml string" do sequence = formula[:sequence] - expect(formula[:dimensions]).to eq("dim_Theta") + expect(formula[:dimension]).to eq("dim_Theta") expect(formula[:integer]).to eq("10") expect(formula[:extender]).to eq("*") - expect(sequence[:dimensions]).to eq("dim_L") + expect(sequence[:dimension]).to eq("dim_L") expect(sequence[:integer]).to eq("2") end end @@ -289,10 +289,10 @@ let(:exp) { "unitsml(Hz^10*darcy^100)" } it "returns parslet tree of parsed Unitsml string" do - expect(formula[:units]).to eq("Hz") + expect(formula[:unit]).to eq("Hz") expect(formula[:integer]).to eq("10") expect(formula[:extender]).to eq("*") - expect(formula[:sequence][:units]).to eq("darcy") + expect(formula[:sequence][:unit]).to eq("darcy") expect(formula[:sequence][:integer]).to eq("100") end end diff --git a/spec/unitsml/parser_spec.rb b/spec/unitsml/parser_spec.rb index 0987b8e..6bc6cae 100644 --- a/spec/unitsml/parser_spec.rb +++ b/spec/unitsml/parser_spec.rb @@ -6,9 +6,9 @@ context "contains Unitsml #1 example" do let(:exp) { "unitsml(K/(kg*m))" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new([ + let(:expected_value) do + Unitsml::Formula.new( + [ Unitsml::Unit.new("K"), Unitsml::Extender.new("/"), Unitsml::Formula.new([ @@ -22,15 +22,17 @@ orig_text: "K/(kg*m)", root: true, ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #2 example" do let(:exp) { "unitsml(m, quantity: NISTq103)" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new( + let(:expected_value) do + Unitsml::Formula.new( [ Unitsml::Unit.new("m"), ], @@ -39,15 +41,17 @@ orig_text: "m, quantity: NISTq103", root: true, ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #3 example" do let(:exp) { "unitsml(cal_th/cm^2, name: langley)" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new( + let(:expected_value) do + Unitsml::Formula.new( [ Unitsml::Unit.new("cal_th"), Unitsml::Extender.new("/"), @@ -58,15 +62,17 @@ orig_text: "cal_th/cm^2, name: langley", root: true, ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #4 example" do let(:exp) { "unitsml(m, symbol: La)" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new( + let(:expected_value) do + Unitsml::Formula.new( [ Unitsml::Unit.new("m"), ], @@ -75,15 +81,17 @@ orig_text: "m, symbol: La", root: true, ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #5 example" do let(:exp) { "unitsml(cm*s^-2, symbol: cm cdot s^-2)" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new( + let(:expected_value) do + Unitsml::Formula.new( [ Unitsml::Unit.new("m", prefix: Unitsml::Prefix.new("c")), Unitsml::Extender.new("*"), @@ -94,15 +102,17 @@ orig_text: "cm*s^-2, symbol: cm cdot s^-2", norm_text: "cm*s^-2" ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #6 example" do let(:exp) { "unitsml(cm*s^-2, multiplier: xx)" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new( + let(:expected_value) do + Unitsml::Formula.new( [ Unitsml::Unit.new("m", prefix: Unitsml::Prefix.new("c")), Unitsml::Extender.new("*"), @@ -113,15 +123,17 @@ orig_text: "cm*s^-2, multiplier: xx", root: true, ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #7 example" do let(:exp) { "unitsml(mm*s^-2)" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new( + let(:expected_value) do + Unitsml::Formula.new( [ Unitsml::Unit.new("m", prefix: Unitsml::Prefix.new("m")), Unitsml::Extender.new("*"), @@ -131,120 +143,144 @@ orig_text: "mm*s^-2", norm_text: "mm*s^-2", ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #8 example" do let(:exp) { "unitsml(um)" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new([ + let(:expected_value) do + Unitsml::Formula.new( + [ Unitsml::Unit.new("m", prefix: Unitsml::Prefix.new("u")), ], norm_text: "um", orig_text: "um", root: true, ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #9 example" do let(:exp) { "unitsml(degK)" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new([ + let(:expected_value) do + Unitsml::Formula.new( + [ Unitsml::Unit.new("degK"), ], norm_text: "degK", orig_text: "degK", root: true, ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #10 example" do let(:exp) { "unitsml(prime)" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new([ + let(:expected_value) do + Unitsml::Formula.new( + [ Unitsml::Unit.new("prime"), ], norm_text: "prime", orig_text: "prime", root: true, ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #11 example" do let(:exp) { "unitsml(rad)" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new([ + let(:expected_value) do + Unitsml::Formula.new( + [ Unitsml::Unit.new("rad"), ], norm_text: "rad", orig_text: "rad", root: true, ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #12 example" do let(:exp) { "unitsml(Hz)" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new([ + let(:expected_value) do + Unitsml::Formula.new( + [ Unitsml::Unit.new("Hz"), ], norm_text: "Hz", orig_text: "Hz", root: true, ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #13 example" do let(:exp) { "unitsml(kg)" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new([ + let(:expected_value) do + Unitsml::Formula.new( + [ Unitsml::Unit.new("g", prefix: Unitsml::Prefix.new("k")), ], norm_text: "kg", orig_text: "kg", root: true, ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #14 example" do let(:exp) { "unitsml(m)" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new([ + let(:expected_value) do + Unitsml::Formula.new( + [ Unitsml::Unit.new("m"), ], norm_text: "m", orig_text: "m", root: true, ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #15 example" do let(:exp) { "unitsml(sqrt(Hz))" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new([ + let(:expected_value) do + Unitsml::Formula.new( + [ Unitsml::Sqrt.new( Unitsml::Unit.new("Hz", "0.5"), ), @@ -253,45 +289,54 @@ orig_text: "sqrt(Hz)", root: true, ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #16 example" do let(:exp) { "unitsml(g)" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new([ + let(:expected_value) do + Unitsml::Formula.new( + [ Unitsml::Unit.new("g"), ], norm_text: "g", orig_text: "g", root: true, ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #17 example" do let(:exp) { "unitsml(hp)" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new([ + let(:expected_value) do + Unitsml::Formula.new( + [ Unitsml::Unit.new("hp"), ], norm_text: "hp", orig_text: "hp", root: true, ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #18 example" do let(:exp) { "unitsml(kg*s^-2)" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new([ + let(:expected_value) do + Unitsml::Formula.new( + [ Unitsml::Unit.new("g", prefix: Unitsml::Prefix.new("k")), Unitsml::Extender.new("*"), Unitsml::Unit.new("s", "-2") @@ -300,90 +345,108 @@ orig_text: "kg*s^-2", root: true, ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #19 example" do let(:exp) { "unitsml(mbar)" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new([ + let(:expected_value) do + Unitsml::Formula.new( + [ Unitsml::Unit.new("bar", prefix: Unitsml::Prefix.new("m")) ], norm_text: "mbar", orig_text: "mbar", root: true, ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #20 example" do let(:exp) { "unitsml(p-)" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new([ + let(:expected_value) do + Unitsml::Formula.new( + [ Unitsml::Prefix.new("p", true) ], norm_text: "p-", orig_text: "p-", root: true, ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #21 example" do let(:exp) { "unitsml(h-)" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new([ + let(:expected_value) do + Unitsml::Formula.new( + [ Unitsml::Prefix.new("h", true) ], norm_text: "h-", orig_text: "h-", root: true, ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #22 example" do let(:exp) { "unitsml(da-)" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new([ + let(:expected_value) do + Unitsml::Formula.new( + [ Unitsml::Prefix.new("da", true) ], norm_text: "da-", orig_text: "da-", root: true, ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #23 example" do let(:exp) { "unitsml(u-)" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new([ + let(:expected_value) do + Unitsml::Formula.new( + [ Unitsml::Prefix.new("u", true) ], norm_text: "u-", orig_text: "u-", root: true, ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #24 example" do let(:exp) { "unitsml(A*C^3)" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new([ + let(:expected_value) do + Unitsml::Formula.new( + [ Unitsml::Unit.new("A"), Unitsml::Extender.new("*"), Unitsml::Unit.new("C", "3"), @@ -392,15 +455,18 @@ orig_text: "A*C^3", root: true, ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #25 example" do let(:exp) { "unitsml(A/C^-3)" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new([ + let(:expected_value) do + Unitsml::Formula.new( + [ Unitsml::Unit.new("A"), Unitsml::Extender.new("/"), Unitsml::Unit.new("C", "3"), @@ -409,15 +475,18 @@ orig_text: "A/C^-3", root: true, ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #26 example" do let(:exp) { "unitsml(J/kg*K)" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new([ + let(:expected_value) do + Unitsml::Formula.new( + [ Unitsml::Unit.new("J"), Unitsml::Extender.new("/"), Unitsml::Formula.new([ @@ -430,30 +499,36 @@ orig_text: "J/kg*K", root: true, ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #27 example" do let(:exp) { "unitsml(kg^-2)" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new([ + let(:expected_value) do + Unitsml::Formula.new( + [ Unitsml::Unit.new("g", "-2", prefix: Unitsml::Prefix.new("k")), ], norm_text: "kg^-2", orig_text: "kg^-2", root: true, ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #28 example" do let(:exp) { "unitsml(mW*cm^(-2))" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new([ + let(:expected_value) do + Unitsml::Formula.new( + [ Unitsml::Unit.new("W", prefix: Unitsml::Prefix.new("m")), Unitsml::Extender.new("*"), Unitsml::Unit.new("m", "-2", prefix: Unitsml::Prefix.new("c")), @@ -462,15 +537,18 @@ orig_text: "mW*cm(-2)", root: true, ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #29 example" do let(:exp) { "unitsml(dim_Theta*dim_L^2)" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new([ + let(:expected_value) do + Unitsml::Formula.new( + [ Unitsml::Dimension.new("dim_Theta"), Unitsml::Extender.new("*"), Unitsml::Dimension.new("dim_L", "2"), @@ -479,15 +557,18 @@ orig_text: "dim_Theta*dim_L^2", root: true, ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #30 example" do let(:exp) { "unitsml(dim_Theta^10*dim_L^2)" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new([ + let(:expected_value) do + Unitsml::Formula.new( + [ Unitsml::Dimension.new("dim_Theta", "10"), Unitsml::Extender.new("*"), Unitsml::Dimension.new("dim_L", "2"), @@ -496,15 +577,18 @@ orig_text: "dim_Theta^10*dim_L^2", root: true, ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #31 example" do let(:exp) { "unitsml(Hz^10*darcy^-100)" } - - it "returns parslet tree of parsed Unitsml string" do - expected_value = Unitsml::Formula.new([ + let(:expected_value) do + Unitsml::Formula.new( + [ Unitsml::Unit.new("Hz", "10"), Unitsml::Extender.new("*"), Unitsml::Unit.new("darcy", "-100"), @@ -513,15 +597,18 @@ orig_text: "Hz^10*darcy^-100", root: true, ) + end + + it "returns parslet tree of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #32 example from metanorma/bipm-si-brochure#245" do let(:exp) { "unitsml(W*m^(−2))" } - - it "returns Unitsml::Formula of parsed Unitsml string" do - expected_value = Unitsml::Formula.new([ + let(:expected_value) do + Unitsml::Formula.new( + [ Unitsml::Unit.new("W"), Unitsml::Extender.new("*"), Unitsml::Unit.new("m", "-2"), @@ -530,15 +617,18 @@ orig_text: "W*m^(-2)", root: true, ) + end + + it "returns Unitsml::Formula of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #33 example" do let(:exp) { "unitsml(((mm*mm)))" } - - it "returns Unitsml::Formula of parsed Unitsml string" do - expected_value = Unitsml::Formula.new([ + let(:expected_value) do + Unitsml::Formula.new( + [ Unitsml::Fenced.new( "(", Unitsml::Formula.new([ @@ -553,15 +643,18 @@ orig_text: "((mm*mm))", root: true, ) + end + + it "returns Unitsml::Formula of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #34 example" do let(:exp) { "((mm*mm))*mm" } - - it "returns Unitsml::Formula of parsed Unitsml string" do - expected_value = Unitsml::Formula.new([ + let(:expected_value) do + Unitsml::Formula.new( + [ Unitsml::Fenced.new( "(", Unitsml::Formula.new([ @@ -578,15 +671,17 @@ orig_text: "((mm*mm))*mm", root: true, ) + end + + it "returns Unitsml::Formula of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #35 example" do let(:exp) { "(mm*mm)*(((mm*m)))" } - - it "returns Unitsml::Formula of parsed Unitsml string" do - expected_value = Unitsml::Formula.new( + let(:expected_value) do + Unitsml::Formula.new( [ Unitsml::Formula.new([ Unitsml::Unit.new("m", prefix: Unitsml::Prefix.new("m")), @@ -610,15 +705,18 @@ orig_text: "(mm*mm)*(mm*m)", root: true, ) + end + + it "returns Unitsml::Formula of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #36 example" do let(:exp) { "((dim_Theta))*dim_N*(dim_J*dim_Theta)" } - - it "returns Unitsml::Formula of parsed Unitsml string" do - expected_value = Unitsml::Formula.new([ + let(:expected_value) do + Unitsml::Formula.new( + [ Unitsml::Fenced.new( "(", Unitsml::Dimension.new("dim_Theta"), @@ -639,15 +737,18 @@ orig_text: "((dim_Theta))*dim_N*(dim_J*dim_Theta)", root: true, ) + end + + it "returns Unitsml::Formula of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #37 example" do let(:exp) { "((dim_Theta^12))*dim_N^12*(dim_J^10*dim_Theta^10)" } - - it "returns Unitsml::Formula of parsed Unitsml string" do - expected_value = Unitsml::Formula.new([ + let(:expected_value) do + Unitsml::Formula.new( + [ Unitsml::Fenced.new( "(", Unitsml::Dimension.new("dim_Theta", "12"), @@ -668,24 +769,26 @@ orig_text: "((dim_Theta^12))*dim_N^12*(dim_J^10*dim_Theta^10)", root: true, ) + end + + it "returns Unitsml::Formula of parsed Unitsml string" do expect(formula).to eq(expected_value) end end context "contains Unitsml #38 example from unitsml/unitsml-ruby#43" do let(:exp) { "unitsml(J/((A*m)))" } - - it "matches Unitsml::Formula of processed Unitsml string" do - expected_value = Unitsml::Formula.new( + let(:expected_value) do + Unitsml::Formula.new( [ Unitsml::Unit.new("J"), Unitsml::Extender.new("/"), Unitsml::Fenced.new( "(", Unitsml::Formula.new([ - Unitsml::Unit.new("A"), + Unitsml::Unit.new("A", "-1"), Unitsml::Extender.new("*"), - Unitsml::Unit.new("m"), + Unitsml::Unit.new("m", "-1"), ]), ")", ), @@ -695,5 +798,467 @@ root: true, ) end + + it "matches Unitsml::Formula of processed Unitsml string" do + expect(formula).to eq(expected_value) + end + end + + describe "implicit extender" do + context "implicit extender example #1 from issue#53" do + let(:exp) { "unitsml(J(kg*K))" } + let(:expected_value) do + Unitsml::Formula.new( + [ + Unitsml::Unit.new("J"), + Unitsml::Fenced.new( + "(", + Unitsml::Formula.new( + [ + Unitsml::Unit.new( + "g", + prefix: Unitsml::Prefix.new("k"), + ), + Unitsml::Extender.new("*"), + Unitsml::Unit.new("K"), + ], + ), + ")", + ) + ], + norm_text: "J(kg*K)", + orig_text: "J(kg*K)", + root: true, + ) + end + + it "returns Unitsml::Formula of parsed Unitsml string" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #2 from issue#53" do + let(:exp) { "unitsml(J kg^-1 * K^-1)" } + let(:expected_value) do + Unitsml::Formula.new( + [ + Unitsml::Formula.new( + [ + Unitsml::Unit.new("J"), + Unitsml::Extender.new(" "), + Unitsml::Unit.new( + "g", + "-1", + prefix: Unitsml::Prefix.new("k"), + ), + ], + ), + Unitsml::Extender.new("*"), + Unitsml::Unit.new("K", "-1"), + ], + norm_text: "J kg^-1 * K^-1", + orig_text: "J kg^-1 * K^-1", + root: true, + ) + end + + it "returns Unitsml::Formula of parsed Unitsml string" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #3 from issue#53" do + let(:exp) { "unitsml(J/mol * K)" } + let(:expected_value) do + Unitsml::Formula.new( + [ + Unitsml::Unit.new("J"), + Unitsml::Extender.new("/"), + Unitsml::Formula.new( + [ + Unitsml::Unit.new("mol", "-1"), + Unitsml::Extender.new("*"), + Unitsml::Unit.new("K", "-1"), + ], + ), + ], + norm_text: "J/mol * K", + orig_text: "J/mol * K", + root: true, + ) + end + + it "returns Unitsml::Formula of parsed Unitsml string" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #4 from issue#53" do + let(:exp) { "unitsml(J/(mol * K))" } + let(:expected_value) do + Unitsml::Formula.new( + [ + Unitsml::Unit.new("J"), + Unitsml::Extender.new("/"), + Unitsml::Formula.new( + [ + Unitsml::Unit.new("mol", "-1"), + Unitsml::Extender.new("*"), + Unitsml::Unit.new("K", "-1"), + ], + ), + ], + norm_text: "J/(mol * K)", + orig_text: "J/(mol * K)", + root: true, + ) + end + + it "returns Unitsml::Formula of parsed Unitsml string" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #5" do + let(:exp) { "unitsml((mol * K)J)" } + let(:expected_value) do + Unitsml::Formula.new( + [ + Unitsml::Fenced.new( + "(", + Unitsml::Formula.new( + [ + Unitsml::Unit.new("mol"), + Unitsml::Extender.new("*"), + Unitsml::Unit.new("K"), + ], + ), + ")", + ), + Unitsml::Unit.new("J"), + ], + norm_text: "(mol * K)J", + orig_text: "(mol * K)J", + root: true, + ) + end + + it "returns Unitsml::Formula of parsed Unitsml string" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #6" do + let(:exp) { "unitsml((mol * K) J)" } + let(:expected_value) do + Unitsml::Formula.new( + [ + Unitsml::Fenced.new( + "(", + Unitsml::Formula.new( + [ + Unitsml::Unit.new("mol"), + Unitsml::Extender.new("*"), + Unitsml::Unit.new("K"), + ], + ), + ")", + ), + Unitsml::Unit.new("J"), + ], + norm_text: "(mol * K) J", + orig_text: "(mol * K) J", + root: true, + ) + end + + it "returns Unitsml::Formula of parsed Unitsml string" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #7" do + let(:exp) { "unitsml((mol * K)(J))" } + let(:expected_value) do + Unitsml::Formula.new( + [ + Unitsml::Fenced.new( + "(", + Unitsml::Formula.new( + [ + Unitsml::Unit.new("mol"), + Unitsml::Extender.new("*"), + Unitsml::Unit.new("K"), + ], + ), + ")", + ), + Unitsml::Fenced.new( + "(", + Unitsml::Unit.new("J"), + ")", + ) + ], + orig_text: "(mol * K)(J)", + norm_text: "(mol * K)(J)", + root: true, + ) + end + + it "returns Unitsml::Formula of parsed Unitsml string" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #8" do + let(:exp) { "unitsml((mol * K)(J*K))" } + let(:expected_value) do + Unitsml::Formula.new( + [ + Unitsml::Fenced.new( + "(", + Unitsml::Formula.new( + [ + Unitsml::Unit.new("mol"), + Unitsml::Extender.new("*"), + Unitsml::Unit.new("K"), + ], + ), + ")", + ), + Unitsml::Fenced.new( + "(", + Unitsml::Formula.new( + [ + Unitsml::Unit.new("J"), + Unitsml::Extender.new("*"), + Unitsml::Unit.new("K"), + ], + ), + ")", + ), + ], + orig_text: "(mol * K)(J*K)", + norm_text: "(mol * K)(J*K)", + root: true, + ) + end + + it "returns Unitsml::Formula of parsed Unitsml string" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #9" do + let(:exp) { "unitsml(E_erlang(mm)*kg)" } + let(:expected_value) do + Unitsml::Formula.new( + [ + Unitsml::Formula.new( + [ + Unitsml::Unit.new("E_erlang"), + Unitsml::Fenced.new( + "(", + Unitsml::Unit.new("m", prefix: Unitsml::Prefix.new("m")), + ")", + ), + ], + ), + Unitsml::Extender.new("*"), + Unitsml::Unit.new("g", prefix: Unitsml::Prefix.new("k")), + ], + orig_text: "E_erlang(mm)*kg", + norm_text: "E_erlang(mm)*kg", + root: true, + ) + end + + it "returns Unitsml::Formula of parsed Unitsml string" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #10" do + let(:exp) { "unitsml(dim_Theta(dim_phi))" } + let(:expected_value) do + Unitsml::Formula.new( + [ + Unitsml::Dimension.new("dim_Theta"), + Unitsml::Fenced.new( + "(", + Unitsml::Dimension.new("dim_phi"), + ")", + ), + ], + orig_text: "dim_Theta(dim_phi)", + norm_text: "dim_Theta(dim_phi)", + root: true, + ) + end + + it "returns Unitsml::Formula of parsed Unitsml string" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #11" do + let(:exp) { "unitsml((dim_Theta)dim_L)" } + let(:expected_value) do + Unitsml::Formula.new( + [ + Unitsml::Fenced.new( + "(", + Unitsml::Dimension.new("dim_Theta"), + ")", + ), + Unitsml::Dimension.new("dim_L"), + ], + orig_text: "dim_Theta(dim_L)", + norm_text: "dim_Theta(dim_L)", + root: true, + ) + end + + it "returns Unitsml::Formula of parsed Unitsml string" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #12" do + let(:exp) { "unitsml(dim_Theta dim_L)" } + let(:expected_value) do + Unitsml::Formula.new( + [ + Unitsml::Dimension.new("dim_Theta"), + Unitsml::Extender.new(" "), + Unitsml::Dimension.new("dim_L"), + ], + orig_text: "dim_Theta dim_L", + norm_text: "dim_Theta dim_L", + root: true, + ) + end + + it "returns Unitsml::Formula of parsed Unitsml string" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #13" do + let(:exp) { "unitsml(dim_phi (dim_Theta dim_L))" } + let(:expected_value) do + Unitsml::Formula.new( + [ + Unitsml::Dimension.new("dim_phi"), + Unitsml::Fenced.new( + "(", + Unitsml::Formula.new( + [ + Unitsml::Dimension.new("dim_Theta"), + Unitsml::Extender.new(" "), + Unitsml::Dimension.new("dim_L"), + ], + ), + ")", + ), + ], + orig_text: "dim_phi (dim_Theta dim_L)", + norm_text: "dim_phi (dim_Theta dim_L)", + root: true, + ) + end + + it "returns Unitsml::Formula of parsed Unitsml string" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #14" do + let(:exp) { "unitsml((dim_phi(dim_I)) ((dim_Theta) dim_L))" } + let(:expected_value) do + Unitsml::Formula.new( + [ + Unitsml::Fenced.new( + "(", + Unitsml::Formula.new( + [ + Unitsml::Dimension.new("dim_phi"), + Unitsml::Fenced.new( + "(", + Unitsml::Dimension.new("dim_I"), + ")", + ), + ], + ), + ")", + ), + Unitsml::Fenced.new( + "(", + Unitsml::Formula.new( + [ + Unitsml::Fenced.new( + "(", + Unitsml::Dimension.new("dim_Theta"), + ")", + ), + Unitsml::Dimension.new("dim_L"), + ], + ), + ")", + ), + ], + orig_text: "(dim_phi(dim_I)) ((dim_Theta) dim_L)", + norm_text: "(dim_phi(dim_I)) ((dim_Theta) dim_L)", + root: true, + ) + end + + it "returns Unitsml::Formula of parsed Unitsml string" do + expect(formula).to eq(expected_value) + end + end + + context "implicit extender example #15" do + let(:exp) { "unitsml(sqrt(dim_phi(dim_I)) ((dim_Theta) dim_L))" } + let(:expected_value) do + Unitsml::Formula.new( + [ + Unitsml::Sqrt.new( + Unitsml::Formula.new( + [ + Unitsml::Dimension.new("dim_phi"), + Unitsml::Fenced.new( + "(", + Unitsml::Dimension.new("dim_I"), + ")", + ), + ], + ), + ), + Unitsml::Fenced.new( + "(", + Unitsml::Formula.new( + [ + Unitsml::Fenced.new( + "(", + Unitsml::Dimension.new("dim_Theta"), + ")", + ), + Unitsml::Dimension.new("dim_L"), + ], + ), + ")", + ), + ], + orig_text: "sqrt(dim_phi(dim_I)) ((dim_Theta) dim_L)", + norm_text: "sqrt(dim_phi(dim_I)) ((dim_Theta) dim_L)", + root: true, + ) + end + + it "returns Unitsml::Formula of parsed Unitsml string" do + expect(formula).to eq(expected_value) + end + end end end