jsus 0.3.6 → 0.4.0

data/lib/jsus/packager.rb

@@ -12,16 +12,21 @@ module Jsus
     #
     # Inits packager with the given sources.
     #
-    # @param [*SourceFile] sources source files
+    # @param [Container, Array] sources source files
     # @api public
-    def initialize(*sources)
-      self.container = Container.new(*sources)
+    def initialize(sources)
+      @sources = case sources
+      when Array
+        Container.new(*sources)
+      else
+        sources
+      end
     end
 
     # @return [Jsus::Container] container with source files
     # @api public
     def sources
-      container
+      @sources
     end
 
     # Concatenates all the sources' contents into a single string.
@@ -31,8 +36,7 @@ module Jsus
     # @return [String] concatenated source files
     # @api public
     def pack(output_file = nil)
-      result = sources.map {|s| s.content }.join("\n")
-
+      result = sources.map {|s| s.source }.join("\n")
       if output_file
         FileUtils.mkdir_p(File.dirname(output_file))
         File.open(output_file, "w") {|f| f << result }

data/lib/jsus/pool.rb

@@ -23,7 +23,7 @@ module Jsus
           # one level of symlinks
           # See also: http://stackoverflow.com/questions/357754/can-i-traverse-symlinked-directories-in-ruby-with-a-glob
           Dir[File.join(dir, '**{,/*/**}', 'package.{yml,json}')].uniq.each do |package_path|
-            Package.new(File.dirname(package_path), :pool => self)
+            self << Package.new(File.dirname(package_path))
           end
         end
       end
@@ -54,15 +54,17 @@ module Jsus
     # @api public
     def lookup(source_or_key)
       case source_or_key
-        when String
-          lookup(Tag[source_or_key])
-        when Tag
-          replacement_map[source_or_key] || provides_map[source_or_key]
-        when SourceFile
-          source_or_key
-        else
-          raise "Illegal lookup query. Expected String, Tag or SourceFile, " <<
-                "given #{source_or_key.inspect}, an instance of #{source_or_key.class.name}."
+      when nil
+        nil
+      when String
+        lookup(Tag[source_or_key])
+      when Tag
+        provides_map[source_or_key]
+      when SourceFile
+        source_or_key
+      else
+        raise "Illegal lookup query. Expected String, Tag or SourceFile, " <<
+              "given #{source_or_key.inspect}, an instance of #{source_or_key.class.name}."
       end
     end
 
@@ -75,7 +77,7 @@ module Jsus
     # @api public
     def lookup_dependencies(source_or_source_key)
       source = lookup(source_or_source_key)
-      result = Container.new
+      result = []
       looked_up = []
       if source
         dependencies = lookup_direct_dependencies(source)
@@ -84,15 +86,22 @@ module Jsus
           dependencies = dependencies.map {|d| lookup_direct_dependencies(d).to_a }.flatten.uniq
         end
       end
-      result.sort!
+      result
     end
 
-    # @param [String, Jsus::Tag] tag_or_tag_key
-    # @return [Array] array with source files with extensions for given tag.
+    # Returns replacement for given source file.
+    # @param [Jsus::SourceFile]
+    # @return [Jsus::SourceFile, nil]
+    # @api public
+    def lookup_replacement(source)
+      source.provides.map {|tag| replacement_map[tag] }.compact[0]
+    end # lookup_replacement
+
+    # @param [Jsus::SourceFile]
+    # @return [Array] array with source files with extensions for given source file
     # @api public
-    def lookup_extensions(tag_or_tag_key)
-      tag = Tag[tag_or_tag_key]
-      extensions_map[tag]
+    def lookup_extensions(source)
+      source.provides.map {|tag| extensions_map[tag] }.flatten.compact
     end
 
     #
@@ -119,13 +128,13 @@ module Jsus
             provides_map[p] = source
           end
 
-          replacement_map[source.replaces] = source if source.replaces if source.replaces
+          replacement_map[source.replaces] = source if source.replaces
         end
       when source_or_sources_or_package.kind_of?(Package)
         package = source_or_sources_or_package
         packages << package
-        package.source_files.each {|s| s.pool = self }
-        package.extensions.each {|e| e.pool = self }
+        package.source_files.each {|s| self << s }
+        package.extensions.each   {|e| self << e }
       when source_or_sources_or_package.kind_of?(Array) || source_or_sources_or_package.kind_of?(Container)
         sources = source_or_sources_or_package
         sources.each {|s| self << s}
@@ -133,6 +142,25 @@ module Jsus
       self
     end
 
