bpm 1.0.0.beta.6 → 1.0.0.beta.8

data/CHANGELOG.md

@@ -1,4 +1,30 @@
 
+  * First cut at support for formats.
+  * Also introduces new requirement for defining transport and format plugins 
+    in the package.json.  Now you must use the "bpm:provides" keyword:
+
+New format for defining a format or transport plugin:
+
+      "bpm:provides": {
+        "transport": {
+          "main": "path/to/transport/plugin"
+        },
+        
+        "format:EXT": {
+          "default:mime": "application/javascript",
+          "main": "path/to/format/plugin"
+        }
+      }
+
+# 1.0.0.beta.7
+
+  * fixed bug where local packages that are indirect dependencies of other 
+    remote packages could cause bpm to error out unable to find dependencies.
+    
+  * improved logging slightly
+  
+# 1.0.0.beta.6 (yanked)
+
   * bpm now passes a context object with build settings and a minify option
     to plugins - this will allow spade to support string loading.
   

data/TODO.md

@@ -2,9 +2,6 @@
 
 ## Important Features
 
-  * Multiple format support.  Format processors supplied by dependencies 
-    should
-    be used to resolve formats.
   * HTML manifest support [in general we need a way for packages to generate 
     new assets]
   * cache-friendly URLs

data/lib/bpm/cli/base.rb

@@ -277,7 +277,7 @@ module BPM
         package = local.pack(File.join(package_path, "package.json"), options[:email])
 
         if package.errors.empty?
-          puts "Successfully built package: #{package.file_name}"
+          say "Successfully built package: #{package.file_name}"
         else
           failure_message = "BPM encountered the following problems building your package:"
           package.errors.each do |error|
@@ -298,7 +298,7 @@ module BPM
           begin
             package     = local.unpack(path, options[:target])
             unpack_path = File.expand_path(File.join(Dir.pwd, options[:target], package.full_name))
-            puts "Unpacked package into: #{unpack_path}"
+            say "Unpacked package into: #{unpack_path}"
           rescue Errno::EACCES, LibGems::FilePermissionError => ex
             abort "There was a problem unpacking #{path}:\n#{ex.message}"
           end
@@ -391,7 +391,7 @@ module BPM
             abort %{No packages found matching "#{names.join('", "')}".}
           else
             packages.each do |name, versions|
-              puts "#{name} (#{versions.sort.reverse.join(", ")})"
+              say "#{name} (#{versions.sort.reverse.join(", ")})"
             end
           end
         end

data/lib/bpm/default.json

@@ -5,5 +5,9 @@
   },
   
   "dependencies": {
-  }
+  },
+  
+  "summary": "(no summary)",
+  "description": "(no description)",
+  "homepage": "(no homepage)"
 }

data/lib/bpm/errors.rb

@@ -48,4 +48,12 @@ module BPM
     end
   end
   
+  class TooManyTransportsError < BPM::Error
+    def format_message(pkg)
+      err = <<EOF
+#{pkg.name} depends on #{pkg.provided_transports.size} packages that define transport plugins. Select a plugin by adding a `bpm:use:transport` property to the package.json
+EOF
+    end
+  end
+  
 end

data/lib/bpm/generator.rb

@@ -45,6 +45,14 @@ module BPM
       [@template_path, self.class.source_root].compact
     end
 
+    def shell
+      @shell ||= Thor::Base.shell.new
+    end
+    
+    def say(*args)
+      shell.say *args
+    end
+
   private
 
     def app_const

data/lib/bpm/init_generator.rb

@@ -26,7 +26,7 @@ module BPM
         package.load_json
         new_json = JSON.pretty_generate(package.as_json)
         File.open("#{name}.json", "w"){|f| f.write new_json }
-        puts "created #{name}.json from package.json"
+        say "created #{name}.json from package.json"
       end
 
   end

data/lib/bpm/package.rb

@@ -26,10 +26,11 @@ module BPM
       "bpm:formats"       => :hash,
       "bpm:transport"     => :string,
       "bpm:use:transport" => :string,
-      "bpm:minifier"      => :string
+      "bpm:minifier"      => :string,
+      "bpm:provides"      => :hash
     }
 
