bpm 0.1.4 → 1.0.0.beta.4

data/lib/bpm/package.rb

@@ -2,63 +2,116 @@ require 'json'
 
 module BPM
   class Package
-    EXT      = "bpkg"
-    METADATA = %w[keywords licenses engines main bin directories]
-    FIELDS   = %w[name version description author homepage summary]
-    attr_accessor :metadata, :lib_path, :tests_path, :errors, :json_path, :attributes, :directories, :dependencies, :root_path
-    attr_accessor *FIELDS
+    EXT = "bpkg"
+
+    # All JSON fields
+    FIELDS = {
+      "keywords"    => :array,
+      "licenses"    => :array,
+      "engines"     => :array,
+      "main"        => :string,
+      "bin"         => :hash,
+      "directories" => :hash,
+      "pipeline"    => :hash,
+      "name"        => :string,
+      "version"     => :string,
+      "description" => :string,
+      "author"      => :string,
+      "homepage"    => :string,
+      "summary"     => :string,
+      "dependencies"             => :hash,
+      "dependencies:development" => :hash,
+      "bpm:build"         => :hash,
+      "bpm:formats"       => :hash,
+      "bpm:transport"     => :string,
+      "bpm:use:transport" => :string,
+      "bpm:minifier"      => :string
+    }
+
+    PLUGIN_FIELDS = %w[bpm:formats bpm:minifier bpm:transport bpm:use:transport]
+    
+    # Fields that can be loaded straight into the gemspec
+    SPEC_FIELDS = %w[name email homepage summary description]
+
+    # Fields that should be bundled up into JSON in the gemspec
+    METADATA_FIELDS = %w[keywords licenses engines main bin directories pipeline bpm:build bpm:formats bpm:transport]
+
+    REQUIRED_FIELDS = %w[name description summary homepage author version directories]
+
+    attr_accessor *FIELDS.keys.map{|f| f.gsub(':', '_') }
+
+    attr_accessor :json_path, :email
+    attr_reader :root_path, :errors
 
     def self.from_spec(spec)
       pkg = new(spec.full_gem_path)
-      pkg.bpkg = spec
+      pkg.fill_from_gemspec(spec)
       pkg
     end
 
     def initialize(root_path=nil, email = "")
-      @root_path = root_path || Dir.pwd
-      @json_path = File.join @root_path, 'package.json'
-      @email     = email
-      @attributes = {}
-      @dependencies = {}
-      @directories = {}
-      @metadata = {}
-    end
-
-    def bpkg=(spec)
-      unless spec.is_a?(LibGems::Specification)
-        spec = LibGems::Format.from_file_by_path(spec.to_s).spec
+      @root_path   = root_path || Dir.pwd
+      @json_path   = File.join @root_path, 'bpm_package.json'
+      unless File.exists? @json_path
+        @json_path   = File.join @root_path, 'package.json'
       end
-      fill_from_gemspec(spec)
+      
+      @email       = email
+      @errors      = []
+      # Set defaults
+      FIELDS.keys.each{|f| send("#{c2u(f)}=", fd(f))}
     end
 
     def to_spec
       return unless valid?
       LibGems::Specification.new do |spec|
-        spec.name              = name
-        spec.version           = version
-        spec.authors           = [author]
-        spec.email             = @email
-        spec.homepage          = homepage
-        spec.summary           = summary
-        spec.description       = description
-        spec.requirements      = [metadata.to_json]
-        spec.files             = directory_files + template_files + transport_files + ["package.json"]
-        spec.test_files        = glob_files(tests_path)
-        spec.bindir            = bin_path
-        spec.executables       = bin_files.map{|p| File.basename(p) } if bin_path
-        # TODO: IS this right?
+        SPEC_FIELDS.each{|f| spec.send("#{f}=", send(f)) }
+        spec.version      = version
+        spec.authors      = [author]
+        spec.files        = directory_files + ["package.json"]
+        spec.test_files   = glob_files(tests_path)
+        spec.bindir       = bin_path
+        spec.licenses     = licenses.map{|l| l["type"]}
+        spec.executables  = bin_files.map{|p| File.basename(p) } if bin_path
+
+        metadata = Hash[METADATA_FIELDS.map{|f| [f, send(c2u(f)) ] }]
+        spec.requirements = [metadata.to_json]
+
+        # TODO: Is this right?
         spec.rubyforge_project = "bpm"
