yard 0.9.20 → 0.9.21

data/Dockerfile.samus

@@ -0,0 +1,28 @@
+FROM lsegal/samus:latest as samus
+
+FROM ruby:2
+ARG VERSION
+ENV VERSION=${VERSION}
+WORKDIR /github/lsegal/yard
+ENTRYPOINT samus publish release-v${VERSION}.tar.gz
+
+# Prepare credential config
+RUN mkdir -p ~/.ssh
+RUN echo "Host *" > ~/.ssh/config
+RUN echo "    StrictHostKeyChecking no" >> ~/.ssh/config
+RUN chmod 400 ~/.ssh/config
+COPY ./.samusprep/.samus /root/.samus
+COPY ./.samusprep/.gitconfig /root/.gitconfig
+
+# Setup Samus
+ENV PATH=$PATH:/samus/bin
+COPY --from=samus /samus /samus
+
+# Install gems
+ENV BUNDLE_PATH=/var/gems
+COPY Gemfile /github/lsegal/yard
+RUN bundle
+
+# Run build
+COPY . /github/lsegal/yard
+RUN samus build --skip-restore ${VERSION}

data/Gemfile

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+source 'https://rubygems.org'
+
+group :development do
+  gem 'rspec'
+  gem 'rake'
+  gem 'rdoc'
+  gem 'json'
+  gem 'simplecov'
+  gem 'samus', '~> 3.0.8', :require => false
+  gem 'coveralls', :require => false
+end
+
+group :asciidoc do
+  gem 'asciidoctor'
+end
+
+group :markdown do
+  gem 'redcarpet', :platforms => [:ruby]
+end
+
+group :textile do
+  gem 'RedCloth', :platforms => [:ruby]
+end
+
+group :server do
+  gem 'rack'
+end
+
+group :i18n do
+  gem 'gettext'
+end

data/README.md

