Introduce Source, Source::Node, Source::Token and Source::Location

Author: yujinakayama

lib/rspec/core/source.rb

@@ -0,0 +1,59 @@
+RSpec::Support.require_rspec_core "source/node"
+RSpec::Support.require_rspec_core "source/token"
+
+module RSpec
+  module Core
+    # @private
+    class Source
+      attr_reader :source, :path
+
+      def self.from_file(path)
+        source = File.read(path)
+        new(source, path)
+      end
+
+      def initialize(source_string, path=nil)
+        @source = source_string
+        @path = path ? File.expand_path(path) : '(string)'
+      end
+
+      def lines
+        @lines ||= source.split("\n")
+      end
+
+      def ast
+        @ast ||= begin
+          require 'ripper'
+          sexp = Ripper.sexp(source)
+          Node.new(sexp)
+        end
+      end
+
+      def tokens
+        @tokens ||= begin
+          require 'ripper'
+          tokens = Ripper.lex(source)
+          Token.tokens_from_ripper_tokens(tokens)
+        end
+      end
+
+      def nodes_by_line_number
+        @nodes_by_line_number ||= begin
+          nodes_by_line_number = ast.select(&:location).group_by { |node| node.location.line }
+          Hash.new { |hash, key| hash[key] = [] }.merge(nodes_by_line_number)
+        end
+      end
+
+      def tokens_by_line_number
+        @tokens_by_line_number ||= begin
+          nodes_by_line_number = tokens.group_by { |token| token.location.line }
+          Hash.new { |hash, key| hash[key] = [] }.merge(nodes_by_line_number)
+        end
+      end
+
+      def inspect
+        "#<#{self.class} #{path}>"
+      end
+    end
+  end
+end

lib/rspec/core/source/location.rb

@@ -0,0 +1,12 @@
+module RSpec
+  module Core
+    class Source
+      # @private
+      Location = Struct.new(:line, :column) do
+        def self.location?(array)
+          array.is_a?(Array) && array.size == 2 && array.all? { |e| e.is_a?(Integer) }
+        end
+      end
+    end
+  end
+end

lib/rspec/core/source/node.rb

@@ -0,0 +1,93 @@
+RSpec::Support.require_rspec_core "source/location"
+
+module RSpec
+  module Core
+    class Source
+      # @private
+      class Node
+        include Enumerable
+
+        attr_reader :sexp, :parent
+
+        def self.sexp?(array)
+          array.is_a?(Array) && array.first.is_a?(Symbol)
+        end
+
+        def initialize(ripper_sexp, parent=nil)
+          @sexp = ripper_sexp.freeze
+          @parent = parent
+        end
+
+        def type
+          sexp[0]
+        end
+
+        def args
+          @args ||= raw_args.map do |raw_arg|
+            if Node.sexp?(raw_arg)
+              Node.new(raw_arg, self)
+            elsif Location.location?(raw_arg)
+              Location.new(*raw_arg)
+            elsif raw_arg.is_a?(Array)
+              GroupNode.new(raw_arg, self)
+            else
+              raw_arg
+            end
+          end.freeze
+        end
+
+        def children
+          @children ||= args.select { |arg| arg.is_a?(Node) }.freeze
+        end
+
+        def location
+          @location ||= args.find { |arg| arg.is_a?(Location) }
+        end
+
+        def each(&block)
+          return to_enum(__method__) unless block_given?
+
+          yield self
+
+          children.each do |child|
+            child.each(&block)
+          end
+        end
+
+        def each_ancestor
+          return to_enum(__method__) unless block_given?
+
+          last_node = self
+
+          while (current_node = last_node.parent)
+            yield current_node
+            last_node = current_node
+          end
+        end
+
+        def inspect
+          "#<#{self.class} #{type}>"
+        end
+
+      private
+
+        def raw_args
+          sexp[1..-1] || []
+        end
+      end
+
+      # @private
+      class GroupNode < Node
+        def type
+          :group
+        end
+
+      private
+
+        def raw_args
+          sexp
+        end
+      end
+    end
+  end
+end

lib/rspec/core/source/token.rb

@@ -0,0 +1,42 @@
+RSpec::Support.require_rspec_core "source/location"
+
+module RSpec
+  module Core
+    class Source
+      # @private
+      class Token
+        attr_reader :token
+
+        def self.tokens_from_ripper_tokens(ripper_tokens)
+          ripper_tokens.map { |ripper_token| new(ripper_token) }.freeze
+        end
+
+        def initialize(ripper_token)
+          @token = ripper_token.freeze
+        end
+
+        def location
+          @location ||= Location.new(*token[0])
+        end
+
+        def type
+          token[1]
+        end
+
+        def string
+          token[2]
+        end
+
+        def ==(other)
+          token == other.token
+        end
+
+        alias_method :eql?, :==
+
+        def inspect
+          "#<#{self.class} #{type} #{string.inspect}>"
+        end
+      end
+    end
+  end
+end

spec/rspec/core/source/node_spec.rb

