jsduck 4.0.1 → 4.1.1

data/lib/jsduck/inline_video.rb

@@ -1,58 +0,0 @@
-require 'jsduck/html'
-require 'jsduck/logger'
-
-module JsDuck
-
-  # Implementation of inline tag {@video}
-  class InlineVideo
-    def initialize(opts={})
-      @templates = {
-        "html5" => '<video src="%u">%a</video>',
-        "vimeo" => [
-          '<p><object width="640" height="360">',
-            '<param name="allowfullscreen" value="true" />',
-            '<param name="allowscriptaccess" value="always" />',
-            '<param name="flashvars" value="api=1" />',
-            '<param name="movie" value="http://vimeo.com/moogaloop.swf?clip_id=%u&amp;server=vimeo.com&amp;color=4CC208&amp;fullscreen=1" />',
-            '<embed src="http://vimeo.com/moogaloop.swf?clip_id=%u&amp;server=vimeo.com&amp;color=4CC208&amp;fullscreen=1" ',
-              'type="application/x-shockwave-flash" allowfullscreen="true" allowscriptaccess="always" width="640" height="360"></embed>',
-          '</object></p>',
-        ].join
-      }
-
-      @re = /\{@video\s+(\w+)\s+(\S*?)(?:\s+(.+?))?\}/m
-    end
-
-    # Takes StringScanner instance.
-    #
-    # Looks for inline tag at the current scan pointer position, when
-    # found, moves scan pointer forward and performs the apporpriate
-    # replacement.
-    def replace(input, doc_context)
-      if input.check(@re)
-        input.scan(@re).sub(@re) { apply_tpl($1, $2, $3, doc_context) }
-      else
-        false
-      end
-    end
-
-    # applies the video template of the specified type
-    def apply_tpl(type, url, alt_text, ctx)
-      unless @templates.has_key?(type)
-        Logger.instance.warn(nil, "Unknown video type #{type}", ctx[:filename], ctx[:linenr])
-      end
-
-      @templates[type].gsub(/(%\w)/) do
-        case $1
-        when '%u'
-          url
-        when '%a'
-          HTML.escape(alt_text||"")
-        else
-          $1
-        end
-      end
-    end
-  end
-
-end

data/lib/jsduck/io.rb

@@ -1,30 +0,0 @@
-module JsDuck
-
-  # A helper to use instead the builtin IO class to read files in
-  # correct encoding.
-  #
-  # By default in Ruby 1.9 the encoding is auto-detected, which can
-  # have surprising results.  So in here we read in all files in UTF-8
-  # (the default) or in some other encoding specified through --encoding
-  # option and convert it to UTF-8 internally.
-  class IO
-    @@encoding = "UTF-8"
-
-    # Sets the external encoding to be used for reading files.
-    # When it's different from UTF-8, the input will be converted to UTF-8.
-    def self.encoding=(e)
-      if e =~ /^UTF-8$/i
-        @@encoding = e
-      else
-        @@encoding = e+":UTF-8"
-      end
-    end
-
-    # Reads given filename into string
-    def self.read(filename)
-      File.open(filename, "r:"+@@encoding) {|f| f.read }
-    end
-
-  end
-
-end

data/lib/jsduck/json_duck.rb

@@ -1,52 +0,0 @@
-require 'jsduck/io'
-require 'jsduck/logger'
-require 'json'
-
-module JsDuck
-
-  # Wrapper around the json gem for use in JsDuck.
-  #
-  # The main benefit of it is that we have a central place for
-  # controlling how the JSON is created (pretty-formatted or not).
-  class JsonDuck
-    @@pretty = false
-
-    # Set to true to turn on pretty-formatting of JSON
-    def self.pretty=(pretty)
-      @@pretty = pretty
-    end
-
-    # Turns object into JSON, places it inside JavaScript that calls the
-    # given callback name, and writes the result to file.
-    def self.write_jsonp(filename, callback_name, data)
-      jsonp = "Ext.data.JsonP." + callback_name + "(" + self.generate(data) + ");"
-      File.open(filename, 'w') {|f| f.write(jsonp) }
-    end
-
-    # Turns object into JSON and writes inside a file
-    def self.write_json(filename, data)
-      File.open(filename, 'w') {|f| f.write(self.generate(data)) }
-    end
-
-    # Generates JSON from object
-    def self.generate(data)
-      @@pretty ? JSON.pretty_generate(data) : JSON.generate(data)
-    end
-
-    # Reads and parses JSON from file
-    def self.read(filename)
-      begin
-        self.parse(JsDuck::IO.read(filename))
-      rescue
-        Logger.instance.fatal("#{filename} is not a valid JSON file")
-        exit(1)
-      end
-    end
-
-    # Parses JSON string
-    def self.parse(string)
-      JSON.parse(string)
-    end
-  end
-
-end

data/lib/jsduck/lexer.rb