-    PLUGIN_FIELDS = %w[bpm:formats bpm:minifier bpm:transport bpm:use:transport]
+    PLUGIN_FIELDS = %w[bpm:minifier]
     
     # Fields that can be loaded straight into the gemspec
     SPEC_FIELDS = %w[name email]
@@ -75,9 +76,9 @@ module BPM
         spec.licenses     = licenses.map{|l| l["type"]}
         spec.executables  = bin_files.map{|p| File.basename(p) } if bin_path
 
-        spec.homepage     = homepage || url
-        spec.description  = description || summary
-        spec.summary      = summary || description
+        spec.homepage     = self.homepage || self.url
+        spec.description  = self.description || self.summary
+        spec.summary      = self.summary || self.description
 
         metadata = Hash[METADATA_FIELDS.map{|f| [f, send(c2u(f)) ] }]
         spec.requirements = [metadata.to_json]
@@ -124,6 +125,14 @@ module BPM
       as_json.to_json
     end
 
+    def shell
+      @shell ||= Thor::Base.shell.new
+    end
+    
+    def say(*args)
+      shell.say *args
+    end
+    
     def full_name
       "#{name}-#{version}"
     end
@@ -133,7 +142,10 @@ module BPM
     end
 
     def directory_files
-      dir_names = directories.reject { |k,_| k == 'tests' }.values
+      dir_names = [bin_path, lib_path, tests_path]
+      dir_names += directories.reject { |k,_| dir_names.include?(k) }.values
+      dir_names.reject! { |t| t == tests_path }
+      
       build_names = bpm_build.values.map do |hash|
         hash['directories'] || hash['assets']
       end
@@ -144,6 +156,12 @@ module BPM
         val
       end
 
+      bpm_provides.each do |_,values|
+        val = values['main']
+        val = val && val =~ /^#{name}\// ? val[name.size+1..-1]+'.js' : nil
+        build_names << val if val
+      end
+
       (dir_names+build_names).flatten.compact.uniq.map do |dir| 
         glob_files(dir)
       end.flatten
@@ -207,6 +225,12 @@ module BPM
           ret.merge! minifier
         end
       end
+      
+      bpm_provides.each do |_,opts|
+        next unless opts.is_a?(Hash) && opts['dependencies']
+        ret.merge! opts['dependencies']
+      end
+
       ret
     end
     
@@ -233,12 +257,12 @@ module BPM
     end
 
     def has_json?
-      File.exist?(json_path)
+      !!json_path && File.exist?(json_path)
     end
 
     def validate_name_and_path
       filename = File.basename(root_path)
-      unless filename==name || filename=="#{name}-#{version}"
+      unless name.nil? || name.empty? || filename==name || filename=="#{name}-#{version}"
         raise BPM::InvalidPackageNameError.new self
       end
     end
@@ -276,6 +300,10 @@ module BPM
       self.author = spec.authors.first
       self.version = spec.version.to_s
 
+      self.description = spec.description
+      self.summary     = spec.summary
+      self.homepage    = spec.homepage
+
       metadata = spec.requirements.first
       if metadata
         metadata = JSON.parse(metadata)
@@ -311,6 +339,69 @@ module BPM
       ret
     end
 
+    def merged_dependencies(*kinds)
+      kinds.inject({}) do |ret, kind|
+        deps = case kind
+        when :runtime
+          dependencies
+        when :development
+          dependencies_development
+        when :build
+          dependencies_build
+        end
+        ret.merge! deps
+      end
+    end
+    
+    def used_dependencies(project)
+      if project.has_local_package?(self.name) 
+        merged_dependencies(:runtime, :development)
+      else
+        merged_dependencies(:runtime)
+      end
+    end
+      
+    def provided_formats
+      ret = {}
+      bpm_provides.each do | key, opts |
+        ret[key[7..-1]] = opts if key =~ /^format:/
+      end
+      ret
+    end
+
+    def used_formats(project)
+      pkgs=project.map_to_packages used_dependencies(project)
+      pkgs.inject({}) { |ret, pkg| ret.merge!(pkg.provided_formats) }
+    end
+
+    def provided_preprocessors
+      bpm_provides['preprocessors'] || []
+    end
+
+    def used_preprocessors(project)
+      pkgs=project.map_to_packages used_dependencies(project)
+      pkgs.map { |pkg| pkg.provided_postprocessors }.flatten
+    end
+    
+    def provided_postprocessors
+      bpm_provides['postprocessors'] || []
+    end
+
+    def used_postprocessors(project)
+      pkgs=project.map_to_packages used_dependencies(project)
+      pkgs.map { |pkg| pkg.provided_postprocessors }.flatten
+    end
+    
+    def provided_transport
+      bpm_provides['transport']
+    end
+
+    def used_transports(project)
+      pkgs=project.map_to_packages used_dependencies(project)
+      pkgs.map { |pkg| pkg.provided_transport }.compact.flatten
+    end      
+      
+          
     # TODO: Make better errors
     # TODO: This might not work well with conflicting versions
     def local_deps(search_path=nil)