+    # @param [Jsus::Package]
+    # @return [Array]
+    # @api public
+    def compile_package(package)
+      result = []
+      package.source_files.each do |source|
+        result << source
+        result << lookup_dependencies(source) unless source.extension? || source.replacement?
+      end
+      result = result.flatten.compact
+      extra_files = []
+      result.each_with_index do |source, i|
+        extra_files << lookup_replacement(source)
+        extra_files << lookup_extensions(source)
+      end
+      result = (result + extra_files).flatten.compact
+      Container.new(result)
+    end # compile_package
+
     #
     # Drops any cached info
     # @api public

data/lib/jsus/source_file.rb

@@ -8,32 +8,44 @@ module Jsus
   # It contains general info about source as well as file content.
   #
   class SourceFile
-    # Filename relative to package root
-    attr_accessor :relative_filename
-    # Full filename
-    attr_accessor :filename
     # Package owning the sourcefile
+    # Is not directly used in SourceFile, but might be useful for introspection.
     attr_accessor :package
 
+    # Original filename (immutable)
+    attr_accessor :original_filename
+
+    # Full filename (when initialized from file)
+    attr_accessor :filename
+    alias_method :path, :filename
+    alias_method :path=, :filename=
+
+    # Original source code (immutable)
+    attr_reader :original_source
+
+    # Source code (mutable)
+    attr_accessor :source
+
+    # Default namespace for source
+    attr_reader :namespace
+
+
     # Constructors
 
     # Basic constructor.
     #
-    # You probably should use SourceFile.from_file instead of this one.
-    #
+    # Initializes a file from source.
+    # @param [String] source original source for the file
     # @param [Hash] options
-    # @option options [Jsus::Package] :package package to assign source file to.
-    # @option options [String] :relative_filename used in Package to generate
-    #   tree structure of the source files
-    # @option options [String] :filename full filename for the given source file
-    # @option options [String] :content file content of the source file
-    # @option options [Jsus::Pool] :pool owner pool for that file
-    # @option options [String] :header header of the file
+    # @option options [String] :namespace source file namespace
     # @api semipublic
-    def initialize(options = {})
-      [:package, :header, :relative_filename, :filename, :content, :pool].each do |field|
-        send("#{field}=", options[field]) if options[field]
-      end
+    def initialize(source, options = {})
+      @namespace       = options[:namespace]
+      @original_source = source.dup
+      prepare_original_source
+      @source          = @original_source.dup
+      parse_header
+      @original_source.freeze
     end
 
     #
@@ -41,44 +53,28 @@ module Jsus
     #
     # @param [String] filename
     # @param [Hash] options
-    # @option options [Jsus::Pool] :pool owning pool
-    # @option options [Jsus::Package] :package owning package
+    # @option options [String] :namespace namespace to which the source file by default belongs
     # @return [Jsus::SourceFile]
-    # @raise [Jsus::BadSourceFileException] when file cannot be parsed
+    # @raise [Jsus::BadSourceFileException] when file cannot be parsed or does not exist
     # @api public
     def self.from_file(filename, options = {})
-      if File.exists?(filename)
-        source = File.open(filename, 'r:utf-8') {|f| f.read }
-        bom = RUBY_VERSION =~ /1.9/ ? "\uFEFF" : "\xEF\xBB\xBF"
-        source.gsub!(bom, "")
-        yaml_data = source.match(%r(^/\*\s*(---.*?)\*/)m)
-        if (yaml_data && yaml_data[1] && header = YAML.load(yaml_data[1]))
-          options[:header]            = header
-          options[:relative_filename] = filename
-          options[:filename]          = File.expand_path(filename)
-          options[:content]           = source
-          new(options)
-        else
-          raise BadSourceFileException, "#{filename} is missing a header or header is invalid"
-        end
-      else
-        raise BadSourceFileException, "Referenced #{filename} does not exist. #{options[:package] ? "Referenced from package #{options[:package].name}" : ""}"
-      end
+      filename = File.expand_path(filename)
+      raise BadSourceFileException, "File does not exist." unless File.exists?(filename)
+      source = Jsus::Util.read_file(filename)
+      source_file = new(source, options)
+      source_file.filename = source_file.original_filename = filename
+      source_file.original_filename.freeze
+      source_file
     rescue Exception => e
-      if !e.kind_of?(BadSourceFileException) # if we didn't raise the error; like in YAML, for example
-        raise "Exception #{e.inspect} happened on #{filename}. Please take appropriate measures"
-      else # if we did it, just reraise
-        raise e
-      end
+      e.message.sub! /^/, "Unexpected exception happened while processing #{filename}: "
+      Jsus.logger.error e.message
+      raise e
     end
 