@@ -1,251 +0,0 @@
-require 'strscan'
-
-module JsDuck
-
-  # Tokenizes JavaScript code into lexical tokens.
-  #
-  # Each token has a type and value.
-  # Types and possible values for them are as follows:
-  #
-  # - :number      -- 25
-  # - :string      -- "Hello world"
-  # - :ident       -- "foo"
-  # - :regex       -- "/abc/i"
-  # - :operator    -- "+"
-  # - :doc_comment -- "/** My comment */"
-  #
-  # Plus a separate types for all keywords: :if, :while, :function, ...
-  # For keywords the type and value are the same.
-  #
-  # Notice that doc-comments are recognized as tokens while normal
-  # comments are ignored just as whitespace.
-  #
-  class Lexer
-    # Input can be either a String or StringScanner.
-    #
-    # In the latter case we ensure that only #next will advance the
-    # scanpointer of StringScanner - this allows context-switching
-    # while parsing some string.  Specifically we need this feature to
-    # parse some JavaScript inside doc-comments.
-    def initialize(input)
-      @input = input.is_a?(StringScanner) ? 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, "=", :regex)
-    #
-    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.
-    #
-    # For efficency we look for tokens in order of frequency in
-    # JavaScript source code:
-    #
-    # - first check for most common operators.
-    # - then for identifiers and keywords.
-    # - then strings
-    # - then comments
-    #
-    # The remaining token types are less frequent, so these are left
-    # to the end.
-    #
-    def next_token
-      while !@input.eos? do
-        skip_white
-        if @input.check(/[.(),;={}:]/)
-          return {
-            :type => :operator,
-            :value => @input.scan(/./)
-          }
-        elsif @input.check(/[a-zA-Z_$]/)
-          value = @input.scan(/[$\w]+/)
-          kw = KEYWORDS[value]
-          return {
-            :type => kw || :ident,
-            :value => kw || value
-          }
-        elsif @input.check(/'/)
-          return {
-            :type => :string,
-            :value => @input.scan(/'([^'\\]|\\.)*('|\Z)/m).gsub(/\A'|'\Z/m, "")
-          }
-        elsif @input.check(/"/)
-          return {
-            :type => :string,
-            :value => @input.scan(/"([^"\\]|\\.)*("|\Z)/m).gsub(/\A"|"\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/)
-          elsif regex?
-            return {
-              :type => :regex,
-              :value => @input.scan(META_REGEX)
-            }
-          else
-            return {
-              :type => :operator,
-              :value => @input.scan(/\//)
-            }
-          end
-        elsif @input.check(/[0-9]+/)
-          nr = @input.scan(/[0-9]+(\.[0-9]*)?/)
-          return {
-            :type => :number,
-            :value => nr
-          }
-        elsif  @input.check(/./)
-          return {
-            :type => :operator,
-            :value => @input.scan(/./)
-          }
-        end
-      end
-    end
-
-    # A slash "/" is a division operator if it follows:
-    # - identifier
-    # - the "this" keyword
-    # - number
-    # - closing bracket )
-    # - closing square-bracket ]
-    # Otherwise it's a beginning of regex
-    def regex?
-      if @previous_token
-        type = @previous_token[:type]
-        value = @previous_token[:value]
-        if type == :ident || type == :number
-          return false
-        elsif type == :this
-          return false
-        elsif type == :operator && (value == ")" || value == "]")
-          return false
-        end
-      end
-      return true
-    end
-
-    def skip_white
-      @input.scan(/\s+/)
-    end
-
-    # A regex to match a regex
-    META_REGEX = %r{
-      /               (?# beginning    )
-      (
-        [^/\[\\]      (?# any character except \ / [    )
-        |
-        \\.           (?# an escaping \ followed by any character    )
-        |
-        \[ ([^\]\\]|\\.)* \]    (?# [...] containing any characters including /    )
-                                (?# except \ ] which have to be escaped    )
-      )*
-      (/[gim]*|\Z)   (?# ending + modifiers    )
-    }x
-
-    KEYWORDS = {
-      "break" => :break,
-      "case" => :case,
-      "catch" => :catch,
-      "continue" => :continue,
-      "default" => :default,
-      "delete" => :delete,
-      "do" => :do,
-      "else" => :else,
-      "finally" => :finally,
-      "for" => :for,
-      "function" => :function,
-      "if" => :if,
-      "in" => :in,
-      "instanceof" => :instanceof,
-      "new" => :new,
-      "return" => :return,
-      "switch" => :switch,
-      "this" => :this,
-      "throw" => :throw,
-      "try" => :try,
-      "typeof" => :typeof,
-      "var" => :var,
-      "void" => :void,
-      "while" => :while,
-      "with" => :with,
-    }
-  end
-
-end

data/lib/jsduck/null_object.rb

@@ -1,19 +0,0 @@
-module JsDuck
-  # A class that does nothing.
-  # Responds to all methods by returning self, unless a hash passed to
-  # constructor.
-  # See: http://en.wikipedia.org/wiki/Null_Object_pattern
-  class NullObject
-    # Optionally takes a hash of method_name => return_value pairs,
-    # making it return those values for those methods, sort of like
-    # OpenStruct, but for all other methods self is still returned and
-    # any number of arguments is accepted.
-    def initialize(methods={})
-      @methods = methods
-    end
-
-    def method_missing(meth, *args, &block)
-      @methods.has_key?(meth) ? @methods[meth] : self
-    end
-  end
-end

data/lib/jsduck/os.rb

@@ -1,11 +0,0 @@
-require 'rbconfig'
-
-module JsDuck
-
-  # Simple helper class to detect operating system
-  class OS
-    def self.windows?
-      RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
-    end
-  end
-end

data/lib/jsduck/parallel_wrap.rb

@@ -1,32 +0,0 @@
-require 'parallel'
-
-module JsDuck
-
-  # Wrapper around the parallel gem that falls back to simple
-  # Array#map and Array#each when :in_processes => 0 specified.
-  class ParallelWrap
-    @@in_processes = nil
-
-    # Sets globally the nr of processes to use.
-    def self.in_processes=(n)
-      @@in_processes = n
-    end
-
-    def self.each(arr, &block)
-      if @@in_processes == 0
-        arr.each &block
-      else
-        Parallel.each(arr, {:in_processes => @@in_processes}, &block)
-      end
-    end
-
-    def self.map(arr, &block)
-      if @@in_processes == 0
-        arr.map &block
-      else
-        Parallel.map(arr, {:in_processes => @@in_processes}, &block)
-      end
-    end
-  end
-
-end