@@ -395,15 +486,26 @@ module BPM
       end
 
       def validate_summary
-        summary || description
+        if (summary.nil? || summary.empty?) && (description.nil? || description.empty?)
+          add_error "Package requires a 'summary' field"
+          add_error "Package requires a 'description' field"
+          false
+        else
+          true
+        end
       end
       
       def validate_homepage
-        homepage || url
+        if (homepage.nil? || homepage.empty?) && (url.nil? || url.empty?)
+          add_error "Package requires a 'homepage' field"
+          false
+        else
+          true
+        end
       end
       
       def add_error(message)
-        self.errors << message
+        self.errors << message unless self.errors.include?(message)
       end
 
       def glob_files(path)

data/lib/bpm/pipeline/format_processor.rb

@@ -0,0 +1,28 @@
+require 'sprockets'
+
+module BPM
+  
+  # A Template that will use a format plugin to compile the content
+  # Register a subclass of the template with the with_plugin
+  class FormatProcessor < BPM::PluginProcessor
+    
+    def self.with_plugin(ext, plugin_opts)
+      ret = super plugin_opts, 'compileFormat'
+      ret.instance_eval do
+        @extension    = ext
+      end
+      ret
+    end
+
+    def self.extension
+      @extension
+    end
+    
+    def self.default_mime_type
+      @plugin_opts["mime:default"]
+    end    
+    
+  end
+end
+
+    

data/lib/bpm/pipeline/generated_asset.rb

@@ -74,9 +74,9 @@ module BPM
   private
 
     def build_source
-      self.class.push_generating_asset self
+      BPM::GeneratedAsset.push_generating_asset self
       ret = minify super
-      self.class.pop_generating_asset
+      BPM::GeneratedAsset.pop_generating_asset
       ret
     end
 

data/lib/bpm/pipeline/package_pipeline.rb

@@ -0,0 +1,79 @@
+require 'sprockets'
+
+module BPM
+  
+  # A sub-environment created for each package in the project.  Requests for
+  # individual assets will usually end up going through one of these 
+  # instances.  This allows each package to have its own set of processors
+  # for each file.
+  class PackagePipeline < Sprockets::Environment
+    
+    attr_reader :pipeline, :package
+    
+    def shell
+      @shell ||= Thor::Base.shell.new
+    end
+    
+    def initialize(pipeline, package)
+      @pipeline = pipeline
+      @package  = package
+      
+      super package.root_path
+      
+      %w(text/css application/javascript).each do |kind|
+        unregister_processor kind, Sprockets::DirectiveProcessor
+        register_processor   kind, BPM::DirectiveProcessor
+      end
+
+      # This gunks things up. I'm not a fan - PDW
+      unregister_postprocessor 'application/javascript', Sprockets::SafetyColons
+
+      package.used_formats(project).each do |ext, opts|
+        register_engine ".#{ext}", BPM::FormatProcessor.with_plugin(ext,opts)
+      end
+
+      package.used_preprocessors(project).each do |opts|
+        register_preprocessor opts['mime'], 
+          BPM::PluginProcessor.with_plugin(opts, 'preprocess')
+      end
+
+      package.used_postprocessors(project).each do |opts|
+        register_postprocessor opts['mime'], 
+          BPM::PluginProcessor.with_plugin(opts, 'postprocess')
+      end
+
+      opts = package.used_transports(project)
+      raise TooManyTransportsError(package) if opts.size>1
+      if opts.size>0
+        register_postprocessor 'application/javascript', 
+          BPM::PluginProcessor.with_plugin(opts.first, 'compileTransport')
+      end
+
+      append_path package.root_path
+    end
+    
+    def package_name
+      package.name
+    end
+    
+    def project
+      pipeline.project
+    end
+    
+    def mode
+      pipeline.mode
+    end
+    
+    def plugin_context_for(logical_path)
+      pipeline.plugin_context_for logical_path
+    end
+    
+    def resolve(*args)
+      super *args
+    rescue Sprockets::FileNotFound => e
+      raise Sprockets::FileNotFound, "#{e.message} in package '#{package_name}'"
+    end
+      
+
+  end
+end

