prettyrb 0.1.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6627cfb70e4dee209000644f4be5d57d6794c240fda5767b4b85d877c7cb2ed5
-  data.tar.gz: ae15fc8e9b154777b0bdaad845047b8a8c6709ee0e8e7616bcabb77cf12f3f06
+  metadata.gz: f3ca66d3c436cf92ecaeef327cd56e32380eb956c844cafcc605e471f80e5a9d
+  data.tar.gz: 6a88f83ea9a52c7cebcb0c70d72a8f599c8480e0a628c2eba016ce506ef99996
 SHA512:
-  metadata.gz: 5e0543768d14fbb1fa9715a2c1657bbcc4d376939e342cd7badc14cddde7a0b8c8354d3ead3321b0a14ad5143fae8381c4eaf55e4d3c66785ac0eb8300ae75d7
-  data.tar.gz: 7d186ac5763c031e88d4357d00cae4afe6ba002d1a82381bf8f00b8050b8c33ca9e3f9a4ca8dde1312488fba002196544ffea134bdb144cefca2a05350a55c13
+  metadata.gz: 3fb301879d8c8905aa82268ac2d04944fc02eb4a3e9d28466b80a70dd3e3b2e1ad93dba3a4916736e5c5533c067eb69b869a610f12ee6746d61ec5165e43d128
+  data.tar.gz: 3a2894fd21b9493aec14b1d85a08e3be929e356ad7dd2dee013409f2ec3dcd47f914ab15d6028146e769533812abb786bbce415d449edcaefd679093c06d5af5

data/.github/workflows/ruby.yml

@@ -0,0 +1,24 @@
+name: Ruby
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby 2.6
+      uses: actions/setup-ruby@v1
+      with:
+        ruby-version: 2.6.x
+    - name: Build and test with Rake
+      run: |
+        gem install bundler
+        bundle install --jobs 4 --retry 3
+        bundle exec rake

data/.gitignore

@@ -6,3 +6,4 @@
 /pkg/
 /spec/reports/
 /tmp/
+coverage

data/.ruby-version

@@ -0,0 +1 @@
+2.6.0

data/Gemfile.lock

@@ -1,26 +1,40 @@
 PATH
   remote: .
   specs:
-    prettyrb (0.1.0)
-      ruby_parser (~> 3.14)
+    prettyrb (0.5.0)
+      parser (~> 2.7.0.5)
+      thor
 
 GEM
   remote: https://rubygems.org/
   specs:
+    ast (2.4.0)
+    coderay (1.1.2)
+    docile (1.3.2)
+    method_source (1.0.0)
     minitest (5.14.0)
-    rake (10.5.0)
-    ruby_parser (3.14.2)
-      sexp_processor (~> 4.9)
-    sexp_processor (4.14.1)
+    parser (2.7.0.5)
+      ast (~> 2.4.0)
+    pry (0.13.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rake (12.3.3)
+    simplecov (0.18.5)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+    simplecov-html (0.12.2)
+    thor (1.0.1)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.17)
+  bundler (~> 2.1.4)
   minitest (~> 5.0)
   prettyrb!
-  rake (~> 10.0)
+  pry (~> 0.13)
+  rake (~> 12.3.3)
+  simplecov (~> 0.18)
 
 BUNDLED WITH
-   1.17.2
+   2.1.4

data/README.md

@@ -1,6 +1,8 @@
 # Prettyrb
 
-Super experimental gem for auto-formatting Ruby files. Pronounced "pretty-erb"
+Super experimental gem for auto-formatting Ruby files. AKA the code isn't great, but things are kind of working.
+
+Pronounced "pretty-erb".
 
 ## Installation
 
@@ -20,12 +22,24 @@ Or install it yourself as:
 
 ## Usage
 
+CLI:
+
+```
+$ prettyrb format FILE
+```
+
+or to re-write the file:
+
+```
+prettyrb format FILE --write
+```
+
+In Ruby code:
+
 ```ruby
 PrettyRb.new(source_code).format
 ```
 
-CLI helper coming soon™
-
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/exe/prettyrb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "prettyrb"
+require "prettyrb/cli"
+
+Prettyrb::CLI.start

data/lib/prettyrb.rb

