replicant-adb 0.0.1 → 1.0.1

data/.travis.yml

@@ -1,4 +0,0 @@
-language: ruby
-rvm: 
-  - "1.9.3"
-script: "bundle exec rake test"

data/Gemfile

@@ -1,19 +0,0 @@
-source "http://rubygems.org"
-# Add dependencies required to use your gem here.
-# Example:
-#   gem "activesupport", ">= 2.3.5"
-
-# Add dependencies to develop your gem here.
-# Include everything needed to run rake, tests, features, etc.
-gem "activesupport-core-ext", "~> 4.0", :require => false
-
-group :development do
-  gem "rake", "~> 10.1"
-  gem "bundler", "~> 1.0"
-  gem "jeweler", "~> 1.8.7"
-end
-
-group :test do
-  gem "minitest", "~> 5.0", :require => 'minitest/autorun'
-  gem "mocha", "~> 0.14.0", :require => 'mocha/setup'
-end

data/Rakefile

@@ -1,40 +0,0 @@
-# encoding: utf-8
-
-require 'rubygems'
-require 'bundler'
-require './lib/replicant/version'
-
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
-require 'rake'
-
-require 'jeweler'
-Jeweler::Tasks.new do |gem|
-  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
-  gem.name = "replicant-adb"
-  gem.version = Replicant::VERSION
-  gem.homepage = "https://github.com/mttkay/replicant"
-  gem.license = "MIT"
-  gem.summary = "A REPL for the Android Debug Bridge"
-  gem.description = "replicant is an interactive shell (a REPL) for ADB, the Android Debug Bridge"
-  gem.email = "m.kaeppler@gmail.com"
-  gem.authors = ["Matthias Kaeppler"]
-  gem.files.exclude 'screenshots/**'
-  # dependencies defined in Gemfile
-end
-Jeweler::RubygemsDotOrgTasks.new
-
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/*_spec.rb'
-  test.verbose = true
-end
-
-task :default => :test
-

data/lib/replicant/command.rb

@@ -1,352 +0,0 @@
-require 'stringio'
-
-class Command
-
-  def self.inherited(subclass)
-    @@subclasses ||= []
-    @@subclasses << subclass
-  end
-
-  def self.all
-    (@@subclasses - [AdbCommand, ListCommand, EnvCommand]).map do |clazz|
-      clazz.new(nil)
-    end
-  end
-
-  def self.load(repl, command_line)
-    if command_line == '!'
-      # load command that lists available commands
-      ListCommand.new(repl)
-    elsif command_line == '?'
-      EnvCommand.new(repl)
-    elsif command_line.start_with?('!')
-      # load custom command
-      command_parts = command_line[1..-1].split
-      command_name = command_parts.first
-      command_args = command_parts[1..-1].join(' ')
-      command_class = "#{command_name.capitalize}Command"
-      begin
-        clazz = Object.const_get(command_class)
-        clazz.new(repl, command_args)
-      rescue NameError => e
-        nil
-      end
-    else
-      # forward command to ADB
-      AdbCommand.new(repl, command_line.strip)
-    end
-  end
-
-  attr_reader :args
-
-  def initialize(repl, args = nil, options = {})
-    @repl = repl
-    @args = args.strip if args
-    @options = options
-  end
-
-  def name
-    "!#{self.class.name.gsub("Command", "").downcase}"
-  end
-
-  # subclasses override this to provide a description of their functionality
-  def description
-    "TODO: description missing"
-  end
-
-  # subclasses override this to provide a usage example
-  def usage
-  end
-
-  def execute
-    if valid_args?
-      run
-    else
-      output "Invalid arguments. Ex.: #{usage}"
-    end
-  end
-
-  private
-
-  def valid_args?
-    true
-  end
-
-  def output(message)
-    puts message unless @options[:silent]
-  end
-
-end
-
-class AdbCommand < Command
-
-  # the command line program
-  ADB = 'adb'
-
-  def run
-    begin
-      cmd = "#{adb} #{args}"
-
-      if interactive?
-        system cmd
-      else
-        cmd << " #{@repl.default_package}" if @repl.default_package && package_dependent?
-        output cmd if @repl.debug?
-        result = `#{cmd}`
-        output result
-        result
-      end
-    end
-  end
-
-  private
-
-  def adb
-    adb = "#{ADB}"
-    adb << " -s #{@repl.default_device.id}" if @repl.default_device
-    adb
-  end
-
-  def interactive?
-    args == "shell" || args.start_with?("logcat")
-  end
-
-  def package_dependent?
-    ["uninstall"].include?(args)
-  end
-end
-
-class DevicesCommand < Command
-  def description
-    "print a list of connected devices"
-  end
-
-  def run
-    adb = AdbCommand.new(@repl, "devices -l", :silent => true)
-    device_lines = adb.execute.lines.to_a.reject do |line|
-      line.strip.empty? || line.include?("daemon") || line.include?("List of devices")
-    end
-
-    device_ids = device_lines.map { |l| /([\S]+)\s+device/.match(l)[1] }
-    device_products = device_lines.map { |l| /product:([\S]+)/.match(l).try(:[], 1) }
-
-    device_names = device_lines.zip(device_ids).map do |l, id|
-      /model:([\S]+)/.match(l).try(:[], 1) || detect_device_name(id)
-    end
-
-    devices = device_ids.zip(device_names, device_products).map do |id, name, product|
-      Device.new(id, humanize_name(name, product))
-    end
-
-    output ""
-    output devices_string(devices)
-    output ""
-    devices
-  end
-
-  private
-
-  def detect_device_name(id)
-    if id.start_with?("emulator-")
-      "Android emulator"
-    else
-      "Unknown device"
-    end
-  end
-
-  def humanize_name(name_string, product)
-    if product == "vbox86p"
-      "Genymotion " + name_string.gsub(/___[\d_]+___/, "_")
-    else
-      name_string
-    end.gsub('_', ' ').squish
-  end
-
-  def devices_string(devices)
-    device_string = if devices.any?
-      padding = devices.map { |d| d.name.length }.max
-      indices = (0..devices.length - 1).to_a
-      indices.zip(devices).map { |i, d| "[#{i}] #{d.name}#{' ' * (padding - d.name.length)} | #{d.id}" }
-    else
-      "No devices found"
-    end
-  end
-end
-
-class PackageCommand < Command
-
-  def description
-    "set a default package to work with"
-  end
-
-  def usage
-    "#{name} com.mydomain.mypackage"
-  end
-
-  def valid_args?
-    args.present? && /^\w+(\.\w+)*$/ =~ args
-  end
-
-  def run
-    output "Setting default package to #{args.inspect}"
-    @repl.default_package = args
-  end
-end
-
-class DeviceCommand < Command
-  def description
-    "set a default device to work with"
-  end
-
-  def usage
-    "#{name} [<index>|<device_id>]"
-  end
-
-  def valid_args?
-    args.present? && /\S+/ =~ args
-  end
-
-  def run
-    default_device = if index?
-      # user selected by index
-      devices[args.to_i]
-    else
-      # user selected by device ID
-      devices.detect { |d| d.id == args }
-    end
-
-    if default_device
-      output "Setting default device to #{default_device.inspect}"
-      @repl.default_device = default_device
-    else
-      output "No such device"
-    end
-  end
-
-  private
-
-  def index?
-    /^\d+$/ =~ args
-  end
-
-  def devices
-    @devices ||= DevicesCommand.new(@repl, nil, :silent => true).execute
-  end
-
-end
-
-class ResetCommand < Command
-
-  def description
-    "clear current device and package"
-  end
-
-  def valid_args?
-    args.blank?
-  end
-
-  def run
-    @repl.default_device = nil
-    @repl.default_package = nil
-  end
-
-end
-
-class ListCommand < Command
-  def valid_args?
-    args.blank?
-  end
-
-  def description
-    "print a list of available commands"
-  end
-
-  def run
-    command_list = Command.all.sort_by {|c| c.name}.map do |command|
-      padding = 20 - command.name.length
-      desc = "#{command.name} #{' ' * padding} -- #{command.description}"
-      desc
-    end
-    output command_list.join("\n")
-  end
-end
-
-class RestartCommand < Command
-  def description
-    "restart ADB"
-  end
-
-  def run
-    # Faster than kill-server, and also catches ADB instances launched by
-    # IntelliJ. Moreover, start-server after kill-server sometimes makes the
-    # server fail to start up unless you sleep for a second or so
-    `killall adb`
-    AdbCommand.new(@repl, "start-server").execute
-  end
-end
-
-class LogcatCommand < Command
-
-  def description
-    "access device logs"
-  end
-
-  def valid_args?
-    args.blank?
-  end
-
-  def run
-    pid = if @repl.default_package
-      processes = AdbCommand.new(@repl, "shell ps", :silent => true).execute
-      pid_line = processes.lines.detect {|l| l.include?(@repl.default_package)}
-      pid_line.split[1].strip if pid_line
-    end
-
-    logcat = "logcat -v time"
-    logcat << " | grep -E '\(\s*#{pid}\)'"
-    AdbCommand.new(@repl, logcat).execute
-  end
-end
-
-class ClearCommand < Command
-
-  def description
-    "clear application data"
-  end
-
-  # TODO: this is not a very good argument validator
-  def valid_args?
-    args.present? || @repl.default_package
-  end
-
-  def usage
-    "#{name} [com.example.package|<empty>(when default package is set)]"
-  end
-
-  def run
-    package = args.present? ? args : @repl.default_package
-    # Clear app data - cache, SharedPreferences, Databases
-    AdbCommand.new(@repl, "shell su -c \"rm -r /data/data/#{package}/*\"").execute
-    # Force application stop to recreate shared preferences, databases with new launch
-    AdbCommand.new(@repl, "shell am force-stop #{package}").execute
-  end
-end
-
-class EnvCommand < Command
-
-  def valid_args?
-    args.blank?
-  end
-
-  def run
-    env = "Package: #{@repl.default_package || 'Not set'}\n"
-    env << "Device: "
-    device = @repl.default_device
-    env << if device
-      "#{device.name} (#{device.id})"
-    else
-      'Not set'
-    end
-    output env
-  end
-end

data/test/commands/adb_command_spec.rb

@@ -1,58 +0,0 @@
-require 'helper'
-
-class AdbCommandSpec < CommandSpecBase
-
-  describe "a basic adb command" do
-    before do
-      @command = silent AdbCommand.new(@repl, "devices")
-      @command.execute
-    end
-
-    it "sends a command to adb and captures the output" do
-      @command.backtick_capture.must_equal "adb devices"
-    end
-
-    it "does not use Kernel#system" do
-      @command.system_capture.must_be_nil
-    end
-  end
-
-  describe "an interactive command" do
-    before do
-      @command = AdbCommand.new(@repl, "shell")
-      @command.execute
-    end
-
-    it "is executed using a Kernel#system call" do
-      @command.system_capture.must_equal "adb shell"
-    end
-
-    describe "when it's 'shell'" do
-      it "is not treated as interactive when arguments are present" do
-        command = AdbCommand.new(@repl, "shell ps")
-        command.execute
-        command.system_capture.must_be_nil
-        command.backtick_capture.must_equal "adb shell ps"
-      end
-    end
-  end
-
-  describe "with a default package set" do
-    before do
-      @repl.stubs(:default_package).returns("com.myapp")
-    end
-
-    it "does not set the default package if command is not package dependent" do
-      command = silent AdbCommand.new(@repl, "devices")
-      command.execute
-      command.backtick_capture.must_equal "adb devices"
-    end
-
-    it "adds the default package if command is package dependent" do
-      command = silent AdbCommand.new(@repl, "uninstall")
-      command.execute
-      command.backtick_capture.must_equal "adb uninstall com.myapp"
-    end
-  end
-
-end