data/lib/bpm/pipeline/plugin_asset.rb

@@ -5,7 +5,7 @@ module BPM
   # Defines an asset that represents a build plugin (such as a transport or
   # a minifier.)  The generated asset will include dependencies of the plugin
   # module as well as the module itself.
-  class PluginAsset < Sprockets::BundledAsset
+  class PluginAsset < BPM::GeneratedAsset
 
     def initialize(environment, module_name)
       pathname = Pathname.new(File.join(environment.project.root_path, '.bpm', 'plugins', module_name+'.js'))
@@ -18,15 +18,14 @@ module BPM
       super(environment, module_name, pathname, {})
     end
     
-  protected
-
-    def dependency_context_and_body
-      @dependency_context_and_body ||= build_dependency_context_and_body
-    end
-
   private
 
-    # Note: logical path must be hte module
+    # do not minify plugin assets
+    def minify(hash)
+      hash
+    end
+    
+    # Note: logical path must be the module
     def plugin_module
       project      = environment.project
       parts        = logical_path.split('/')

data/lib/bpm/pipeline/plugin_processor.rb

@@ -0,0 +1,52 @@
+require 'sprockets'
+
+module BPM
+
+  # A processor that will invoke a JavaScript-based plugin provided by a 
+  # package in the system.  The passed method name will be invoked on the 
+  # plugin.
+  class PluginProcessor < Tilt::Template
+    
+    def self.with_plugin(plugin_opts, method_name)
+      ret = Class.new(self)
+      ret.instance_eval do
+        @method_name  = method_name
+        @plugin_opts  = plugin_opts
+      end
+      ret
+    end
+
+    def self.method_name
+      @method_name
+    end
+    
+    def self.plugin_name
+      @plugin_opts["main"]
+    end
+  
+    def prepare
+    end
+    
+    def evaluate(context, locals, &block)
+      ctx = context.environment.plugin_context_for self.class.plugin_name
+      project = context.environment.project
+      pkg, module_id = project.package_and_module_from_path file
+      
+      filepath   = file.to_s
+      out = ''
+
+      V8::C::Locker() do
+        ctx["DATA"]  = data
+        ctx["CTX"]   = BPM::PluginContext.new(pkg, module_id)
+        out = ctx.eval("BPM_PLUGIN.#{self.class.method_name}(DATA, CTX, '#{filepath}');")
+      end
+
+      out
+    end
+    
+  end
+end
+
+      
+    
+    

data/lib/bpm/pipeline.rb

@@ -5,8 +5,15 @@ module BPM
 
   class Console
     def log(str)
-      puts str
+      shell.say str
     end
+    
+    private
+    
+    def shell
+      @shell ||= Thor::Base.shell.new
+    end
+    
   end
   
   # A BPM package-aware asset pipeline.  Asset lookup respects package.json
@@ -17,6 +24,7 @@ module BPM
     
     attr_reader :project
     attr_reader :mode
+    attr_reader :package_pipelines
 
     # Pass in the project you want the pipeline to manage.
     def initialize(project, mode = :debug, include_preview = false)
@@ -24,34 +32,84 @@ module BPM
       @project = project
       @mode    = mode
       @plugin_contexts = {}
+
+      # Create a pipeline for each package.  Will be used for searching.
+      @package_pipelines = project.local_deps.map do |pkg|
+        BPM::PackagePipeline.new self, pkg
+      end
+      @package_pipelines << BPM::PackagePipeline.new(self, project)
       
       project_path = project.root_path
 
       super project_path
 
