mulang 5.3.0 → 6.0.4

data/lib/mulang/language.rb

@@ -1,43 +1,115 @@
 module Mulang::Language
-  class Native
-    def initialize(language)
-      @language = language
+  CORE_LANGUAGES = %w(
+    Java
+    JavaScript
+    Prolog
+    Haskell
+    Python
+    Python2
+    Python3
+    Ruby
+    Php
+    C
+    Mulang
+  )
+
+  class Base
+    def identifiers(content, **options)
+      Mulang.analyse(identifiers_analysis(content, **options), **options)['outputIdentifiers'] rescue nil
+    end
+
+    def identifiers_analysis(content, **options)
+      build_analysis content, {includeOutputIdentifiers: true}, **options
+    end
+
+    def transformed_asts(content, operations, **options)
+      Mulang.analyse(transformed_asts_analysis(content, operations, **options), **options)['transformedAsts'] rescue nil
+    end
+
+    def transformed_asts_analysis(content, operations, **options)
+      build_analysis content, {transformationSpecs: operations}, **options
     end
 
-    def ast(content)
-      Mulang.analyse(ast_analysis(content))['intermediateLanguage'] rescue nil
+    def normalization_options(**options)
+      options.except(:serialization).presence
     end
 
-    def ast_analysis(content)
+    def ast(content, **options)
+      Mulang.analyse(ast_analysis(content, **options), **options)['outputAst'] rescue nil
+    end
+
+    def ast_analysis(content, **options)
+      build_analysis content, {includeOutputAst: true}, **options
+    end
+
+    def build_analysis(content, spec, **options)
       {
-        sample: { tag: 'CodeSample', language: @language, content: content },
-        spec: { expectations: [], smellsSet: { tag: 'NoSmells' }, includeIntermediateLanguage: true }
+        sample: sample(content),
+        spec: {
+          expectations: [],
+          smellsSet: { tag: 'NoSmells' },
+          includeOutputAst: false,
+          normalizationOptions: normalization_options(options)
+        }.merge(spec).compact
       }
     end
+  end
+
+  class Native < Base
+    attr_accessor :name
+
+    def initialize(language_name)
+      @name = language_name
+    end
 
     def sample(content)
       {
         tag: 'CodeSample',
-        language: @language,
+        language: @name,
         content: content
       }
     end
+
+    def core_name
+      @name
+    end
   end
 
-  class External
-    def initialize(&tool)
+  class External < Base
+    attr_accessor :name
+
+    def initialize(language_name = nil, &tool)
+      @name = language_name
       @tool = block_given? ? tool : proc { |it| it }
     end
 
-    def ast(content)
-      @tool.call(content) rescue nil
+    def ast(content, **args)
+      if args[:serialization]
+        super
+      else
+        call_tool content
+      end
     end
 
     def sample(content)
       {
         tag: 'MulangSample',
-        ast: ast(content)
+        ast: call_tool(content)
       }
     end
+
+    def build_analysis(*)
+      super.deep_merge(spec: {originalLanguage: core_name}.compact)
+    end
+
+    def core_name
+      @name.in?(CORE_LANGUAGES) ? name : nil
+    end
+
+    private
+
+    def call_tool(content)
+      @tool.call(content) rescue nil
+    end
   end
 end

data/lib/mulang/sexp.rb

@@ -0,0 +1,80 @@
+module Mulang
+  module Sexp
+
+    # Basic S-expression
+
+    def ms(tag, *contents)
+      if contents.empty?
+        {tag: tag}
+      elsif contents.size == 1
+        {tag: tag, contents: contents.first}
+      else
+        {tag: tag, contents: contents}
+      end
+    end
+
+    # Basic elements
+
+    def primitive(operator)
+      ms(:Primitive, operator)
+    end
+
+    def sequence(*contents)
+      if contents.empty?
+        none
+      elsif contents.size == 1
+        contents[0]
+      else
+        ms(:Sequence, *contents)
+      end
+    end
+
+    def none
+      ms(:None)
+    end
+
+    # Callables
+
+    def simple_function(name, args, body)
+      callable :Function, name, args, body
+    end
+
+    def simple_method(name, args, body)
+      callable :Method, name, args, body
+    end
+
+    def primitive_method(name, args, body)
+      callable :PrimitiveMethod, name, args, body
+    end
+
+    def callable(type, name, args, body)
+      {
+          tag: type,
+          contents: [
+              name,
+              [
+                  [ args, {tag: :UnguardedBody, contents: body }]
+              ]
+          ]
+      }
+    end
+
+    # Applications
+
+    def primitive_send(sender, op, args)
+      ms(:Send, sender, primitive(op), args)
+    end
+
+    def simple_send(sender, message, args)
+      ms(:Send, sender, ms(:Reference, message), args)
+    end
+
+    def application(name, args)
+      ms :Application, [ms(:Reference, name), args]
+    end
+
+    def binary_application(operator, left, right)
+      application operator, [left, right]
+    end
+  end
+end

