bpm 0.1.0

data/lib/bpm/libgems_ext/libgems.rb

@@ -0,0 +1,39 @@
+require 'libgems'
+
+module LibGems
+  def self.default_sources
+    %w[https://sproutcutter.heroku.com/]
+  end
+
+  def self.host
+    @host ||= "https://sproutcutter.heroku.com"
+  end
+
+  def self.default_dir
+    File.join LibGems.user_home, BPM::BPM_DIR
+  end
+
+  def self.user_dir
+    File.join LibGems.user_home, BPM::BPM_DIR
+  end
+
+  def self.config_file
+    File.join LibGems.user_home, '.bpmrc'
+  end
+
+  def self.path
+    @gem_path ||= nil
+
+    unless @gem_path then
+      paths = [ENV['BPM_PATH'] || LibGems.configuration.path || default_path]
+      set_paths paths.compact.join(File::PATH_SEPARATOR)
+    end
+
+    @gem_path
+  end
+
+  def self.dir
+    set_home(ENV['BPM_HOME'] || LibGems.configuration.home || default_dir) unless @gem_home
+    @gem_home
+  end
+end

data/lib/bpm/libgems_ext/spec_fetcher.rb

@@ -0,0 +1,11 @@
+require 'libgems/spec_fetcher'
+
+module LibGems
+  class SpecFetcher
+    alias :orig_initialize :initialize
+    def initialize(*args)
+      orig_initialize(*args)
+      @dir = File.join LibGems.dir, 'specs'
+    end
+  end
+end

data/lib/bpm/local.rb

@@ -0,0 +1,76 @@
+require 'libgems/uninstaller'
+
+module BPM
+  class Local < Repository
+    def uninstall(package)
+      LibGems::Uninstaller.new(package).uninstall
+      true
+    rescue LibGems::InstallError
+      false
+    end
+
+    def pack(path, email=nil)
+      package_path = File.dirname(File.expand_path path)
+      cur_pwd = Dir.pwd
+
+      FileUtils.cd package_path if package_path != cur_pwd
+      package = BPM::Package.new(nil, email || creds.email)
+      package.json_path = File.basename path
+      
+      
+      if package.valid?
+        silence do
+          LibGems::Builder.new(package.to_spec).build
+        end
+      end
+
+      FileUtils.cd cur_pwd if package_path != cur_pwd
+      package
+    end
+
+    def unpack(path, target)
+      package       = BPM::Package.new
+      package.bpkg  = path
+      unpack_dir    = File.expand_path(File.join(Dir.pwd, target, package.to_full_name))
+      LibGems::Installer.new(path, :unpack => true).unpack unpack_dir
+      package
+    end
+
+    def installed(packages)
+      specs = LibGems.source_index.search dependency_for(packages)
+
+      specs.map do |spec|
+        [spec.name, spec.version, spec.original_platform]
+      end
+    end
+    
+    def preferred_version(package, vers, prerelease)
+      dep = LibGems::Dependency.new package, vers
+      specs = LibGems.source_index.search dep
+      specs.last.version.to_s
+    end
+
+    def source_root(package, vers, prerelease)
+      dep = LibGems::Dependency.new package, vers
+      specs = LibGems.source_index.search dep
+
+      dep2 = LibGems::Dependency.new package, '>= 0'
+      specs2 = LibGems.source_index.search dep2 
+
+      spec = specs.last
+      spec &&
+      File.join(spec.installation_path, 'gems', "#{spec.name}-#{spec.version}") 
+    end
+    
+    private
+
+    def silence
+      original_verbose = LibGems.configuration.verbose
+      LibGems.configuration.verbose = false
+      yield
+    ensure
+      LibGems.configuration.verbose = original_verbose
+    end
+  end
+end
+

data/lib/bpm/package.rb

@@ -0,0 +1,277 @@
+require 'json'
+
+module BPM
+  class Package
+    EXT      = "spd"
+    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
+
+    def self.from_spec(spec)
+      pkg = new(spec.full_gem_path)
+      pkg.bpkg = 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 bpm
+      @bpm || BPM::VERSION
+    end
+
+    def bpkg=(spec)
+      unless spec.is_a?(LibGems::Specification)
+        spec = LibGems::Format.from_file_by_path(spec.to_s).spec
+      end
+      fill_from_gemspec(spec)
+    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 + ["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.rubyforge_project = "bpm"
+        def spec.file_name
+          "#{full_name}.#{EXT}"
+        end
+        dependencies.each{|d,v| spec.add_dependency(d, v) } if dependencies
+      end
+    end
+
+    def as_json(options = {})
+      json = self.metadata.clone
+      FIELDS.each{|key| json[key] = send(key)}
+      json["dependencies"] = self.dependencies
+      json
+    end
+
+    def to_json
+      as_json.to_json
+    end
+
+    def to_full_name
+      "#{name}-#{version}"
+    end
+
+    def to_ext
+      "#{self.to_full_name}.#{EXT}"
+    end
+
+    def template_path(name)
+      path = File.join(root_path, 'templates', name.to_s)
+      File.exist?(path) ? path : nil
+    end
+
+    def generator_for(type)
+      unless generator = BPM.generator_for(name, type, false)
+        path = File.join(root_path, 'templates', "#{type}_generator.rb")
+        load path if File.exist?(path)
+        generator = BPM.generator_for(name, type)
+      end
+      generator
+    end
+
+    def errors
+      @errors ||= []
+    end
+
+    def validate
+      validate_fields && validate_version && validate_paths
+    end
+
+    def valid?
+      load_json && validate
+    end
+
+    def has_json?
+      File.exist?(json_path)
+    end
+
+    def load_json
+      read && parse
+    end
+
+    # TODO: Make better errors
+    # TODO: This might not work well with conflicting versions
+    def local_deps(search_path=nil)
+      search_path ||= File.join(root_path, "packages")
+
+      dependencies.inject([]) do |list, (name, version)|
+        package = Package.new(File.join(search_path, name))
+        requirement = LibGems::Requirement.new(version)
+        if package.has_json?
+          package.load_json
+        else
+          raise "Can't find package #{name} required in #{self.name}"
+        end
+        unless requirement.satisfied_by?(LibGems::Version.new(package.version))
+          raise "#{name} (#{package.version}) doesn't match #{version} required in #{self.name}"
+        end
+        (package.local_deps(search_path) << package).each do |dep|
+          list << dep unless list.any?{|d| d.name == dep.name }
+        end
+        list
+      end
+    end
+
+    def directory_files
+      directories.reject{|k,_| k == 'tests' }.values.map{|dir| glob_files(dir) }.flatten
+    end
+
+    def bin_files
+      if @attributes["bin"]
+        @attributes["bin"].values
+      else
+        []
+      end
+    end
+
+    def template_files
+      glob_files("templates")
+    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)
+    end
+
+    def plugin_modules(key_name, project)
+      return [@attributes[key_name]] if @attributes[key_name]
+      dependencies.keys.map do |pkg_name| 
+        dep = project.local_deps.find do |pkg| 
+          pkg.load_json
+          pkg.name == pkg_name
+        end
+        dep.attributes[key_name]
+      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
+
+      if paths = [*lib_path]
+        non_dirs = paths.reject{|p| File.directory?(File.join(@root_path, p))}
+        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"
+          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
+
+      success
+    end
+
+    def validate_version
+      LibGems::Version.new(version)
+      true
+    rescue ArgumentError => ex
+      add_error ex.to_s
+    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
+        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 }
+
+      if spec.requirements && spec.requirements.size>0
+        self.metadata = JSON.parse(spec.requirements.first)
+      end
+    end
+
+  end
+end
+

