prettyrb 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cfaf933924416b3773afaed63ee03ca8c2ddaa9a3e36147c3db453f24245e375
-  data.tar.gz: b5fcfe41b9738e7bd628501b1aff497e7083cb7f6e061fa7e5821719c7c86bcf
+  metadata.gz: f3ca66d3c436cf92ecaeef327cd56e32380eb956c844cafcc605e471f80e5a9d
+  data.tar.gz: 6a88f83ea9a52c7cebcb0c70d72a8f599c8480e0a628c2eba016ce506ef99996
 SHA512:
-  metadata.gz: de542dd1e0f5999aa4aec410a8329e387944e1ce370805c2c4aaa805f5020034287fb7db8e0bfe4d3c2627b722c6b0d3a3cfa0024dbc4255fba9e3161cea0a9f
-  data.tar.gz: 953349398a0107c7012336a3a69dd0ae5c700cde330fced7db07cd96876178cfe87457273fc4440b48caabd2f050b26f79b26e0ec8f2c40af279fe2c3246ab4a
+  metadata.gz: 3fb301879d8c8905aa82268ac2d04944fc02eb4a3e9d28466b80a70dd3e3b2e1ad93dba3a4916736e5c5533c067eb69b869a610f12ee6746d61ec5165e43d128
+  data.tar.gz: 3a2894fd21b9493aec14b1d85a08e3be929e356ad7dd2dee013409f2ec3dcd47f914ab15d6028146e769533812abb786bbce415d449edcaefd679093c06d5af5

data/.ruby-version

@@ -1 +1 @@
-2.7.0
+2.6.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    prettyrb (0.3.1)
+    prettyrb (0.5.0)
       parser (~> 2.7.0.5)
       thor
 

data/lib/prettyrb.rb

@@ -1,17 +1,29 @@
+require "forwardable"
+
 require "parser/current"
 require "prettyrb/version"
 
 require "prettyrb/nodes/base_node"
 require "prettyrb/nodes/if_node"
 require "prettyrb/nodes/string_helper"
+require "prettyrb/nodes/logical_operator_helper"
 require "prettyrb/nodes/str_node"
 require "prettyrb/nodes/dstr_node"
+require "prettyrb/nodes/def_node"
+require "prettyrb/nodes/and_node"
+require "prettyrb/nodes/or_node"
+require "prettyrb/nodes/regexp_node"
+require "prettyrb/nodes/send_node"
+
+require "prettyrb/document"
 require "prettyrb/builder"
 require "prettyrb/formatter"
 require "prettyrb/visitor"
+require "prettyrb/writer"
 
 require "prettyrb/cli"
 
 module Prettyrb
+  MAX_LINE_LENGTH = 100
   class Error < StandardError; end
 end

data/lib/prettyrb/builder.rb

@@ -1,9 +1,14 @@
 module Prettyrb
   class Builder < Parser::Builders::Default
     NODE_TYPES = {
+      and: Prettyrb::Nodes::AndNode,
+      dstr: Prettyrb::Nodes::DstrNode,
       if: Prettyrb::Nodes::IfNode,
+      or: Prettyrb::Nodes::OrNode,
+      regexp: Prettyrb::Nodes::RegexpNode,
+      send: Prettyrb::Nodes::SendNode,
       str: Prettyrb::Nodes::StrNode,
-      dstr: Prettyrb::Nodes::DstrNode,
+      def: Prettyrb::Nodes::DefNode,
     }.freeze
 
     def n(type, children, source_map)

data/lib/prettyrb/cli.rb

@@ -3,18 +3,27 @@ require "thor"
 module Prettyrb
   class CLI < Thor
     desc "format [FILE]", "Ruby file to prettify"
-    option :write, type: :boolean
-    method_option :files, type: :array
-    def format(*files)
+    def format(file)
       content = File.read(file)
       formatted_content = Prettyrb::Formatter.new(content).format
 
