unparser 0.4.7 → 0.6.7

data/lib/unparser/generation.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+module Unparser
+  # rubocop:disable Metrics/ModuleLength
+  module Generation
+    EXTRA_NL = %i[kwbegin def defs module class sclass].freeze
+
+    private_constant(*constants(false))
+
+    def emit_heredoc_reminders; end
+
+    def symbol_name; end
+
+    def write_to_buffer
+      with_comments { dispatch }
+      self
+    end
+
+  private
+
+    def delimited(nodes, delimiter = ', ', &block)
+      return if nodes.empty?
+
+      emit_join(nodes, block || method(:visit), -> { write(delimiter) })
+    end
+
+    def emit_join(nodes, emit_node, emit_delimiter)
+      return if nodes.empty?
+
+      head, *tail = nodes
+      emit_node.call(head)
+
+      tail.each do |node|
+        emit_delimiter.call
+        emit_node.call(node)
+      end
+    end
+
+    def nl
+      emit_eol_comments
+      buffer.nl
+    end
+
+    def with_comments
+      emit_comments_before if buffer.fresh_line?
+      yield
+      comments.consume(node)
+    end
+
+    def ws
+      write(' ')
+    end
+
+    def emit_eol_comments
+      comments.take_eol_comments.each do |comment|
+        write(' ', comment.text)
+      end
+    end
+
+    def emit_eof_comments
+      emit_eol_comments
+      comments_left = comments.take_all
+      return if comments_left.empty?
+
+      buffer.nl
+      emit_comments(comments_left)
+    end
+
+    def emit_comments_before(source_part = :expression)
+      comments_before = comments.take_before(node, source_part)
+      return if comments_before.empty?
+
+      emit_comments(comments_before)
+      buffer.nl
+    end
+
+    def emit_comments(comments)
+      max = comments.size - 1
+      comments.each_with_index do |comment, index|
+        if comment.type.equal?(:document)
+          buffer.append_without_prefix(comment.text.chomp)
+        else
+          write(comment.text)
+        end
+        buffer.nl if index < max
+      end
+    end
+
+    def write(*strings)
+      strings.each(&buffer.method(:append))
+    end
+
+    def k_end
+      buffer.indent
+      emit_comments_before(:end)
+      buffer.unindent
+      write('end')
+    end
+
+    def parentheses(open = '(', close = ')')
+      write(open)
+      yield
+      write(close)
+    end
+
+    def indented
+      buffer = buffer()
+      buffer.indent
+      nl
+      yield
+      nl
+      buffer.unindent
+    end
+
+    def emit_optional_body(node, indent: true)
+      if node
+        emit_body(node, indent: indent)
+      else
+        nl
+      end
+    end
+
+    def emit_body(node, indent: true)
+      if indent
+        buffer.indent
+        nl
+      end
+
+      if n_begin?(node)
+        if node.children.one?
+          visit_deep(node)
+        else
+          emit_body_inner(node)
+        end
+      else
+        visit_deep(node)
+      end
+
+      if indent
+        buffer.unindent
+        nl
+      end
+    end
+
+    def emit_body_inner(node)
+      head, *tail = node.children
+      emit_body_member(head)
+
+      tail.each do |child|
+        nl
+
+        nl if EXTRA_NL.include?(child.type)
+
+        emit_body_member(child)
+      end
+    end
+
+    def emit_body_member(node)
+      if n_rescue?(node)
+        emit_rescue_postcontrol(node)
+      else
+        visit_deep(node)
+      end
+    end
+
+    def emit_ensure(node)
+      body, ensure_body = node.children
+
+      if body
+        emit_body_rescue(body)
+      else
+        nl
+      end
+
+      write('ensure')
+
+      emit_optional_body(ensure_body)
+    end
+
+    def emit_body_rescue(node)
+      if n_rescue?(node)
+        emit_rescue_regular(node)
+      else
+        emit_body(node)
+      end
+    end
+
+    def emit_optional_body_ensure_rescue(node)
+      if node
+        emit_body_ensure_rescue(node)
+      else
+        nl
+      end
+    end
+
+    def emit_body_ensure_rescue(node)
+      if n_ensure?(node)
+        emit_ensure(node)
+      elsif n_rescue?(node)
+        emit_rescue_regular(node)
+      else
+        emit_body(node)
+      end
+    end
+
+    def emit_rescue_postcontrol(node)
+      writer = writer_with(Writer::Rescue, node)
+      writer.emit_postcontrol
+      writer.emit_heredoc_reminders
+    end
+
+    def emit_rescue_regular(node)
+      writer_with(Writer::Rescue, node).emit_regular
+    end
+
+    def writer_with(klass, node)
+      klass.new(to_h.merge(node: node))
+    end
+
+    def emitter(node)
+      Emitter.emitter(**to_h.merge(node: node))
+    end
+
+    def visit(node)
+      emitter(node).write_to_buffer
+    end
+
+    def visit_deep(node)
+      emitter(node).tap do |emitter|
+        emitter.write_to_buffer
+        emitter.emit_heredoc_reminders
+      end
+    end
+
+    def first_child
+      children.first
+    end
+
+    def conditional_parentheses(flag, &block)
+      if flag
+        parentheses(&block)
+      else
+        block.call
+      end
+    end
+
+    def children
+      node.children
+    end
+  end # Generation
+  # rubocop:enable Metrics/ModuleLength
+end # Unparser