-    # Public API
-
     # @return [Hash] a header parsed from YAML-formatted source file first comment.
     # @api public
     def header
-      self.header = {} unless @header
-      @header
+      @header ||= {}
     end
 
     # @return [String] description of the source file.
@@ -87,54 +83,32 @@ module Jsus
       header["description"]
     end
 
-    # @return [Array] list of dependencies for given file
-    # @api public
-    def dependencies
-      @dependencies
-    end
-    alias_method :requires, :dependencies
+    # @return [String] license of source file
+    def license
+      header["license"]
+    end # license
 
-    #
-    # @param [Hash] options
-    # @option options [Boolean] :short whether inner dependencies should not
-    #   prepend package name, e.g. 'Class' instead of 'Core/Class' when in
-    #   package 'Core'.
-    #
-    #   Note Doesn't change anything for external dependencies
-    #
-    # @return [Array] array with names of dependencies. Unordered.
-    # @api public
-    def dependencies_names(options = {})
-      dependencies.map {|d| d.name(options) }
-    end
-    alias_method :requires_names, :dependencies_names
-
-    # @return [Array] array of external dependencies tags. Unordered.
+    # @return [Array] list of authors
     # @api public
-    def external_dependencies
-      dependencies.select {|d| d.external? }
-    end
+    def authors
+      @authors
+    end # authors
 
-    # @returns [Array] array with names for external dependencies. Unordered.
+    # @return [Array] list of dependencies for given file
     # @api public
-    def external_dependencies_names
-      external_dependencies.map {|d| d.name }
+    def requires
+      @requires
     end
+    alias_method :dependencies, :requires
+    alias_method :requirements, :requires
 
     # @return [Array] array with provides tags.
     # @api public
     def provides
       @provides
     end
+    alias_method :provisions, :provides
 
-    # @param [Hash] options
-    # @option options [Boolean] :short whether provides should not prepend package
-    #   name, e.g. 'Class' instead of 'Core/Class' when in package 'Core'.
-    # @return [Array] array with provides names.
-    # @api public
-    def provides_names(options = {})
-      provides.map {|p| p.name(options)}
-    end
 
     # @return [Jsus::Tag] tag for replaced file, if any
     # @api public
@@ -142,7 +116,6 @@ module Jsus
       @replaces
     end
 
-
     # @returns [Jsus::Tag] tag for source file, for which this one is an extension.
     # @example file Foo.js in package Core provides ['Class', 'Hash']. File
     # Bar.js in package Bar extends 'Core/Class'. That means its contents would be
@@ -158,45 +131,23 @@ module Jsus
       extends && !extends.empty?
     end
 
-    # @return [Array] new_value array of included extensions for given source.
+    # @return [Boolean] whether the source file is an extension.
     # @api public
-    def extensions
-      @extensions ||= []
-      @extensions = @extensions.flatten.compact.uniq
-      @extensions
-    end
-
-    # @param [Array] new_value list of extensions for given file
-    # @api semipublic
-    def extensions=(new_value)
-      @extensions = new_value
-    end
-
-    # Looks up for extensions in the pool and then includes
-    # extensions for all the provides tag this source file has.
-    # Caches the result.
-    #
-    # @api semipublic
-    def include_extensions
-      @included_extensions ||= include_extensions!
-    end
+    def replacement?
+      replaces && !replaces.empty?
+    end # replacement?
 
-    # @see #include_extensions
-    # @api semipublic
-    def include_extensions!
-      if pool
-        provides.each do |p|
-          extensions << pool.lookup_extensions(p)
-        end
-      end
-    end
+    # @api private
+    def reset
+      @source   = @original_source.dup
+      @filename = @original_filename.dup if @original_filename
+    end # reset_linked
 
     # @return [Array] array of files required by this files including all the filenames for extensions.
     #    SourceFile filename always goes first, all the extensions are unordered.
     # @api public
     def required_files
-      include_extensions
-      [filename, extensions.map {|e| e.filename}].flatten
+      [filename].flatten
     end
 
     # @return [Hash] hash containing basic info with dependencies/provides tags' names
@@ -206,8 +157,8 @@ module Jsus
     def to_hash
       {
         "desc"     => description,
-        "requires" => dependencies_names(:short => true),
-        "provides" => provides_names(:short => true)
+        "requires" => requires.map {|tag| tag.namespace == namespace ? tag.name : tag.full_name},
+        "provides" => provides.map {|tag| tag.name}
       }
     end
 