+
         def spec.file_name
           "#{full_name}.#{EXT}"
         end
-        dependencies.each{|d,v| spec.add_dependency(d, v) } if dependencies
+
+        dependencies.each{|d,v| spec.add_dependency(d,v) }
+        dependencies_development.each{|d,v| spec.add_development_dependency(d,v) }
       end
     end
 
-    def as_json(options = {})
-      json = self.metadata.clone
-      FIELDS.each{|key| json[key] = send(key)}
-      json["dependencies"] = self.dependencies
+    def as_json
+
+      seen_keys = @read_keys || []
+      json   = {}
+      
+      # keep order of keys read in
+      seen_keys.each do |key|
+        if FIELDS.include?(key)
+          val = send(c2u(key == 'build' ? 'pipeline' : key))
+        else
+          val = @attributes[key]
+        end
+        
+        json[key] = val if val && !val.empty?
+      end
+      
+      FIELDS.keys.each do |key|
+        next if seen_keys.include?(key)
+        val = send(c2u(key))
+        key = 'build' if key == 'pipeline'
+        json[key] = val if val && !val.empty?
+      end
+
       json
     end
 
@@ -66,14 +119,93 @@ module BPM
       as_json.to_json
     end
 
-    def to_full_name
+    def full_name
       "#{name}-#{version}"
     end
 
-    def to_ext
-      "#{self.to_full_name}.#{EXT}"
+    def file_name
+      "#{full_name}.#{EXT}"
+    end
+
+    def directory_files
+      dir_names = directories.reject { |k,_| k == 'tests' }.values
+      build_names = bpm_build.values.map do |hash|
+        hash['directories'] || hash['assets']
+      end
+
+      build_names += PLUGIN_FIELDS.map do |field_name|
+        val = self.send(c2u(field_name))
+        val = val && val =~ /^#{name}\// ? val[name.size+1..-1]+'.js' : nil
+        puts "FIELD: #{field_name} #{self.send(c2u(field_name))} val=#{val}"
+        val
+      end
+
+      (dir_names+build_names).flatten.compact.uniq.map do |dir| 
+        glob_files(dir)
+      end.flatten
+    end
+
+    def bin_files
+      bin && bin.values
+    end
+
+    def bin_path
+      directories["bin"] || "bin"
+    end
+
+    def lib_path
+      directories["lib"] || "lib"
+    end
+
+    def tests_path
+      directories["tests"] || "tests"
     end
 
+    def find_transport_plugins(project)
+      dependencies.keys.map do |pkg_name|
+        dep = project.local_deps.find do |pkg|
+          pkg.load_json
+          pkg.name == pkg_name
+        end
+        raise "Could not find dependency: #{pkg_name}" unless dep
+        dep.bpm_transport
+      end.compact
+    end
+
+    def pipeline_libs
+      (pipeline && pipeline['libs']) || ['lib']
+    end
+
+    def pipeline_css
+      (pipeline && pipeline['css']) || ['css']
+    end
+
+    def pipeline_assets
+      (pipeline && pipeline['assets']) || ['assets', 'resources']
+    end
+
+    def pipeline_tests
+      (pipeline && pipeline['tests']) || ['tests']
+    end
+    
+    # Returns a hash of dependencies inferred from the build settings.
+    def dependencies_build
+      ret = {}
+        
+      bpm_build.each do |target_name, opts|
+        next unless opts.is_a?(Hash)
+        
+        minifier = opts['minifier']
+        case minifier
+        when String
+          ret[minifier] = '>= 0'
+        when Hash
+          ret.merge! minifier
+        end
+      end
+      ret
+    end
+    
     def template_path(name)
       path = File.join(root_path, 'templates', name.to_s)
       File.exist?(path) ? path : nil
@@ -88,10 +220,6 @@ module BPM
       generator
     end
 
-    def errors
-      @errors ||= []
-    end
-
     def validate
       validate_fields && validate_version && validate_paths
     end
@@ -104,10 +232,60 @@ module BPM
       File.exist?(json_path)
     end
 
+    def validate_name_and_path
+      filename = File.basename(root_path)
+      unless filename==name || filename=="#{name}-#{version}"
+        raise BPM::InvalidPackageNameError.new self
+      end
+    end
+    
     def load_json