-      # use custom directive processor
+      # Unregister built-in processors.  We want most things served by the 
+      # pipeline directly to just pass through.  (package pipelines do the
+      # processing)
       %w(text/css application/javascript).each do |kind|
         unregister_processor kind, Sprockets::DirectiveProcessor
-        register_processor   kind, BPM::DirectiveProcessor
       end
-
-      register_postprocessor 'application/javascript', BPM::TransportProcessor
-      #register_postprocessor 'application/javascript', BPM::SourceURLProcessor
-
-      # This gunks things up. I'm not a fan - PDW
       unregister_postprocessor 'application/javascript', Sprockets::SafetyColons
 
       # configure search paths
-      append_path File.join project_path, '.bpm', 'packages'
-      append_path File.dirname project_path
       append_path project.assets_root
       append_path project.preview_root if include_preview
     end    
-      
-    def plugin_context_for(module_id)
-      @plugin_contexts[module_id] ||= build_plugin_context(module_id)
+    
+    # determines the proper pipeline for the path  
+    def pipeline_for(path)
+      return nil if magic_paths.include?(path)
+      package_pipelines.find do |cur_pipeline|
+        path.to_s[cur_pipeline.package.root_path.to_s]
+      end
     end
     
+    def attributes_for(path)
+      if path.to_s[File.join(project.root_path, '.bpm')] ||  !Pathname.new(path).absolute?
+        return super(path) 
+      end
+
+      pipeline = pipeline_for path
+      pipeline ? pipeline.attributes_for(path) : super(path)
+    end
+
+    def resolve(logical_path, options={}, &block)
+      
+      magic_path = magic_paths.find do |path|
+        path =~ /#{Regexp.escape logical_path.to_s}(\..+)?$/
+      end
+      
+      package_name = logical_path.to_s.sub(/#{Regexp.escape File::SEPARATOR}.+/,'')
+      pipeline = package_pipelines.find do |cur_pipeline| 
+        cur_pipeline.package_name == package_name
+      end
+      
+      if pipeline && magic_path.nil?
+        logical_path = logical_path.to_s[package_name.size+1..-1]
+        pipeline.resolve Pathname.new(logical_path), options, &block
+      else
+        super logical_path, options, &block
+      end
+      
+    end
+
+    # Detect whenever we are asked to build some of the magic files and swap
+    # in a custom asset type that can generate the contents.
+    def build_asset(logical_path, pathname, options)
+      if magic_paths.include? pathname.to_s
+        BPM::GeneratedAsset.new(self, logical_path, pathname, options)
+      elsif pipeline = pipeline_for(pathname)
+        pipeline.build_asset logical_path, pathname, options
+      else
+        super logical_path, pathname, options
+      end
+    end
+
+    # Paths to files that should be built.
+    def magic_paths
+      @magic_paths ||= build_magic_paths
+    end
+
     # Returns an array of all the buildable assets in the current directory.
     # These are the assets that will be built when you compile the project.
     def buildable_assets
@@ -85,29 +143,34 @@ module BPM
 
       ret.sort.map { |x| find_asset x }.compact
     end
+
+    def plugin_context_for(logical_path)
+      @plugin_contexts[logical_path] ||= build_plugin_context(logical_path)
+    end
     
-    # Detect whenever we are asked to build some of the magic files and swap
-    # in a custom asset type that can generate the contents.
-    def build_asset(logical_path, pathname, options)
+  protected
+
+    def build_magic_paths
       magic_paths = project.buildable_asset_filenames(mode).map do |filename|
         project.assets_root filename
       end
-
+      
       magic_paths += project.buildable_asset_filenames(mode).map do |filename|
         project.preview_root filename
       end
-
-      if magic_paths.include? pathname.to_s
-        BPM::GeneratedAsset.new(self, logical_path, pathname, options)
-      else
-        super logical_path, pathname, options
-      end
     end
-    
+      
+    # Pass along to package pipelines
+    def expire_index!
+      super
+      @magic_paths = nil
+      package_pipelines.each { |pipeline| pipeline.expire_index! }
+    end
+      
   private
   
-    def build_plugin_context(module_id)
-      asset = BPM::PluginAsset.new(self, module_id)
+    def build_plugin_context(logical_path)
+      asset = BPM::PluginAsset.new(self, logical_path)
       plugin_text = asset.to_s
       
       ctx = nil