data/lib/mulang/tokens.rb

@@ -0,0 +1,276 @@
+module Mulang
+  module Tokens
+    TOKENS = {
+      Common: {
+        keyword_False: 'false',
+        keyword_Null: 'null',
+        keyword_True: 'true',
+        keyword_For: 'for',
+        keyword_If: 'if',
+        keyword_Return: 'return',
+        keyword_While: 'while',
+        operator_And: '&&',
+        operator_Divide: '/',
+        operator_Equal: '==',
+        operator_GreatherOrEqualThan: '>=',
+        operator_GreatherThan: '>',
+        operator_LessOrEqualThan: '<=',
+        operator_LessThan: '<',
+        operator_Minus: '-',
+        operator_Multiply: '*',
+        operator_Negation: '!',
+        operator_NotEqual: '!=',
+        operator_Or: '||',
+        operator_Plus: '+',
+        operator_Modulo: '%',
+        operator_BitwiseOr: '|',
+        operator_BitwiseAnd: '&',
+        operator_BitwiseXor: '^',
+        operator_BitwiseLeftShift: '<<',
+        operator_BitwiseRightShift: '>>'
+      },
+      C: {
+        keyword_False: 'FALSE',
+        keyword_Null: 'NULL',
+        keyword_True: 'TRUE',
+        keyword_For: 'for',
+        keyword_If: 'if',
+        keyword_Return: 'return',
+        keyword_While: 'while',
+        keyword_Switch: 'switch',
+        operator_And: '&&',
+        operator_Divide: '/',
+        operator_Equal: '==',
+        operator_GreatherOrEqualThan: '>=',
+        operator_GreatherThan: '>',
+        operator_LessOrEqualThan: '<=',
+        operator_LessThan: '<',
+        operator_Minus: '-',
+        operator_Multiply: '*',
+        operator_Negation: '!',
+        operator_NotEqual: '!=',
+        operator_Or: '||',
+        operator_Plus: '+',
+        operator_Modulo: '%',
+        operator_BitwiseOr: '|',
+        operator_BitwiseAnd: '&',
+        operator_BitwiseXor: '^',
+        operator_BitwiseLeftShift: '<<',
+        operator_BitwiseRightShift: '>>'
+      },
+      Haskell: {
+        keyword_False: 'False',
+        keyword_True: 'True',
+        keyword_If: 'if',
+        keyword_TypeAlias: 'type',
+        operator_And: '&&',
+        operator_Divide: '/',
+        operator_Equal: '==',
+        operator_GreatherOrEqualThan: '>=',
+        operator_GreatherThan: '>',
+        operator_LessOrEqualThan: '<=',
+        operator_LessThan: '<',
+        operator_Minus: '-',
+        operator_Multiply: '*',
+        operator_Negation: 'not',
+        operator_NotEqual: '/=',
+        operator_Or: '||',
+        operator_Plus: '+',
+        operator_Modulo: 'mod',
+        operator_Otherwise: 'otherwise',
+        operator_BackwardComposition: '.'
+      },
+      Java: {
+        keyword_False: 'false',
+        keyword_Null: 'null',
+        keyword_True: 'true',
+        keyword_For: 'for',
+        keyword_If: 'if',
+        keyword_Return: 'return',
+        keyword_While: 'while',
+        keyword_Class: 'class',
+        keyword_ForEach: 'for',
+        keyword_Interface: 'interface',
+        keyword_Switch: 'switch',
+        operator_And: '&&',
+        operator_Divide: '/',
+        operator_Equal: 'equal',
+        operator_GreatherOrEqualThan: '>=',
+        operator_GreatherThan: '>',
+        operator_LessOrEqualThan: '<=',
+        operator_LessThan: '<',
+        operator_Minus: '-',
+        operator_Multiply: '*',
+        operator_Negation: '!',
+        operator_NotEqual: '!=',
+        operator_Or: '||',
+        operator_Plus: '+',
+        operator_Modulo: '%',
+        operator_BitwiseOr: '|',
+        operator_BitwiseAnd: '&',
+        operator_BitwiseXor: '^',
+        operator_BitwiseLeftShift: '<<',
+        operator_BitwiseRightShift: '>>',
+        operator_Hash: 'hashCode',
+        operator_Same: '==',
+        operator_NotSame: '!='
+      },
+      JavaScript: {
+        keyword_False: 'false',
+        keyword_Null: 'null',
+        keyword_True: 'true',
+        keyword_For: 'for',
+        keyword_If: 'if',
+        keyword_Return: 'return',
+        keyword_While: 'while',
+        operator_And: '&&',
+        operator_Divide: '/',
+        operator_Equal: '===',
+        operator_GreatherOrEqualThan: '>=',
+        operator_GreatherThan: '>',
+        operator_LessOrEqualThan: '<=',
+        operator_LessThan: '<',
+        operator_Minus: '-',
+        operator_Multiply: '*',
+        operator_Negation: '!',
+        operator_NotEqual: '!==',
+        operator_Or: '||',
+        operator_Plus: '+',
+        operator_Modulo: '%',
+        operator_BitwiseOr: '|',
+        operator_BitwiseAnd: '&',
+        operator_BitwiseXor: '^',
+        operator_BitwiseLeftShift: '<<',
+        operator_BitwiseRightShift: '>>',
+        operator_Size: 'length',
+        operator_Similar: '==',
+        operator_NotSimilar: '!=',
+        operator_Push: 'push'
+      },
+      Python: {
+        keyword_False: 'False',
+        keyword_Null: 'None',
+        keyword_True: 'True',
+        keyword_For: 'for',
+        keyword_If: 'if',
+        keyword_Return: 'return',
+        keyword_While: 'while',
+        operator_And: 'and',
+        operator_Divide: '/',
+        operator_Equal: '==',
+        operator_GreatherOrEqualThan: '>=',
+        operator_GreatherThan: '>',
+        operator_LessOrEqualThan: '<=',
+        operator_LessThan: '<',
+        operator_Minus: '-',
+        operator_Multiply: '*',
+        operator_Negation: 'not',
+        operator_NotEqual: '!=',
+        operator_Or: 'or',
+        operator_Plus: '+',
+        operator_Modulo: '%',
+        operator_BitwiseOr: '|',
+        operator_BitwiseAnd: '&',
+        operator_BitwiseXor: '^',
+        operator_BitwiseLeftShift: '<<',
+        operator_BitwiseRightShift: '>>',
+        operator_Hash: 'hash'
+      },
+      Ruby: {
+        keyword_False: 'false',
+        keyword_Null: 'null',
+        keyword_True: 'true',
+        keyword_For: 'for',
+        keyword_If: 'if',
+        keyword_Return: 'return',
+        keyword_While: 'while',
+        keyword_Class: 'class',
+        keyword_ForEach: 'for',
+        keyword_Include: 'include',
+        keyword_Switch: 'case',
+        operator_And: '&&',
+        operator_Divide: '/',
+        operator_Equal: '==',
+        operator_GreatherOrEqualThan: '>=',
+        operator_GreatherThan: '>',
+        operator_LessOrEqualThan: '<=',
+        operator_LessThan: '<',
+        operator_Minus: '-',
+        operator_Multiply: '*',
+        operator_Negation: '!',
+        operator_NotEqual: '!=',
+        operator_Or: '||',
+        operator_Plus: '+',
+        operator_Modulo: '%',
+        operator_BitwiseOr: '|',
+        operator_BitwiseAnd: '&',
+        operator_BitwiseXor: '^',
+        operator_BitwiseLeftShift: '<<',
+        operator_BitwiseRightShift: '>>',
+        operator_Size: 'length',
+        operator_Hash: 'hash',
+        operator_ForwardComposition: '>>',
+        operator_BackwardComposition: '<<'
+      },
+      Php: {
+        keyword_False: 'false',
+        keyword_Null: 'null',
+        keyword_True: 'true',
+        keyword_For: 'for',
+        keyword_If: 'if',
+        keyword_Return: 'return',
+        keyword_While: 'while',
+        operator_And: '&&',
+        operator_Divide: '/',
+        operator_Equal: '==',
+        operator_GreatherOrEqualThan: '>=',
+        operator_GreatherThan: '>',
+        operator_LessOrEqualThan: '<=',
+        operator_LessThan: '<',
+        operator_Minus: '-',
+        operator_Multiply: '*',
+        operator_Negation: '!',
+        operator_NotEqual: '!=',
+        operator_Or: '||',
+        operator_Plus: '+',
+        operator_Modulo: '%',
+        operator_BitwiseOr: '|',
+        operator_BitwiseAnd: '&',
+        operator_BitwiseXor: '^',
+        operator_BitwiseLeftShift: '<<',
+        operator_BitwiseRightShift: '>>'
+      },
+      Prolog: {
+        keyword_Fail: 'fail',
+        keyword_Findall: 'findall',
+        keyword_Forall: 'forall',
+        keyword_Not: 'not',
+        keyword_Is: 'is',
+        operator_Divide: '/',
+        operator_GreatherOrEqualThan: '>=',
+        operator_GreatherThan: '>',
+        operator_LessOrEqualThan: '=<',
+        operator_LessThan: '<',
+        operator_Minus: '-',
+        operator_Multiply: '*',
+        operator_NotEqual: '/=',
+        operator_Plus: '+'
+      }
+    }.freeze
+
+    POLYFILLS = {
+      Common: {
+        keyword_EntryPoint: 'program',
+        keyword_ForEach: 'foreach',
+        keyword_Repeat: 'repeat',
+        keyword_Switch: 'switch',
+        keyword_Yield: 'yield',
+        operator_Hash: 'hash',
+        operator_BackwardComposition: '.',
+        operator_ForwardComposition: '>>'
+      }
+    }.freeze
+
+    DEFAULT_TOKENS = TOKENS[:Common].merge(POLYFILLS[:Common]).freeze
+  end
+end