-      read && parse
+      begin
+        json = JSON.parse(File.read(@json_path))
+      rescue JSON::ParserError, Errno::EACCES, Errno::ENOENT => ex
+        raise BPM::InvalidPackageError.new self, ex.message
+      end
+
+      @read_keys = json.keys.dup # to retain order on save
+      @attributes = json # save for saving
+      
+      FIELDS.keys.each do |field|
+        if field == 'pipeline'
+          self.pipeline = json['build'] || fd(field)
+        else
+          send("#{c2u(field)}=", json[field] || fd(field))
+        end
+      end
+
+      validate_name_and_path
+      
+      true
+    end
+
+    def fill_from_gemspec(spec)
+      unless spec.is_a?(LibGems::Specification)
+        spec = LibGems::Format.from_file_by_path(spec.to_s).spec
+      end
+
+      SPEC_FIELDS.each{|f| send("#{f}=", spec.send(f) || fd(field)) }
+
+      self.author = spec.authors.first
+      self.version = spec.version.to_s
+
+      metadata = spec.requirements.first
+      if metadata
+        metadata = JSON.parse(metadata)
+        METADATA_FIELDS.each{|f| send("#{c2u(f)}=", metadata[f] || fd(f))}
+      end
+
+      self.dependencies = Hash[spec.dependencies.map{|d| [d.name, d.requirement.to_s ]}]
+      self.dependencies_development = Hash[spec.development_dependencies.map{|d| [d.name, d.requirement.to_s ]}]
     end
 
+    # Collects an expanded list of all dependencies this package depends on 
+    # directly or indirectly.  This assume the project has already resolved
+    # any needed dependencies and therefore will raise an exception if a 
+    # dependency cannot be found locally in the project.
     def expanded_deps(project)
       ret  = []
       seen = []
@@ -122,14 +300,13 @@ module BPM
             todo << found
             ret  << found
           else
-            puts "COULD NOT FIND DEP: #{dep_name}"
+            raise "Required local dependency not found #{dep_name}"
           end
         end
-        
       end
       ret
     end
-    
+
     # TODO: Make better errors
     # TODO: This might not work well with conflicting versions
     def local_deps(search_path=nil)
@@ -153,157 +330,74 @@ module BPM
       end
     end
 
-    def directory_files
-      directories.reject{|k,_| k == 'tests' }.values.map{|dir| glob_files(dir) }.flatten
-    end
+    private
 
-    def bin_files
-      if @attributes["bin"]
-        @attributes["bin"].values
-      else
-        []
+      # colon to underscore
+      def c2u(key)
+        key.gsub(':', '_')
       end
-    end
-
-    def template_files
-      glob_files("templates")
-    end
-
-    def transport_files
-      glob_files("transports")
-    end
-
-    def bin_path
-      @directories["bin"] || "bin"
-    end
-
-    def lib_path
-      @directories["lib"] || "lib"
-    end
-
-    def tests_path
-      @directories["tests"] || "tests"
-    end
 
-    def transport_plugins(project)
-      plugin_modules('plugin:transport', project, false)
-    end
-    
-    def minifier_plugins(project)
-      [@attributes['plugin:minifier']].compact
-    end
-
-    def plugin_modules(key_name, project, own=true)
-      return [@attributes[key_name]] if own && @attributes[key_name]
-      dependencies.keys.map do |pkg_name| 
-        dep = project.local_deps.find do |pkg| 
-          pkg.load_json
-          pkg.name == pkg_name
+      # field default
+      def fd(key)
+        case FIELDS[key]
+        when :array then []
+        when :hash  then {}
         end
-        
-        if dep
-          dep.attributes[key_name]
-        else
-          puts "COULD NOT FIND DEP: #{pkg_name}"
-        end
-        
-      end.compact
-    end
-      
-    # named directories that are expected to contain code.  These will be 
-    # searched for supported modules
-    def pipeline_libs
-      (@attributes['pipeline'] && @attributes['pipeline']['libs']) || ['lib']
-    end
-
-    def pipeline_css
-      (@attributes['pipeline'] && @attributes['pipeline']['css']) || ['css']
-    end
-
-    def pipeline_assets
-      (@attributes['pipeline'] && @attributes['pipeline']['assets']) || ['assets', 'resources']
-    end
-
-  private
-  
-    def parse
-      FIELDS.each do |field|
-        send("#{field}=", @attributes[field])
       end
 
