mulang 5.1.0.2 → 6.0.2

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)
@@ -43,12 +60,25 @@ module Mulang
       native(*args).tap { |it| it.expect('Parses') }
     end
 
-    def self.external(content, &tool)
-      new Mulang::Language::External.new(&tool), content
+    def self.external(language_name = nil, content, &tool)
+      new Mulang::Language::External.new(language_name, &tool), content
+    end
+
+    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
 
-    def self.ast(ast)
-      new Mulang::Language::External.new, ast
+    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
 
     private

data/lib/mulang/expectation.rb

@@ -1,12 +1,73 @@
 module Mulang::Expectation
-  SMELLS = %w(DiscardsExceptions DoesConsolePrint DoesNilTest DoesNullTest DoesTypeTest
-              HasAssignmentReturn HasCodeDuplication HasEmptyIfBranches HasRedundantRepeat HasLongParameterList
-              HasMisspelledBindings HasMisspelledIdentifiers
-              HasRedundantBooleanComparison HasRedundantGuards HasRedundantIf
-              HasRedundantLambda HasRedundantLocalVariableReturn HasRedundantParameter
-              HasRedundantReduction HasTooManyMethods HasTooShortBindings HasTooShortIdentifiers HasUnreachableCode
-              HasWrongCaseBinding HasWrongCaseIdentifiers IsLongCode OverridesEqualOrHashButNotBoth
-              ReturnsNil ReturnsNull UsesCut UsesFail UsesUnificationOperator)
+  LOGIC_SMELLS = %w(
+    HasRedundantReduction
+    UsesCut
+    UsesFail
+    UsesUnificationOperator
+  )
+
+  FUNCTIONAL_SMELLS = %w(
+    HasRedundantGuards
+    HasRedundantParameter
+    ShouldUseOtherwise
+  )
+
+  OBJECT_ORIENTED_SMELLS = %w(
+    DoesNilTest
+    DoesNullTest
+    HasTooManyMethods
+    OverridesEqualOrHashButNotBoth
+    ReturnsNil
+    ReturnsNull
+    DoesTypeTest
+  )
+
+  IMPERATIVE_SMELLS = %w(
+    HasAssignmentCondition
+    HasAssignmentReturn
+    HasEmptyRepeat
+    HasRedundantRepeat
+  )
+
+  EXPRESSIVENESS_SMELLS = %w(
+    HasMisspelledBindings
+    HasMisspelledIdentifiers
+    HasTooShortIdentifiers
+    HasWrongCaseBinding
+    HasWrongCaseIdentifiers
+  )
+
+  GENERIC_SMELLS = %w(
+    DiscardsExceptions
+    DoesConsolePrint
+    HasCodeDuplication
+    HasDeclarationTypos
+    HasEmptyIfBranches
+    HasEqualIfBranches
+    HasLongParameterList
+    HasRedundantBooleanComparison
+    HasRedundantLocalVariableReturn
+    HasRedundantIf
+    HasRedundantLambda
+    HasTooShortBindings
+    HasUnreachableCode
+    HasUsageTypos
+    IsLongCode
+    ShouldInvertIfCondition
+    ShouldUseStrictComparators
+  )
+
+  JAVA_SCRIPT_SMELLS = %w(
+    JavaScript#UsesVarInsteadOfLet
+  )
+
+  SMELLS = GENERIC_SMELLS +
+           EXPRESSIVENESS_SMELLS +
+           IMPERATIVE_SMELLS +
+           OBJECT_ORIENTED_SMELLS +
+           FUNCTIONAL_SMELLS +
+           LOGIC_SMELLS +
+           JAVA_SCRIPT_SMELLS
 
   def self.guess_type(expectation)
     if expectation[:binding] == '<<custom>>'
@@ -19,7 +80,7 @@ module Mulang::Expectation
   end
 
   def self.has_smell?(smell)
-    SMELLS.include? smell
+    SMELLS.include? smell.split(':').first
   end
 
   def self.parse(expectation)

data/lib/mulang/expectation/i18n.rb

@@ -1,45 +1,27 @@
 module Mulang::Expectation::I18n
   class << self
-    DEFAULT_KEYWORDS = {
-      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
-    }
-
-    def translate(e, keywords = nil)
-      translate!(e, keywords)
+    def translate(e, tokens = nil)
+      translate!(e, tokens)
     rescue
       '<unknown expectation>'
     end
 
-    def translate!(e, keywords = nil)
+    def translate!(e, tokens = nil)
       e = e.as_v2
       key = key_for e.binding, e.inspection
-      ::I18n.t key, translation_params(e, keywords)
+      ::I18n.t key, translation_params(e, tokens)
     end
 
     alias t translate
 
     private
 
-    def translation_params(e, keywords)
-      with_keywords keywords,
+    def translation_params(e, tokens)
+      with_tokens tokens,
                     binding: t_binding(e.binding),
                     target: t_target(e.inspection),
                     must: t_must(e.inspection),
-                    matching: t_matching(keywords, e.inspection)
+                    matching: t_matching(tokens, e.inspection)
     end
 
     def key_for(binding, inspection)
@@ -47,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)
@@ -55,15 +37,23 @@ 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(keywords, parsed)
-      ::I18n.t("mulang.expectation.#{parsed.matcher.type}", with_keywords(keywords, value: parsed.matcher.value)) if parsed.matcher
+    def t_matching(tokens, parsed)
+      ::I18n.t("mulang.expectation.#{parsed.matcher.type}", with_tokens(tokens, value: parsed.matcher.value)) if parsed.matcher
     end
 
-    def with_keywords(keywords, params)
-      params.merge(DEFAULT_KEYWORDS).merge(keywords || {})
+    def with_tokens(tokens, params)
+      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/expectation/standard.rb

@@ -11,12 +11,12 @@ class Mulang::Expectation::Standard
     raise "Wrong inspection #{to_h}" unless inspection?
   end
 
-  def translate(keywords = nil)
-    Mulang::Expectation::I18n.translate self, keywords
+  def translate(tokens = nil)
+    Mulang::Expectation::I18n.translate self, tokens
   end
 
-  def translate!(keywords = nil)
-    Mulang::Expectation::I18n.translate! self, keywords
+  def translate!(tokens = nil)
+    Mulang::Expectation::I18n.translate! self, tokens
   end
 
   def to_h
@@ -72,7 +72,7 @@ class Mulang::Expectation::V0 < Mulang::Expectation::Standard
   end
 
   def as_v2_use
-    Mulang::Expectation::V2.new binding, new_inspection(inspection.type.gsub('Has', 'Uses'), nil)
+    Mulang::Expectation::V2.new binding, new_inspection(inspection.type.gsub(/^Has/, 'Uses'), nil)
   end
 
   def as_v2_declare(simple_type)

data/lib/mulang/language.rb

@@ -1,43 +1,95 @@
 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
+
+    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
+
+    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
+    attr_accessor :name
+
+    def initialize(language_name)
+      @name = language_name
+    end
 
     def sample(content)
       {
         tag: 'CodeSample',
-        language: @language,
+        language: @name,
         content: content
       }
     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 base_analysis(*)
+      super.deep_merge(spec: {originalLanguage: @name}.compact)
+    end
+
+    private
+
+    def call_tool(content)
+      @tool.call(content) rescue nil
+    end
   end
 end