jsduck 4.10.4 → 5.0.0.beta01

data/lib/jsduck/css_lexer.rb

@@ -1,201 +0,0 @@
-require 'strscan'
-
-module JsDuck
-
-  # Tokenizes CSS or SCSS code into lexical tokens.
-  #
-  # Each token has a type and value.
-  # Types and possible values for them are as follows:
-  #
-  # - :number      -- "25.8"
-  # - :percentage  -- "25%"
-  # - :dimension   -- "2em"
-  # - :string      -- '"Hello world"'
-  # - :ident       -- "foo-bar"
-  # - :at_keyword  -- "@mixin"
-  # - :hash        -- "#00FF66"
-  # - :delim       -- "{"
-  # - :doc_comment -- "/** My comment */"
-  #
-  # Notice that doc-comments are recognized as tokens while normal
-  # comments are ignored just as whitespace.
-  #
-  class CssLexer
-    # Initializes lexer with input string.
-    def initialize(input)
-      @input = StringScanner.new(input)
-      @buffer = []
-    end
-
-    # Tests if given pattern matches the tokens that follow at current
-    # position.
-    #
-    # Takes list of strings and symbols.  Symbols are compared to
-    # token type, while strings to token value.  For example:
-    #
-    #     look(:ident, ":", :dimension)
-    #
-    def look(*tokens)
-      buffer_tokens(tokens.length)
-      i = 0
-      tokens.all? do |t|
-        tok = @buffer[i]
-        i += 1
-        if !tok
-          false
-        elsif t.instance_of?(Symbol)
-          tok[:type] == t
-        else
-          tok[:value] == t
-        end
-      end
-    end
-
-    # Returns the value of next token, moving the current token cursor
-    # also to next token.
-    #
-    # When full=true, returns full token as hash like so:
-    #
-    #     {:type => :ident, :value => "foo"}
-    #
-    # For doc-comments the full token also contains the field :linenr,
-    # pointing to the line where the doc-comment began.
-    #
-    def next(full=false)
-      buffer_tokens(1)
-      tok = @buffer.shift
-      # advance the scanpointer to the position after this token
-      @input.pos = tok[:pos]
-      full ? tok : tok[:value]
-    end
-
-    # True when no more tokens.
-    def empty?
-      buffer_tokens(1)
-      return !@buffer.first
-    end
-
-    # Ensures next n tokens are read in buffer
-    #
-    # At the end of buffering the initial position scanpointer is
-    # restored.  Only the #next method will advance the scanpointer in
-    # a way that's visible outside this class.
-    def buffer_tokens(n)
-      prev_pos = @input.pos
-      @input.pos = @buffer.last[:pos] if @buffer.last
-      (n - @buffer.length).times do
-        @previous_token = tok = next_token
-        if tok
-          # remember scanpointer position after each token
-          tok[:pos] = @input.pos
-          @buffer << tok
-        end
-      end
-      @input.pos = prev_pos
-    end
-
-    # Parses out next token from input stream.
-    def next_token
-      while !@input.eos? do
-        skip_white
-        if @input.check(IDENT)
-          return {
-            :type => :ident,
-            :value => @input.scan(IDENT)
-          }
-        elsif @input.check(/'/)
-          return {
-            :type => :string,
-            :value => @input.scan(/'([^'\\]|\\.)*('|\Z)/m)
-          }
-        elsif @input.check(/"/)
-          return {
-            :type => :string,
-            :value => @input.scan(/"([^"\\]|\\.)*("|\Z)/m)
-          }
-        elsif @input.check(/\//)
-          # Several things begin with dash:
-          # - comments, regexes, division-operators
-          if @input.check(/\/\*\*[^\/]/)
-            return {
-              :type => :doc_comment,
-              # Calculate current line number, starting with 1
-              :linenr => @input.string[0...@input.pos].count("\n") + 1,
-              :value => @input.scan_until(/\*\/|\Z/).sub(/\A\/\*\*/, "").sub(/\*\/\Z/, "")
-            }
-          elsif @input.check(/\/\*/)
-            # skip multiline comment
-            @input.scan_until(/\*\/|\Z/)
-          elsif @input.check(/\/\//)
-            # skip line comment
-            @input.scan_until(/\n|\Z/)
-          else
-            return {
-              :type => :operator,
-              :value => @input.scan(/\//)
-            }
-          end
-        elsif @input.check(NUM)
-          nr = @input.scan(NUM)
-          if @input.check(/%/)
-            return {
-              :type => :percentage,
-              :value => nr + @input.scan(/%/)
-            }
-          elsif @input.check(IDENT)
-            return {
-              :type => :dimension,
-              :value => nr + @input.scan(IDENT)
-            }
-          else
-            return {
-              :type => :number,
-              :value => nr
-            }
-          end
-        elsif @input.check(/@/)
-          return maybe(:at_keyword, /@/, IDENT)
-        elsif @input.check(/#/)
-          return maybe(:hash, /#/, NAME)
-        elsif @input.check(/\$/)
-          return maybe(:var, /\$/, IDENT)
-        elsif @input.check(/./)
-          return {
-            :type => :delim,
-            :value => @input.scan(/./)
-          }
-        end
-      end
-    end
-
-    # Returns token of given type when both regexes match.
-    # Otherwise returns :delim token with value of first regex match.
-    # First regex must always match.
-    def maybe(token_type, before_re, after_re)
-      before = @input.scan(before_re)
-      if @input.check(after_re)
-        return {
-          :type => token_type,
-          :value => before + @input.scan(after_re)
-        }
-      else
-        return {
-          :type => :delim,
-          :value => before
-        }
-      end
-    end
-
-    def skip_white
-      @input.scan(/\s+/)
-    end
-
-    # Simplified token syntax based on:
-    # http://www.w3.org/TR/CSS21/syndata.html
-    IDENT = /-?[_a-z][_a-z0-9-]*/i
-    NAME = /[_a-z0-9-]+/i
-    NUM = /[0-9]*\.[0-9]+|[0-9]+/
-
-  end
-
-end

data/lib/jsduck/css_parser.rb

@@ -1,119 +0,0 @@
-require 'jsduck/css_lexer'
-
-module JsDuck
-
-  class CssParser
-    def initialize(input, options = {})
-      @lex = CssLexer.new(input)
-      @docs = []
-    end
-
-    # Parses the whole CSS block and returns same kind of structure
-    # that JavaScript parser does.
-    def parse
-      while !@lex.empty? do
-        if look(:doc_comment)
-          comment = @lex.next(true)
-          @docs << {
-            :comment => comment[:value],
-            :linenr => comment[:linenr],
-            :code => code_block,
-            :type => :doc_comment,
-          }
-        else
-          @lex.next
-        end
-      end
-      @docs
-    end
-
-    # <code-block> := <mixin-declaration> | <var-declaration> | <property>
-    def code_block
-      if look("@mixin")
-        mixin_declaration
-      elsif look(:var, ":")
-        var_declaration
-      else
-        # Default to property like in JsParser.
-        {:tagname => :property}
-      end
-    end
-
-    # <mixin-declaration> := "@mixin" <ident>
-    def mixin_declaration
-      match("@mixin")
-      return {
-        :tagname => :css_mixin,
-        :name => look(:ident) ? match(:ident) : nil,
-      }
-    end
-
-    # <var-declaration> := <var> ":" <css-value>
-    def var_declaration
-      name = match(:var)
-      match(":")
-      value_list = css_value
-      return {
-        :tagname => :css_var,
-        :name => name,
-        :default => value_list.map {|v| v[:value] }.join(" "),
-        :type => value_type(value_list),
-      }
-    end
-
-    # <css-value> := ...anything up to... [ ";" | "}" | "!default" ]
-    def css_value
-      val = []
-      while !look(";") && !look("}") && !look("!", "default")
-        val << @lex.next(true)
-      end
-      val
-    end
-
-    # Determines type of CSS value
-    def value_type(val)
-      case val[0][:type]
-      when :number
-        "number"
-      when :dimension
-        "length"
-      when :percentage
-        "percentage"
-      when :string
-        "string"
-      when :hash
-        "color"
-      when :ident
-        case val[0][:value]
-        when "true", "false"
-          return "boolean"
-        when "rgb", "rgba", "hsl", "hsla"
-          return "color"
-        when "black", "silver", "gray", "white", "maroon",
-          "red", "purple", "fuchsia", "green", "lime", "olive",
-          "yellow", "navy", "blue", "teal", "aqua", "orange"
-          return "color"
-        when "transparent"
-          return "color"
-        end
-      end
-    end
-
-    # Matches all arguments, returns the value of last match
-    # When the whole sequence doesn't match, throws exception
-    def match(*args)
-      if look(*args)
-        last = nil
-        args.length.times { last = @lex.next }
-        last
-      else
-        throw "Expected: " + args.join(", ")
-      end
-    end
-
-    def look(*args)
-      @lex.look(*args)
-    end
-  end
-
-end

data/lib/jsduck/doc_ast.rb

@@ -1,319 +0,0 @@
-require 'jsduck/logger'
-require 'jsduck/meta_tag_registry'
-
-module JsDuck
-
-  # Detects docs info directly from comment.
-  class DocAst
-    # Allow passing in filename and line for error reporting
-    attr_accessor :filename
-    attr_accessor :linenr
-
-    def initialize
-      @filename = ""
-      @linenr = 0
-      @meta_tags = MetaTagRegistry.instance
-    end
-
-    # Given tagname and array of tags from DocParser, produces docs
-    # of the type determined by tagname.
-    def detect(tagname, docs)
-      case tagname
-      when :class
-        create_class(docs)
-      when :event
-        create_event(docs)
-      when :method
-        create_method(docs)
-      when :cfg
-        create_cfg(docs)
-      when :property
-        create_property(docs)
-      when :css_var
-        create_css_var(docs)
-      when :css_mixin
-        create_css_mixin(docs)
-      end
-    end
-
-    private
-
-    def create_class(docs)
-      doc_map = build_doc_map(docs)
-      return add_shared({
-        :tagname => :class,
-        :name => detect_name(:class, doc_map),
-        :doc => detect_doc(docs),
-        :extends => detect_extends(doc_map),
-        :mixins => detect_list(:mixins, doc_map),
-        :alternateClassNames => detect_list(:alternateClassNames, doc_map),
-        :aliases => detect_aliases(doc_map),
-        :singleton => !!doc_map[:singleton],
-        :requires => detect_list(:requires, doc_map),
-        :uses => detect_list(:uses, doc_map),
-        :enum => detect_enum(doc_map),
-        :override => extract(doc_map, :override, :class),
-      }, doc_map)
-    end
-
-    def create_method(docs)
-      doc_map = build_doc_map(docs)
-      return add_shared({
-        :tagname => :method,
-        :name => detect_name(:method, doc_map),
-        :owner => detect_owner(doc_map),
-        :doc => detect_doc(docs),
-        :params => detect_params(doc_map),
-        :return => detect_return(doc_map),
-        :throws => detect_throws(doc_map),
-      }, doc_map)
-    end
-
-    def create_event(docs)
-      doc_map = build_doc_map(docs)
-      return add_shared({
-        :tagname => :event,
-        :name => detect_name(:event, doc_map),
-        :owner => detect_owner(doc_map),
-        :doc => detect_doc(docs),
-        :params => detect_params(doc_map),
-      }, doc_map)
-    end
-
-    def create_cfg(docs)
-      doc_map = build_doc_map(docs)
-      return add_shared({
-        :tagname => :cfg,
-        :name => detect_name(:cfg, doc_map),
-        :owner => detect_owner(doc_map),
-        :type => detect_type(:cfg, doc_map),
-        :doc => detect_doc(docs),
-        :default => detect_default(:cfg, doc_map),
-        :properties => detect_subproperties(:cfg, docs),
-        :accessor => !!doc_map[:accessor],
-        :evented => !!doc_map[:evented],
-      }, doc_map)
-    end
-
-    def create_property(docs)
-      doc_map = build_doc_map(docs)
-      return add_shared({
-        :tagname => :property,
-        :name => detect_name(:property, doc_map),
-        :owner => detect_owner(doc_map),
-        :type => detect_type(:property, doc_map),
-        :doc => detect_doc(docs),
-        :default => detect_default(:property, doc_map),
-        :properties => detect_subproperties(:property, docs),
-      }, doc_map)
-    end
-
-    def create_css_var(docs)
-      doc_map = build_doc_map(docs)
-      return add_shared({
-        :tagname => :css_var,
-        :name => detect_name(:css_var, doc_map),
-        :owner => detect_owner(doc_map),
-        :type => detect_type(:css_var, doc_map),
-        :default => detect_default(:css_var, doc_map),
-        :doc => detect_doc(docs),
-      }, doc_map)
-    end
-
-    def create_css_mixin(docs)
-      doc_map = build_doc_map(docs)
-      return add_shared({
-        :tagname => :css_mixin,
-        :name => detect_name(:css_mixin, doc_map),
-        :owner => detect_owner(doc_map),
-        :doc => detect_doc(docs),
-        :params => detect_params(doc_map),
-      }, doc_map)
-    end
-
-    # Detects properties common for each doc-object and adds them
-    def add_shared(hash, doc_map)
-      hash.merge!({
-        :inheritable => !!doc_map[:inheritable],
-        :inheritdoc => extract(doc_map, :inheritdoc),
-        :meta => detect_meta(doc_map),
-      })
-
-      # copy :private also to main hash
-      hash[:private] = hash[:meta][:private] ? true : nil
-
-      return hash
-    end
-
-    def detect_name(tagname, doc_map)
-      name = extract(doc_map, tagname, :name)
-      if name
-        name
-      else
-        doc_map[:constructor] ? "constructor" : nil
-      end
-    end
-
-    def extract(doc_map, tagname, propname = nil)
-      tag = doc_map[tagname] ? doc_map[tagname].first : nil
-      if tag && propname
-        tag[propname]
-      else
-        tag
-      end
-    end
-
-    def detect_owner(doc_map)
-      extract(doc_map, :member, :member)
-    end
-
-    def detect_type(tagname, doc_map)
-      extract(doc_map, tagname, :type) || extract(doc_map, :type, :type)
-    end
-
-    def detect_extends(doc_map)
-      extract(doc_map, :extends, :extends)
-    end
-
-    def detect_default(tagname, doc_map)
-      extract(doc_map, tagname, :default)
-    end
-
-    # for detecting mixins and alternateClassNames
-    def detect_list(type, doc_map)
-      if doc_map[type]
-        doc_map[type].map {|d| d[type] }.flatten
-      else
-        nil
-      end
-    end
-
-    def detect_aliases(doc_map)
-      if doc_map[:alias]
-        doc_map[:alias].map {|tag| tag[:name] }
-      else
-        nil
-      end
-    end
-
-    def detect_meta(doc_map)
-      meta = {}
-      (doc_map[:meta] || []).map do |tag|
-        meta[tag[:name]] = [] unless meta[tag[:name]]
-        meta[tag[:name]] << tag[:doc]
-      end
-
-      meta.each_pair do |key, value|
-        tag = @meta_tags[key]
-        meta[key] = tag.to_value(tag.boolean ? true : value)
-      end
-
-      meta[:required] = true if detect_required(doc_map)
-      meta
-    end
-
-    def detect_required(doc_map)
-      doc_map[:cfg] && doc_map[:cfg].first[:optional] == false
-    end
-
-    def detect_params(doc_map)
-      combine_properties(doc_map[:param] || [])
-    end
-
-    def detect_subproperties(tagname, docs)
-      prop_docs = docs.find_all {|tag| tag[:tagname] == tagname}
-      prop_docs.length > 0 ? combine_properties(prop_docs)[0][:properties] : []
-    end
-
-    def combine_properties(raw_items)
-      # First item can't be namespaced, if it is ignore the rest.
-      if raw_items[0] && raw_items[0][:name] =~ /\./
-        return [raw_items[0]]
-      end
-
-      # build name-index of all items
-      index = {}
-      raw_items.each {|it| index[it[:name]] = it }
-
-      # If item name has no dots, add it directly to items array.
-      # Otherwise look up the parent of item and add it as the
-      # property of that parent.
-      items = []
-      raw_items.each do |it|
-        if it[:name] =~ /^(.+)\.([^.]+)$/
-          it[:name] = $2
-          parent = index[$1]
-          if parent
-            parent[:properties] = [] unless parent[:properties]
-            parent[:properties] << it
-          else
-            Logger.warn(:subproperty, "Ignoring subproperty #{$1}.#{$2}, no parent found with name '#{$1}'.", @filename, @linenr)
-          end
-        else
-          items << it
-        end
-      end
-      items
-    end
-
-    def detect_return(doc_map)
-      has_return_tag = !!extract(doc_map, :return)
-      ret = extract(doc_map, :return) || {}
-      return {
-        :type => ret[:type] || (has_return_tag ? "Object" : "undefined"),
-        :name => ret[:name] || "return",
-        :doc => ret[:doc] || "",
-        :properties => doc_map[:return] ? detect_subproperties(:return, doc_map[:return]) : []
-      }
-    end
-
-    def detect_throws(doc_map)
-      return unless doc_map[:throws]
-
-      doc_map[:throws].map do |throws|
-        {
-          :type => throws[:type] || "Object",
-          :doc => throws[:doc] || "",
-        }
-      end
-    end
-
-    def detect_enum(doc_map)
-      return nil unless extract(doc_map, :class, :enum)
-
-      default = extract(doc_map, :class, :default)
-
-      return {
-        :type => extract(doc_map, :class, :type),
-        :default => default,
-        :doc_only => !!default,
-      }
-    end
-
-    # Combines :doc-s of most tags
-    # Ignores tags that have doc comment themselves and subproperty tags
-    def detect_doc(docs)
-      ignore_tags = [:param, :return, :throws, :meta]
-      doc_tags = docs.find_all { |tag| !ignore_tags.include?(tag[:tagname]) && !subproperty?(tag) }
-      doc_tags.map { |tag| tag[:doc] }.compact.join(" ")
-    end
-
-    def subproperty?(tag)
-      (tag[:tagname] == :cfg || tag[:tagname] == :property) && tag[:name] =~ /\./
-    end
-
-    # Build map of at-tags for quick lookup
-    def build_doc_map(docs)
-      map = {}
-      docs.each do |tag|
-        if map[tag[:tagname]]
-          map[tag[:tagname]] << tag
-        else
-          map[tag[:tagname]] = [tag]
-        end
-      end
-      map
-    end
-  end
-
-end