bpm 0.1.0

data/lib/bpm/cli/owner.rb

@@ -0,0 +1,46 @@
+module BPM::CLI
+  class Owner < Thor
+    default_task :list
+
+    desc "list [PACKAGE]", "Display owners of a package"
+    def list(package)
+      remote = BPM::Remote.new
+      if remote.logged_in?
+        yaml   = remote.list_owners(package)
+        owners = YAML.load(yaml)
+
+        if owners.is_a?(Array)
+          say "Owners for package: #{package}"
+          owners.each do |owner|
+            say "- #{owner['email']}"
+          end
+        else
+          say owners
+        end
+      else
+        abort LOGIN_MESSAGE
+      end
+    end
+
+    desc "add [PACKAGE] [EMAIL]", "Allow another user to push new versions of your bpm package"
+    def add(package, email)
+      remote = BPM::Remote.new
+      if remote.logged_in?
+        say remote.add_owner(package, email)
+      else
+        abort LOGIN_MESSAGE
+      end
+    end
+
+    desc "remove [PACKAGE] [EMAIL]", "Allow another user to push new versions of your bpm package"
+    def remove(package, email)
+      remote = BPM::Remote.new
+      if remote.logged_in?
+        say remote.remove_owner(package, email)
+      else
+        abort LOGIN_MESSAGE
+      end
+    end
+  end
+end
+

data/lib/bpm/credentials.rb

@@ -0,0 +1,36 @@
+module BPM
+  class Credentials
+    attr_reader :email, :api_key
+
+    def initialize
+      parse
+    end
+
+    def save(email, api_key)
+      @email   = email
+      @api_key = api_key
+      write
+    end
+
+    private
+
+    def write
+      FileUtils.mkdir_p(File.dirname(path))
+      File.open(path, "w") do |file|
+        file.write YAML.dump(:bpm_api_key => api_key, :bpm_email => email)
+      end
+    end
+
+    def path
+      LibGems.configuration.credentials_path
+    end
+
+    def parse
+      if File.exist?(path)
+        hash     = YAML.load_file(path)
+        @email   = hash[:bpm_email]
+        @api_key = hash[:bpm_api_key]
+      end
+    end
+  end
+end

data/lib/bpm/default.json

@@ -0,0 +1,9 @@
+{
+  "directories": {
+    "lib":        "./lib",
+    "test":       "./tests"
+  },
+  
+  "dependencies": {
+  }
+}

data/lib/bpm/generator.rb

@@ -0,0 +1,69 @@
+require 'thor'
+require 'bpm'
+
+module BPM
+
+  def self.generators
+    @generators ||= {}
+  end
+
+  def self.register_generator(pkg, type, generator)
+    generators[pkg] ||= {}
+    generators[pkg][type] = generator
+  end
+
+  def self.generator_for(pkg_or_type, type=nil, default=true)
+    if type
+      pkg = pkg_or_type
+    else
+      pkg = :default
+      type = pkg_or_type
+    end
+
+    generator = generators[pkg] && generators[pkg][type]
+    generator ||= generators[:default] && generators[:default][type] if default
+    generator
+  end
+
+  # Knows how to generate items out of the local templates directory
+  class Generator
+    include Thor::Actions
+
+    attr_reader :name
+
+    def initialize(thor, name, root, template_path=nil)
+      @thor, @name, @template_path = thor, name, template_path
+
+      self.destination_root = root
+    end
+
+    def dir_name
+      File.basename destination_root
+    end
+
+    def source_paths
+      [@template_path, self.class.source_root].compact
+    end
+
+  private
+
+    def app_const
+      name.gsub(/\W|-/, '_').squeeze('_').gsub(/(?:^|_)(.)/) { $1.upcase }
+    end
+
+    def current_year
+      Time.now.year
+    end
+
+    def respond_to?(*args)
+      super || @thor.respond_to?(*args)
+    end
+
+    def method_missing(name, *args, &blk)
+      @thor.send(name, *args, &blk)
+    end
+  end
+end
+
+require 'bpm/init_generator'
+require 'bpm/project_generator'

data/lib/bpm/init_generator.rb

