solvas-jsduck 6.0.0.beta.1888

data/lib/jsduck/util/html.rb

@@ -0,0 +1,27 @@
+require 'cgi'
+
+module JsDuck
+  module Util
+
+    # Helpers for dealing with HTML
+    class HTML
+
+      # Strips tags from HTML text
+      def self.strip_tags(html)
+        html.gsub(/<.*?>/, "")
+      end
+
+      # Escapes HTML, replacing < with &lt; ...
+      def self.escape(html)
+        CGI.escapeHTML(html)
+      end
+
+      # Unescapes HTML, replacing &lt; with < ...
+      def self.unescape(html)
+        CGI.unescapeHTML(html)
+      end
+
+    end
+
+  end
+end

data/lib/jsduck/util/io.rb

@@ -0,0 +1,49 @@
+module JsDuck
+  module Util
+
+    # 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.
+    #
+    # We also allow for UTF-8 byte order mark.
+    class IO
+      @@encoding = "BOM|UTF-8"
+
+      # Configures the encoding from command line options.
+      def self.configure(opts)
+        encoding = opts.encoding if opts.encoding
+      end
+
+      # 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 =~ /^(BOM\|)?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| self.strip_utf8_bom(f.read) }
+      end
+
+      # Takes care of removing UTF-8 byte order mark in Ruby <= 1.8 which
+      # doesn't have built-in encodings support.
+      def self.strip_utf8_bom(string)
+        if "".respond_to?(:encoding)
+          string
+        else
+          string.sub(/\A\xEF\xBB\xBF/, "")
+        end
+      end
+
+    end
+
+  end
+end

data/lib/jsduck/util/json.rb

@@ -0,0 +1,60 @@
+require 'jsduck/util/singleton'
+require 'jsduck/util/io'
+require 'jsduck/logger'
+require 'json'
+
+module JsDuck
+  module Util
+
+    # 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 Json
+      include Util::Singleton
+
+      def initialize
+        @pretty = false
+      end
+
+      # Configures the pretty-formatting from command line options.
+      def configure(opts)
+        @pretty = true if opts.pretty_json
+      end
+
+      # Turns object into JSON, places it inside JavaScript that calls the
+      # given callback name, and writes the result to file.
+      def write_jsonp(filename, callback_name, data)
+        jsonp = "Ext.data.JsonP." + callback_name + "(" + generate(data) + ");"
+        File.open(filename, 'w') {|f| f.write(jsonp) }
+      end
+
+      # Turns object into JSON and writes inside a file
+      def write_json(filename, data)
+        File.open(filename, 'w') {|f| f.write(generate(data)) }
+      end
+
+      # Generates JSON from object
+      def generate(data)
+        @pretty ? JSON.pretty_generate(data) : JSON.generate(data)
+      end
+
+      # Reads and parses JSON from file
+      def read(filename)
+        begin
+          parse(Util::IO.read(filename))
+        rescue
+          Logger.fatal("#{filename} is not a valid JSON file")
+          exit(1)
+        end
+      end
+
+      # Parses JSON string
+      def parse(string, opts = {})
+        JSON.parse(string, opts)
+      end
+
+    end
+
+  end
+end

data/lib/jsduck/util/md5.rb

@@ -0,0 +1,32 @@
+require 'digest/md5'
+require 'jsduck/util/singleton'
+
+module JsDuck
+  module Util
+
+    # Helper to rename files so that the MD5 hash of their contents is
+    # placed into their name.
+    class MD5
+      include Util::Singleton
+
+      # Calculates MD5 hash of a file and renames the file to contain the
+      # hash inside the filename.  Returns the new name of the file.
+      def rename(fname)
+        hash = Digest::MD5.file(fname).hexdigest
+        hashed_name = inject_hash_to_filename(fname, hash)
+        File.rename(fname, hashed_name)
+        return hashed_name
+      end
+
+      private
+
+      # Given filename "foo/bar.js" and hash "HASH" produces "foo/bar-HASH.js"
+      def inject_hash_to_filename(fname, hash)
+        parts = File.basename(fname).split(/\./)
+        parts[0] += "-" + hash
+        File.dirname(fname) + "/" + parts.join(".")
+      end
+    end
+
+  end
+end

data/lib/jsduck/util/null_object.rb

@@ -0,0 +1,36 @@
+module JsDuck
+  module Util
+
+    # 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)
+        if @methods.has_key?(meth)
+          value = @methods[meth]
+          if value.respond_to?(:call)
+            value.call(*args, &block)
+          else
+            value
+          end
+        else
+          self
+        end
+      end
+
+      def respond_to?(meth)
+        @methods.has_key?(meth)
+      end
+    end
+
+  end
+end

data/lib/jsduck/util/os.rb

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

data/lib/jsduck/util/parallel.rb

@@ -0,0 +1,38 @@
+require 'jsduck/util/os'
+require 'parallel'
+
+module JsDuck
+  module Util
+
+    # Wrapper around the parallel gem that falls back to simple
+    # Array#map and Array#each when :in_processes => 0 specified.
+    class Parallel
+      @@in_processes = nil
+
+      # Configures the logger to use as many processes as set in
+      # command line options.  When in Windows, turns the parallel
+      # processing off by default.
+      def self.configure(opts)
+        @@in_processes = 0 if Util::OS::windows?
+        @@in_processes = opts.processes if opts.processes
+      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
+end

data/lib/jsduck/util/singleton.rb