@@ -226,6 +226,8 @@ The second most obvious is to generate docs via a Rake task. You can do this by
 adding the following to your `Rakefile`:
 
 ```ruby
+require 'yard'
+
 YARD::Rake::YardocTask.new do |t|
  t.files   = ['lib/**/*.rb', OTHER_PATHS]   # optional
  t.options = ['--any', '--extra', '--opts'] # optional

data/SECURITY.md

@@ -0,0 +1,26 @@
+# Security Policy
+
+## Supported Versions
+
+The following versions are supported with security patches for
+any reported vulnerabilities in YARD or dependent software.
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 0.9.x   | :white_check_mark: |
+| < 0.9   | :x:                |
+
+## Reporting a Vulnerability
+
+If you've discovered a vulnerability in YARD source code, please email
+lsegal@soen.ca with as much information as possible. You should typically
+receive a response within 24-48 hours, though depending on scheduling
+it may take up to a week to respond. If you do not get a response on
+your initial email within a few days, please re-send your email or
+reach out on other channels (such as yardoc@googlegroups.com) to
+try to get a hold of a maintainer. Please do not include sensitive
+material if you are reaching out through secondary channels unless
+you first receive confirmation that it is okay.
+
+Thank you for your help and cooperation in making YARD a stable and
+safe piece of software.

data/lib/yard/code_objects/base.rb

@@ -189,6 +189,10 @@ module YARD
         def new(namespace, name, *args, &block)
           raise ArgumentError, "invalid empty object name" if name.to_s.empty?
           if namespace.is_a?(ConstantObject)
+            unless namespace.value =~ /\A#{NAMESPACEMATCH}\Z/
+              raise Parser::UndocumentableError, "constant mapping"
+            end
+
             namespace = Proxy.new(namespace.namespace, namespace.value)
           end
 
@@ -382,11 +386,14 @@ module YARD
       #   as a +String+ for the definition of the code object only (not the block)
       def source=(statement)
         if statement.respond_to?(:source)
-          self.signature = statement.first_line
           @source = format_source(statement.source.strip)
         else
           @source = format_source(statement.to_s)
         end
+
+        if statement.respond_to?(:signature)
+          self.signature = statement.signature
+        end
       end
 
       # The documentation string associated with the object

data/lib/yard/code_objects/proxy.rb

@@ -58,6 +58,10 @@ module YARD
         self.type = type
 
         if @namespace.is_a?(ConstantObject)
+          unless @namespace.value =~ /\A#{NAMESPACEMATCH}\Z/
+            raise Parser::UndocumentableError, "constant mapping"
+          end
+
           @origname = nil # forget these for a constant
           @orignamespace = nil
           @namespace = Proxy.new(@namespace.namespace, @namespace.value)

data/lib/yard/handlers/ruby/attribute_handler.rb

@@ -45,7 +45,7 @@ class YARD::Handlers::Ruby::AttributeHandler < YARD::Handlers::Ruby::Base
           else
             src = "def #{meth}"
             full_src = "#{src}\n  @#{name}\nend"
-            doc = "Returns the value of attribute #{name}"
+            doc = "Returns the value of attribute #{name}."
           end
           o.source ||= full_src
           o.signature ||= src

data/lib/yard/handlers/ruby/dsl_handler_methods.rb

@@ -40,9 +40,9 @@ module YARD
             return register_docstring(nil)
           end
 
-          object = MethodObject.new(namespace, method_name, scope)
-          object.signature = method_signature
-          register(object)
+          register MethodObject.new(namespace, method_name, scope) do |o|
+            o.signature = method_signature
+          end
         end
 
         def register_docstring(object, docstring = @docstring, stmt = statement)

data/lib/yard/handlers/ruby/method_handler.rb

@@ -21,7 +21,6 @@ class YARD::Handlers::Ruby::MethodHandler < YARD::Handlers::Ruby::Base
 
     nobj = P(namespace, nobj.value) while nobj.type == :constant
     obj = register MethodObject.new(nobj, meth, mscope) do |o|
-      o.signature = method_signature
       o.explicit = true
       o.parameters = args
     end
@@ -102,13 +101,4 @@ class YARD::Handlers::Ruby::MethodHandler < YARD::Handlers::Ruby::Base
 
     params
   end
-
-  def method_signature
-    method_name = statement.method_name(true)
-    if statement.parameters.any? {|e| e }
-      "def #{method_name}(#{statement.parameters.source})"
-    else
-      "def #{method_name}"
-    end
-  end
 end

data/lib/yard/handlers/ruby/mixin_handler.rb

@@ -32,6 +32,18 @@ class YARD::Handlers::Ruby::MixinHandler < YARD::Handlers::Ruby::Base
       obj = Proxy.new(namespace, mixin.source, :module)
     end
 
-    namespace.mixins(scope).unshift(obj) unless namespace.mixins(scope).include?(obj)
+    rec = recipient(mixin)
+    return if rec.nil? || rec.mixins(scope).include?(obj)
+    rec.mixins(scope).unshift(obj)
+  end
+
+  def recipient(mixin)
+    if statement[0].type == :var_ref && statement[0][0] != s(:kw, "self")
+      statement[0][0].type == :const ?
+        Proxy.new(namespace, statement.namespace.source) :
+        nil
+    else
+      namespace
+    end
   end
 end

data/lib/yard/parser/c/statement.rb

@@ -31,6 +31,8 @@ module YARD
           source.split(/\n/).first
         end
 
+        alias signature first_line
+
         def show
           "\t#{line}: #{first_line}"
         end

data/lib/yard/parser/ruby/ast_node.rb

@@ -485,6 +485,17 @@ module YARD
           include_block_param ? params : params[0...-1]
         end
 
+        def signature
+          params_src = ''
+          params = self[1 + index_adjust]
+          if params.first
+            params_src = params.type == :paren ? '' : ' '
+            params_src += params.source.gsub(/\s+(\s|\))/m, '\1')
+          end
+
+          "def #{method_name(true)}#{params_src}"
+        end
+
         alias block last
 
         private

data/lib/yard/parser/ruby/legacy/irb/slex.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: false
+#
+#   irb/slex.rb - simple lex analyzer
+#   	$Release Version: 0.9.6$
+#   	$Revision$
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+
+require "irb/notifier"
+
+# :stopdoc:
+module IRB
+  class SLex
+    DOUT = Notifier::def_notifier("SLex::")
+    D_WARN = DOUT::def_notifier(1, "Warn: ")
+    D_DEBUG = DOUT::def_notifier(2, "Debug: ")
+    D_DETAIL = DOUT::def_notifier(4, "Detail: ")
+
+    DOUT.level = Notifier::D_NOMSG
+
+    def initialize
+      @head = Node.new("")
+    end
+
+    def def_rule(token, preproc = nil, postproc = nil, &block)
+      D_DETAIL.pp token
+
+      postproc = block if block_given?
+      create(token, preproc, postproc)
+    end
+
+    def def_rules(*tokens, &block)
+      if block_given?
+        p = block
+      end
+      for token in tokens
+        def_rule(token, nil, p)
+      end
+    end
+
+    def preproc(token, proc)
+      node = search(token)
+      node.preproc=proc
+    end
+
+    # need a check?
+    def postproc(token)
+      node = search(token, proc)
+      node.postproc=proc
+    end
+
+    def search(token)
+      @head.search(token.split(//))
+    end
+
+    def create(token, preproc = nil, postproc = nil)
+      @head.create_subnode(token.split(//), preproc, postproc)
+    end
+
+    def match(token)
+      case token
+      when Array
+      when String
+        return match(token.split(//))
+      else
+        return @head.match_io(token)
+      end
+      ret = @head.match(token)
+      D_DETAIL.exec_if{D_DETAIL.printf "match end: %s:%s\n", ret, token.inspect}
+      ret
+    end
+
+    def inspect
+      format("<SLex: @head = %s>", @head.inspect)
+    end
+
+    #----------------------------------------------------------------------
+    #
+    #   class Node -
+    #
+    #----------------------------------------------------------------------
+    class Node
+      # if postproc is nil, this node is an abstract node.
+      # if postproc is non-nil, this node is a real node.
+      def initialize(preproc = nil, postproc = nil)
+        @Tree = {}
+        @preproc = preproc
+        @postproc = postproc
+      end
+
+      attr_accessor :preproc
+      attr_accessor :postproc
+
+      def search(chrs, opt = nil)
+        return self if chrs.empty?
+        ch = chrs.shift
+        if node = @Tree[ch]
+          node.search(chrs, opt)
+        else
+          if opt
+            chrs.unshift ch
+            self.create_subnode(chrs)
+          else
+            raise "node nothing"
+          end
+        end
+      end
+
+      def create_subnode(chrs, preproc = nil, postproc = nil)
+        if chrs.empty?
+          if @postproc
+            D_DETAIL.pp node
+            raise "node already exists"
+          else
+            D_DEBUG.puts "change abstract node to real node."
+            @preproc = preproc
+            @postproc = postproc
+          end
+          return self
+        end
+
+        ch = chrs.shift
+        if node = @Tree[ch]
+          if chrs.empty?
+            if node.postproc
+              DebugLogger.pp node
+              DebugLogger.pp self
+              DebugLogger.pp ch
+              DebugLogger.pp chrs
+              raise "node already exists"
+            else
+              D_WARN.puts "change abstract node to real node"
+              node.preproc = preproc
+              node.postproc = postproc
+            end
+          else
+            node.create_subnode(chrs, preproc, postproc)
+          end
+        else
+          if chrs.empty?
+            node = Node.new(preproc, postproc)
+          else
+            node = Node.new
+            node.create_subnode(chrs, preproc, postproc)
+          end
+          @Tree[ch] = node
+        end
+        node
+      end
+
+      #
+      # chrs: String
+      #       character array
+      #       io must have getc()/ungetc(); and ungetc() must be
+      #       able to be called arbitrary number of times.
+      #
+      def match(chrs, op = "")
+        D_DETAIL.print "match>: ", chrs, "op:", op, "\n"
+        if chrs.empty?
+          if @preproc.nil? || @preproc.call(op, chrs)
+            DOUT.printf(D_DETAIL, "op1: %s\n", op)
+            @postproc.call(op, chrs)
+          else
+            nil
+          end
+        else
+          ch = chrs.shift
+          if node = @Tree[ch]
+            if ret = node.match(chrs, op+ch)
+              return ret
+            else
+              chrs.unshift ch
+              if @postproc and @preproc.nil? || @preproc.call(op, chrs)
+                DOUT.printf(D_DETAIL, "op2: %s\n", op.inspect)
+                ret = @postproc.call(op, chrs)
+                return ret
+              else
+                return nil
+              end
+            end
+          else
+            chrs.unshift ch
+            if @postproc and @preproc.nil? || @preproc.call(op, chrs)
+              DOUT.printf(D_DETAIL, "op3: %s\n", op)
+              @postproc.call(op, chrs)
+              return ""
+            else
+              return nil
+            end
+          end
+        end
+      end
+
+      def match_io(io, op = "")
+        if op == ""
+          ch = io.getc
+          if ch == nil
+            return nil
+          end
+        else
+          ch = io.getc_of_rests
+        end
+        if ch.nil?
+          if @preproc.nil? || @preproc.call(op, io)
+            D_DETAIL.printf("op1: %s\n", op)
+            @postproc.call(op, io)
+          else
+            nil
+          end
+        else
+          if node = @Tree[ch]
+            if ret = node.match_io(io, op+ch)
+              ret
+            else
+              io.ungetc ch
+              if @postproc and @preproc.nil? || @preproc.call(op, io)
+                DOUT.exec_if{D_DETAIL.printf "op2: %s\n", op.inspect}
+                @postproc.call(op, io)
+              else
+                nil
+              end
+            end
+          else
+            io.ungetc ch
+            if @postproc and @preproc.nil? || @preproc.call(op, io)
+              D_DETAIL.printf("op3: %s\n", op)
+              @postproc.call(op, io)
+            else
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end
+# :startdoc:
+
+if $0 == __FILE__
+  case $1
+  when "1"
+    tr = SLex.new
+    print "0: ", tr.inspect, "\n"
+    tr.def_rule("=") {print "=\n"}
+    print "1: ", tr.inspect, "\n"
+    tr.def_rule("==") {print "==\n"}
+    print "2: ", tr.inspect, "\n"
+
+    print "case 1:\n"
+    print tr.match("="), "\n"
+    print "case 2:\n"
+    print tr.match("=="), "\n"
+    print "case 3:\n"
+    print tr.match("=>"), "\n"
+
+  when "2"
+    tr = SLex.new
+    print "0: ", tr.inspect, "\n"
+    tr.def_rule("=") {print "=\n"}
+    print "1: ", tr.inspect, "\n"
+    tr.def_rule("==", proc{false}) {print "==\n"}
+    print "2: ", tr.inspect, "\n"
+
+    print "case 1:\n"
+    print tr.match("="), "\n"
+    print "case 2:\n"
+    print tr.match("=="), "\n"
+    print "case 3:\n"
+    print tr.match("=>"), "\n"
+  end
+  exit
+end