arpm 0.9.0

data/lib/arpm/config.rb

@@ -0,0 +1,16 @@
+module ARPM
+  class Config
+
+    def self.base_directory
+      if OS.windows?
+        lib_dir = "/My Documents/Arduino/libraries/"
+      else OS.mac?
+        lib_dir = "/Documents/Arduino/libraries/"
+      end
+
+      base = File.expand_path("~")
+
+      "#{base}#{lib_dir}"
+    end
+  end
+end

data/lib/arpm/libfile.rb

@@ -0,0 +1,33 @@
+module ARPM
+  class Libfile
+
+    attr_accessor :content
+
+    def initialize(content)
+      @content = content
+    end
+
+    def self.location
+      Dir.pwd + "/Libfile"
+    end
+
+    def dependencies
+
+      packages = []
+
+      content.gsub!(/\r\n?/, "\n")
+      content.each_line do |line|
+
+        if line.start_with?('lib')
+            elements = line.scan(/"([^"]*)"/) + line.scan(/'([^']*)'/)
+            packages << {elements[0][0] => elements[1][0]}
+        end
+
+      end
+
+      packages
+
+    end
+
+  end
+end

data/lib/arpm/list.rb

@@ -0,0 +1,106 @@
+module ARPM
+  class List
+
+    def self.register(package, version)
+      # Make sure the list exists
+      FileUtils.touch(path) unless File.exists?(path)
+
+      packages = JSON.parse(File.read(path)) rescue []
+
+      # Is any version of this pacakge installed?
+      if ARPM::List.includes?(package.name)
+
+        # Is this version already installed?
+        unless ARPM::List.includes?(package.name, version)
+
+          # No it isn't, so add this version to the list
+          packages.select { |p| p.keys[0] == package.name }.first[package.name] << version
+
+        end
+
+      else
+
+        # It isn't so add the whole package
+        packages << {package.name => [version]}
+
+      end
+
+      # Write that shit down
+      f = File.open(path, 'w')
+      f.write(JSON.generate(packages, :quirks_mode => true))
+      f.close
+
+    end
+
+    def self.unregister(package, version)
+
+      packages = JSON.parse(File.read(path)) rescue []
+
+      # Is any version of this pacakge installed?
+      if ARPM::List.includes?(package.name)
+        if package.installed_versions.size > 0
+
+          # Get the remaining versions
+          remaining_versions = packages.select { |p| p.keys[0] == package.name }.first[package.name] - [version]
+
+          packages.select { |p| p.keys[0] == package.name }.first[package.name] = remaining_versions
+        else
+          packages.delete(package.name)
+        end
+      end
+
+      # Write that shit down
+      f = File.open(path, 'w')
+      f.write(JSON.generate(packages, :quirks_mode => true))
+      f.close
+
+    end
+
+    def self.includes?(package_name, version = nil)
+
+      # Get all the packages
+      packages = JSON.parse(File.read(path)) rescue []
+
+      # Search for the specified package
+      list_package = packages.select { |p| p.keys[0] == package_name }
+
+      # Was the version specified?
+      if version
+
+        # Yes, so only return yes if the specified version is installed
+        return list_package.first[package_name].include?(version)
+
+      else
+
+        # No, so return yes if any versions of the package are installed
+        return list_package.first
+      end
+    end
+
+    def self.versions(package_name)
+      # Get all the packages
+      packages = JSON.parse(File.read(path)) rescue []
+
+      # Search for the specified package
+      list_package = packages.select { |p| p.keys[0] == package_name }.first
+
+      # Return an array of the versions
+      list_package[package_name]
+
+    end
+
+    def self.all
+      # Get all the packages
+      packages = JSON.parse(File.read(path)) rescue []
+
+      packages
+    end
+
+    private
+
+    def self.path
+      ARPM::Config.base_directory + "/arpm.txt"
+    end
+
+  end
+end

data/lib/arpm/os.rb

@@ -0,0 +1,17 @@
+module OS
+  def OS.windows?
+    (/cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM) != nil
+  end
+
+  def OS.mac?
+   (/darwin/ =~ RUBY_PLATFORM) != nil
+  end
+
+  def OS.unix?
+    !OS.windows?
+  end
+
+  def OS.linux?
+    OS.unix? and not OS.mac?
+  end
+end

data/lib/arpm/package.rb