@@ -0,0 +1,43 @@
+require 'bpm/version'
+
+module BPM
+  class InitGenerator < BPM::Generator
+
+    source_root File.join(::BPM::TEMPLATES_DIR, 'init')
+
+    def bpm_version
+      BPM::VERSION
+    end
+
+    def run
+      if File.exist?("package.json")
+        convert_package(destination_root)
+      else
+        template "project.json", "#{name}.json"
+      end
+
+      empty_directory "assets"
+
+      inside "assets" do
+        template "bpm_packages.js"
+        template "bpm_styles.css"
+      end
+
+      true
+    end
+
+    private
+
+      def convert_package(destination_root)
+        package = BPM::Package.new(destination_root)
+        package.load_json
+        File.open("#{name}.json", "w") do |f|
+          f.write JSON.pretty_generate(package.as_json)
+        end
+        puts "created #{name}.json from package.json"
+      end
+
+  end
+end
+
+BPM.register_generator(:default, :init, BPM::InitGenerator)

data/lib/bpm/libgems_ext.rb

@@ -0,0 +1,11 @@
+require 'bpm/libgems_ext/libgems'
+require 'bpm/libgems_ext/config_file'
+require 'bpm/libgems_ext/dependency_installer'
+require 'bpm/libgems_ext/installer'
+require 'bpm/libgems_ext/spec_fetcher'
+
+# Empty sources to make sure we don't get ones from RubyGems
+LibGems.sources = nil
+
+# Reload from new paths
+LibGems.load_configuration

data/lib/bpm/libgems_ext/config_file.rb

@@ -0,0 +1,33 @@
+require 'libgems/config_file'
+
+module LibGems
+  class ConfigFile
+
+    # Duplicate, with slight work-arounds, but needed for SYSTEM_WIDE_CONFIG_FILE
+    system_config_path =
+      if defined?(Win32API) # Already required in original version
+        CSIDL_COMMON_APPDATA = 0x0023
+        path = 0.chr * 260
+        if RUBY_VERSION > '1.9' then
+          SHGetFolderPath = Win32API.new 'shell32', 'SHGetFolderPath', 'PLPLP',
+                                         'L', :stdcall
+          SHGetFolderPath.call nil, CSIDL_COMMON_APPDATA, nil, 1, path
+        else
+          SHGetFolderPath = Win32API.new 'shell32', 'SHGetFolderPath', 'LLLLP',
+                                         'L'
+          SHGetFolderPath.call 0, CSIDL_COMMON_APPDATA, 0, 1, path
+        end
+
+        path.strip
+      else
+        '/etc'
+      end
+
+    remove_const(:SYSTEM_WIDE_CONFIG_FILE)
+    SYSTEM_WIDE_CONFIG_FILE = File.join system_config_path, 'bpmrc'
+
+    def credentials_path
+      File.join(LibGems.user_dir, "credentials")
+    end
+  end
+end

data/lib/bpm/libgems_ext/dependency_installer.rb