data/lib/unparser/node_details/send.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Unparser
+  module NodeDetails
+    class Send
+      include NodeDetails
+
+      ASSIGN_SUFFIX    = '='.freeze
+      NON_ASSIGN_RANGE = (0..-2).freeze
+
+      private_constant(*constants(false))
+
+      children :receiver, :selector
+
+      public :receiver, :selector
+
+      def selector_binary_operator?
+        BINARY_OPERATORS.include?(selector)
+      end
+
+      def binary_syntax_allowed?
+        selector_binary_operator? \
+          && arguments.one? \
+          && !n_splat?(arguments.first) \
+          && !n_kwargs?(arguments.first)
+      end
+
+      def selector_unary_operator?
+        UNARY_OPERATORS.include?(selector)
+      end
+
+      def assignment_operator?
+        assignment? && !selector_binary_operator? && !selector_unary_operator?
+      end
+
+      def arguments?
+        arguments.any?
+      end
+
+      def non_assignment_selector
+        if assignment?
+          string_selector[NON_ASSIGN_RANGE]
+        else
+          string_selector
+        end
+      end
+
+      def assignment?
+        string_selector[-1].eql?(ASSIGN_SUFFIX)
+      end
+      memoize :assignment?
+
+      def arguments
+        children[2..]
+      end
+      memoize :arguments
+
+      def string_selector
+        selector.to_s
+      end
+      memoize :string_selector
+
+    end # Send
+  end # NodeDetails
+end # Unparser

data/lib/unparser/node_details.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Unparser
+  module NodeDetails
+    include Constants, NodeHelpers
+
+    def self.included(descendant)
+      descendant.class_eval do
+        include Adamantium, Concord.new(:node)
+
+        extend DSL
+      end
+    end
+
+    private
+
+    def children
+      node.children
+    end
+  end # NodeDetails
+end # Unparser

data/lib/unparser/node_helpers.rb

@@ -11,9 +11,6 @@ module Unparser
     # @return [Parser::AST::Node]
     #
     # @api private
-    #
-    # ignore :reek:UncommunicativeMethodName
-    # ignore :reek:UtilityFunction
     def s(type, *children)
       Parser::AST::Node.new(type, children)
     end
@@ -26,12 +23,57 @@ module Unparser
     # @param [Array] children
     #
     # @api private
-    #
-    # ignore :reek:UncommunicativeMethodName
-    # ignore :reek:UtilityFunction
     def n(type, children = [])
       Parser::AST::Node.new(type, children)
     end
 
+    def n?(type, node)
+      node.type.equal?(type)
+    end
+
+    %i[
+      arg
+      args
+      array
+      array_pattern
+      begin
+      block
+      cbase
+      const
+      dstr
+      empty_else
+      ensure
+      hash
+      hash_pattern
+      if
+      in_pattern
+      int
+      kwarg
+      kwargs
+      kwsplat
+      lambda
+      match_rest
+      pair
+      rescue
+      send
+      shadowarg
+      splat
+      str
+      sym
+    ].each do |type|
+      name = "n_#{type}?"
+      define_method(name) do |node|
+        n?(type, node)
+      end
+      private(name)
+    end
+
+    def unwrap_single_begin(node)
+      if n_begin?(node) && node.children.one?
+        node.children.first
+      else
+        node
+      end
+    end
   end # NodeHelpers
 end # Unparser