@@ -215,87 +166,7 @@ module Jsus
     # @return [String]
     # @api public
     def inspect
-      self.to_hash.inspect
-    end
-
-    # Parses header and gets info from it.
-    # @param [String] new_header header content
-    # @api private
-    def header=(new_header)
-      @header = new_header
-      # prepare defaults
-      @header["description"] ||= ""
-      # handle tags
-      @dependencies = parse_tag_list(Array(@header["requires"]))
-      @provides = parse_tag_list(Array(@header["provides"]))
-
-      @extends = case @header["extends"]
-      when Array then Tag.new(@header["extends"][0])
-      when String then Tag.new(@header["extends"])
-      else nil
-      end
-
-      @replaces = case @header["replaces"]
-      when Array then Tag.new(@header["replaces"][0])
-      when String then Tag.new(@header["replaces"])
-      else nil
-      end
-    end
-
-    # @param [String] new_value file content
-    # @api private
-    def content=(new_value)
-      @content = new_value
-    end
-
-    # @return [String] file contents, *including* extensions
-    # @api semipublic
-    def content
-      include_extensions
-      [@content, extensions.map {|e| e.content}].flatten.compact.join("\n")
-    end
-
-    # @return [String] Original file contents
-    # @api semipublic
-    def original_content
-      @content
-    end
-
-    # @param [Enumerable] tag_list list of tags
-    # @return [Array] normalized tags list
-    # @api private
-    def parse_tag_list(tag_list)
-      tag_list.map do |tag_name|
-        case tag_name
-        when String
-          Tag.new(tag_name, :package => package)
-        when Hash
-          tags = []
-          tag_name.each do |pkg_name, sources|
-            normalized_package_name = pkg_name.sub(/(.+)\/.*$/, "\\1")
-            Array(sources).each do |source|
-              tags << Tag.new([normalized_package_name, source].join("/"))
-            end
-          end
-          tags
-        end
-      end.flatten
-    end # parse_tag_list
-
-    # Assigns an instance of Jsus::Pool to the source file.
-    # Also performs push to that pool.
-    # @param [Jsus::Pool] new_value
-    # @api private
-    def pool=(new_value)
-      @pool = new_value
-      @pool << self if @pool
-    end
-
-    # A pool which the source file is assigned to. Used in #include_extensions!
-    # @return [Jsus::Pool]
-    # @api semipublic
-    def pool
-      @pool
+      self.to_hash.merge("namespace" => namespace).inspect
     end
 
     # @api public
@@ -312,5 +183,55 @@ module Jsus
     def hash
       [self.class, filename].hash
     end
+
+    private
+
+    # @api private
+    def prepare_original_source
+      bom = RUBY_VERSION[/1.9/] ? "\uFEFF" : "\xEF\xBB\xBF"
+      original_source.gsub!(bom, "")
+    end # prepare_original_source
+
+    # @api private
+    def parse_header
+      yaml_data = source.match(%r(^/\*\s*(---.*?)\*/)m)
+      if yaml_data && yaml_data[1] && header = YAML.load(yaml_data[1])
+        @header   = header
+        @authors  = Array(@header["author"] || @header["authors"])
+        @requires = process_tag_list(@header["requires"])
+        @provides = process_tag_list(@header["provides"])
+        @replaces = process_tag(@header["replaces"]) if @header["replaces"]
+        @extends  = process_tag(@header["extends"]) if @header["extends"]
+      else
+        raise BadSourceFileException, "#{filename} is missing a header or header is invalid"
+      end
+    end # parse_header
+
+    # @api private
+    def process_tag(tag_name)
+      if tag_name.kind_of?(String)
+        tag_name.sub!(%r{^\.?/}, "") # remove leading slash / dot+slash
+        if tag_name.index("/") || !namespace
+          Tag[tag_name]
+        else
+          Tag["#{namespace}/#{tag_name}"]
+        end
+      elsif tag_name.kind_of?(Hash)
+        # Quirky mootools tags
+        ns, tag = tag_name.first[0], tag_name.first[1]
+        # Removes strings like "/1.3.0" from the end of namespace part
+        ns = ns.sub(%r{/(\d+\.?)+\d+$}, "")
+        ns = Util::Inflection.random_case_to_mixed_case(ns)
+        "#{ns}/#{tag}"
+      else
+        nil
+      end
+    end # process_tag
+
+    # @api private
+    def process_tag_list(tag_list)
+      Array(tag_list).map {|tag| process_tag(tag) }.compact
+    end # process_tag_list
+
   end
 end