rails5-spec-converter 1.0.15 → 1.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8f809b54f88c799e62a3da375d7e1c6386a24e71
-  data.tar.gz: 853ab71eb42ad2ff5f6834f25596e6f92a45a1d9
+  metadata.gz: da659c54addaff82abd519274ed54477c401438a
+  data.tar.gz: 217e06555325fb97b3e10fdfc8cae7c44f096de5
 SHA512:
-  metadata.gz: 169d693d60ed16a8f81b30cf0e2e77d1cb019451b0ab64b5224bfaf2b3ed9c3a610fde5723a8d322b87c14aa8d70b8f9fb0943e1d979dbf1f1a5d633decd3f70
-  data.tar.gz: b2683718f15845812229c662c977302d58bcfa18a1d47b1efe95cf679194b5678fae3b9236d66f7fd962366c251d738f8787c85f6e1c8efe2421a3c02b9f3d73
+  metadata.gz: 1c2ced79435fb5d7dd440e863c46a49be07e15a9ef648173342e0680235625e4be3011890ff3afd5fd1e69acef81b6d3f98d2216346de2646db51329d1a47454
+  data.tar.gz: 2c478082acb31b1db660f1c35ae12e6a376921ab8acd81e089f7bdf38d6253027a594a8e0ee34550cbc90d497ed50578a8259271125d1408f1e97d2626f26f20

data/lib/rails5/spec_converter/hash_rewriter.rb