data/lib/unparser/validation.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module Unparser
+  # Validation of unparser results
+  class Validation
+    include Adamantium, Anima.new(
+      :generated_node,
+      :generated_source,
+      :identification,
+      :original_node,
+      :original_source
+    )
+
+    # Test if source could be unparsed successfully
+    #
+    # @return [Boolean]
+    #
+    # @api private
+    #
+    def success?
+      [
+        original_source,
+        original_node,
+        generated_source,
+        generated_node
+      ].all?(&:right?) && generated_node.from_right.==(original_node.from_right)
+    end
+
+    # Return error report
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def report
+      message = [identification]
+
+      message.concat(make_report('Original-Source',  :original_source))
+      message.concat(make_report('Generated-Source', :generated_source))
+      message.concat(make_report('Original-Node',    :original_node))
+      message.concat(make_report('Generated-Node',   :generated_node))
+      message.concat(node_diff_report)
+
+      message.join("\n")
+    end
+    memoize :report
+
+    # Create validator from string
+    #
+    # @param [String] original_source
+    #
+    # @return [Validator]
+    def self.from_string(original_source)
+      original_node = Unparser
+        .parse_either(original_source)
+
+      generated_source = original_node
+        .lmap(&method(:const_unit))
+        .bind(&Unparser.method(:unparse_either))
+
+      generated_node = generated_source
+        .lmap(&method(:const_unit))
+        .bind(&Unparser.method(:parse_either))
+
+      new(
+        identification:   '(string)',
+        original_source:  Either::Right.new(original_source),
+        original_node:    original_node,
+        generated_source: generated_source,
+        generated_node:   generated_node
+      )
+    end
+
+    # Create validator from node
+    #
+    # @param [Parser::AST::Node] original_node
+    #
+    # @return [Validator]
+    def self.from_node(original_node)
+      generated_source = Unparser.unparse_either(original_node)
+
+      generated_node = generated_source
+        .lmap(&method(:const_unit))
+        .bind(&Unparser.public_method(:parse_either))
+
+      new(
+        identification:   '(string)',
+        original_source:  generated_source,
+        original_node:    Either::Right.new(original_node),
+        generated_source: generated_source,
+        generated_node:   generated_node
+      )
+    end
+
+    # Create validator from file
+    #
+    # @param [Pathname] path
+    #
+    # @return [Validator]
+    def self.from_path(path)
+      from_string(path.read).with(identification: path.to_s)
+    end
+
+  private
+
+    def make_report(label, attribute_name)
+      ["#{label}:"].concat(public_send(attribute_name).either(method(:report_exception), ->(value) { [value] }))
+    end
+
+    def report_exception(exception)
+      if exception
+        [exception.inspect].concat(exception.backtrace.take(20))
+      else
+        ['undefined']
+      end
+    end
+
+    def node_diff_report
+      diff = nil
+
+      original_node.fmap do |original|
+        generated_node.fmap do |generated|
+          diff = Diff.new(
+            original.to_s.lines.map(&:chomp),
+            generated.to_s.lines.map(&:chomp)
+          ).colorized_diff
+        end
+      end
+
+      diff ? ['Node-Diff:', diff] : []
+    end
+
+    def self.const_unit(_value); end
+    private_class_method :const_unit
+
+    class Literal < self
+      def success?
+        original_source.eql?(generated_source)
+      end
+
+      def report
+        message = [identification]
+
+        message.concat(make_report('Original-Source',  :original_source))
+        message.concat(make_report('Generated-Source', :generated_source))
+        message.concat(make_report('Original-Node',    :original_node))
+        message.concat(make_report('Generated-Node',   :generated_node))
+        message.concat(node_diff_report)
+        message.concat(source_diff_report)
+
+        message.join("\n")
+      end
+
+    private
+
+      def source_diff_report
+        diff = nil
+
+        original_source.fmap do |original|
+          generated_source.fmap do |generated|
+            diff = Diff.new(
+              original.split("\n", -1),
+              generated.split("\n", -1)
+            ).colorized_diff
+          end
+        end
+
+        diff ? ['Source-Diff:', diff] : []
+      end
+    end # Literal
+  end # Validation
+end # Unparser

data/lib/unparser/writer/binary.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Unparser
+  module Writer
+    class Binary
+      include Writer, Adamantium
+
+      children :left, :right
+
+      OPERATOR_TOKENS =
+        {
+          and: '&&',
+          or:  '||'
+        }.freeze
+
+      KEYWORD_TOKENS =
+        {
+          and: 'and',
+          or:  'or'
+        }.freeze
+
+      KEYWORD_SYMBOLS =
+        {
+          and: :kAND,
+          or:  :kOR
+        }.freeze
+
+      OPERATOR_SYMBOLS =
+        {
+          and: :tANDOP,
+          or:  :tOROP
+        }.freeze
+
+      MAP =
+        {
+          kAND:   'and',
+          kOR:    'or',
+          tOROP:  '||',
+          tANDOP: '&&'
+        }.freeze
+
+      NEED_KEYWORD = %i[return break next].freeze
+
+      private_constant(*constants(false))
+
+      def emit_operator
+        emit_with(OPERATOR_TOKENS)
+      end
+
+      def symbol_name
+        true
+      end
+
+      def dispatch
+        left_emitter.write_to_buffer
+        write(' ', MAP.fetch(effective_symbol), ' ')
+        visit(right)
+      end
+
+    private
+
+      def effective_symbol
+        if NEED_KEYWORD.include?(right.type) || NEED_KEYWORD.include?(left.type)
+          return keyword_symbol
+        end
+
+        unless left_emitter.symbol_name
+          return operator_symbol
+        end
+
+        keyword_symbol
+      end
+
+      def emit_with(map)
+        visit(left)
+        write(' ', map.fetch(node.type), ' ')
+        visit(right)
+      end
+
+      def keyword_symbol
+        KEYWORD_SYMBOLS.fetch(node.type)
+      end
+
+      def operator_symbol
+        OPERATOR_SYMBOLS.fetch(node.type)
+      end
+
+      def left_emitter
+        emitter(left)
+      end
+      memoize :left_emitter
+
+      def right_emitter
+        emitter(right)
+      end
+      memoize :right_emitter
+    end # Binary
+  end # Writer
+end # Unparser