@@ -1,191 +1,29 @@
-require "ruby_parser"
+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
-
-  class Formatter
-    def self.for(sexp)
-      case sexp.sexp_type
-      when :if
-        IfFormatter
-      when :str
-        StringFormatter
-      when :or
-        OrFormatter
-      when :and
-        AndFormatter
-      when :lit
-        LitFormatter
-      when :call
-        CallFormatter
-      when :class
-        ClassFormatter
-      when :cdecl
-        CdeclFormatter
-      when :array
-        ArrayFormatter
-      else
-        raise "can't handle #{sexp}"
-      end
-    end
-
-    def initialize(code)
-      @code = code
-    end
-
-    def format
-      sexp_tree = RubyParser.new.parse(@code)
-
-      self.class.for(sexp_tree).new(sexp_tree, 0, nil).format
-    end
-
-    private
-
-    def format_type(sexp, indentation)
-      case sexp.sexp_type
-      when :if
-        IfFormatter.new(sexp, indentation).format
-      else
-        raise "can't handle #{sexp}"
-      end
-    end
-
-    attr_reader :code
-  end
-
-  class BaseFormatter
-    attr_reader :sexp, :indentation, :parent
-
-    def initialize(sexp, indentation, parent)
-      @sexp = sexp
-      @indentation = indentation
-      @parent = parent
-    end
-
-    def type
-      sexp.sexp_type
-    end
-
-    def indents
-      ' ' * indentation
-    end
-  end
-
-  class LitFormatter < BaseFormatter
-    def format
-      sexp[1]
-    end
-  end
-
-  class StringFormatter < BaseFormatter
-    def format
-      if parent.type == :array
-        "\"#{sexp[1]}\""
-      else
-        "#{indents}\"#{sexp[1]}\""
-      end
-    end
-  end
-
-  class IfFormatter < BaseFormatter
-    def format
-      start = "#{' ' * @indentation}if "
-      condition = Formatter.for(sexp[1]).new(@sexp[1], @indentation + 2, self).format
-      body = Formatter.for(sexp[2]).new(@sexp[2], @indentation + 2, self).format
-      ending = "#{' ' * @indentation}end"
-
-      "#{start}#{condition}\n#{body}\n#{ending}"
-    end
-  end
-
-  class OrFormatter < BaseFormatter
-    def format
-      left = Formatter.for(sexp[1]).new(sexp[1], @indentation, self).format
-      right = Formatter.for(sexp[2]).new(sexp[2], @indentation, self).format
-
-      if needs_parens?
-        "(#{left} || #{right})"
-      else
-        "#{left} || #{right}"
-      end
-    end
-
-    private
-
-    def needs_parens?
-      parent&.type == :or || parent&.type == :and
-    end
-  end
-
-  class AndFormatter < BaseFormatter
-    def format
-      left = Formatter.for(sexp[1]).new(sexp[1], @indentation, self).format
-      right = Formatter.for(sexp[2]).new(sexp[2], @indentation, self).format
-
-      if needs_parens?
-        "(#{left} && #{right})"
-      else
-        "#{left} && #{right}"
-      end
-    end
-
-    private
-
-    def needs_parens?
-      parent&.type == :or || parent&.type == :and
-    end
-  end
-
-  class CallFormatter < BaseFormatter
-    def format
-      if infix?
-        left = Formatter.for(sexp[1]).new(sexp[1], @indentation, self).format
-        right = Formatter.for(sexp[3]).new(sexp[3], @indentation, self).format
-
-        if needs_parens?
-          "(#{left} #{sexp[2]} #{right})"
-        else
-          "#{left} #{sexp[2]} #{right}"
-        end
-      else
-        content = Formatter.for(sexp[1]).new(sexp[1], @indentation, self).format
-        "#{content}.#{sexp[2]}"
-      end
-    end
-
-    private
-
-    def infix?
-      sexp.length == 4
-    end
-
-    def needs_parens?
-      parent&.type == :or || parent&.type == :and
-    end
-  end
-
-  class ClassFormatter < BaseFormatter
-    def format
-      content = Formatter.for(sexp[3]).new(sexp[3], indentation + 2, self).format
-      "#{indents}class #{sexp[1]}\n#{content}\n#{indents}end" # TODO handle inheritance
-    end
-  end
-
-  class CdeclFormatter < BaseFormatter
-    def format
-      content = Formatter.for(sexp[2]).new(sexp[2], indentation + 2, self).format
-      "#{indents}#{sexp[1]} = #{content}"
-    end
-  end
-
-  class ArrayFormatter < BaseFormatter
-    def format
-      elements = sexp[1..-1].map do |nested_sexp|
-        Formatter.for(nested_sexp).new(nested_sexp, indentation + 2, self).format
-      end
-
-      "[#{elements.join(", ")}]"
-    end
-  end
 end

data/lib/prettyrb/builder.rb

@@ -0,0 +1,20 @@
+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,
+      def: Prettyrb::Nodes::DefNode,
+    }.freeze
+
+    def n(type, children, source_map)
+      node_class = NODE_TYPES.fetch(type, Prettyrb::Nodes::BaseNode)
+
+      node_class.new(type, children, location: source_map)
+    end
+  end
+end

data/lib/prettyrb/cli.rb

@@ -0,0 +1,30 @@
+require "thor"
+
+module Prettyrb
+  class CLI < Thor
+    desc "format [FILE]", "Ruby file to prettify"
+    def format(file)
+      content = File.read(file)
+      formatted_content = Prettyrb::Formatter.new(content).format
+
+      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
+      end
+    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