-      self.dependencies = @attributes["dependencies"] || {}
-      self.directories = @attributes["directories"] || {}
-      self.metadata    = Hash[*@attributes.select { |k, v| METADATA.include?(k) }.flatten(1)]
-    end
-
-    def read
-      @attributes = JSON.parse(File.read(@json_path))
-    rescue *[JSON::ParserError, Errno::EACCES, Errno::ENOENT] => ex
-      add_error "There was a problem parsing #{File.basename(@json_path)}: #{ex.message}"
-    end
-
-    def validate_paths
-      success = true
+      def validate_paths
+        success = true
 
-      if paths = [*lib_path]
-        non_dirs = paths.reject{|p| File.directory?(File.join(@root_path, p))}
+        paths = [*lib_path]
         if paths.empty?
           add_error "A lib directory is required"
           success = false
-        elsif !non_dirs.empty?
-          add_error "#{non_dirs.map{|p| "'#{p}'" }.join(", ")}, specified for lib directory, is not a directory"
+        else
+          non_dirs = paths.reject{|p| File.directory?(File.join(root_path, p))}
+          unless non_dirs.empty?
+            add_error "#{non_dirs.map{|p| "'#{p}'" }.join(", ")}, specified for lib directory, is not a directory"
+            success = false
+          end
+        end
+
+        # look for actual 'tests' in directories hash since simply having no
+        # tests dir is allowed as well.
+        unless directories['tests'].nil? || File.directory?(File.join(@root_path, tests_path))
+          add_error "'#{tests_path}', specified for tests directory, is not a directory"
           success = false
         end
-      end
 
-      # look for actual 'tests' in directories hash since simply having no
-      # tests dir is allowed as well.
-      unless @directories['tests'].nil? || File.directory?(File.join(@root_path, tests_path))
-        add_error "'#{tests_path}', specified for tests directory, is not a directory"
-        success = false
+        success
       end
 
-      success
-    end
-
-    def validate_version
-      LibGems::Version.new(version)
-      true
-    rescue ArgumentError => ex
-      add_error ex.to_s
-    end
+      def validate_version
+        LibGems::Version.new(version)
+        true
+      rescue ArgumentError => ex
+        add_error ex.to_s
+        false
+      end
 
-    def validate_fields
-      %w[name description summary homepage author version directories].all? do |field|
-        value = send(field)
-        if value.nil? || value.size.zero?
-          add_error "Package requires a '#{field}' field"
-        else
-          true
+      def validate_fields
+        REQUIRED_FIELDS.all? do |field|
+          value = send(field)
+          if value.nil? || value.empty?
+            add_error "Package requires a '#{field}' field"
+            false
+          else
+            true
+          end
         end
       end
-    end
 
-    def add_error(message)
-      self.errors << message
-      false
-    end
-
-    def glob_files(path)
-      Dir[File.join(path, "**", "*")].reject{|f| File.directory?(f) }
-    end
-
-    def fill_from_gemspec(spec)
-      FIELDS.each{|field| send("#{field}=", spec.send(field).to_s) }
-
-      self.dependencies = {}
-      spec.dependencies.each{|d| self.dependencies[d.name] = d.requirement.to_s }
+      def add_error(message)
+        self.errors << message
+      end
 
-      if spec.requirements && spec.requirements.size>0
-        self.metadata = JSON.parse(spec.requirements.first)
+      def glob_files(path)
+        return path if File.exists?(path) && !File.directory?(path)
+        Dir[File.join(path, "**", "*")].reject{|f| File.directory?(f) }
       end
-    end
 
   end
 end
-

data/lib/bpm/pipeline/generated_asset.rb

@@ -21,30 +21,86 @@ module BPM
       minify super
     end
 
