etude_for_ruby 0.1.4 → 0.2.3

data/vendor/bundle/ruby/2.2.0/gems/yard-0.9.8/lib/yard/parser/base.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-module YARD
-  module Parser
-    # Represents the abstract base parser class that parses source code in
-    # a specific way. A parser should implement {#parse}, {#tokenize} and
-    # {#enumerator}.
-    #
-    # == Registering a Custom Parser
-    # To register a parser, see {SourceParser.register_parser_type}
-    #
-    # @abstract
-    # @see #parse
-    # @see #tokenize
-    # @see #enumerator
-    # @since 0.5.6
-    class Base
-      # Convenience method to create a new parser and {#parse}
-      def self.parse(source, filename = nil)
-        new(source, filename).parse
-      end
-
-      # This default constructor does nothing. The subclass is responsible for
-      # storing the source contents and filename if they are required.
-      # @param [String] source the source contents
-      # @param [String] filename the name of the file if from disk
-      def initialize(source, filename) # rubocop:disable Lint/UnusedMethodArgument
-        raise NotImplementedError, "invalid parser implementation"
-      end
-
-      # This method should be implemented to parse the source and return itself.
-      # @abstract
-      # @return [Base] this method should return itself
-      def parse
-        raise NotImplementedError, "#{self.class} must implement #parse"
-      end
-
-      # This method should be implemented to tokenize given source
-      # @abstract
-      # @return [Array] a list/tree of lexical tokens
-      def tokenize
-        raise NotImplementedError, "#{self.class} does not support tokenization"
-      end
-
-      # This method should be implemented to return a list of semantic tokens
-      # representing the source code to be post-processed. Otherwise the method
-      # should return nil.
-      #
-      # @abstract
-      # @return [Array] a list of semantic tokens representing the source code
-      #   to be post-processed
-      # @return [nil] if no post-processing should be done
-      def enumerator
-        nil
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/yard-0.9.8/lib/yard/parser/c/c_parser.rb