-      if options[:write]
+      puts formatted_content
+    end
+
+    desc "write [FILES]", "Write prettified Ruby files"
+    def write(*files)
+      files.each do |file|
+        content = File.read(file)
+        begin
+          formatted_content = Prettyrb::Formatter.new(content).format
+        rescue Exception => e
+          puts "Failed to write #{file}"
+          throw e
+        end
+
         File.open(file, 'w') do |f|
           f.write(formatted_content)
         end
-      else
-        puts formatted_content
       end
     end
   end

data/lib/prettyrb/document.rb

@@ -0,0 +1,164 @@
+module Prettyrb
+  module Document
+    module DSL
+      def concat(*args)
+        Document::Concat.new(*args)
+      end
+
+      def join(*args)
+        Document::Join.new(*args)
+      end
+
+      def group(*args)
+        Document::Group.new(*args)
+      end
+
+      def if_break(*args)
+        Document::IfBreak.new(*args)
+      end
+
+      def indent(*args)
+        Document::Indent.new(*args)
+      end
+
+      def dedent(*args)
+        Document::Dedent.new(*args)
+      end
+
+      def hardline(*args)
+        Document::Hardline.new(*args)
+      end
+
+      def softline(*args)
+        Document::Softline.new(*args)
+      end
+    end
+
+    class Builder
+      attr_reader :parts
+
+      include Enumerable
+
+      def initialize(*args)
+        @parts = args
+      end
+
+      def each
+        @parts.each
+      end
+
+      def inspect
+        inspect_children(self, indent_level: 0)
+      end
+
+      def has_group_part?
+        parts.any? { |p| p.is_a?(Group) }
+      end
+
+      def groups
+        parts.select { |p| p.is_a?(Group) } + parts.flat_map do |p|
+          p.groups if p.respond_to?(:groups)
+        end.compact
+      end
+
+      def max_group_depth
+        return 0 if !parts
+        return @max_group_depth if defined?(@max_group_depth)
+
+        has_groups = parts.any? { |p| p.is_a?(Group) }
+
+        total = if has_groups
+          1
+        else
+          0
+        end
+
+        # TODO swap filter/flat_map for single iteration
+        nested_total = parts.
+          filter { |p| p.respond_to?(:max_group_depth) }.
+          flat_map { |p| p.max_group_depth }.
+          max
+
+        @max_group_depth = total + (nested_total || 0)
+      end
+
+      private
+
+      def inspect_children(builder, indent_level:)
+        if builder.respond_to?(:parts)
+          children = if builder.parts
+            builder.parts.map do |p|
+              inspect_children(p, indent_level: indent_level + 1)
+            end.join("\n")
+          end
+
+          "  " * indent_level + "(#{builder.class}\n#{"  "*indent_level}#{children}\n #{"  " * indent_level})"
+        else
+          "  " * indent_level + builder.inspect
+        end
+      end
+    end
+
+    class Concat < Builder
+    end
+
+    class Group < Builder
+      attr_reader :joiner
+
+      def initialize(*args, joiner: "")
+        super(*args)
+        @joiner = joiner
+      end
+    end
+
+    class Join < Builder
+      attr_reader :separator
+
+      def initialize(separator: ",", parts:)
+        if parts.is_a?(Array)
+          super(*parts)
+        else
+          super(parts)
+        end
+        @separator = separator
+      end
+    end
+
+    class IfBreak
+      attr_reader :without_break, :with_break
+      def initialize(without_break:, with_break: )
+        @without_break = without_break
+        @with_break = with_break
+      end
+    end
+
+    class Indent < Builder
+      attr_reader :only_when_break
+
+      def initialize(*args, only_when_break: false)
+        @only_when_break = only_when_break
+        super(*args)
+      end
+    end
+
+    class Dedent < Builder
+    end
+
+    class Hardline < Builder
+      attr_reader :count, :skip_indent
+      def initialize(count: 1, skip_indent: false)
+        @count = count
+        @skip_indent = skip_indent
+      end
+    end
+
+    class Softline < Builder
+      attr_reader :fallback
+
+      def initialize(*args, fallback: nil)
+        super(args)
+        @fallback = fallback
+      end
+    end
+  end
+end