@@ -0,0 +1,120 @@
+module ARPM
+  class Package
+
+    attr_accessor :name
+    attr_accessor :authors
+    attr_accessor :versions
+    attr_accessor :repository
+
+    def initialize(opts = {})
+      opts.each { |k,v| instance_variable_set("@#{k}", v) }
+    end
+
+    # Search for a new package
+    def self.search(name, exact_match = true)
+
+      # Grab the package list
+      data = URI.parse("https://raw.githubusercontent.com/alfo/arpm/master/packages.json").read
+      packages = JSON.parse(data)
+
+      if exact_match
+
+        # Search the packages for one with the same name
+        remote_packages = packages.select { |p| p['name'] == name }
+
+      else
+
+        # Search for packages with similar names and return them
+        remote_packages = packages.select { |p| p['name'].include? name }
+
+      end
+
+      # Did the search return any results?
+      if remote_packages.any?
+
+        packages = []
+        remote_packages.each do |remote_package|
+
+          # Get a list of tags from the remote repo
+          tags = Git::Lib.new.ls_remote(remote_package["repository"])["tags"]
+
+          # Delete any tags that aren't version numbers
+          tags.each { |t| tags.delete(t) unless t[0].is_number? }
+
+          # Sort the tags newest to oldest
+          versions = Hash[tags.sort.reverse]
+
+          # Create a new package object and return it
+          packages << Package.new(:name => remote_package["name"],
+                      :authors => remote_package["authors"],
+                      :repository => remote_package["repository"],
+                      :versions => versions)
+
+        end
+
+        if exact_match
+          return packages.first
+        else
+          return packages
+        end
+
+      else
+        # The package doesn't exist, so return false
+        false
+      end
+    end
+
+    def latest_version
+      if versions.kind_of?(Array)
+        versions.first
+      else
+        versions.keys.first.to_s
+      end
+    end
+
+    def install_path(version = nil)
+
+      # Take the latest_version unless it's been specified
+      version = latest_version unless version
+
+      # Creat the install path
+      path = ARPM::Config.base_directory + name
+
+      # Arduino doesn't like dots or dashes in library names
+      path = path + "_#{version.gsub('.', '_')}"
+
+    end
+
+    def install(version)
+      # Clone the repository!
+      repo = Git.clone(repository, install_path(version))
+
+      # It does, so checkout the right version
+      repo.checkout("tags/#{version}")
+
+      # Register the package to the list
+      register(version)
+    end
+
+    def uninstall(version)
+      # Remove the files
+      FileUtils.rm_r(install_path(version)) rescue ""
+
+      # Unregister it
+      unregister(version)
+    end
+
+    def register(version)
+      ARPM::List.register(self, version)
+    end
+
+    def unregister(version)
+      ARPM::List.unregister(self, version)
+    end
+
+    def installed_versions
+      ARPM::List.versions(self.name)
+    end
+
+  end
+end

data/lib/arpm/string.rb

@@ -0,0 +1,24 @@
+class String
+    def black;          "\033[30m#{self}\033[0m" end
+    def red;            "\033[31m#{self}\033[0m" end
+    def green;          "\033[32m#{self}\033[0m" end
+    def  brown;         "\033[33m#{self}\033[0m" end
+    def blue;           "\033[34m#{self}\033[0m" end
+    def magenta;        "\033[35m#{self}\033[0m" end
+    def cyan;           "\033[36m#{self}\033[0m" end
+    def gray;           "\033[37m#{self}\033[0m" end
+    def bg_black;       "\033[40m#{self}\0330m"  end
+    def bg_red;         "\033[41m#{self}\033[0m" end
+    def bg_green;       "\033[42m#{self}\033[0m" end
+    def bg_brown;       "\033[43m#{self}\033[0m" end
+    def bg_blue;        "\033[44m#{self}\033[0m" end
+    def bg_magenta;     "\033[45m#{self}\033[0m" end
+    def bg_cyan;        "\033[46m#{self}\033[0m" end
+    def bg_gray;        "\033[47m#{self}\033[0m" end
+    def bold;           "\033[1m#{self}\033[22m" end
+    def reverse_color;  "\033[7m#{self}\033[27m" end
+
+    def is_number?
+      true if Float(self) rescue false
+    end
+end

data/lib/arpm/vendor/ruby-git/git.rb