@@ -1,232 +0,0 @@
-# frozen_string_literal: true
-module YARD
-  module Parser
-    module C
-      class CParser < Base
-        def initialize(source, file = '(stdin)')
-          @file = file
-          @namespaces = {}
-          @content = source
-          @index = 0
-          @line = 1
-          @state = nil
-          @newline = true
-          @statements = []
-          @last_comment = nil
-          @last_statement = nil
-        end
-
-        def parse
-          parse_toplevel
-          enumerator
-        end
-
-        def enumerator
-          @statements
-        end
-
-        def tokenize
-          raise NotImplementedError, "no tokenization support for C/C++ files"
-        end
-
-        private
-
-        def parse_toplevel
-          advance_loop do
-            case char
-            when /['"]/; consume_quote(char)
-            when '#'; consume_directive
-            when '/'; consume_comment
-            when /\s/; consume_whitespace
-            else consume_toplevel_statement
-            end
-          end
-        end
-
-        def consume_quote(type = '"')
-          advance
-          advance_loop do
-            case char
-            when "\n"; advance; nextline
-            when '\\'; advance(2)
-            when type; advance; return
-            else advance
-            end
-          end
-        end
-
-        def consume_directive
-          return(advance) unless @newline
-          @last_comment = nil
-          @last_statement = nil
-          advance_loop do
-            if char == '\\' && nextchar =~ /[\r\n]/
-              advance_loop { advance; break(nextline) if char == "\n" }
-            elsif char == "\n"
-              return
-            end
-            advance
-          end
-        end
-
-        def consume_toplevel_statement
-          @newline = false
-          start = @index
-          line = @line
-          decl = consume_until(/[{;]/)
-          return nil if decl =~ /\A\s*\Z/
-          statement = ToplevelStatement.new(nil, @file, line)
-          @statements << statement
-          attach_comment(statement)
-          stmts = nil
-          if prevchar == '{'
-            stmts = consume_body_statements
-            if decl =~ /\A(typedef|enum|class|#{struct}|union)/
-              consume_until(';')
-            end
-          end
-          statement.source = @content[start..@index]
-          statement.block = stmts
-          statement.declaration = decl # rubocop:disable Lint/UselessSetterCall
-        end
-
-        def consume_body_statements
-          stmts = []
-          brace_level = 1
-          loop do
-            strip_non_statement_data
-            start = @index
-            line = @line
-            consume_until(/[{};]/)
-            brace_level += 1 if prevchar == '{'
-            brace_level -= 1 if prevchar == '}'
-
-            break if prevchar.empty? || (brace_level <= 0 && prevchar == '}')
-            src = @content[start...@index]
-            next unless src && src !~ /\A\s*\Z|\A\}\Z/
-
-            stmt = BodyStatement.new(src, @file, line)
-            attach_comment(stmt)
-            stmts << stmt
-          end
-          stmts
-        end
-
-        def strip_non_statement_data
-          start = @index
-          loop do
-            start = @index
-            case char
-            when /\s/; consume_whitespace
-            when '#';  consume_directive
-            when '/';  consume_comment
-            end
-
-            break if start == @index
-          end
-        end
-
-        def consume_whitespace
-          advance_loop { nextline if char == "\n"; break if char =~ /\S/; advance }
-        end
-
-        def consume_comment(add_comment = true)
-          return(advance) unless nextchar == '*' || nextchar == '/'
-          line = @line
-          type = nextchar == '*' ? :multi : :line
-          advance(2)
-          comment = String.new("")
-          advance_loop do
-            comment << char
-            if type == :multi
-              nextline if char == "\n"
-              if char(2) == '*/'
-                if add_comment
-                  comment << '/'
-                  stmt = Comment.new(comment, @file, line)
-                  stmt.type = type
-                  attach_comment(stmt)
-                  @statements << stmt
-                end
-                return advance(2)
-              end
-            elsif char == "\n"
-              if add_comment
-                stmt = Comment.new(comment[0...-1], @file, line)
-                stmt.type = type
-                attach_comment(stmt)
-                @statements << stmt
-              end
-              return
-            end
-            advance
-          end
-        end
-
-        def consume_until(end_char, bracket_level = 0, brace_level = 0, add_comment = true)
-          end_char = /#{end_char}/ if end_char.is_a?(String)
-          start = @index
-          advance_loop do
-            chr = char
-            case chr
-            when /\s/; consume_whitespace
-            when /['"]/; consume_quote(char)
-            when '#'; consume_directive
-            when '/'; consume_comment(add_comment)
-            when '{'; advance; brace_level += 1
-            when '}'; advance; brace_level -= 1
-            when '('; advance; bracket_level += 1
-            when ')'; advance; bracket_level -= 1
-            else advance
-            end
-            @newline = false if chr !~ /\s/
-
-            if chr =~ end_char
-              break if chr == '{' || chr == '('
-              break if bracket_level <= 0 && brace_level <= 0
-            end
-          end
-          @content[start...@index]
-        end
-
-        def attach_comment(statement)
-          if Comment === statement
-            if @last_statement && @last_statement.line == statement.line
-              @last_statement.comments = statement
-              statement.statement = @last_statement
-            end
-            @last_comment = statement
-            @last_statement = nil
-          else
-            if @last_comment
-              statement.comments = @last_comment
-              @last_comment.statement = statement
-            end
-            @last_statement = statement
-            @last_comment = nil
-          end
-        end
-
-        def advance(num = 1) @index += num end
-        def back(num = 1) @index -= num end
-
-        def advance_loop
-          yield while @index <= @content.size
-        end
-
-        def nextline
-          @line += 1
-          @newline = true
-        end
-
-        def char(num = 1) @content[@index, num] end
-        def prevchar(num = 1) @content[@index - 1, num] end
-        def nextchar(num = 1) @content[@index + 1, num] end
-
-        def struct
-          /struct\s[a-zA-Z0-9]+\s\{/
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/yard-0.9.8/lib/yard/parser/c/comment_parser.rb

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-module YARD
-  module Parser
-    module C
-      module CommentParser
-        protected
-
-        def parse_comments(comments)
-          @overrides = []
-          spaces = nil
-          comments = remove_private_comments(comments)
-          comments = comments.split(/\r?\n/).map do |line|
-            line.gsub!(%r{^\s*/?\*/?}, '')
-            line.gsub!(%r{\*/\s*$}, '')
-            if line =~ /^\s*$/
-              next if spaces.nil?
-              next ""
-            end
-            spaces = (line[/^(\s+)/, 1] || "").size if spaces.nil?
-            line.gsub(/^\s{0,#{spaces}}/, '').rstrip
-          end.compact
-
-          comments = parse_overrides(comments)
-          comments = parse_callseq(comments)
-          comments.join("\n")
-        end
-
-        private
-
-        def parse_overrides(comments)
-          comments.map do |line|
-            type, name = *line.scan(/^\s*Document-(class|module|method|attr|const):\s*(\S.*)\s*$/).first
-            if type
-              @overrides << [type.to_sym, name]
-              nil
-            else
-              line
-            end
-          end.compact
-        end
-
-        def parse_callseq(comments)
-          return comments unless comments[0] =~ /\Acall-seq:\s*(\S.+)?/
-          if $1
-            comments[0] = " #{$1}"
-          else
-            comments.shift
-          end
-          overloads = []
-          seen_data = false
-          while comments.first =~ /^\s+(\S.+)/ || comments.first =~ /^\s*$/
-            line = comments.shift.strip
-            break if line.empty? && seen_data
-            next if line.empty?
-            seen_data = true
-            line.sub!(/^\w+[\.#]/, '')
-            signature, types = *line.split(/ [-=]> /)
-            types = parse_types(types)
-            if signature.sub!(/\[?\s*(\{(?:\s*\|(.+?)\|)?.*\})\s*\]?\s*$/, '') && $1
-              blk = $1
-              blkparams = $2
-            else
-              blk = nil
-              blkparams = nil
-            end
-            case signature
-            when /^(\w+)\s*=\s+(\w+)/
-              signature = "#{$1}=(#{$2})"
-            when /^\w+\s+\S/
-              signature = signature.split(/\s+/)
-              signature = "#{signature[1]}#{signature[2] ? '(' + signature[2..-1].join(' ') + ')' : ''}"
-            when /^\w+\[(.+?)\]\s*(=)?/
-              signature = "[]#{$2}(#{$1})"
-            when /^\w+\s+(#{CodeObjects::METHODMATCH})\s+(\w+)/
-              signature = "#{$1}(#{$2})"
-            end
-            break unless signature =~ /^#{CodeObjects::METHODNAMEMATCH}/
-            signature = signature.rstrip
-            overloads << "@overload #{signature}"
-            overloads << "  @yield [#{blkparams}]" if blk
-            overloads << "  @return [#{types.join(', ')}]" unless types.empty?
-          end
-
-          comments + [""] + overloads
-        end
-
-        def parse_types(types)
-          if types =~ /true or false/
-            ["Boolean"]
-          else
-            (types || "").split(/,| or /).map do |t|
-              case t.strip.gsub(/^an?_/, '')
-              when "class"; "Class"
-              when "obj", "object", "anObject"; "Object"
-              when "arr", "array", "anArray", /^\[/; "Array"
-              when /^char\s*\*/, "char", "str", "string", "new_str"; "String"
-              when "enum", "anEnumerator"; "Enumerator"
-              when "exc", "exception"; "Exception"
-              when "proc", "proc_obj", "prc"; "Proc"
-              when "binding"; "Binding"
-              when "hsh", "hash", "aHash"; "Hash"
-              when "ios", "io"; "IO"
-              when "file"; "File"
-              when "float"; "Float"
-              when "time", "new_time"; "Time"
-              when "dir", "aDir"; "Dir"
-              when "regexp", "new_regexp"; "Regexp"
-              when "matchdata"; "MatchData"
-              when "encoding"; "Encoding"
-              when "fixnum", "fix"; "Fixnum"
-              when /^(?:un)?signed$/, /^(?:(?:un)?signed\s*)?(?:short|int|long|long\s+long)$/, "integer", "Integer"; "Integer"
-              when "num", "numeric", "Numeric", "number"; "Numeric"
-              when "aBignum"; "Bignum"
-              when "nil"; "nil"
-              when "true"; "true"
-              when "false"; "false"
-              when "bool", "boolean", "Boolean"; "Boolean"
-              when "self"; "self"
-              when /^[-+]?\d/; t
-              when /[A-Z][_a-z0-9]+/; t
-              end
-            end.compact
-          end
-        end
-
-        def remove_private_comments(comment)
-          comment = comment.gsub(%r{/?\*--\n(.*?)/?\*\+\+}m, '')
-          comment = comment.sub(%r{/?\*--\n.*}m, '')
-          comment
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/yard-0.9.8/lib/yard/parser/c/statement.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-module YARD
-  module Parser
-    module C
-      class Statement
-        attr_accessor :source
-        attr_accessor :line
-        attr_accessor :file
-
-        # @deprecated Groups are now defined by directives
-        # @see Tags::GroupDirective
-        attr_accessor :group
-
-        attr_accessor :comments_hash_flag
-
-        def initialize(source, file = nil, line = nil)
-          @source = source
-          @file = file
-          @line = line
-        end
-
-        def line_range
-          line...(line + source.count("\n"))
-        end
-
-        def comments_range
-          comments.line_range
-        end
-
-        def first_line
-          source.split(/\n/).first
-        end
-
-        def show
-          "\t#{line}: #{first_line}"
-        end
-      end
-
-      class BodyStatement < Statement
-        attr_accessor :comments
-      end
-
-      class ToplevelStatement < Statement
-        attr_accessor :block
-        attr_accessor :declaration
-        attr_accessor :comments
-      end
-
-      class Comment < Statement
-        include CommentParser
-
-        attr_accessor :type
-        attr_accessor :overrides
-        attr_accessor :statement
-
-        def initialize(source, file = nil, line = nil)
-          super(parse_comments(source), file, line)
-        end
-
-        def comments; self end
-      end
-    end
-  end
-end