data/lib/prettyrb/formatter.rb

@@ -20,7 +20,7 @@ module Prettyrb
         Parser::CurrentRuby.send(:setup_source_buffer, "file='(string)'", 1, @code, parser.default_encoding)
       )
 
-      visitor = Visitor.new
+      visitor = Visitor.new(root_node)
       visitor.visit(root_node)
 
       visitor.output
@@ -28,15 +28,6 @@ module Prettyrb
 
     private
 
-    def format_type(node, indentation)
-      case node.node_type
-      when :if
-        IfFormatter.new(node, indentation).format
-      else
-        raise "can't handle #{node}"
-      end
-    end
-
     attr_reader :code
   end
 end

data/lib/prettyrb/nodes/and_node.rb

@@ -0,0 +1,11 @@
+module Prettyrb
+  module Nodes
+    class AndNode < BaseNode
+      include LogicalOperatorHelper
+
+      def operator
+        "&&"
+      end
+    end
+  end
+end

data/lib/prettyrb/nodes/base_node.rb

@@ -8,7 +8,7 @@ module Prettyrb
 
         super
 
-        children.each do |child|
+        children&.each do |child|
           next unless child.is_a?(BaseNode)
           child.parent = self
         end
@@ -20,6 +20,10 @@ module Prettyrb
         @mutable[:parent]
       end
 
+      def string?
+        type == :str || type == :dstr
+      end
+
       protected
 
       def parent=(parent)

data/lib/prettyrb/nodes/def_node.rb

@@ -0,0 +1,17 @@
+module Prettyrb
+  module Nodes
+    class DefNode < BaseNode
+      def name
+        children[0]
+      end
+
+      def args
+        children[1]
+      end
+
+      def body
+        children[2]
+      end
+    end
+  end
+end

data/lib/prettyrb/nodes/if_node.rb

@@ -11,7 +11,7 @@ module Prettyrb
         end
       end
 
-      def conditions_node
+      def conditions
         children[0]
       end
 
@@ -42,6 +42,22 @@ module Prettyrb
       def unless_node?
         children[1].nil? && children[2] != :if
       end
+
+      def elsif_branches
+        if has_elsif?
+          [else_body_node] + else_body_node.elsif_branches
+        else
+          []
+        end
+      end
+
+      def else_branch
+        if has_elsif?
+          elsif_branches.last.children[2]
+        else
+          else_body_node
+        end
+      end
     end
   end
 end

data/lib/prettyrb/nodes/logical_operator_helper.rb

@@ -0,0 +1,13 @@
+module Prettyrb
+  module Nodes
+    module LogicalOperatorHelper
+      def left
+        children[0]
+      end
+
+      def right
+        children[1]
+      end
+    end
+  end
+end

data/lib/prettyrb/nodes/or_node.rb

@@ -0,0 +1,11 @@
+module Prettyrb
+  module Nodes
+    class OrNode < BaseNode
+      include LogicalOperatorHelper
+
+      def operator
+        "||"
+      end
+    end
+  end
+end

data/lib/prettyrb/nodes/regexp_node.rb

@@ -0,0 +1,41 @@
+module Prettyrb
+  module Nodes
+    class RegexpNode < BaseNode
+      include StringHelper
+
+      PERCENT_PAIRS = {
+        "{" => "}",
+        "[" => "]",
+        "(" => ")",
+        "<" => ">",
+      }
+
+      def percent?
+        loc.expression.source.start_with?("%")
+      end
+
+      def percent_type
+        loc.expression.source[1]
+      end
+
+      def start_delimiter
+        loc.expression.source[2]
+      end
+
+      def end_delimiter
+        PERCENT_PAIRS.fetch(start_delimiter, start_delimiter)
+      end
+
+      def format
+        raw_content = loc.expression.source
+        content = raw_content[1...-1]
+
+        if raw_content[0] == "'"
+          content.gsub('"', '\\"').gsub('#{', '\\#{')
+        else
+          content.gsub("\\", "\\\\")
+        end
+      end
+    end
+  end
+end