bpm 0.1.0

data/lib/bpm/pipeline/directive_processor.rb

@@ -0,0 +1,47 @@
+require 'sprockets'
+
+module BPM
+  
+  # Like the regular directive processor but knows how to resolve directives
+  # as module ids, not just file paths
+  class DirectiveProcessor < Sprockets::DirectiveProcessor
+    
+    def process_require_directive(path)
+      project      = context.environment.project
+      module_path  = project.path_from_module(path)
+      path = context.resolve(module_path) rescue path
+      context.require_asset(path)
+    end
+    
+    def process_require_tree_directive(path = ".")
+      if relative?(path)
+        super path
+      else
+        project     = context.environment.project
+        module_path = project.path_from_module path
+        root = module_path.sub(/^([^\/]+)\//) do |s|
+          project.path_from_package s
+        end
+                
+        context.depend_on(root)
+
+        Dir["#{root}/**/*"].sort.each do |filename|
+          if filename == self.file
+            next
+          elsif File.directory?(filename)
+            context.depend_on(filename)
+          elsif context.asset_requirable?(filename)
+            context.require_asset(filename)
+          end
+        end
+      end
+    end
+    
+  private
+    def relative?(path)
+      path =~ /^\.($|\.?\/)/
+    end
+    
+  end
+  
+end

data/lib/bpm/pipeline/generated_asset.rb

@@ -0,0 +1,68 @@
+require 'sprockets'
+
+module BPM
+  
+  class GeneratedAsset < Sprockets::BundledAsset
+
+    FORMAT_METHODS = {
+      'text/css' => ['css', 'pipeline_css'],
+      'application/javascript' => ['lib', 'pipeline_libs']
+    }
+
+  protected
+
+    def dependency_context_and_body
+      @dependency_context_and_body ||= build_dependency_context_and_body
+    end
+
+  private
+
+    def build_dependency_context_and_body
+
+      project = environment.project
+      if project.local_deps.size > 0
+        manifest = project.local_deps.map do |x| 
+          "#{x.name} (#{x.version})"
+        end.join " "
+      else
+        manifest = "(none)"
+      end
+
+      # Add in the generated header
+      body = <<EOF
+/* ===========================================================================
+   BPM Static Dependencies
+   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
+
+      # Prime digest cache with data, since we happen to have it
+      environment.file_digest(pathname, body)
+
+      # add requires for each depedency to context
+      context = blank_context
+      context.require_asset(pathname) # start with self
+
+      dir_name, dir_method = FORMAT_METHODS[content_type] || ['lib', 'pipeline_libs']
+
+      project.local_deps.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
+          end
+        end
+      end
+
+      return context, body
+    end
+
+  end
+end

data/lib/bpm/pipeline/transport_processor.rb

@@ -0,0 +1,32 @@
+require 'sprockets'
+
+module BPM
+  
+  class TransportProcessor < Sprockets::Processor
+    
+    def evaluate(context, locals)
+      project = context.environment.project
+      pkg, module_id = project.package_and_module_from_path file
+      transport_plugins = pkg.transport_plugins(project)
+      
+      if transport_plugins.size > 1
+        raise "#{pkg.name} depends on #{transport_plugins.size} packages that define transport plugins.  Select a plugin by adding a `plugin:transport` property to the package.json"
+      elsif transport_plugins.size == 1
+        transport_module = transport_plugins.first
+        
+        transport_path   = context.resolve project.path_from_module(transport_module)
+
+        ctx = context.environment.js_context_for transport_path
+        ctx["PACKAGE_INFO"] = pkg.attributes
+        ctx["DATA"]         = data
+        wrapped = ctx.eval "exports.compileTransport(DATA, PACKAGE_INFO, '#{module_id}');"
+
+        wrapped
+      else
+        data
+      end
+    end
+    
+  end
+
+end

data/lib/bpm/project.rb

@@ -0,0 +1,427 @@
+require 'json'
+
+module BPM
+
+  class Project < Package
+
+    DEFAULT_CONFIG_PATH = File.expand_path('../default.json', __FILE__)
+    DEFAULT_CONFIG = JSON.load File.read(DEFAULT_CONFIG_PATH)
+    BPM_DIR = '.bpm'
+
+    def self.project_file_path(path)
+      json_path = File.join path, "#{File.basename(path)}.json"
+      json = JSON.load(File.read(json_path)) rescue nil
+      return json && json["bpm"] && json_path
+    end
+
+    def self.is_project_root?(path)
+      !!project_file_path(path) ||
+      File.exists?(File.join(path, 'assets', 'bpm_packages.js'))
+    end
+
+    def self.nearest_project(path)
+      path = File.expand_path path
+
+      last = nil
+      while path != last
+        return new(path) if is_project_root?(path)
+        last = path
+        path = File.dirname path
+      end
+      nil
+    end
+
+    attr_reader :name
+
+    def initialize(root_path, name=nil)
+      super root_path
+
+      @name = name || File.basename(root_path)
+      @json_path = File.join root_path, "#{@name}.json"
+
+      load_json && validate
+    end
+
+    def add_dependencies(new_deps, verbose=false)
+
+      old_deps  = build_local_deps(false) || []
+      
+      hard_deps = dependencies.dup
+      new_deps.each { |pkg_name, pkg_vers| hard_deps[pkg_name] = pkg_vers }
+
+      exp_deps = expand_local_packages hard_deps, true
+      core_fetch_dependencies exp_deps, :runtime, true
+
+      @dependencies = hard_deps
+      rebuild_dependencies hard_deps, verbose
+      
+      local_deps.each do |dep|
+        next if old_deps.find { |pkg| (pkg.name == dep.name) && (pkg.version == dep.version) }
+        puts "Added package '#{dep.name}' (#{dep.version})"
+      end
+
+      save!
+          
+    end
+
+    def remove_dependencies(package_names, verbose=false)
+
+      hard_deps = dependencies.dup
+      old_deps = build_local_deps false
+      
+      package_names.each do |pkg_name|
+        raise "'#{pkg_name}' is not a dependency" if hard_deps[pkg_name].nil?
+        hard_deps.delete pkg_name
+      end
+
+      @dependencies = hard_deps
+      rebuild_dependencies hard_deps, verbose
+      
+      old_deps.each do |dep|
+        next if local_deps.find { |pkg| (pkg.name == dep.name) && (pkg.version == dep.version) }
+        puts "Removed package '#{dep.name}' (#{dep.version})"
+      end
+        
+      save!
+      
+    end
+
+    def save!
+      @had_changes = false
+      File.open @json_path, 'w+' do |fd|
+        fd.write JSON.pretty_generate as_json
+      end
+    end
+    
+    def fetch_dependencies(verbose=false)
+      core_fetch_dependencies(dependencies, :runtime, verbose)
+    end
+
+    # Builds assets directory for dependent packages
+    def build(mode=:debug, verbose=false)
+      puts "Building static assets..." if verbose
+      pipeline = BPM::Pipeline.new self
+      asset_root = File.join root_path, 'assets'
+
+      pipeline.buildable_assets.each do |asset|
+        dst_path = File.join asset_root, asset.logical_path
+        FileUtils.mkdir_p File.dirname(dst_path)
+
+        if asset.kind_of? Sprockets::StaticAsset
+          puts "~ Copying #{asset.logical_path}" if verbose
+          FileUtils.rm dst_path if File.exists? dst_path
+          FileUtils.cp asset.pathname, dst_path
+        else
+          puts "~ Building #{asset.logical_path}" if verbose
+          File.open(dst_path, 'w+') { |fd| fd << asset.to_s }
+        end
+      end
+      
+      puts "\n" if verbose
+    end
+      
+    # Removes any built assets from the project.  Usually called before a
+    # package is removed from the project to cleanup any assets
+    def unbuild(verbose=false)
+      
+      puts "Removing stale assets..." if verbose
+      
+      pipeline = BPM::Pipeline.new self
+      asset_root = File.join root_path, 'assets'
+      pipeline.buildable_assets.each do |asset|
+        next if asset.logical_path =~ /^bpm_/
+        asset_path = File.join asset_root, asset.logical_path
+        next unless File.exists? asset_path
+        puts "~ Removing #{asset.logical_path}" if verbose
+        FileUtils.rm asset_path
+        
+        # cleanup empty directories
+        while !File.exists?(asset_path)
+          asset_path = File.dirname asset_path
+          FileUtils.rmdir(asset_path) if File.directory?(asset_path)
+          if verbose && !File.exists?(asset_path) 
+            puts "~ Removed empty directory #{File.basename asset_path}"
+          end
+        end
+      end
+      
+      puts "\n" if verbose
+    end
+    
+    # Returns the path on disk to reach a given package name
+    def path_from_package(package_name)
+      return root_path if package_name == self.name
+      path = local_deps.find { |pkg| pkg.name == package_name }
+      path && path.root_path
+    end
+    
+    # Returns the path on disk for a given module id (relative to the project)
+    def path_from_module(module_path)
+      path_parts   = module_path.to_s.split '/'
+      package_name = path_parts.shift
+      module_path = path_from_package(package_name)
+      if module_path
+        # expand package_name => package_name/main
+        path_parts = ['main'] if path_parts.size == 0
+    
+        # expand package_name/~dirname => package_name/mapped_dirname
+        if path_parts.first && path_parts.first =~ /^~/
+          dirname = path_parts.shift[1..-1]
+        else
+          dirname = 'lib'
+        end
+        pkg = BPM::Package.new(module_path)
+        pkg.load_json
+        dirname = (pkg && pkg.directories[dirname]) || dirname
+    
+        # join the rest of the path
+        module_path = [package_name, dirname, *path_parts] * '/'
+      end
+      
+      module_path
+    end
+    
+    # Returns the package object and module id for the path. Path must match
+    # a package known to the project.
+    def package_and_module_from_path(path)
+      path = File.expand_path path.to_s
+      pkg = local_deps.find {|cur| path =~ /^#{Regexp.escape cur.root_path.to_s}/}
+      pkg = self if pkg.nil? && path =~ /^#{Regexp.escape root_path.to_s}/
+      raise "#{path} is not within a known package" if pkg.nil?
+      
+      path = Pathname.new(path).relative_path_from(Pathname.new(pkg.root_path)).split.map { |x| x.to_s }
+      
+      dir_name = pkg.directories.find do |dir_key, dname| 
+        Array(dname).include?(path.first)
+      end
+      
+      dir_name = dir_name ? dir_name.first : path.first
+      if dir_name == 'lib'
+        path.shift
+      else
+        path[0] = "~#{dir_name}"
+      end
+            
+      path[path.size-1] = File.basename path.last, '.*'
+      [pkg, path.join('/')]
+    end
+    
+    def local_deps(verbose=false)
+      @local_deps ||= build_local_deps
+    end
+
+
+    # Verifies that packages are available to meet all the dependencies
+    def rebuild_dependencies(deps=nil, verbose=false)
+      
+      puts "Selecting local dependencies..." if verbose
+      
+      found = locate_dependencies deps||dependencies, verbose
+
+      install_root = File.join root_path, '.bpm', 'packages'
+      FileUtils.rm_r install_root if File.exists? install_root
+      FileUtils.mkdir_p install_root
+
+      found.each do |pkg|
+        dst_path = File.join install_root, pkg.name
+        FileUtils.ln_s pkg.root_path, dst_path
+      end
+      
+      @local_deps = nil
+    end
+    
+  private
+
+    def read
+      if File.exists? @json_path
+        super
+      else
+        @attributes = DEFAULT_CONFIG.dup
+        @attributes["name"] = File.basename(@json_path, '.json')
+        @attributes["version"] = "0.0.1"
+      end
+    end
+
+    def validate_fields
+      # TODO: Define other fields that are required for projects
+      %w[name].all? do |field|
+        value = send(field)
+        if value.nil? || value.size.zero?
+          add_error "Projects requires a '#{field}' field"
+        else
+          true
+        end
+      end
+    end
+    
+    # builds a set of dependencies that excludes locally installed packages
+    # and includes their dependencies instead.
+    def expand_local_packages(deps, verbose)
+      ret = {}
+      
+      todo = []
+      seen = []
+      
+      deps.each { |pkg_name, pkg_version| todo << [pkg_name, pkg_version] }
+      
+      while todo.size > 0
+        package_name, package_version = todo.shift
+        next if seen.include? package_name
+        seen << package_name
+        
+        package_root = File.join(@root_path, 'packages', package_name)
+        
+        if File.exists? package_root
+          pkg = BPM::Package.new package_root
+          pkg.load_json
+
+          req = LibGems::Requirement.new(package_version)
+          unless req.satisfied_by? LibGems::Version.new(pkg.version)
+            raise "Local package '#{pkg.name}' (#{pkg.version}) is not compatible with required version #{package_version}"
+          end
+           
+          puts "~ Using local package '#{pkg.name}' (#{pkg.version})" if verbose
+          pkg.dependencies.each do |pkg_name, pkg_vers| 
+            todo << [pkg_name, pkg_vers]
+          end
+          
+        else
+          ret[package_name] = package_version
+        end
+      end
+      
+      ret
+    end
+    
+    # Fetch any dependencies into local cache for the passed set of deps
+    def core_fetch_dependencies(deps, kind, verbose)
+      puts "Fetching packages from remote..." if verbose
+      deps.each do |pkg_name, pkg_version|
+        core_fetch_dependency pkg_name, pkg_version, kind, verbose
+      end
+    end 
+  
+    def core_fetch_dependency(package_name, vers, kind, verbose)
+      
+      prerelease = false
+      if vers == '>= 0-pre'
+        prerelease = true
+        vers = '>= 0'
+      else
+        prerelease = vers =~ /[a-zA-Z]/
+      end
+
+      dep = LibGems::Dependency.new(package_name, vers, kind)
+      cur_installed = LibGems.source_index.search(dep)
+
+      # TODO: Why are we fetching even if we already have it? Are we looking for newer versions?
+      installed = BPM::Remote.new.install(package_name, vers, prerelease)
+
+      cur_installed.each do |ci|
+        installed.reject! { |i| ci.name == i.name && ci.version == i.version }
+      end
+
+      installed.each do |i|
+        puts "Fetched #{i.name} (#{i.version}) from remote" if verbose 
+      end
+      
+    end
+
+    def build_local_deps(force=true)
+      install_root = File.join root_path, '.bpm', 'packages'
+      unless File.exists? install_root
+        return nil if !force
+        rebuild_dependencies 
+      end
+      
+      Dir[File.join(install_root, '*')].map do |package_name|
+        pkg = BPM::Package.new package_name
+        pkg.load_json
+        pkg
+      end
+    end
+
+    def has_local_package?(package_name)
+      package_root = File.join @root_path, 'packages', package_name
+      File.exists? package_root
+    end
+
+    def satisfied_by?(req_vers, new_vers)
+      req = LibGems::Requirement.new req_vers
+      req_vers.sub(/^= /,'') == new_vers.sub(/^= /,'') ||
+      req.satisfied_by?(LibGems::Version.new(new_vers)) 
+    end
+
+    def clean_version(vers)
+      if vers == '>= 0-pre'
+        prerel = true
+        vers   = '>= 0'
+      else
+        prerel = vers =~ /[a-zA-Z]/
+      end
+      [vers, prerel]
+    end
+    
+    def locate_dependencies(deps, verbose)
+      todo = []
+      seen = []
+      ret  = []
+      
+      deps.each { |package_name, vers| todo << [package_name, vers] }
+      
+      while todo.size > 0
+        package_name, vers = todo.shift
+        
+        if seen.include? package_name
+
+          # already seen - verify requirements are not in conflict
+          pkg = ret.find { |p| p.name == package_name }
+          unless satisfied_by? vers, pkg.version
+            raise "Conflicting dependencies '#{package_name}' requires #{pkg.version} and #{vers}"
+          end
+          
+          next
+        end
+
+        seen << package_name
+
+        # Find locally installed or fetched package
+        pkg = locate_package package_name, vers, verbose
+
+        if pkg.nil?
+          raise "Could not find eligable package for '#{package_name}' (#{vers})"
+        end
+
+        # Add dependencies for found package to list
+        pkg.dependencies.each do |dep_name, dep_vers|
+          todo << [dep_name, dep_vers]
+        end
+        
+        ret << pkg
+      end
+      
+      ret
+    end
+    
+    def locate_package(package_name, vers, verbose)
+      if has_local_package? package_name 
+        src_path = File.join root_path, 'packages', package_name
+        pkg = BPM::Package.new src_path
+        pkg.load_json
+        puts "~ Using local package '#{pkg.name}' (#{pkg.version})" if verbose
+      else
+        vers, prerel = clean_version vers
+        src_path = BPM::Local.new.source_root package_name, vers, prerel
+        if src_path
+          pkg = BPM::Package.new src_path
+          pkg.load_json
+          puts "~ Using fetched package '#{pkg.name}' (#{pkg.version})" if verbose
+        end
+      end
+      
+      pkg
+    end
+    
+  end
+
+end