mulang 5.1.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,12 +1,63 @@
 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
+  )
+
+  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
+    HasEqualIfBranches
+    HasLongParameterList
+    HasRedundantBooleanComparison
+    HasRedundantIf
+    HasRedundantLambda
+    HasTooShortBindings
+    HasUnreachableCode
+    HasUsageTypos
+    IsLongCode
+    ShouldInvertIfCondition
+    ShouldUseStrictComparators
+  )
+
+  SMELLS = GENERIC_SMELLS + EXPRESSIVENESS_SMELLS +  IMPERATIVE_SMELLS + OBJECT_ORIENTED_SMELLS + FUNCTIONAL_SMELLS + LOGIC_SMELLS
 
   def self.guess_type(expectation)
     if expectation[:binding] == '<<custom>>'
@@ -19,7 +70,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/custom.rb

@@ -9,6 +9,8 @@ class Mulang::Expectation::Custom
     name
   end
 
+  alias translate! translate
+
   def to_h
     {binding: '<<custom>>', inspection: name}
   end

data/lib/mulang/expectation/i18n.rb

@@ -1,49 +1,35 @@
 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, 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)
-    rescue
-      '<unknown expectation>'
+      ::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)
-      "mulang.inspection.#{inspection.type}#{inspection.target ? inspection.target.i18n_suffix : nil}"
+      "#{inspection.i18n_namespace}.#{inspection.type}#{inspection.target ? inspection.target.i18n_suffix : nil}"
     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)
@@ -51,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,8 +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!(tokens = nil)
+    Mulang::Expectation::I18n.translate! self, tokens
   end
 
   def to_h
@@ -68,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/inspection.rb

@@ -20,11 +20,12 @@ module Mulang
     attr_accessor :type, :target, :matcher, :negated
     alias negated? negated
 
-    def initialize(type, target, negated: false, matcher: nil)
+    def initialize(type, target, negated: false, matcher: nil, i18n_namespace: nil)
       @type = type
       @target = target
       @negated = negated
       @matcher = matcher
+      @i18n_namespace = i18n_namespace
     end
 
     def to_s
@@ -43,6 +44,10 @@ module Mulang
       matcher ? ":#{matcher.to_s}" : nil
     end
 
+    def i18n_namespace
+      @i18n_namespace || 'mulang.inspection'
+    end
+
     def self.parse_binding_name(binding_s)
       if binding_s.start_with? 'Intransitive:'
         binding_s[13..-1]
@@ -52,14 +57,34 @@ module Mulang
     end
 
     def self.parse(inspection_s)
+      parse_extension(inspection_s).try { |it| return it }
       match = REGEXP.match inspection_s
       raise "Invalid inspection #{inspection_s}" unless match
-      Inspection.new(
+      Mulang::Inspection.new(
         match['type'],
         Mulang::Inspection::Target.parse(match['target']),
         matcher: Mulang::Inspection::Matcher.parse(match['matcher'], match['value']),
         negated: match['negation'].present?)
     end
+
+    def self.parse_extension(inspection_s)
+      extensions.each do |extension|
+        extension.parse(inspection_s).try { |it| return it }
+      end
+      nil
+    end
+
+    def self.extensions
+      @extensions ||= []
+    end
+
+    def self.register_extension!(extension)
+      extensions << extension
+    end
+
+    def self.unregister_extension!(extension)
+      extensions.delete extension
+    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