mulang 5.3.0 → 6.0.0

data/lib/mulang.rb

@@ -9,16 +9,65 @@ module Mulang
   def self.bin_path
     File.join(__dir__, '..', 'bin', 'mulang')
   end
-  def self.analyse(analysis)
-    Open3.popen2(bin_path, '-s') do |input, output, _thread|
-      input.puts analysis.to_json
+  def self.analyse(analysis, **options)
+    arg, mode = Mulang::RunMode.for analysis, options
+    Open3.popen2(bin_path, arg) do |input, output, _thread|
+      input.puts mode.input(analysis).to_json
       input.close
-      JSON.parse output.read
+      result = JSON.parse output.read
+      mode.output result
+    end
+  end
+
+  private
+
+  module RunMode
+    def self.for(analysis, options)
+      serialization = options[:serialization]
+      many = analysis.is_a?(Array)
+      if many
+        [encode_serialization(serialization), Mulang::RunMode::Natural]
+      elsif serialization
+        [encode_serialization(serialization), Mulang::RunMode::ForcedMany]
+      else
+        ["-s", Mulang::RunMode::Natural]
+      end
+    end
+
+    def self.encode_serialization(option)
+      case option
+      when nil then '-S'
+      when :bracket then '-B'
+      when :brace then '-C'
+      else raise "Unsupported serialization #{option}"
+      end
+    end
+
+    module Natural
+      def self.input(analysis)
+        analysis
+      end
+
+      def self.output(result)
+        result
+      end
+    end
+
+    module ForcedMany
+      def self.input(analysis)
+        [analysis]
+      end
+
+      def self.output(result)
+        result[0]
+      end
     end
   end
 end
 
+require_relative './mulang/tokens'
 require_relative './mulang/inspection'
 require_relative './mulang/expectation'
 require_relative './mulang/code'
 require_relative './mulang/language'
+require_relative './mulang/sexp'

data/lib/mulang/code.rb

@@ -1,12 +1,29 @@
 module Mulang
   class Code
+    attr_accessor :language, :content
     def initialize(language, content)
       @language = language
       @content  = content
     end
 
-    def ast
-      @language.ast @content
+    def identifiers(**options)
+      @language.identifiers @content, **options
+    end
+
+    def ast(**options)
+      @language.ast @content, **options
+    end
+
+    def ast_analysis(**options)
+      @language.ast_analysis @content, **options
+    end
+
+    def transformed_asts(operations, **options)
+      @language.transformed_asts @content, operations, **options
+    end
+
+    def transformed_asts_analysis(operations, **options)
+      @language.transformed_asts_analysis @content, operations, **options
     end
 
     def sample
@@ -17,8 +34,8 @@ module Mulang
       { sample: sample, spec: spec }
     end
 
-    def analyse(spec)
-      Mulang.analyse analysis(spec)
+    def analyse(spec, **options)
+      Mulang.analyse analysis(spec), **options
     end
 
     def expect(binding='*', inspection)
@@ -47,12 +64,25 @@ module Mulang
       new Mulang::Language::External.new(&tool), content
     end
 
-    def self.ast(ast)
-      new Mulang::Language::External.new, ast
+    def self.analyse_many(codes, spec, **options)
+      run_many(codes, **options) { |it| it.analysis(spec)  }
+    end
+
+    def self.ast_many(codes, **options)
+      run_many(codes, key: 'outputAst', **options) { |it| it.ast_analysis(**options) }
+    end
+
+    def self.transformed_asts_many(codes, operations, **options)
+      run_many(codes, key: 'transformedAsts', **options) { |it| it.transformed_asts_analysis(operations, **options) }
     end
 
     private
 
+    def self.run_many(codes, key: nil, **options)
+      result = Mulang.analyse(codes.map { |it| yield it }, **options)
+      key ? result.map { |it| it[key] } : result
+    end
+
     def expectation_results_for(result)
       raise result['reason'] if result['tag'] == 'AnalysisFailed'
       result['expectationResults']

data/lib/mulang/expectation.rb

@@ -1,43 +1,63 @@
 module Mulang::Expectation
-  SMELLS = %w(
-    DiscardsExceptions
-    DoesConsolePrint
+  LOGIC_SMELLS = %w(
+    HasRedundantReduction
+    UsesCut
+    UsesFail
+    UsesUnificationOperator
+  )
+
+  FUNCTIONAL_SMELLS = %w(
+    HasRedundantGuards
+    HasRedundantParameter
+    ShouldUseOtherwise
+  )
+
+  OBJECT_ORIENTED_SMELLS = %w(
     DoesNilTest
     DoesNullTest
-    DoesTypeTest
-    HasAssignmentReturn
+    HasTooManyMethods
+    OverridesEqualOrHashButNotBoth
+    ReturnsNil
+    ReturnsNull
+  )
+
+  IMPERATIVE_SMELLS = %w(
     HasAssignmentCondition
+    HasAssignmentReturn
+    HasEmptyRepeat
+    HasRedundantLocalVariableReturn
+    HasRedundantRepeat
+  )
+
+  EXPRESSIVENESS_SMELLS = %w(
+    HasMisspelledBindings
+    HasMisspelledIdentifiers
+    HasTooShortIdentifiers
+    HasWrongCaseBinding
+    HasWrongCaseIdentifiers
+  )
+
+  GENERIC_SMELLS = %w(
+    DiscardsExceptions
+    DoesConsolePrint
+    DoesTypeTest
     HasCodeDuplication
     HasDeclarationTypos
     HasEmptyIfBranches
-    HasEmptyRepeat
+    HasEqualIfBranches
     HasLongParameterList
-    HasMisspelledBindings
-    HasMisspelledIdentifiers
     HasRedundantBooleanComparison
-    HasRedundantGuards
     HasRedundantIf
     HasRedundantLambda
-    HasRedundantLocalVariableReturn
-    HasRedundantParameter
-    HasRedundantReduction
-    HasRedundantRepeat
-    HasTooManyMethods
     HasTooShortBindings
-    HasTooShortIdentifiers
     HasUnreachableCode
     HasUsageTypos
-    HasWrongCaseBinding
-    HasWrongCaseIdentifiers
     IsLongCode
-    OverridesEqualOrHashButNotBoth
-    ReturnsNil
-    ReturnsNull
     ShouldInvertIfCondition
-    ShouldUseOtherwise
-    UsesCut
-    UsesFail
-    UsesUnificationOperator)
+    ShouldUseStrictComparators
+  )
+
+  SMELLS = GENERIC_SMELLS + EXPRESSIVENESS_SMELLS +  IMPERATIVE_SMELLS + OBJECT_ORIENTED_SMELLS + FUNCTIONAL_SMELLS + LOGIC_SMELLS
 
   def self.guess_type(expectation)
     if expectation[:binding] == '<<custom>>'

