spot_feel 0.0.1

data/lib/spot_feel/spot_feel.treetop

@@ -0,0 +1,659 @@
+grammar SpotFeel
+
+  rule start
+    expression_or_tests
+  end
+
+  rule expression_or_tests
+    simple_expression /
+    simple_unary_tests
+  end
+
+  #
+  # 1. expression =
+  # 1.a textual expression |
+  # 1.b boxed expression ;
+  #
+  rule expression
+    simple_expression
+  end
+
+  rule bracketed_expression
+    "(" __ expression __ ")" {
+      def eval(context={})
+        expression.eval(context)
+      end
+    }
+  end
+
+  #
+  # 2. textual expression =
+  # 2.a function definition | for expression | if expression | quantified expression |
+  # 2.b disjunction |
+  # 2.c conjunction |
+  # 2.d comparison |
+  # 2.e arithmetic expression |
+  # 2.f instance of |
+  # 2.g path expression |
+  # 2.h filter expression | function invocation |
+  # 2.i literal | simple positive unary test | name | "(" , textual expression , ")" ;
+  #
+
+  #
+  # 3. textual expressions = textual expression , { "," , textual expression } ;
+  #
+
+  #
+  # 4. arithmetic expression =
+  # 4.a addition | subtraction |
+  # 4.b multiplication | division |
+  # 4.c exponentiation |
+  # 4.d arithmetic negation ;
+  #
+  rule arithmetic_expression
+    addition /
+    subtraction /
+    multiplication /
+    division /
+    exponentiation /
+    arithmetic_negation /
+    bracketed_arithmetic_expression
+  end
+
+  rule bracketed_arithmetic_expression
+    "(" __ arithmetic_expression __ ")" {
+      def eval(context={})
+        arithmetic_expression.eval(context)
+      end
+    }
+  end
+
+  #
+  # 5. simple expression = arithmetic expression | simple value ;
+  #
+  # Note: added boxed_expression here to support list and context
+  #
+  rule simple_expression
+    expanded_simple_expression /
+    arithmetic_expression /
+    comparison /
+    simple_value /
+    bracketed_expression
+  end
+
+  #
+  # NOTE: these rules go beyond S-FEEL spec
+  #
+  rule expanded_simple_expression
+    if_expression /
+    comparison /
+    boxed_expression
+  end
+
+  #
+  # 6. simple expressions = simple expression , { "," , simple expression } ;
+  #
+  rule simple_expressions
+    expr:simple_expression more_exprs:(__ "," __ simple_expression)* <SimpleExpressions>
+  end
+
+  #
+  # 7. simple positive unary test =
+  # 7.a [ "<" | "<=" | ">" | ">=" ] , endpoint |
+  # 7.b interval ;
+  #
+  rule simple_positive_unary_test
+    head:((unary_operator / "not") __)? tail:endpoint <SimplePositiveUnaryTest> /
+    interval
+  end
+
+  rule unary_operator
+    "<=" /
+    ">=" /
+    "<" /
+    ">"
+  end
+
+  #
+  # 8. interval = ( open interval start | closed interval start ) , endpoint , ".." , endpoint , ( open interval end | closed interval end ) ;
+  #
+  rule interval
+    start_token:("(" / "]") __ first:endpoint __ ".." __ second:endpoint __ end_token:(")" / "[") <Interval> /
+    start_token:"[" __ first:endpoint __ ".." __ second:endpoint __ end_token:"]" <Interval>
+  end
+
+  #
+  # 9. open interval start = "(" | "]" ;
+  #
+  rule open_interval_start
+    "(" <OpenIntervalStart> /
+    "]" <OpenIntervalStart>
+  end
+
+  #
+  # 10. closed interval start = "[" ;
+  #
+  rule closed_interval_start
+    "[" <ClosedIntervalStart>
+  end
+
+  #
+  # 11. open interval end = ")" | "[" ;
+  #
+  rule open_interval_end
+    ")" <OpenIntervalEnd> /
+    "[" <OpenIntervalEnd>
+  end
+
+  #
+  # 12. closed interval end = "]" ;
+  #
+  rule closed_interval_end
+    "]" <ClosedIntervalEnd>
+  end
+
+  #
+  # 13. simple positive unary tests = simple positive unary test , { "," , simple positive unary test } ;
+  #
+  rule simple_positive_unary_tests
+    test:simple_positive_unary_test more_tests:(__ "," __ simple_positive_unary_test)* <SimplePositiveUnaryTests>
+  end
+
+  #
+  # 14. simple unary tests =
+  # 14.a simple positive unary tests |
+  # 14.b "not", "(", simple positive unary tests, ")" |
+  # 14.c "-";
+  #
+  rule simple_unary_tests
+    expr:simple_positive_unary_tests <SimpleUnaryTests> /
+    negate:"not" __ "(" __ expr:simple_positive_unary_tests __ ")" <SimpleUnaryTests> /
+    "-" <SimpleUnaryTests>
+  end
+
+  #
+  # 15. positive unary test = simple positive unary test | "null" ;
+  #
+  rule positive_unary_test
+    simple_positive_unary_test /
+    null_literal
+  end
+
+  #
+  # 16. positive unary tests = positive unary test , { "," , positive unary test } ;
+  #
+  rule positive_unary_tests
+    test:positive_unary_test more_tests:(__ "," __ positive_unary_test)* <PositiveUnaryTests>
+  end
+
+  #
+  # 17. unary tests =
+  # 17.a positive unary tests |
+  # 17.b "not", " (", positive unary tests, ")" |
+  # 17.c "-"
+  #
+
+  #
+  # 18. endpoint = simple value ;
+  #
+  rule endpoint
+    arithmetic_expression /
+    simple_value
+  end
+
+  #
+  # 19. simple value = qualified name | simple literal ;
+  #
+  # Note: dmn-eval = simple literal | qualified name | function invocation
+  #
+  rule simple_value
+    literal /
+    function_invocation /
+    qualified_name
+  end
+
+  #
+  # 20. qualified name = name , { "." , name } ;
+  #
+  rule qualified_name
+    head:name tail:(__ "." __ name)* <QualifiedName>
+  end
+
+  #
+  # 21. addition = expression , "+" , expression ;
+  #
+  rule addition
+    head:non_recursive_simple_expression_for_arithmetic_expression __ "+" __ tail:expression <Addition>
+  end
+
+  rule non_recursive_simple_expression_for_arithmetic_expression
+    bracketed_arithmetic_expression /
+    simple_value
+  end
+
+  rule non_recursive_simple_expression_for_comparison
+    arithmetic_expression /
+    simple_value
+  end
+
+  #
+  # 22. subtraction = expression , "-" , expression ;
+  #
+  rule subtraction
+    head:non_recursive_simple_expression_for_arithmetic_expression __ "-" __ tail:expression <Subtraction>
+  end
+
+  #
+  # 23. multiplication = expression , "\*" , expression ;
+  #
+  rule multiplication
+    head:non_recursive_simple_expression_for_arithmetic_expression __ "*" __ tail:expression <Multiplication>
+  end
+
+  #
+  # 24. division = expression , "/" , expression ;
+  #
+  rule division
+    head:non_recursive_simple_expression_for_arithmetic_expression __ "/" __ tail:expression <Division>
+  end
+
+  #
+  # 25. exponentiation = expression, "\*\*", expression ;
+  #
+  rule exponentiation
+    head:non_recursive_simple_expression_for_arithmetic_expression __ "**" __ tail:expression <Exponentiation>
+  end
+
+  #
+  # 26. arithmetic negation = "-" , expression ;
+  #
+  rule arithmetic_negation
+    "not" __ "(" __ expr:expression __ ")" {
+      def eval(context={})
+        -expr.eval(context)
+      end
+    }
+  end
+
+  #
+  # 27. name = name start , { name part | additional name symbols } ;
+  #
+  rule name
+    head:name_start tail:(__ name_part)* <Name>
+  end
+
+  rule reserved_word
+    keyword /
+    date_time_keyword /
+    null_literal /
+    boolean_literal
+  end
+
+  #
+  # 28. name start = name start char, { name part char } ; 
+  #
+  rule name_start
+    head:name_start_char tail:(name_part_char)* {
+      def eval(context={})
+        head + tail.map{|t| t[1]}.join("")
+      end
+    }
+  end
+
+  #
+  # 29. name part = name part char , { name part char } ;
+  #
+  rule name_part
+    head:name_part_char tail:(__ name_part_char)* {
+      def eval(context={})
+        head + tail.map{|t| t[1]}.join("")
+      end
+    }
+  end
+
+  #
+  # 30. name start char = "?" | [A-Z] | "\_" | [a-z] | [\uC0-\uD6] | [\uD8-\uF6] | [\uF8-\u2FF] | [\u370-\u37D] | [\u37F-\u1FFF] | [\u200C-\u200D] | [\u2070-\u218F] | [\u2C00-\u2FEF] | [\u3001-\uD7FF] | [\uF900-\uFDCF] | [\uFDF0-\uFFFD] | [\u10000-\uEFFFF] ;
+  # 
+  rule name_start_char
+    [A-Z] / [a-z] / "_" / name_start_unicode_char
+  end
+
+  rule name_start_unicode_char
+    [\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]
+  end
+
+  #
+  # 31. name part char = name start char | digit | \uB7 | [\u0300-\u036F] | [\u203F-\u2040] ;
+  #
+  rule name_part_char
+    name_start_char /
+    digit /
+    name_part_unicode_char /
+    "'"
+  end
+
+  rule name_part_unicode_char
+    [\u0B70\u0300-\u036F\u203F-\u2040]
+  end
+
+  #
+  # 32. additional name symbols = "." | "/" | "-" | "’" | "+" | "\*" ;
+  #
+  rule additional_name_symbols
+    "." / "/" / "-" / "'" / "+" / "*"
+  end
+
+  #
+  # 33. literal = simple literal | "null" ;
+  #
+  rule literal
+    simple_literal /
+    null_literal
+  end
+
+  #
+  # 34. simple literal = numeric literal | string literal | boolean literal | date time literal ;
+  #
+  rule simple_literal
+    numeric_literal /
+    string_literal /
+    boolean_literal /
+    date_time_literal
+  end
+
+  #
+  # 35. string literal = '"' , { character – ('"' | vertical space) }, '"' ;
+  #
+  rule string_literal
+    '"' chars:double_string_character* '"' <StringLiteral> /
+    "'" chars:single_string_character* "'" <StringLiteral>
+  end
+
+  rule double_string_character
+    !('"' / "\\" / line_terminator) source_character /
+    "\\" escape_sequence /
+    line_continuation
+  end
+
+  rule single_string_character
+    !("'" / "\\" / line_terminator) source_character /
+    "\\" escape_sequence /
+    line_continuation
+  end
+
+  rule source_character
+    .
+  end
+
+  rule line_continuation
+    "\\" __ line_terminator_sequence __
+  end
+
+  rule escape_sequence
+    character_escape_sequence
+  end
+
+  rule character_escape_sequence
+    single_escape_character
+  end
+
+  rule single_escape_character
+    "'" / '"' / "\\"
+  end
+
+  rule line_terminator
+    line_terminator_sequence
+  end
+
+  rule line_terminator_sequence
+    "\n" / "\r" / "\r\n"
+  end
+
+  #
+  # 36. Boolean literal = "true" | "false" ;
+  #
+  rule boolean_literal
+    "true" <BooleanLiteral> / 
+    "false" <BooleanLiteral>
+  end
+
+  #
+  # 37. numeric literal = [ "-" ] , ( digits , [ ".", digits ] | "." , digits ) ;
+  #
+  rule numeric_literal
+    '-'? digits ('.' digits)? <NumericLiteral>
+  end
+
+  rule null_literal
+    "null" <NullLiteral>
+  end
+
+  #
+  # 38. digit = [0-9] ;
+  #
+  rule digit
+    [0-9]
+  end
+
+  #
+  # 39. digits = digit , {digit} ;
+  #
+  rule digits
+    digit+
+  end
+
+  #
+  # 40. function invocation = expression , parameters ;
+  #
+  rule function_invocation
+    fn_name:(!reserved_word qualified_name) __ "(" __ params:(positional_parameters)? __ ")" <FunctionInvocation>
+  end
+
+  #
+  # 41. parameters = "(" , ( named parameters | positional parameters ) , ")" ;
+  #
+
+  #
+  # 42. named parameters = parameter name , ":" , expression , { "," , parameter name , ":" , expression } ;
+  #
+
+  #
+  # 43. parameter name = name ;
+  #
+
+  #
+  # 44. positional parameters = [ expression , { "," , expression } ] ;
+  #
+  rule positional_parameters
+    expression __ more_expressions:(__ "," __ expression)* <PositionalParameters>
+  end
+
+  #
+  # 45. path expression = expression , "." , name ;
+  #
+  rule path_expression
+    expression __ "." __ name:name <PathExpression>
+  end
+
+  #
+  # 46. for expression = "for" , name , "in" , expression { "," , name , "in" , expression } , "return" , expression ;
+  #
+  rule for_expression
+    "for" __ name:name __ "in" __ expression __ more_for_expressions:(__ "," __ name:name __ "in" __ expression)* __ "return" __ return_expression:expression <ForExpression>
+  end
+
+  #
+  # 47. if expression = "if" , expression , "then" , expression , "else" expression ;
+  #
+  rule if_expression
+    "if" __ condition:expression __ "then" __ true_case:expression __ "else" __ false_case:expression <IfExpression>
+  end
+
+  #
+  # 48. quantified expression = ("some" | "every") , name , "in" , expression , { name , "in" , expression } , "satisfies" , expression ;
+  #
+  rule quantified_expression
+    quantifier:("some" / "every") __ name:name __ "in" __ expression __ more_quantifiers:(__ name:name __ "in" __ expression)* __ "satisfies" __ satisfies:expression <QuantifiedExpression>
+  end
+
+  #
+  # 49. disjunction = expression , "or" , expression ;
+  #
+  rule disjunction
+    head:expression tail:(__ "or" __ expression)+ <Disjunction>
+  end
+
+  #
+  # 50. conjunction = expression , "and" , expression ;
+  #
+  rule conjunction
+    head:expression tail:(__ "and" __ expression)+ <Conjunction>
+  end
+
+  #
+  # 51. comparison =
+  # 51.a expression , ( "=" | "!=" | "<" | "<=" | ">" | ">=" ) , expression |
+  # 51.b expression , "between" , expression , "and" , expression |
+  # 51.c expression , "in" , positive unary test ;
+  # 51.d expression , "in" , " (", positive unary tests, ")" ;
+  #
+  rule comparison
+    left:non_recursive_simple_expression_for_comparison __ operator:comparision_operator __ right:expression <Comparison>
+  end
+
+  rule non_recursive_simple_expression_for_comparison
+    arithmetic_expression /
+    simple_value
+  end
+
+  #
+  # 52. filter expression = expression , "[" , expression , "]" ;
+  #
+  rule filter_expression
+    expression __ "[" __ filter:expression __ "]" <FilterExpression>
+  end
+
+  rule comparision_operator
+    "=" / "!=" / "<=" / ">=" / "<" / ">"
+  end
+
+  #
+  # 53. instance of = expression , "instance" , "of" , type ;
+  #
+  rule instance_of
+    expression __ "instance" __ "of" __ type <InstanceOf>
+  end
+
+  #
+  # 54. type = qualified name ;
+  #
+  rule type
+    qualified_name
+  end
+
+  #
+  # 55. boxed expression = list | function definition | context ;
+  #
+  # Note: function definition not supported yet
+  #
+  rule boxed_expression
+    list /
+    context
+  end
+
+  #
+  # 56. list = "[" [ expression , { "," , expression } ] , "]" ;
+  #
+  rule list
+    '[' __ list_entries __ ']' <List>
+    /
+    '[]' <List>
+  end
+
+  rule list_entries
+    expression more_expressions:(__ ',' __ expression)* <ListEntries>
+  end
+
+  #
+  # 57. function definition = "function" , "(" , [ formal parameter { "," , formal parameter } ] , ")" , [ "external" ] , expression ;
+  #
+  rule function_definition
+    "function" __ "(" __ formal_parameters:(formal_parameter_list)? __ ")" __ external:(__ "external")? __ expression <FunctionDefinition>
+  end
+
+  #
+  # 58. formal parameter = parameter name ;
+  #
+  rule formal_parameter
+    parameter_name:name <FormalParameter>
+  end
+
+  #
+  # 59. context = "{" , [context entry , { "," , context entry } ] , "}" ;
+  #
+  rule context
+    '{' __ entries:(context_entry_list)? __ '}' <Context>
+    /
+    '{}' <Context>
+  end
+
+  rule context_entry_list
+    context_entry tail:(__ ',' __ context_entry)* ','? <ContextEntryList>
+  end
+
+  #
+  # 60. context entry = key , ":" , expression ;
+  #
+  rule context_entry
+    context_key:expression __ ':' __ context_value:expression <ContextEntry>
+  end
+
+  #
+  # 61. key = name | string literal ;
+  #
+
+  #
+  # 62. date time literal = ( "date" | "time" | "date and time" | "duration" ) , "(" , string literal , ")" ;
+  #
+  rule date_time_literal
+    keyword:date_time_keyword __ "(" __ head:expression __ tail:("," __ expression)* __ ")" <DateTimeLiteral>
+  end
+
+  rule date_time_keyword
+    "date and time" /
+    "time" /
+    "date" /
+    "duration"
+  end
+
+  rule keyword
+    true_token /
+    false_token /
+    null_token /
+    not_token
+  end
+
+  rule not_token 
+    "not"
+  end
+
+  rule true_token
+    "true" / "TRUE" / "True" !name_part_char
+  end
+
+  rule false_token
+    "false" / "FALSE" / "False" !name_part_char
+  end
+
+  rule null_token
+    "null" !name_part_char
+  end
+
+  rule __
+    white_space*
+  end
+
+  rule white_space
+    " " / "\t" / "\n" / "\r"
+  end
+end

