jsus 0.3.6 → 0.4.0

data/lib/jsus/tag.rb

@@ -6,46 +6,51 @@ module Jsus
   # @example
   # "Core/Class" is a tag
   class Tag
-    # Owner package
-    attr_accessor :package
-    # Whether tag is external
-    attr_accessor :external
+    # Default separator of full name parts
+    SEPARATOR = "/".freeze
 
     # Constructors
 
     #
-    # Creates a tag from given name/options.
-    #
-    # The way it works may seem a bit tricky but actually it parses name/options
-    # combinations in different ways and may be best described by examples:
+    # Creates a tag from given string.
     #
     # @example
     #
-    #     a = Tag.new("Class")      # :package_name => "",     :name => "Class", :external => false
-    #     b = Tag.new("Core/Class") # :package_name => "Core", :name => "Class", :external => true
-    #     core = Package.new(...) # let's consider its name is 'Core'
-    #     c = Tag.new("Class", :package => core) # :package_name => "Core", :name => "Class", :external => false
-    #     d = Tag.new("Core/Class", :package => core) # :package_name => "Core", :name => "Class", :external => false
-    #     mash = Package.new(...) # let's consider its name is 'Mash'
-    #     e = Tag.new("Core/Class", :package => mash) # :package_name => "Core", :name => "Class", :external => true
-    #
-    # Between all those, tags b,c,d and e are equal, meaning they all use
-    # the same spot in Hash or wherever else.
+    #     a = Tag.new("Class")         # :namespace => nil,             :name => "Class"
+    #     b = Tag.new("Core/Class")    # :namespace => "Core",          :name => "Class"
+    #     c = Tag.new("Mootools/Core") # :namespace => "Mootools/Core", :name => "Class"
     #
-    # @param [String] name tag name
-    # @param [Hash] options
-    # @option options [String] :package_name owner package name
-    # @option options [Jsus::Package] :package :owner package
-    # @option options [Boolean] :external whether tag is considered external
+    # @param [String] name full tag name
     # @api public
-    def initialize(name, options = {})
-      normalized_options = Tag.normalize_name_and_options(name, options)
-      [:name, :package, :package_name, :external].each do |field|
-        self.send("#{field}=", normalized_options[field])
-      end
+    def initialize(full_name)
+      self.full_name = full_name
     end
 
-    # When given a tag instead of tag name, just returns it.
+    # Full name, including namespace
+    # @return [String]
+    # @api public
+    def full_name
+      if namespace
+        "#{namespace}#{SEPARATOR}#{name}"
+      else
+        "#{name}"
+      end
+    end # full_name
+    alias_method :to_s, :full_name
+
+
+    # Assigns full name
+    # @param [String] full_name full tag name, including namespace
+    # @api semipublic
+    def full_name=(full_name)
+      @full_name     = full_name
+      name_parts     = @full_name.split(SEPARATOR)
+      self.namespace = name_parts[0..-2].join(SEPARATOR) if name_parts.size > 1
+      self.name      = name_parts[-1]
+    end # full_name=
+
+    # Instantiates a tag.
+    # @note When given a tag instead of tag name, returns the input
     # @api public
     def self.new(tag_or_name, *args, &block)
       if tag_or_name.kind_of?(Tag)
@@ -63,46 +68,56 @@ module Jsus
 
     # Public API
 
-    # @returns [Boolean] whether tag is external
-    # @api public
-    def external?
-      !!external
-    end
-
-    # @param [Hash] options
-    # @option options [Boolean] :short whether the tag should try using short form
-    # @note only non-external tags support short forms.
+    # Returns the last part of the tag.
     # @example
-    #     Tag.new('Core/Class').name(:short => true) # => 'Core/Class'
-    #     core = Package.new(...) # let's consider its name is 'Core'
-    #     Tag.new('Core/Class', :package => core).name(:short => true) # => 'Class'
-    # @return [String] a well-formed name for the tag.
+    #     Tag.new('Core/Class').name # => 'Class'
+    # @return [String] last part of the tag
     # @api public