-    def minify(body)
-      project = environment.project
-      minifier_name = project.minifier_name
-      if minifier_name && content_type == 'application/javascript' 
-        pkg = project.package_from_name minifier_name
-        minifier_plugin_name = pkg.minifier_plugins(project).first
-        plugin_ctx = environment.plugin_context_for minifier_plugin_name
-        
-        V8::C::Locker() do
-          plugin_ctx["PACKAGE_INFO"] = pkg.attributes
-          plugin_ctx["DATA"]         = body
-          body = plugin_ctx.eval("BPM_PLUGIN.minify(DATA, PACKAGE_INFO)")
+    def minify(hash)
+      return hash if environment.mode == :debug
+      
+      hash = environment.cache_hash("#{pathname}:minify", id) do
+        project = environment.project
+        minifier_name = project.minifier_name asset_name
+        minifier_name = minifier_name.keys.first if minifier_name
+
+        if minifier_name && content_type == 'application/javascript'
+          pkg = project.package_from_name minifier_name
+          if pkg.nil?
+            raise MinifierNotFoundError.new(minifier_name)
+          end
+
+          minifier_plugin_name = pkg.bpm_minifier
+          if minifier_plugin_name.nil?
+            raise MinifierNotFoundError.new(minifier_name)
+          end
+
+          plugin_ctx = environment.plugin_context_for minifier_plugin_name
+
+          # slice out the header at the top - we don't want the minifier to 
+          # touch it.
+          data     = hash['source']
+          header   = data.match /^(\/\* ====.+====\*\/)$/m
+          if header
+            header = header[0] + "\n"
+            data   = data[header.size..-1]
+          end
+
+          V8::C::Locker() do
+            plugin_ctx["PACKAGE_INFO"] = pkg.as_json
+            plugin_ctx["DATA"]         = data
+            data = plugin_ctx.eval("BPM_PLUGIN.minify(DATA, PACKAGE_INFO)")
+          end
+
+          data = header+data if header
+          
+          { 'length' => Rack::Utils.bytesize(data),
+            'digest' => environment.digest.update(data).hexdigest,
+            'source' => data }
+        else
+          hash
         end
       end
-      
-      body
+
+      hash['length'] = Integer(hash['length']) if hash['length'].is_a?(String)
+
+      @length = hash['length']
+      @digest = hash['digest']
+      @source = hash['source']
+
+      hash
+    end
+    
+    def asset_name
+      project = environment.project
+      if pathname.to_s.include?(project.assets_root)
+        pathname.relative_path_from(Pathname.new(project.assets_root)).to_s
+      elsif pathname.to_s.include?(project.preview_root)
+        pathname.relative_path_from(Pathname.new(project.preview_root)).to_s
+      end
     end
     
     def build_dependency_context_and_body
 
-      project = environment.project
-      pkgs = pathname.to_s =~ /app_/ ? [project] : project.local_deps
+      project       = environment.project
+      settings = project.build_settings(environment.mode)[asset_name]
+      pkgs     = settings.keys.map do |pkg_name| 
+        next if pkg_name == 'bpm:minifier'
+        if pkg_name == project.name
+          project
+        else
+          project.local_deps.find { |dep| dep.name == pkg_name } 
+        end
+      end.compact
+
       if pkgs.size > 0
-        manifest = pkgs.map do |x| 
+        manifest = pkgs.sort { |a,b| a.name <=> b.name } 
+        manifest = manifest.map do |x| 
           "#{x.name} (#{x.version})"
         end.join " "
       else
@@ -54,10 +110,9 @@ module BPM
       # Add in the generated header
       body = <<EOF
 /* ===========================================================================
-   BPM Static Dependencies
+   BPM Combined Asset File
    MANIFEST: #{manifest}
    This file is generated automatically by the bpm (http://www.bpmjs.org)    
-   To use this file, load this file in your HTML head.
    =========================================================================*/
 
 EOF
@@ -69,17 +124,22 @@ EOF
       context = blank_context
       context.require_asset(pathname) # start with self
 
-      dir_name, dir_method = FORMAT_METHODS[content_type] || ['lib', 'pipeline_libs']
+      if pathname.to_s =~ /_tests\.js$/
+        dir_name, dir_method = ['tests', 'pipeline_tests']
+      else
+        dir_name, dir_method = FORMAT_METHODS[content_type] || ['lib', 'pipeline_libs']
+      end
 
       pkgs.map do |pkg|
-        pkg.load_json
-        pkg.send(dir_method).each do |dir|
-          dir_name = pkg.directories[dir] || dir 
-          search_path = File.expand_path File.join(pkg.root_path, dir_name)
-
-          Dir[File.join(search_path, '**', '*')].sort.each do |fn|
-            context.depend_on File.dirname(fn)
-            context.require_asset(fn) if context.asset_requirable? fn
+        settings[pkg.name].each do |dir|
+          dir_names = Array(pkg.directories[dir] || dir)
+          dir_names.each do |dir_name|
+            search_path = File.expand_path File.join(pkg.root_path, dir_name)
+
+            Dir[File.join(search_path, '**', '*')].sort.each do |fn|
+              context.depend_on File.dirname(fn)
+              context.require_asset(fn) if context.asset_requirable? fn
+            end
           end
         end
       end