@@ -0,0 +1,256 @@
+require 'rails5/spec_converter/node_textifier'
+
+class HashRewriter
+  # technically format is special
+  ALLOWED_KWARG_KEYS = %i(params session flash method body xhr format)
+
+  attr_reader :hash_node, :original_indent
+
+  def initialize(content:, hash_node:, original_indent:, options:)
+    @options = options
+    @content = content
+    @hash_node = hash_node
+    @original_indent = original_indent
+    @textifier = NodeTextifier.new(@content)
+    partition_params(@hash_node)
+  end
+
+  def rewritten_params_hash
+    return if @pairs_that_belong_in_params.length == 0
+
+    rewritten_hashes = []
+
+    warn_if_inconsistent_indentation
+
+    if multiline? && should_wrap_rewritten_hash_in_curly_braces?
+      params_hash = restring_hash(
+        @pairs_that_belong_in_params,
+        joiner: ",\n"
+      )
+
+      other_hash = restring_hash(
+        @pairs_that_belong_outside_params,
+        joiner: ",\n"
+      )
+
+      optional_comma = has_trailing_comma?(hash_node) ? ',' : ''
+      new_wrapped_hash_content = wrap_and_indent(
+        "{",
+        "}",
+        [
+          wrap_and_indent(
+            "params: {",
+            "}#{optional_comma}",
+            params_hash,
+            @options.indent
+          ),
+          "#{other_hash}"
+        ].join("\n"),
+        @options.indent
+      )
+      return add_indent(new_wrapped_hash_content, original_indent, skip_first_line: true)
+    elsif multiline? && should_try_to_rewrite_multiline_hash?
+      params_hash = appropriately_indented_params_hash(
+        pairs: @pairs_that_belong_in_params
+      )
+
+      rewritten_hashes << "params: #{params_hash}"
+    else
+      curly_sep = determine_curly_sep(hash_node)
+      rewritten_hashes << "params: {#{curly_sep}#{restring_hash(@pairs_that_belong_in_params)}#{curly_sep}}"
+    end
+
+    if has_keys_outside_params?
+      rewritten_hashes << restring_hash(
+        @pairs_that_belong_outside_params,
+        joiner: first_joiner_between_pairs
+      )
+    end
+
+    rewritten_hashes.join(first_joiner_between_pairs)
+  end
+
+  def should_rewrite_hash?
+    @pairs_that_belong_in_params.length > 0
+  end
+
+  def has_keys_outside_params?
+    @pairs_that_belong_outside_params.length > 0
+  end
+
+  def should_wrap_rewritten_hash_in_curly_braces?
+    multiline? && has_keys_outside_params? && @textifier.node_to_string(hash_node) =~ /^{\n/
+  end
+
+  def should_try_to_rewrite_multiline_hash?
+    return false unless multiline?
+    return true unless first_joiner_between_pairs
+    first_joiner_between_pairs =~ /\n/
+  end
+
+  private
+
+  def partition_params(hash_node)
+    @pairs_that_belong_in_params = []
+    @pairs_that_belong_outside_params = []
+
+    hash_node.children.each do |pair|
+      key = pair.children[0].children[0]
+
+      if ALLOWED_KWARG_KEYS.include?(key)
+        @pairs_that_belong_outside_params << pair
+      else
+        @pairs_that_belong_in_params << pair
+      end
+    end
+  end
+
+  def has_trailing_comma?(hash_node)
+    @textifier.text_after_last_pair(hash_node) =~ /,/
+  end
+
+  def indent_before_first_pair(hash_node)
+    return nil unless hash_node.children.length > 0
+
+    extract_indent(@textifier.text_before_first_pair(hash_node))
+  end
+
+  def indent_after_last_pair(hash_node)
+    return nil unless hash_node.children.length > 0
+
+    extract_indent(@textifier.text_after_last_pair(hash_node))
+  end
+
+  def multiline?
+    @textifier.node_to_string(hash_node).include?("\n")
+  end
+
+  def indent_of_first_value_if_multiline(hash_node)
+    return nil if hash_node.children.length == 0
+    return nil unless hash_node.children[0].pair_type?
+
+    first_value = hash_node.children[0].children[1]
+    return nil unless first_value.hash_type? || first_value.array_type?
+    value_str_lines = @textifier.node_to_string(first_value).split("\n")
+    return nil if value_str_lines.length == 1
+    return nil unless value_str_lines[0].match(/[\s\[{]/)
+
+    value_str_lines[1].match(/^(\s*)/)[1].sub(original_indent, '')
+  end
+
+  def additional_indent(hash_node)
+    return nil if indent_before_first_pair(hash_node)
+
+    joiner = first_joiner_between_pairs
+    joiner && joiner.include?("\n") ? @options.indent : nil
+  end
+
+  def existing_indent(hash_node)
+    text_before_hash = @textifier.text_before_node(hash_node)
+    whitespace_indent = extract_indent(text_before_hash)
+    return whitespace_indent if whitespace_indent
+
+    return indent_before_first_pair(hash_node) if indent_before_first_pair(hash_node)
+
+    joiner = first_joiner_between_pairs
+    extract_indent(joiner) || ''
+  end
+
+  def no_space_after_curly?(hash_node)
+    hash_node.parent.loc.expression.source.match(/{\S/)
+  end
+
+  def texts_between_pairs
+    return @texts_between if @texts_between
+
+    @texts_between = []
+    hash_node.children[0..-2].each_with_index do |pair, index|
+      next_pair = hash_node.children[index + 1]
+      @texts_between << @textifier.text_between_siblings(pair, next_pair)
+    end
+    @texts_between
+  end
+
+  def first_joiner_between_pairs
+    texts_between_pairs[0]
+  end
+
+  def has_inconsistent_indentation?
+    texts_between_pairs.uniq.length > 1
+  end
+
+  def warn_if_inconsistent_indentation
+    return unless has_inconsistent_indentation?
+
+    log "Inconsistent whitespace between hash pairs, using the first separator (#{texts_between_pairs[0].inspect})."
+    log "Seen when processing this expression: \n```\n#{hash_node.loc.expression.source}\n```\n\n"
+  end
+
+  def appropriately_indented_params_hash(pairs:)
+    outer_indent = existing_indent(hash_node)
+    middle_indent = indent_of_first_value_if_multiline(hash_node)
+    inner_indent = additional_indent(hash_node)
+
+    restrung_hash = restring_hash(
+      pairs,
+      indent: outer_indent + (inner_indent || ''),
+      joiner: ",\n"
+    )
+    if middle_indent
+      restrung_hash = original_indent + add_indent(restrung_hash, middle_indent)
+    end
+    final_brace_indent = if middle_indent
+                           original_indent
+                         else
+                           indent_after_last_pair(hash_node) || outer_indent
+                         end
+    "{\n#{restrung_hash}\n#{final_brace_indent}}"
+  end
+
+  def determine_curly_sep(hash_node)
+    return ' ' if @options.hash_spacing == true
+    return '' if @options.hash_spacing == false
+
+    no_space_after_curly?(hash_node) ? '' : ' '
+  end
+
+  def restring_hash(pairs, joiner: ", ", indent: '')
+    hash_string = pairs.map { |pair| "#{indent}#{pair.loc.expression.source}" }.join(joiner)
+    if has_trailing_comma?(hash_node)
+      hash_string + ','
+    else
+      hash_string
+    end
+  end
+
+  def add_indent_and_curly_braces(str, indent)
+    "{\n#{add_indent(str, indent)}\n}"
+  end
+
+  def wrap_and_indent(start_string, end_string, inner_string, indent)
+    "#{start_string}\n#{add_indent(inner_string, indent)}\n#{end_string}"
+  end
+
+  def add_indent(str, indent, skip_first_line: false)
+    str.split("\n").each_with_index.map do |line, index|
+      if index.zero? && skip_first_line
+        line
+      else
+        indent + line
+      end
+    end.join("\n")
+  end
+
+  def extract_indent(str)
+    return unless str
+
+    match = str.match("\n(\s*)")
+    match[1] if match
+  end
+
+  def log(str)
+    return if @options.quiet?
+
+    puts str
+  end
+end

data/lib/rails5/spec_converter/node_textifier.rb

@@ -0,0 +1,28 @@
+class NodeTextifier
+  def initialize(content)
+    @content = content
+  end
+
+  def text_before_first_pair(hash_node)
+    @content[hash_node.loc.expression.begin_pos...hash_node.children.first.loc.expression.begin_pos]
+  end
+
+  def text_after_last_pair(hash_node)
+    @content[hash_node.children.last.loc.expression.end_pos...hash_node.loc.expression.end_pos]
+  end
+
+  def text_before_node(node)
+    previous_sibling = node.parent.children[node.sibling_index - 1]
+    return nil unless previous_sibling.loc.expression
+
+    text_between_siblings(previous_sibling, node)
+  end
+
+  def text_between_siblings(node1, node2)
+    @content[node1.loc.expression.end_pos...node2.loc.expression.begin_pos]
+  end
+
+  def node_to_string(node)
+    @content[node.loc.expression.begin_pos...node.loc.expression.end_pos]
+  end
+end

data/lib/rails5/spec_converter/text_transformer.rb

@@ -1,13 +1,11 @@
 require 'parser/current'
 require 'astrolabe/builder'
 require 'rails5/spec_converter/text_transformer_options'
-require 'rails5/spec_converter/hash_node_text_analyzer'
+require 'rails5/spec_converter/hash_rewriter'
 
 module Rails5
   module SpecConverter
     HTTP_VERBS = %i(get post put patch delete)
-    # technically format is special
-    ALLOWED_KWARG_KEYS = %i(params session flash method body xhr format)
 
     class TextTransformer
       def initialize(content, options = TextTransformerOptions.new)
@@ -41,10 +39,17 @@ module Rails5
                 next unless @options.wrap_ambiguous_params?
               end
 
-              write_params_hash(
+              hash_rewriter = HashRewriter.new(
+                content: @content,
+                options: @options,
                 hash_node: args[0],
                 original_indent: node.loc.expression.source_line.match(/^(\s*)/)[1]
               )
+
+              @source_rewriter.replace(
+                args[0].loc.expression,
+                hash_rewriter.rewritten_params_hash
+              ) if hash_rewriter.should_rewrite_hash?
             end
           else
             warn_about_ambiguous_params(node) if @options.warn_about_ambiguous_params?
@@ -81,156 +86,10 @@ module Rails5
         hash_node.children.any? { |node| node.kwsplat_type? }
       end
 
-      def has_trailing_comma?(hash_node)
-        HashNodeTextAnalyzer.new(@content, hash_node).text_after_last_pair =~ /,/
-      end
-
       def has_key?(hash_node, key)
         hash_node.children.any? { |pair| pair.children[0].children[0] == key }
       end
 
-      def write_params_hash(hash_node:, original_indent: )
-        pairs_that_belong_in_params, pairs_that_belong_outside_params = partition_params(hash_node)
-        use_trailing_comma = has_trailing_comma?(hash_node)
-
-        if pairs_that_belong_in_params.length > 0
-          joiner = joiner_between_pairs(hash_node)
-          params_hash = appropriately_spaced_params_hash(
-            hash_node: hash_node,
-            pairs: pairs_that_belong_in_params,
-            original_indent: original_indent,
-            use_trailing_comma: use_trailing_comma
-          )
-
-          rewritten_hashes = ["params: #{params_hash}"]
-          if pairs_that_belong_outside_params.length > 0
-            rewritten_hashes << restring_hash(
-              pairs_that_belong_outside_params,
-              joiner: joiner,
-              use_trailing_comma: use_trailing_comma
-            )
-          end
-          @source_rewriter.replace(
-            hash_node.loc.expression,
-            rewritten_hashes.join(joiner)
-          )
-        end
-      end
-
-      def partition_params(hash_node)
-        pairs_that_belong_in_params = []
-        pairs_that_belong_outside_params = []
-
-        hash_node.children.each do |pair|
-          key = pair.children[0].children[0]
-
-          if ALLOWED_KWARG_KEYS.include?(key)
-            pairs_that_belong_outside_params << pair
-          else
-            pairs_that_belong_in_params << pair
-          end
-        end
-        return pairs_that_belong_in_params, pairs_that_belong_outside_params
-      end
-
-      def indent_before_first_pair(hash_node)
-        return nil unless hash_node.children.length > 0
-
-        extract_indent(HashNodeTextAnalyzer.new(@content, hash_node).text_before_first_pair)
-      end
-
-      def indent_after_last_pair(hash_node)
-        return nil unless hash_node.children.length > 0
-
-        extract_indent(HashNodeTextAnalyzer.new(@content, hash_node).text_after_last_pair)
-      end
-
-      def indent_of_first_value_if_multiline(hash_node, original_indent)
-        return nil if hash_node.children.length == 0
-        return nil unless hash_node.children[0].pair_type?
-
-        first_value = hash_node.children[0].children[1]
-        return nil unless first_value.hash_type? || first_value.array_type?
-        value_str_lines = node_to_string(first_value).split("\n")
-        return nil if value_str_lines.length == 1
-        return nil unless value_str_lines[0].match(/[\s\[{]/)
-
-        value_str_lines[1].match(/^(\s*)/)[1].sub(original_indent, '')
-      end
-
-      def additional_indent(hash_node)
-        return nil if indent_before_first_pair(hash_node)
-
-        joiner = joiner_between_pairs(hash_node)
-        joiner && joiner.include?("\n") ? @options.indent : nil
-      end
-
-      def existing_indent(hash_node)
-        text_before_hash = text_before_node(hash_node)
-        whitespace_indent = extract_indent(text_before_hash)
-        return whitespace_indent if whitespace_indent
-
-        return indent_before_first_pair(hash_node) if indent_before_first_pair(hash_node)
-
-        joiner = joiner_between_pairs(hash_node)
-        extract_indent(joiner) || ''
-      end
-
-      def no_space_after_curly?(hash_node)
-        hash_node.parent.loc.expression.source.match(/{\S/)
-      end
-
-      def joiner_between_pairs(hash_node)
-        texts_between = []
-        hash_node.children[0..-2].each_with_index do |pair, index|
-          next_pair = hash_node.children[index + 1]
-          texts_between << text_between_siblings(pair, next_pair)
-        end
-        if texts_between.uniq.length > 1
-          log "Inconsistent whitespace between hash pairs, using the first separator (#{texts_between[0].inspect})."
-          log "Seen when processing this expression: \n```\n#{hash_node.loc.expression.source}\n```\n\n"
-        end
-        texts_between[0]
-      end
-
-      def text_between_siblings(node1, node2)
-        @content[node1.loc.expression.end_pos...node2.loc.expression.begin_pos]
-      end
-
-      def appropriately_spaced_params_hash(hash_node:, pairs:, original_indent:, use_trailing_comma:)
-        outer_indent = existing_indent(hash_node)
-        middle_indent = indent_of_first_value_if_multiline(hash_node, original_indent)
-        inner_indent = additional_indent(hash_node)
-
-        if inner_indent || middle_indent || indent_before_first_pair(hash_node)
-          restrung_hash = restring_hash(
-            pairs,
-            indent: outer_indent + (inner_indent || ''),
-            joiner: ",\n",
-            use_trailing_comma: use_trailing_comma
-          )
-          if middle_indent
-            restrung_hash = original_indent + add_indent(restrung_hash, middle_indent)
-          end
-          final_brace_indent = if middle_indent
-                                 original_indent
-                               else
-                                 indent_after_last_pair(hash_node) || outer_indent
-                               end
-          "{\n#{restrung_hash}\n#{final_brace_indent}}"
-        else
-          curly_sep = determine_curly_sep(hash_node)
-          "{#{curly_sep}#{restring_hash(pairs, use_trailing_comma: use_trailing_comma)}#{curly_sep}}"
-        end
-      end
-
-      def determine_curly_sep(hash_node)
-        return ' ' if @options.hash_spacing == true
-        return '' if @options.hash_spacing == false
-
-        no_space_after_curly?(hash_node) ? '' : ' '
-      end
-
       def wrap_arg(node, key)
         node_loc = node.loc.expression
         node_source = node_loc.source
@@ -240,37 +99,6 @@ module Rails5
         @source_rewriter.replace(node_loc, "#{key}: #{node_source}")
       end
 
-      def restring_hash(pairs, joiner: ", ", indent: '', use_trailing_comma: false)
-        hash_string = pairs.map { |pair| "#{indent}#{pair.loc.expression.source}" }.join(joiner)
-        if use_trailing_comma
-          hash_string + ','
-        else
-          hash_string
-        end
-      end
-
-      def add_indent(str, indent)
-        str.split("\n").map { |line| indent + line }.join("\n")
-      end
-
-      def extract_indent(str)
-        return unless str
-
-        match = str.match("\n(\s*)")
-        match[1] if match
-      end
-
-      def text_before_node(node)
-        previous_sibling = node.parent.children[node.sibling_index - 1]
-        return nil unless previous_sibling.loc.expression
-
-        text_between_siblings(previous_sibling, node)
-      end
-
-      def node_to_string(node)
-        @content[node.loc.expression.begin_pos...node.loc.expression.end_pos]
-      end
-
       def warn_about_ambiguous_params(node)
         log "Ambiguous params found"
         log "#{@options.file_path}:#{node.loc.line}" if @options.file_path

data/lib/rails5/spec_converter/version.rb

@@ -1,5 +1,5 @@
 module Rails5
   module SpecConverter
-    VERSION = "1.0.15"
+    VERSION = "1.0.16"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails5-spec-converter
 version: !ruby/object:Gem::Version
-  version: 1.0.15
+  version: 1.0.16
 platform: ruby
 authors:
 - Travis Grathwell
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-09-12 00:00:00.000000000 Z
+date: 2016-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -116,7 +116,8 @@ files:
 - exe/rails5-spec-converter
 - lib/rails5/spec_converter.rb
 - lib/rails5/spec_converter/cli.rb
-- lib/rails5/spec_converter/hash_node_text_analyzer.rb
+- lib/rails5/spec_converter/hash_rewriter.rb
+- lib/rails5/spec_converter/node_textifier.rb
 - lib/rails5/spec_converter/text_transformer.rb
 - lib/rails5/spec_converter/text_transformer_options.rb
 - lib/rails5/spec_converter/version.rb

data/lib/rails5/spec_converter/hash_node_text_analyzer.rb

@@ -1,16 +0,0 @@
-class HashNodeTextAnalyzer
-  attr_reader :content, :hash_node
-
-  def initialize(content, hash_node)
-    @content = content
-    @hash_node = hash_node
-  end
-
-  def text_before_first_pair
-    content[hash_node.loc.expression.begin_pos...hash_node.children.first.loc.expression.begin_pos]
-  end
-
-  def text_after_last_pair
-    content[hash_node.children.last.loc.expression.end_pos...hash_node.loc.expression.end_pos]
-  end
-end