-    def name(options = {})
-      if !package_name || package_name.empty? || (options[:short] && !external?)
-        @name
-      else
-        "#{package_name}/#{@name}"
-      end
+    def name
+      @name
     end
-    alias_method :to_s, :name
 
-    # @returns [String] package name or an empty string
+    # Set name.
+    # @param [String] name
+    # @api semipublic
+    def name=(name)
+      @name = normalize(name)
+    end # name=
+
+
+    # Name without namespace
+    # @return [String]
     # @api public
-    def package_name
-      @package_name ||= (@package ? @package.name : "")
-    end
+    attr_reader :namespace
+
+    # Set namespace
+    # @param [String] namespace
+    # @api semipublic
+    def namespace=(namespace)
+      @namespace = normalize(namespace)
+    end # namespace=
+
+    # Normalizes name or namespace (converts snake_case to MixedCase)
+    # @param [String] string
+    # @return [String]
+    # @api semipublic
+    def normalize(string)
+      return unless string
+      return string if string.include?("*")
+      parts = string.split(SEPARATOR)
+      parts.map {|part| Util::Inflection.random_case_to_mixed_case_preserve_dots(part) }.join(SEPARATOR)
+    end # normalize
 
     # @return [Boolean] whether name is empty
     # @api public
     def empty?
-      @name.empty?
+      !@name || @name.empty?
     end
 
     # @api public
     def ==(other)
       if other.kind_of?(Tag)
-        self.name == other.name
+        self.name == other.name && self.namespace == other.namespace
       else
         super
       end
@@ -115,62 +130,13 @@ module Jsus
 
     # @api semipublic
     def hash
-      self.name.hash
+      [self.name, self.namespace].hash
     end
 
     # @return [String] human-readable representation
     # @api public
     def inspect
-      "<Jsus::Tag: #{name}>"
-    end
-
-    # Private API
-
-    # @api private
-    def self.normalize_name_and_options(name, options = {})
-      result = {}
-      name.gsub!(%r(^(\.)?/), "")
-      if name.index("/")
-        parsed_name = name.split("/")
-        result[:package_name], result[:name] = parsed_name[0..-2].join("/"), parsed_name[-1]
-        result[:external] = options[:package] ? (result[:package_name] != options[:package].name) : true
-      else
-        if options[:package]
-          result[:package] = options[:package]
-          result[:package_name] = options[:package].name
-        end
-        result[:name] = name
-      end
-      result[:package_name] = normalize_package_name(result[:package_name]) if result[:package_name]
-      result
-    end
-
-    # @api private
-    def self.normalized_options_to_full_name(options)
-      [options[:package_name], options[:name]].compact.join("/")
-    end
-
-    # @api private
-    def self.name_and_options_to_full_name(name, options = {})
-      normalized_options_to_full_name(normalize_name_and_options(name, options))
-    end
-
-    # @api private
-    def self.normalize_package_name(name)
-      package_chunks = name.split("/")
-      package_chunks.map do |pc|
-        Jsus::Util::Inflection.random_case_to_mixed_case(pc)
-      end.join("/")
-    end # normalize_name
-
-    # @api private
-    def package_name=(new_value)
-      @package_name = new_value
-    end
-
-    # @api private
-    def name=(new_value)
-      @name = new_value
+      "<Jsus::Tag: #{full_name}>"
     end
   end
 end

data/lib/jsus/util.rb

@@ -1,14 +1,16 @@
 module Jsus
   # Utility namespace.
   module Util
+    autoload :CodeGenerator, 'jsus/util/code_generator'
     autoload :Compressor,    'jsus/util/compressor'
-    autoload :Tree,          'jsus/util/tree'
     autoload :Documenter,    'jsus/util/documenter'
-    autoload :Validator,     'jsus/util/validator'
-    autoload :Inflection,    'jsus/util/inflection'
     autoload :FileCache,     'jsus/util/file_cache'
-    autoload :CodeGenerator, 'jsus/util/code_generator'
+    autoload :Inflection,    'jsus/util/inflection'
     autoload :Logger,        'jsus/util/logger'