data/lib/bpm/pipeline.rb

@@ -0,0 +1,100 @@
+require 'sprockets'
+
+module BPM
+
+  autoload :DirectiveProcessor,   'bpm/pipeline/directive_processor'
+  autoload :GeneratedAsset,       'bpm/pipeline/generated_asset'
+  autoload :TransportProcessor,   'bpm/pipeline/transport_processor'
+  
+  # A BPM package-aware asset pipeline.  Asset lookup respects package.json
+  # directory configurations as well as loading preprocessors, formats, and
+  # postprocessors from the package config.
+  #
+  class Pipeline < Sprockets::Environment
+    
+    attr_reader :project
+    
+    # Pass in the project you want the pipeline to manage.
+    def initialize(project)
+      @project = project
+      project_path = project.root_path
+
+      super project_path
+
+      # use custom directive processor
+      %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
+      
+
+      # configure search paths
+      append_path File.join project_path, '.bpm', 'packages'
+      append_path File.dirname project_path
+      append_path File.join project_path, 'assets'
+    end    
+      
+    # Loads the passed JavaScript file and evals it.  Used for loading 
+    # transport and other plugins.
+    def js_context_for(path)
+      @js_contexts ||= {}
+      @js_contexts[path] ||= build_js_context(path)
+    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
+      
+      # make sure the logical_path can be used to simply build into the 
+      # assets directory when we are done
+      ret = ['bpm_packages.js', 'bpm_styles.css']
+      
+      project.local_deps.each do |pkg|
+        pkg.load_json
+        pkg.pipeline_assets.each do |dir|
+          dir_name = pkg.directories[dir] || dir
+          dir_name.sub! /^\.?\//, ''
+          pkg_root = File.join(pkg.root_path, dir_name)
+          Dir[File.join(pkg_root, '**', '*')].each do |fn|
+            fn.sub! /^#{Regexp.escape pkg_root}\//, ''
+            ret << File.join(pkg.name, dir_name, fn)
+          end
+        end
+      end
+
+      ret.sort.map { |x| find_asset x }.compact
+    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)
+      magic_paths = %w(bpm_packages.js bpm_styles.css).map do |filename|
+        File.join project.root_path, 'assets', 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
+    
+  private
+  
+    def build_js_context(path)
+      require 'v8'
+      
+      ctx = V8::Context.new do |ctx|
+        ctx['exports'] = {}
+        ctx.eval "(function(exports) { #{File.read path} })(exports);"
+      end
+      
+      @js_contexts[path] = ctx
+    end
+    
+        
+  end
+  
+end