@@ -0,0 +1,150 @@
+require 'libgems/dependency_installer'
+
+module LibGems
+  class DependencyInstaller
+
+    # Had to overwrite this all just to change the match from /gem$/ to /spd$/
+    # TODO: Consider whether extension should be settable in LibGems
+    def find_spec_by_name_and_version(gem_name,
+                                      version = LibGems::Requirement.default,
+                                      prerelease = false)
+      spec_and_source = nil
+
+      glob = if File::ALT_SEPARATOR then
+               gem_name.gsub File::ALT_SEPARATOR, File::SEPARATOR
+             else
+               gem_name
+             end
+
+      local_gems = Dir["#{glob}*"].sort.reverse
+
+      unless local_gems.empty? then
+        local_gems.each do |gem_file|
+          next unless gem_file =~ /spd$/
+          begin
+            spec = LibGems::Format.from_file_by_path(gem_file).spec
+            spec_and_source = [spec, gem_file]
+            break
+          rescue SystemCallError, LibGems::Package::FormatError
+          end
+        end
+      end
+
+      if spec_and_source.nil? then
+        dep = LibGems::Dependency.new gem_name, version
+        dep.prerelease = true if prerelease
+        spec_and_sources = find_gems_with_sources(dep).reverse
+
+        spec_and_source = spec_and_sources.find { |spec, source|
+          LibGems::Platform.match spec.platform
+        }
+      end
+
+      if spec_and_source.nil? then
+        raise LibGems::GemNotFoundException.new(
+          "Could not find #{prerelease ? 'prerelease ' : ''}package '#{gem_name}' (#{version}) locally or in a repository",
+          gem_name, version, @errors)
+      end
+
+      @specs_and_sources = [spec_and_source]
+    end
+
+    # Overwrite this to use our custom installer
+    def install dep_or_name, version = LibGems::Requirement.default
+      LibGems.with_rubygems_compat do
+        if String === dep_or_name then
+          find_spec_by_name_and_version dep_or_name, version, @prerelease
+        else
+          dep_or_name.prerelease = @prerelease
+          @specs_and_sources = [find_gems_with_sources(dep_or_name).last]
+        end
+
+        @installed_gems = []
+
+        gather_dependencies
+
+        @gems_to_install.each do |spec|
+          last = spec == @gems_to_install.last
+          # HACK is this test for full_name acceptable?
+          next if @source_index.any? { |n,_| n == spec.full_name } and not last
+
+          # TODO: make this sorta_verbose so other users can benefit from it
+          say "Installing spd #{spec.full_name}" if LibGems.configuration.really_verbose
+
+          _, source_uri = @specs_and_sources.assoc spec
+          begin
+            local_gem_path = LibGems::RemoteFetcher.fetcher.download spec, source_uri,
+                                                                 @cache_dir
+          rescue LibGems::RemoteFetcher::FetchError
+            next if @force
+            raise
+          end
+
+          inst = LibGems::Installer.new local_gem_path,
+                                    :bin_dir             => @bin_dir,
+                                    :development         => @development,
+                                    :env_shebang         => @env_shebang,
+                                    :force               => @force,
+                                    :format_executable   => @format_executable,
+                                    :ignore_dependencies => @ignore_dependencies,
+                                    :install_dir         => @install_dir,
+                                    :security_policy     => @security_policy,
+                                    :source_index        => @source_index,
+                                    :user_install        => @user_install,
+                                    :wrappers            => @wrappers
+
+          spec = inst.install
+
+          @installed_gems << spec
+        end
+
+        @installed_gems
+      end
+    end
+
+    def find_gems_with_sources(dep)
+      # Reset the errors
+      @errors = nil
+      gems_and_sources = []
+
+      if @domain == :both or @domain == :local then
+        Dir[File.join(Dir.pwd, "#{dep.name}-[0-9]*.spd")].each do |gem_file|
+          spec = LibGems::Format.from_file_by_path(gem_file).spec
+          gems_and_sources << [spec, gem_file] if spec.name == dep.name
+        end
+      end
+
+      if @domain == :both or @domain == :remote then
+        begin
+          requirements = dep.requirement.requirements.map do |req, ver|
+            req
+          end
+
+          all = !dep.prerelease? &&
+                # we only need latest if there's one requirement and it is
+                # guaranteed to match the newest specs
+                (requirements.length > 1 or
+                  (requirements.first != ">=" and requirements.first != ">"))
+
+          found, @errors = LibGems::SpecFetcher.fetcher.fetch_with_errors dep, all, true, dep.prerelease?
+
+          gems_and_sources.push(*found)
+
+        rescue LibGems::RemoteFetcher::FetchError => e
+          if LibGems.configuration.really_verbose then
+            say "Error fetching remote data:\t\t#{e.message}"
+            say "Falling back to local-only install"
+          end
+          @domain = :local
+        end
+      end
+
+      gems_and_sources.sort_by do |gem, source|
+        [gem, source =~ /^http:\/\// ? 0 : 1] # local gems win
+      end
+    end
+
+  end
+end
+
+

data/lib/bpm/libgems_ext/installer.rb

@@ -0,0 +1,39 @@
+require 'libgems/installer'
+
+module LibGems
+  class Installer
+
+    def app_script_text(bin_file_name)
+      <<-TEXT
+#{shebang bin_file_name}
+#
+# This file was generated by BPM.
+#
+# The application '#{@spec.name}' is installed as part of an spd, and
+# this file is here to facilitate running it.
+#
+
+version = "#{LibGems::Requirement.default}"
+
+if ARGV.first =~ /^_(.*)_$/ and LibGems::Version.correct? $1 then
+  version = $1
+  ARGV.shift
+end
+
+gem '#{@spec.name}', version
+
+path = LibGems.bin_path('#{@spec.name}', '#{bin_file_name}', version)
+shebang = File.open(path){|f| f.readline }
+
+if shebang =~ /^\#\!.*ruby/
+  load path
+else
+  exec path, *ARGV
+end
+TEXT
+    end
+
+  end
+end
+
+