+    autoload :Mixins,        'jsus/util/mixins'
+    autoload :PostProcessor, 'jsus/util/post_processor'
+    autoload :Tree,          'jsus/util/tree'
+    autoload :Validator,     'jsus/util/validator'
     autoload :Watcher,       'jsus/util/watcher'
 
     class <<self
@@ -28,6 +30,14 @@ module Jsus
           false
         end
       end
+
+      # Reads file in UTF-8 encoding in a safe way.
+      # Some ruby versions mess up the encodings and some spill out lots of warnings
+      # unless you do the right thing
+      def read_file(filename)
+        mode_string = RUBY_VERSION =~ /^1.9/ ? 'r:utf-8' : 'r'
+        File.open(filename, mode_string) {|f| f.read }
+      end # read_file
     end # class <<self
   end # Util
 end # Jsus

data/lib/jsus/util/compressor.rb

@@ -56,7 +56,7 @@ module Jsus
 
         # @api private
         def try_compress(source, library, libname = nil)
-          if Jsus::Util.try_load(library, libname) then
+          if Jsus::Util.try_load(library, libname)
             yield
           else
             source

data/lib/jsus/util/documenter.rb

@@ -127,7 +127,7 @@ module Jsus
       # @api private
       def create_documentation_for_source(source, template) # :nodoc:
         skipped_lines = 0
