unparser 0.4.5 → 0.5.0

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::Flat, Concord.new(:node)
+
+        extend DSL
+      end
+    end
+
+    private
+
+    def children
+      node.children
+    end
+  end # NodeDetails
+end # Unparser

data/lib/unparser/node_details/send.rb

@@ -0,0 +1,62 @@
+# 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)
+      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..-1]
+      end
+      memoize :arguments
+
+      def string_selector
+        selector.to_s
+      end
+      memoize :string_selector
+
+    end # Send
+  end # NodeDetails
+end # Unparser

data/lib/unparser/node_helpers.rb

@@ -5,31 +5,72 @@ module Unparser
 
     # Helper for building nodes
     #
-    # @param [Symbol]
+    # @param [Symbol] type
+    # @param [Parser::AST::Node] children
     #
     # @return [Parser::AST::Node]
     #
     # @api private
-    #
-    # ignore :reek:UncommunicativeMethodName
-    # ignore :reek:UtilityFunction
     def s(type, *children)
       Parser::AST::Node.new(type, children)
     end
 
     # Helper for building nodes
     #
-    # @param [Symbol]
+    # @param [Symbol] type
     #
     # @return [Parser::AST::Node]
+    # @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
+      empty_else
+      begin
+      block
+      cbase
+      const
+      dstr
+      ensure
+      hash
+      hash_pattern
+      in_pattern
+      int
+      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,151 @@
+# frozen_string_literal: true
+
+module Unparser
+  # Validation of unparser results
+  class Validation
+    include Adamantium::Flat, 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:  MPrelude::Either::Right.new(original_source),
+        original_node:    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.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Unparser
+  module Writer
+    include Generation, NodeHelpers
+
+    def self.included(descendant)
+      descendant.class_eval do
+        include Anima.new(:buffer, :comments, :node, :local_variable_scope)
+
+        extend DSL
+      end
+    end
+  end # Writer
+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::Flat
+
+      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

data/lib/unparser/writer/dynamic_string.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+module Unparser
+  module Writer
+    class DynamicString
+      include Writer, Adamantium::Flat
+
+      PATTERNS_2 = IceNine.deep_freeze(
+        [
+          %i[str_empty begin],
+          %i[begin str_nl]
+        ]
+      )
+
+      PATTERNS_3 = IceNine.deep_freeze(
+        [
+          %i[begin str_nl_eol str_nl_eol],
+          %i[str_nl_eol begin str_nl_eol],
+          %i[str_ws begin str_nl_eol]
+        ]
+      )
+
+      FLAT_INTERPOLATION = %i[ivar cvar gvar].to_set.freeze
+
+      private_constant(*constants(false))
+
+      def emit_heredoc_reminder
+        return unless heredoc?
+
+        emit_heredoc_body
+        emit_heredoc_footer
+      end
+
+      def dispatch
+        if heredoc?
+          emit_heredoc_header
+        else
+          emit_dstr
+        end
+      end
+
+    private
+
+      def heredoc_header
+        need_squiggly? ? '<<~HEREDOC' : '<<-HEREDOC'
+      end
+
+      def heredoc?
+        children.empty? || (nl_last_child? && heredoc_pattern?)
+      end
+
+      def emit_heredoc_header
+        write(heredoc_header)
+      end
+
+      def emit_heredoc_body
+        nl
+        if need_squiggly?
+          emit_squiggly_heredoc_body
+        else
+          emit_normal_heredoc_body
+        end
+      end
+
+      def emit_heredoc_footer
+        write('HEREDOC')
+      end
+
+      def classify(node)
+        if n_str?(node)
+          classify_str(node)
+        else
+          node.type
+        end
+      end
+
+      def classify_str(node)
+        if str_nl?(node)
+          :str_nl
+        elsif node.children.first.end_with?("\n")
+          :str_nl_eol
+        elsif str_ws?(node)
+          :str_ws
+        elsif str_empty?(node)
+          :str_empty
+        end
+      end
+
+      def str_nl?(node)
+        node.eql?(s(:str, "\n"))
+      end
+
+      def str_empty?(node)
+        node.eql?(s(:str, ''))
+      end
+
+      def str_ws?(node)
+        /\A( |\t)+\z/.match?(node.children.first)
+      end
+
+      def heredoc_pattern?
+        heredoc_pattern_2? || heredoc_pattern_3?
+      end
+
+      def heredoc_pattern_3?
+        children.each_cons(3).any? do |group|
+          PATTERNS_3.include?(group.map(&method(:classify)))
+        end
+      end
+
+      def heredoc_pattern_2?
+        children.each_cons(2).any? do |group|
+          PATTERNS_2.include?(group.map(&method(:classify)))
+        end
+      end
+
+      def nl_last_child?
+        last = children.last
+        n_str?(last) && last.children.first[-1].eql?("\n")
+      end
+
+      def need_squiggly?
+        children.any?(s(:str, ''))
+      end
+
+      def emit_squiggly_heredoc_body
+        buffer.indent
+        children.each do |child|
+          if n_str?(child)
+            write(escape_dynamic(child.children.first))
+          else
+            emit_dynamic(child)
+          end
+        end
+        buffer.unindent
+      end
+
+      def emit_normal_heredoc_body
+        buffer.root_indent do
+          children.each do |child|
+            if n_str?(child)
+              write(escape_dynamic(child.children.first))
+            else
+              emit_dynamic(child)
+            end
+          end
+        end
+      end
+
+      def escape_dynamic(string)
+        string.gsub('#', '\#')
+      end
+
+      def emit_dynamic(child)
+        if FLAT_INTERPOLATION.include?(child.type)
+          write('#')
+          visit(child)
+        elsif n_dstr?(child)
+          emit_body(child.children)
+        else
+          write('#{')
+          emit_dynamic_component(child.children.first)
+          write('}')
+        end
+      end
+
+      def emit_dynamic_component(node)
+        visit(node) if node
+      end
+
+      def emit_dstr
+        segments.each_with_index do |children, index|
+          emit_segment(children, index)
+        end
+      end
+
+      def breakpoint?(child, current)
+        last_type = current.last&.type
+
+        [
+          n_str?(child) && last_type.equal?(:str) && current.none?(&method(:n_begin?)),
+          last_type.equal?(:dstr),
+          n_dstr?(child) && last_type
+        ].any?
+      end
+
+      def segments
+        segments = []
+
+        segments << current = []
+
+        children.each do |child|
+          if breakpoint?(child, current)
+            segments << current = []
+          end
+
+          current << child
+        end
+
+        segments
+      end
+
+      def emit_segment(children, index)
+        write(' ') unless index.zero?
+
+        write('"')
+        emit_body(children)
+        write('"')
+      end
+
+      def emit_body(children)
+        buffer.root_indent do
+          children.each_with_index do |child, index|
+            if n_str?(child)
+              string = child.children.first
+              if string.eql?("\n") && children.fetch(index.pred).type.equal?(:begin)
+                write("\n")
+              else
+                write(string.inspect[1..-2])
+              end
+            else
+              emit_dynamic(child)
+            end
+          end
+        end
+      end
+    end # DynamicString
+  end # Writer
+end # Unparser