data/lib/spot_feel/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SpotFeel
+  VERSION = '0.0.1'
+end

data/lib/spot_feel.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "spot_feel/version"
+
+require "awesome_print"
+
+require "active_support"
+require "active_support/duration"
+require "active_support/time"
+require "active_support/core_ext/hash"
+require "active_support/core_ext/object/json"
+require "active_support/configurable"
+
+require "treetop"
+require "xmlhasher"
+
+require "spot_feel/configuration"
+require "spot_feel/nodes"
+require "spot_feel/parser"
+
+require "spot_feel/dmn"
+
+module SpotFeel
+  class SyntaxError < StandardError; end
+  class EvaluationError < StandardError; end
+
+  def self.evaluate(expression_text, variables: {})
+    literal_expression = Dmn::LiteralExpression.new(text: expression_text)
+    raise SyntaxError, "Expression is not valid" unless literal_expression.valid?
+    literal_expression.evaluate(variables)
+  end
+
+  def self.test(input, unary_tests_text, variables: {})
+    unary_tests = Dmn::UnaryTests.new(text: unary_tests_text)
+    raise SyntaxError, "Unary tests are not valid" unless unary_tests.valid?
+    unary_tests.test(input, variables)
+  end
+
+  def self.decide(decision_id, definitions: nil, definitions_json: nil, definitions_xml: nil, variables: {})
+    if definitions_xml.present?
+      definitions = Dmn::Definitions.from_xml(definitions_xml)
+    elsif definitions_json.present?
+      definitions = Dmn::Definitions.from_json(definitions_json)
+    end
+    definitions.evaluate(decision_id, variables: variables)
+  end
+
+  def self.definitions_from_xml(xml)
+    Dmn::Definitions.from_xml(xml)
+  end
+
+  def self.definitions_from_json(json)
+    Dmn::Definitions.from_json(json)
+  end
+
+  def self.config
+    @config ||= Configuration.new
+  end
+
+  def self.configure
+    yield(config)
+  end
+end