-        content = source.original_content.gsub(/\A\s*\/\*.*?\*\//m) {|w| skipped_lines += w.split("\n").size; "" }
+        content = source.original_source.gsub(/\A\s*\/\*.*?\*\//m) {|w| skipped_lines += w.split("\n").size; "" }
         annotator = Murdoc::Annotator.new(content, :javascript, options)
         Murdoc::Formatter.new(template).render(:paragraphs => annotator.paragraphs, :header => source.header, :source => source, :skipped_lines => skipped_lines)
       end

data/lib/jsus/util/mixins.rb

@@ -0,0 +1,7 @@
+module Jsus
+  module Util
+    module Mixins
+      autoload :OperatesOnSources, 'jsus/util/mixins/operates_on_sources'
+    end # module Mixins
+  end # module Util
+end # module Jsus

data/lib/jsus/util/mixins/operates_on_sources.rb

@@ -0,0 +1,29 @@
+module Jsus
+  module Util
+    module Mixins
+      module OperatesOnSources
+        # @return [Array] source files for validation
+        # @api public
+        def source_files
+          @source_files ||= []
+        end
+        alias_method :sources, :source_files
+
+        # @param [Jsus::Pool, Jsus::Container, Array] pool_or_array_or_container
+        #    source files for validation
+        # @api public
+        def source_files=(pool_or_array_or_container)
+          case pool_or_array_or_container
+          when Pool
+            @source_files = pool_or_array_or_container.sources.to_a
+          when Array
+            @source_files = pool_or_array_or_container
+          when Container
+            @source_files = pool_or_array_or_container.to_a
+          end
+        end
+        alias_method :sources=, :source_files=
+      end # module OperatesOnSources
+    end # module Mixins
+  end # module Util
+end # module Jsus

data/lib/jsus/util/post_processor.rb

@@ -0,0 +1,35 @@
+module Jsus
+  module Util
+    module PostProcessor
+      autoload :Base,        "jsus/util/post_processor/base"
+      autoload :Moocompat12, "jsus/util/post_processor/moocompat12"
+      autoload :MooltIE8,    "jsus/util/post_processor/mooltie8"
+      autoload :Semicolon,   "jsus/util/post_processor/semicolon"
+
+      AVAILABLE_PROCESSORS = ["mooltie8", "moocompat12", "semicolon"].freeze
+      # Accepts a collection of source files and list of processors and applies
+      # these processors to the sources.
+      #
+      # @param [Array, Pool, Container] source_files source files
+      # @param [Array] processors array with names of processors
+      #        Available postprocs: "mooltie8", "moocompat12"
+      # @return [Array] processed sources
+      def self.process(source_files, processors)
+        Array(processors).each do |processor|
+          source_files = case processor.strip
+          when /moocompat12/i
+            Moocompat12.new(source_files).process
+          when /mooltie8/i
+            MooltIE8.new(source_files).process
+          when /semicolon/i
+            Semicolon.new(source_files).process
+          else
+            Jsus.logger.error "Unknown post-processor: #{processor}"
+            source_files
+          end
+        end
+        source_files
+      end # self.process
+    end # module PostProcessor
+  end # module Util
+end # module Jsus

data/lib/jsus/util/post_processor/base.rb

@@ -0,0 +1,32 @@
+module Jsus
+  module Util
+    module PostProcessor
+      # Base class for post-processing routines.
+      # Post-processors are non-mutating boxes that accept a collection of
+      # SourceFile-s on input and return a collection of SourceFiles on output.
+      #
+      # Post-processing is not mutating the arguments, but dupes them instead
+      class Base
+        include Jsus::Util::Mixins::OperatesOnSources
+
+        # Constructor accepts pool or array or container and adds every file
+        # to its source files set.
+        # @param [Jsus::Pool, Jsus::Container, Array] source files to validate
+        # @api public
+        def initialize(pool_or_array_or_container = [])
+          self.source_files = pool_or_array_or_container
+        end # initialize
+
+        # Processes input source files, return a resulting collection
+        # @note This method should not mutate input sources
+        # @abstract Override in subclasses
+        # @param [Hash] options options hash
+        # @return [Array] processed source files
+        # @api public
+        def process(options = {})
+          raise NotImplementedError, "override #process in subclasses"
+        end # process
+      end # class Base
+    end # module PostProcessor
+  end # module Util
+end # module Jsus

data/lib/jsus/util/post_processor/moocompat12.rb

@@ -0,0 +1,19 @@
+module Jsus
+  module Util
+    module PostProcessor
+      class Moocompat12 < Base
+        # Removes everything between <1.2compat> </1.2compat> tags
+        # @return [Array]
+        # @see Jsus::Util::PostProcessor::Base#process
+        def process(options = {})
+          source_files.map do |file|
+            file = file.dup
+            file.source = file.source.gsub(/\/\/<1.2compat>.*?\/\/<\/1.2compat>/m, '')
+            file.source = file.source.gsub(/\/\*<1.2compat>\*\/.*?\/\*<\/1.2compat>\*\//m, '')
+            file
+          end
+        end # process
+      end # class Moocompat12
+    end # module PostProcessor
+  end # module Util
+end # module Jsus

data/lib/jsus/util/post_processor/mooltie8.rb

@@ -0,0 +1,19 @@
+module Jsus
+  module Util
+    module PostProcessor
+      class MooltIE8 < Base
+        # Removes everything between <ltIE8> </ltIE8> tags
+        # @return [Array]
+        # @see Jsus::Util::PostProcessor::Base#process
+        def process(options = {})
+          source_files.map do |file|
+            file = file.dup
+            file.source = file.source.gsub(/\/\/<ltIE8>.*?\/\/<\/ltIE8>/m, '')
+            file.source = file.source.gsub(/\/\*<ltIE8>\*\/.*?\/\*<\/ltIE8>\*\//m, '')
+            file
+          end
+        end # process
+      end # class MooltIE8
+    end # module PostProcessor
+  end # module Util
+end # module Jsus

data/lib/jsus/util/post_processor/semicolon.rb

@@ -0,0 +1,18 @@
+module Jsus
+  module Util
+    module PostProcessor
+      class Semicolon < Base
+        # Adds a semicolon to the beginning of every file
+        # @return [Array]
+        # @see Jsus::Util::PostProcessor::Base#process
+        def process(options = {})
+          source_files.map do |file|
+            file = file.dup
+            file.source = file.source.gsub(/^([^;])/, ";\n")
+            file
+          end
+        end # process
+      end # class Semicolon
+    end # module PostProcessor
+  end # module Util
+end # module Jsus