@@ -0,0 +1,114 @@
+require 'rspec/core/source/node'
+
+class RSpec::Core::Source
+  RSpec.describe Node, :if => RSpec::Support::RubyFeatures.ripper_supported? do
+    let(:root_node) do
+      Node.new(sexp)
+    end
+
+    let(:sexp) do
+      require 'ripper'
+      Ripper.sexp(source)
+    end
+
+    let(:source) { <<-END }
+      variable = do_something(1, 2)
+      variable.do_anything do |arg|
+        puts arg
+      end
+    END
+
+    # [:program,
+    #  [[:assign,
+    #    [:var_field, [:@ident, "variable", [1, 6]]],
+    #    [:method_add_arg,
+    #     [:fcall, [:@ident, "do_something", [1, 17]]],
+    #     [:arg_paren,
+    #      [:args_add_block,
+    #       [[:@int, "1", [1, 30]], [:@int, "2", [1, 33]]],
+    #       false]]]],
+    #   [:method_add_block,
+    #    [:call,
+    #     [:var_ref, [:@ident, "variable", [2, 6]]],
+    #     :".",
+    #     [:@ident, "do_anything", [2, 15]]],
+    #    [:do_block,
+    #     [:block_var,
+    #      [:params, [[:@ident, "arg", [2, 31]]], nil, nil, nil, nil, nil, nil],
+    #      false],
+    #     [[:command,
+    #       [:@ident, "puts", [3, 8]],
+    #       [:args_add_block, [[:var_ref, [:@ident, "arg", [3, 13]]]], false]]]]]]]
+
+    describe '#args' do
+      context 'when the sexp args consist of direct child sexps' do
+        let(:target_node) do
+          root_node.find { |node| node.type == :method_add_arg }
+        end
+
+        it 'returns the child nodes' do
+          expect(target_node.args).to match([
+            an_object_having_attributes(:type => :fcall),
+            an_object_having_attributes(:type => :arg_paren)
+          ])
+        end
+      end
+
+      context 'when the sexp args include an array of sexps' do
+        let(:target_node) do
+          root_node.find { |node| node.type == :args_add_block }
+        end
+
+        it 'returns pseudo group node for the array' do
+          expect(target_node.args).to match([
+            an_object_having_attributes(:type => :group),
+            false
+          ])
+        end
+      end
+    end
+
+    describe '#each_ancestor' do
+      let(:target_node) do
+        root_node.find { |node| node.type == :arg_paren }
+      end
+
+      it 'yields ancestor nodes from parent to root' do
+        expect { |b| target_node.each_ancestor(&b) }.to yield_successive_args(
+          an_object_having_attributes(:type => :method_add_arg),
+          an_object_having_attributes(:type => :assign),
+          an_object_having_attributes(:type => :group),
+          an_object_having_attributes(:type => :program)
+        )
+      end
+    end
+
+    describe '#location' do
+      context 'with identifier type node' do
+        let(:target_node) do
+          root_node.find { |node| node.type == :@ident }
+        end
+
+        it 'returns a Location object with line and column numbers' do
+          expect(target_node.location).to have_attributes(:line => 1, :column => 6)
+        end
+      end
+
+      context 'with non-identifier type node' do
+        let(:target_node) do
+          root_node.find { |node| node.type == :assign }
+        end
+
+        it 'returns nil' do
+          expect(target_node.location).to be_nil
+        end
+      end
+    end
+
+    describe '#inspect' do
+      it 'returns a string including class name and node type' do
+        expect(root_node.inspect).to eq('#<RSpec::Core::Source::Node program>')
+      end
+    end
+  end
+end

spec/rspec/core/source/token_spec.rb

@@ -0,0 +1,67 @@
+require 'rspec/core/source/token'
+
+class RSpec::Core::Source
+  RSpec.describe Token, :if => RSpec::Support::RubyFeatures.ripper_supported? do
+    let(:target_token) do
+      tokens.first
+    end
+
+    let(:tokens) do
+      Token.tokens_from_ripper_tokens(ripper_tokens)
+    end
+
+    let(:ripper_tokens) do
+      require 'ripper'
+      Ripper.lex(source)
+    end
+
+    let(:source) do
+      'puts :foo'
+    end
+
+    # [
+    #   [[1, 0], :on_ident, "puts"],
+    #   [[1, 4], :on_sp, " "],
+    #   [[1, 5], :on_symbeg, ":"],
+    #   [[1, 6], :on_ident, "foo"]
+    # ]
+
+    describe '#location' do
+      it 'returns a Location object with line and column numbers' do
+        expect(target_token.location).to have_attributes(:line => 1, :column => 0)
+      end
+    end
+
+    describe '#type' do
+      it 'returns a type of the token' do
+        expect(target_token.type).to eq(:on_ident)
+      end
+    end
+
+    describe '#string' do
+      it 'returns a source string corresponding to the token' do
+        expect(target_token.string).to eq('puts')
+      end
+    end
+
+    describe '#==' do
+      context 'when both tokens have same Ripper token' do
+        it 'returns true' do
+          expect(Token.new(ripper_tokens[0]) == Token.new(ripper_tokens[0])).to be true
+        end
+      end
+
+      context 'when both tokens have different Ripper token' do
+        it 'returns false' do
+          expect(Token.new(ripper_tokens[0]) == Token.new(ripper_tokens[1])).to be false
+        end
+      end
+    end
+
+    describe '#inspect' do
+      it 'returns a string including class name, token type and source string' do
+        expect(target_token.inspect).to eq('#<RSpec::Core::Source::Token on_ident "puts">')
+      end
+    end
+  end
+end