data/lib/mulang/expectation/i18n.rb

@@ -1,47 +1,5 @@
 module Mulang::Expectation::I18n
   class << self
-    DEFAULT_TOKENS = {
-      keyword_EntryPoint: 'program',
-      keyword_Fail: 'fail',
-      keyword_False: 'false',
-      keyword_findall: 'findall',
-      keyword_For: 'for',
-      keyword_Forall: 'forall',
-      keyword_Foreach: 'foreach',
-      keyword_If: 'if',
-      keyword_Is: 'is',
-      keyword_Not: 'not',
-      keyword_Null: 'null',
-      keyword_Repeat: 'repeat',
-      keyword_Switch: 'switch',
-      keyword_True: 'true',
-      keyword_While: 'while',
-      keyword_Yield: 'yield',
-      operator_And: '&&',
-      operator_BackwardComposition: '.',
-      operator_Divide: '/',
-      operator_Equal: '==',
-      operator_ForwardComposition: '>>',
-      operator_GreatherOrEqualThan: '>=',
-      operator_GreatherThan: '>',
-      operator_Hash: 'hash',
-      operator_LessOrEqualThan: '<=',
-      operator_LessThan: '<',
-      operator_Minus: '-',
-      operator_Multiply: '*',
-      operator_Negation: '!',
-      operator_NotEqual: '!=',
-      operator_Or: '||',
-      operator_Otherwise: 'otherwise',
-      operator_Plus: '+',
-      operator_Modulo: '%',
-      operator_BitwiseOr: '|',
-      operator_BitwiseAnd: '&',
-      operator_BitwiseXor: '^',
-      operator_BitwiseLeftShift: '<<',
-      operator_BitwiseRightShift: '>>'
-    }.transform_values { |v| CGI::escapeHTML(v) }.freeze
-
     def translate(e, tokens = nil)
       translate!(e, tokens)
     rescue
@@ -71,7 +29,7 @@ module Mulang::Expectation::I18n
     end
 
     def t_binding(binding)
-      binding == '*' ? ::I18n.t("mulang.expectation.solution") : "<strong>#{Mulang::Inspection.parse_binding_name binding}</strong>"
+      binding == '*' ? ::I18n.t("mulang.expectation.solution") : "<code>#{Mulang::Inspection.parse_binding_name binding}</code>"
     end
 
     def t_must(parsed)
@@ -79,7 +37,7 @@ module Mulang::Expectation::I18n
     end
 
     def t_target(parsed)
-      "<strong>#{parsed.target.value}</strong>" if parsed.target
+      "<code>#{parsed.target.value}</code>" if parsed.target
     end
 
     def t_matching(tokens, parsed)
@@ -87,7 +45,15 @@ module Mulang::Expectation::I18n
     end
 
     def with_tokens(tokens, params)
-      params.merge(DEFAULT_TOKENS).merge(tokens || {})
+      hash = if tokens.nil?
+        {}
+      elsif tokens.is_a?(Hash)
+        tokens
+      else
+        params.merge(Mulang::Tokens::TOKENS.indifferent_get(tokens))
+      end
+
+      params.merge(Mulang::Tokens::DEFAULT_TOKENS.merge(hash))
     end
   end
 end

data/lib/mulang/language.rb

@@ -1,19 +1,52 @@
 module Mulang::Language
-  class Native
-    def initialize(language)
-      @language = language
+  class Base
+    def identifiers(content, **options)
+      Mulang.analyse(identifiers_analysis(content, **options), **options)['outputIdentifiers'] rescue nil
     end
 
-    def ast(content)
-      Mulang.analyse(ast_analysis(content))['intermediateLanguage'] rescue nil
+    def identifiers_analysis(content, **options)
+      base_analysis content, {includeOutputIdentifiers: true}, **options
     end
 
-    def ast_analysis(content)
+    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)
+      base_analysis content, {transformationSpecs: operations}, **options
+    end
+
+    def normalization_options(**options)
+      options.except(:serialization).presence
+    end
+
+    private
+
+    def base_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
+    def initialize(language)
+      @language = language
+    end
+
+    def ast(content, **options)
+      Mulang.analyse(ast_analysis(content, **options), **options)['outputAst'] rescue nil
+    end
+
+    def ast_analysis(content, **options)
+      base_analysis content, {includeOutputAst: true}, **options
+    end
 
     def sample(content)
       {
@@ -24,12 +57,12 @@ module Mulang::Language
     end
   end
 
-  class External
+  class External < Base
     def initialize(&tool)
       @tool = block_given? ? tool : proc { |it| it }
     end
 
-    def ast(content)
+    def ast(content, **args)
       @tool.call(content) rescue nil
     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