@@ -0,0 +1,148 @@
+# Add the directory containing this file to the start of the load path if it
+# isn't there already.
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'git/author'
+require 'git/base'
+require 'git/branch'
+require 'git/branches'
+require 'git/diff'
+require 'git/index'
+require 'git/lib'
+require 'git/log'
+require 'git/object'
+require 'git/path'
+require 'git/remote'
+require 'git/repository'
+require 'git/status'
+require 'git/stash'
+require 'git/stashes'
+require 'git/working_directory'
+
+lib = Git::Lib.new(nil, nil)
+unless lib.meets_required_version?
+  $stderr.puts "[WARNING] The git gem requires git #{lib.required_command_version.join('.')} or later, but only found #{lib.current_command_version.join('.')}. You should probably upgrade."
+end
+
+# Git/Ruby Library
+#
+# This provides bindings for working with git in complex
+# interactions, including branching and merging, object
+# inspection and manipulation, history, patch generation
+# and more.  You should be able to do most fundamental git
+# operations with this library.
+#
+# This module provides the basic functions to open a git
+# reference to work with. You can open a working directory,
+# open a bare repository, initialize a new repo or clone an
+# existing remote repository.
+#
+# Author::    Scott Chacon (mailto:schacon@gmail.com)
+# License::   MIT License
+module Git
+
+  #g.config('user.name', 'Scott Chacon') # sets value
+  #g.config('user.email', 'email@email.com')  # sets value
+  #g.config('user.name')  # returns 'Scott Chacon'
+  #g.config # returns whole config hash
+  def config(name = nil, value = nil)
+    lib = Git::Lib.new
+    if(name && value)
+      # set value
+      lib.config_set(name, value)
+    elsif (name)
+      # return value
+      lib.config_get(name)
+    else
+      # return hash
+      lib.config_list
+    end
+  end
+
+  def global_config(name = nil, value = nil)
+    self.class.global_config(name, value)
+  end
+
+  # open a bare repository
+  #
+  # this takes the path to a bare git repo
+  # it expects not to be able to use a working directory
+  # so you can't checkout stuff, commit things, etc.
+  # but you can do most read operations
+  def self.bare(git_dir, options = {})
+    Base.bare(git_dir, options)
+  end
+
+  # clones a remote repository
+  #
+  # options
+  #   :bare => true (does a bare clone)
+  #   :repository => '/path/to/alt_git_dir'
+  #   :index => '/path/to/alt_index_file'
+  #
+  # example
+  #  Git.clone('git://repo.or.cz/rubygit.git', 'clone.git', :bare => true)
+  #
+  def self.clone(repository, name, options = {})
+    Base.clone(repository, name, options)
+  end
+
+  # Export the current HEAD (or a branch, if <tt>options[:branch]</tt>
+  # is specified) into the +name+ directory, then remove all traces of git from the
+  # directory.
+  #
+  # See +clone+ for options.  Does not obey the <tt>:remote</tt> option,
+  # since the .git info will be deleted anyway; always uses the default
+  # remote, 'origin.'
+  def self.export(repository, name, options = {})
+    options.delete(:remote)
+    repo = clone(repository, name, {:depth => 1}.merge(options))
+    repo.checkout("origin/#{options[:branch]}") if options[:branch]
+    Dir.chdir(repo.dir.to_s) { FileUtils.rm_r '.git' }
+  end
+
+  # Same as g.config, but forces it to be at the global level
+  #
+  #g.config('user.name', 'Scott Chacon') # sets value
+  #g.config('user.email', 'email@email.com')  # sets value
+  #g.config('user.name')  # returns 'Scott Chacon'
+  #g.config # returns whole config hash
+  def self.global_config(name = nil, value = nil)
+    lib = Git::Lib.new(nil, nil)
+    if(name && value)
+      # set value
+      lib.global_config_set(name, value)
+    elsif (name)
+      # return value
+      lib.global_config_get(name)
+    else
+      # return hash
+      lib.global_config_list
+    end
+  end
+
+  # initialize a new git repository, defaults to the current working directory
+  #
+  # options
+  #   :repository => '/path/to/alt_git_dir'
+  #   :index => '/path/to/alt_index_file'
+  def self.init(working_dir = '.', options = {})
+    Base.init(working_dir, options)
+  end
+
+  # open an existing git working directory
+  #
+  # this will most likely be the most common way to create
+  # a git reference, referring to a working directory.
+  # if not provided in the options, the library will assume
+  # your git_dir and index are in the default place (.git/, .git/index)
+  #
+  # options
+  #   :repository => '/path/to/alt_git_dir'
+  #   :index => '/path/to/alt_index_file'
+  def self.open(working_dir, options = {})
+    Base.open(working_dir, options)
+  end
+
+end