@@ -0,0 +1,35 @@
+require 'singleton'
+
+module JsDuck
+  module Util
+
+    # A more convenient Singleton implementation.
+    #
+    # With the standard ruby Singleton you need to call the methods of
+    # your singleton instance as follows:
+    #
+    #     MyClass.instance.my_method()
+    #
+    # But with JsDuck::Util::Singleton you can skip the .instance. part:
+    #
+    #     MyClass.my_method()
+    #
+    # This also conveniently hides from the calling code the fact that
+    # a class is implemented as Singleton - it could just as well only
+    # have static methods.
+    #
+    module Singleton
+      def self.included(base)
+        base.class_eval do
+          include ::Singleton
+
+          # Redirect calls from MyClass.method to MyClass.instance.method
+          def self.method_missing(meth, *args, &block)
+            self.instance.send(meth, *args, &block)
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/jsduck/util/stdout.rb

@@ -0,0 +1,33 @@
+require 'jsduck/util/json'
+require 'jsduck/util/singleton'
+
+module JsDuck
+  module Util
+
+    # Central place for buffering JSON data that's meant to be written to STDOUT
+    class Stdout
+      include Util::Singleton
+
+      def initialize
+        @data = nil
+      end
+
+      # Adds array of new data
+      def add(data)
+        if @data
+          @data += data
+        else
+          @data = data
+        end
+      end
+
+      # Writes data to STDOUT in JSON format,
+      # but only if some data was added.
+      def flush
+        puts Util::Json.generate(@data) if @data
+      end
+
+    end
+
+  end
+end

data/lib/jsduck/version.rb

@@ -0,0 +1,5 @@
+# This file is updated by rake bump task.
+# Do not edit by hand.
+module JsDuck
+  VERSION = "6.0.0.beta.1888"
+end

data/lib/jsduck/videos.rb

@@ -0,0 +1,40 @@
+require 'jsduck/util/json'
+require 'jsduck/util/null_object'
+require 'jsduck/grouped_asset'
+
+module JsDuck
+
+  # Reads in videos JSON file
+  class Videos < GroupedAsset
+    # Parses videos config file
+    def self.create(filename)
+      if filename
+        Videos.new(filename)
+      else
+        Util::NullObject.new(:to_array => [], :[] => nil)
+      end
+    end
+
+    def initialize(filename)
+      @groups = Util::Json.read(filename)
+      add_names_if_missing
+      build_map_by_name
+    end
+
+    # Each video should have a name, which is used in URL to reference the video.
+    # For backwards compatibility, when name is missing, we turn the "id" (that must exist)
+    # into a name.
+    def add_names_if_missing
+      each_item do |video|
+        video["name"] = video["id"] unless video["name"]
+      end
+    end
+
+    # Extracts video icon URL from video hash
+    def icon_url(video)
+      video["thumb"]
+    end
+
+  end
+
+end

data/lib/jsduck/warning/all.rb

@@ -0,0 +1,36 @@
+module JsDuck
+  module Warning
+
+    # A composite warning, encompassing all the other warning types.
+    class All
+
+      # Creates a deprecated warning with a mapping to :nodoc warning
+      # type with given parameters.  The warning is disabled by
+      # default.
+      def initialize(warnings)
+        @warnings = warnings
+      end
+
+      # Enables/disables all warnings.
+      def set(enabled, path_pattern=nil, params=[])
+        # When used with a path_pattern, only add the pattern to the rules
+        # where it can have an effect - otherwise we get a warning.
+        @warnings.each do |w|
+          w.set(enabled, path_pattern, params)
+        end
+      end
+
+      # Doesn't make sense to check if the :all warning is enabled.
+      def enabled?(filename="", params=[])
+        raise "Warning type 'all' must not be checked for enabled/disabled"
+      end
+
+      # The all-warning is documented separately
+      def doc
+        nil
+      end
+
+    end
+
+  end
+end

data/lib/jsduck/warning/basic.rb

@@ -0,0 +1,57 @@
+require 'jsduck/warning/warn_exception'
+
+module JsDuck
+  module Warning
+
+    # A basic warning type.
+    class Basic
+
+      # Creates a simple warning with a message text.
+      # The warning is disabled by default.
+      def initialize(type, msg)
+        @type = type
+        @msg = msg
+
+        @rules = []
+        # disable by default
+        set(false)
+      end
+
+      # Enables or disables the warning.
+      # Optionally enables/disables it for files matching a path_pattern.
+      # params array is not used for the basic warning type.
+      def set(enabled, path_pattern=nil, params=[])
+        if path_pattern
+          # Prepend to the front of array, so we can use #find to
+          # search for the latest rule.
+          @rules.unshift({
+            :enabled => enabled,
+            :path_re => Regexp.new(Regexp.escape(path_pattern))
+          })
+        else
+          # When no path specified, the warning is turned on/off
+          # globally, so we can discard all the existing rules and
+          # start over with just one.
+          @rules = [{
+            :enabled => enabled,
+            :path_re => nil
+          }]
+        end
+      end
+
+      # True when warning is enabled for the given filename.
+      # (The params parameter is ignored).
+      def enabled?(filename="", params=[])
+        # Find the most recently added rule that has an effect to our current item
+        @rules.find {|r| r[:path_re].nil? || r[:path_re] =~ filename }[:enabled]
+      end
+
+      # Documentation for the warning.
+      def doc
+        " #{@rules[0][:enabled] ? '+' : '-'}#{@type} - #{@msg}"
+      end
+
+    end
+
+  end
+end