firebrew 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 64ff3a699d6eb6038ac49fad26c13ea38d20f9b7
-  data.tar.gz: ead1c868230eee2dc80afe8595f17430715978f4
+  metadata.gz: cfb18b86ed200214495e26c35083760ee06adbfa
+  data.tar.gz: 5d06456d51c4d55ac9cc11355a38b6fe0de60599
 SHA512:
-  metadata.gz: b4fe6fbb93d9127d839c7917cd44ed6cf688e676d39d98933a2793c9464fc43452785463c3ba85bbcfc53998e530feeb1d6f3bc7d9c34835caa1ef8057c7b550
-  data.tar.gz: 83bd15df6e84aff5f351f2fdfdb9b16956bfcb385eaa5982b7597f204108e4991408973d71b88aecb324414bcc38ae7bc7017efaaca687cfb1703c7c34e409b4
+  metadata.gz: b466f350381f97a8ae2e178d3d0a08fa3379ccff2524dfec7f72b14d8945fc33333a787ee839c137b8b6d536f659fff2c452137b1661b3fb4e177085319f0e40
+  data.tar.gz: 54367c7cb733c9a08466ef91a6ef2142783fb7924d0a7e8336a7afea1153e8d5d95915df33b1e7ed0a2fcd87c14b71dae4fe720a1c3c440efe6cb46ae9970e78

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [0.2.0](https://github.com/mrk21/firebrew/tree/v0.2.0) - 2014-08-31
+
+* Future [#35](https://github.com/mrk21/firebrew/issues/35): Add the subcommand help
+* Future [#34](https://github.com/mrk21/firebrew/issues/34): Make the help message in detail
+* Future [#33](https://github.com/mrk21/firebrew/issues/33): Change to 0 a return value of the help command and version command
+* Bugfix [#32](https://github.com/mrk21/firebrew/issues/32): The `OptionParser` exceptions has not been handled enough
+* Bugfix [#31](https://github.com/mrk21/firebrew/issues/31): Has not been throw the `SystemCall` exception when executed the command which is not existed
+* Future [#30](https://github.com/mrk21/firebrew/issues/30): Add the detailed error messages
+* Future [#29](https://github.com/mrk21/firebrew/issues/29): Change the command return value
+* Future [#28](https://github.com/mrk21/firebrew/issues/28): Stop depending on `ActiveSupport`
+* Future [#27](https://github.com/mrk21/firebrew/issues/27): Stop depending on `ActiveResource`
+* Future [#26](https://github.com/mrk21/firebrew/issues/26): Stop depending on `ActiveModel`
+* Future [#25](https://github.com/mrk21/firebrew/issues/25): Add the command of getting the profile information
+* Future [#16](https://github.com/mrk21/firebrew/issues/16): The handling of when the network errors of the 404 Not Found HTTP error, etc occurs on the Amo::Search
+
 ## [0.1.3](https://github.com/mrk21/firebrew/tree/v0.1.3) - 2014-08-19
 
 * Bugfix [#24](https://github.com/mrk21/firebrew/issues/24): When the `em:unpack` value of the install manifests was true, is unable to normally installing

data/README.md

@@ -71,7 +71,25 @@ Enumerate the installed extensions:
 $ firebrew list
 ```
 
-### options
+#### profile
+
+Show the profile information:
+
+```bash
+$ firebrew profile [--attribute=<attr-name>]
+```
+
+##### options
+
+###### --attribute
+
+The name of the attribute which want to display:
+
+```bash
+-a <attr-name>, --attribute=<attr-name>
+```
+
+### global options
 
 #### --base-dir
 

data/firebrew.gemspec

@@ -22,9 +22,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", "~> 3.0"
   
-  spec.add_dependency "activesupport", "~> 4.1"
-  spec.add_dependency "activeresource", "~> 4.0"
-  spec.add_dependency "activemodel", "~> 4.1"
   spec.add_dependency "inifile", "~> 2.0"
   spec.add_dependency "rubyzip", "~> 1.1"
+  spec.add_dependency "faraday", "~> 0.9"
 end

data/lib/firebrew.rb

@@ -1,19 +1,17 @@
 require "firebrew/version"
+require 'rake/pathmap'
 
 module Firebrew
   class Error < StandardError; def status; 1 end end
-  class ProfilesFileNotFoundError < Error; def status; 2 end end
-  class ProfileNotFoundError < Error; def status; 3 end end
-  class ExtensionNotFoundError < Error; def status; 4 end end
-  class FirefoxCommandError < Error; def status; 5 end end
-  class CommandLineError < Error; def status; 6 end end
-  class OperationAlreadyCompletedError < Error; def status; 7 end end
+  class ProfilesFileNotFoundError < Error; end
+  class ProfileNotFoundError < Error; end
+  class ExtensionNotFoundError < Error; end
+  class FirefoxCommandError < Error; end
+  class CommandLineError < Error; end
+  class NetworkError < Error; end
+  class OperationAlreadyCompletedError < Error; def status; 2 end end
 end
 
-require 'firebrew/entity'
-require 'firebrew/amo_api/search'
-require 'firebrew/firefox/profile'
-require 'firebrew/firefox/extension'
-require 'firebrew/firefox/command'
-require 'firebrew/runner'
-require 'firebrew/command_line'
+Dir[__FILE__.pathmap('%X/*.rb')].each do |rb|
+  require rb.pathmap('%-1d/%n')
+end

data/lib/firebrew/amo_api/search.rb

@@ -1,20 +1,17 @@
-require 'active_resource'
 require 'uri'
+require 'rexml/document'
+require 'faraday'
 require 'firebrew/firefox/basic_extension'
 
 module Firebrew::AmoApi
-  class Search < ActiveResource::Base
-    class Format
-      include ActiveResource::Formats::XmlFormat
-      
-      def decode(xml)
-        results = super(xml)['addon'] || []
-        results.instance_of?(Array) ? results : [results]
-      end
+  class Search < Firebrew::Firefox::BasicExtension
+    def self.connection=(val)
+      @connection = val
     end
     
-    self.site = 'https://services.addons.mozilla.org'
-    self.format = Format.new
+    def self.connection
+      @connection ||= Faraday.new(url: 'https://services.addons.mozilla.org')
+    end
     
     def self.path(params={})
       path_source = '/ja/firefox/api/%{api_version}/search/%{term}/%{type}/%{max}/%{os}/%{version}'
@@ -29,21 +26,38 @@ module Firebrew::AmoApi
     end
     
     def self.fetch(params={})
-      self.find(:all, from: self.path(params)).to_a
+      response = self.connection.get(self.path params)
+      raise Firebrew::NetworkError, "Invalid HTTP status: #{response.status}" unless response.status == 200
+      dom = REXML::Document.new response.body
+      addons = REXML::XPath.match(dom, '/searchresults/addon')
+      addons.map{|v| Search.new v}
+      
+    rescue Faraday::Error => e
+      m = e.message
+      m[0] = m[0].upcase
+      raise Firebrew::NetworkError, m
     end
     
     def self.fetch!(params={})
       results = self.fetch(params)
-      raise Firebrew::ExtensionNotFoundError if results.empty?
+      raise Firebrew::ExtensionNotFoundError, %[Extension not found: like "#{params[:term]}"] if results.empty?
       results
     end
     
-    def extension
-      Firebrew::Firefox::BasicExtension.new(
-        name: self.name,
-        guid: self.guid,
-        uri: self.install,
-        version: self.version
+    attr_reader :data
+    
+    def initialize(data)
+      @data = data
+      
+      val = lambda do |name|
+        REXML::XPath.match(self.data, "#{name}/text()").first.value.strip
+      end
+      
+      super(
+        name: val[:name],
+        guid: val[:guid],
+        uri: val[:install],
+        version: val[:version]
       )
     end
   end

data/lib/firebrew/command_line.rb

@@ -1,8 +1,10 @@
 require 'optparse'
+require 'erb'
+require 'firebrew/runner'
 
 module Firebrew
   class CommandLine
-    attr_accessor :arguments
+    attr_reader :arguments
     
     def self.execute
       begin
@@ -15,83 +17,137 @@ module Firebrew
         $stderr.puts e.message
         exit e.status
       rescue SystemExit => e
-        exit 1
+        exit 0
       rescue Exception => e
         $stderr.puts e.inspect
         $stderr.puts e.backtrace
-        exit 255
+        exit 1
       else
         exit 0
       end
     end
     
     def initialize(args=[])
-      opt = OptionParser.new
-      opt.version = Firebrew::VERSION
-      opt.banner = <<-USAGE.split(/\n/).map{|v| v.gsub(/^(  ){4}/,'')}.join("\n")
-        Usage: firebrew [--help] [--version]
-               [--base-dir=<path>] [--profile=<name>] [--firefox=<path>]
-               <command> [<args>]
-        
-        commands:
-            install:
-                firebrew install <extension-name>
-            
-            uninstall:
-                firebrew uninstall <extension-name>
-            
-            info:
-                firebrew info <extension-name>
-            
-            search:
-                firebrew search <term>
-            
-            list:
-                firebrew list
-        
-        options:
-      USAGE
-      
-      self.arguments = {
+      @arguments = {
         command: nil,
         params: {},
         config: {}
       }
+      global_parser = self.option_parser do |parser|
+        parser.banner = self.desc(<<-DESC)
+          Usage: firebrew [--help] [--version]
+                 [--base-dir=<path>] [--profile=<name>] [--firefox=<path>]
+                 <command> [<args>]
+        DESC
+        
+        parser.separator ''
+        parser.separator 'commands:'
+        begin
+          pos = 11
+          
+          self.summary(parser, :install, <<-DESC, pos)
+            Install the Firefox extension
+          DESC
+          
+          self.summary(parser, :uninstall, <<-DESC, pos)
+            Uninstall the Firefox extension
+          DESC
+          
+          self.summary(parser, :info, <<-DESC, pos)
+            Show detail information of the Firefox extension
+          DESC
+          
+          self.summary(parser, :search, <<-DESC, pos)
+            Search Firefox extensions
+          DESC
+          
+          self.summary(parser, :list, <<-DESC, pos)
+            Enumerate the installed Firefox extensions
+          DESC
+          
+          self.summary(parser, :profile, <<-DESC, pos)
+            Show the profile information
+          DESC
+        end
+      end
       
-      self.register_global_options(opt)
-      self.class.opt_operation(opt, :order!, args)
+      global_parser.order!(args)
+      command = args.shift.to_s.intern
       
-      case args.shift
-      when 'install' then
-        self.class.opt_operation(opt, :permute!, args)
-        self.arguments[:command] = :install
-        self.arguments[:params][:term] = args[0]
+      case command
+      when :install, :uninstall, :info then
+        subcommand_parser = self.option_parser do |parser|
+          parser.banner = self.desc(<<-DESC)
+            Usage: firebrew [--help] [--version]
+                   [--base-dir=<path>] [--profile=<name>] [--firefox=<path>]
+                   #{command} <extension-name>
+          DESC
+        end
         
-      when 'uninstall' then
-        self.class.opt_operation(opt, :permute!, args)
-        self.arguments[:command] = :uninstall
+        subcommand_parser.permute!(args)
+        self.arguments[:command] = command
         self.arguments[:params][:term] = args[0]
         
-      when 'info' then
-        self.class.opt_operation(opt, :permute!, args)
-        self.arguments[:command] = :info
-        self.arguments[:params][:term] = args[0]
+      when :search then
+        subcommand_parser = self.option_parser do |parser|
+          parser.banner = self.desc(<<-DESC)
+            Usage: firebrew [--help] [--version]
+                   [--base-dir=<path>] [--profile=<name>] [--firefox=<path>]
+                   #{command} <term>
+          DESC
+        end
         
-      when 'search' then
-        self.class.opt_operation(opt, :permute!, args)
-        self.arguments[:command] = :search
+        subcommand_parser.permute!(args)
+        self.arguments[:command] = command
         self.arguments[:params][:term] = args[0]
         
-      when 'list' then
-        self.class.opt_operation(opt, :permute!, args)
-        self.arguments[:command] = :list
+      when :list then
+        subcommand_parser = self.option_parser do |parser|
+          parser.banner = self.desc(<<-DESC)
+            Usage: firebrew [--help] [--version]
+                   [--base-dir=<path>] [--profile=<name>] [--firefox=<path>]
+                   #{command}
+          DESC
+        end
+        
+        subcommand_parser.permute!(args)
+        self.arguments[:command] = command
+        
+      when :profile then
+        subcommand_parser = self.option_parser do |parser|
+          parser.summary_width = 30
+          parser.banner = self.desc(<<-DESC)
+            Usage: firebrew [--help] [--version]
+                   [--base-dir=<path>] [--profile=<name>] [--firefox=<path>]
+                   #{command} [--attribute=<attr-name>]
+          DESC
+          
+          parser.separator ''
+          parser.separator 'options:'
+          begin
+            chooses = %r[#{Firebrew::Firefox::Profile.attributes.join('|')}]
+            parser.on('-a <attr-name>','--attribute=<attr-name>', chooses, self.desc(<<-DESC)) do |v|
+              The name of the attribute which want to display
+            DESC
+              self.arguments[:params][:attribute] = v
+            end
+          end
+        end
+        
+        subcommand_parser.permute!(args)
+        self.arguments[:command] = command
+        
+      when :'' then
+        global_parser.permute(['--help'])
         
-      when nil then
-        self.class.opt_operation(opt, :permute, ['--help'])
-      
       else
-        raise Firebrew::CommandLineError
+        raise Firebrew::CommandLineError, "Invalid command: #{command}"
       end
+      
+    rescue OptionParser::ParseError => e
+      m = e.message
+      m[0] = m[0].upcase
+      raise Firebrew::CommandLineError, m
     end
     
     def execute
@@ -106,7 +162,23 @@ module Firebrew
         
       when :info then
         result = runner.send(self.arguments[:command], self.arguments[:params])
-        puts result.to_xml
+        puts result.data
+        
+      when :profile then
+        r = runner.profile
+        attr = self.arguments[:params][:attribute]
+        if attr.nil? then
+          attrs = r.class.attributes
+          puts ERB.new(self.desc(<<-XML),nil,'-').result(binding)
+            <profile>
+            <% attrs.each do |attr| -%>
+              <<%= attr %>><%= r.send(attr) %></<%= attr %>>
+            <% end -%>
+            </profile>
+          XML
+        else
+          puts r.send(attr)
+        end
         
       else
         runner.send(self.arguments[:command], self.arguments[:params])
@@ -115,26 +187,86 @@ module Firebrew
     
     protected
     
-    def self.opt_operation(opt, operation, args)
-      begin
-        opt.send(operation, args)
-      rescue OptionParser::InvalidOption
-        raise Firebrew::CommandLineError
-      end
+    def desc(str)
+      lines = str.split(/\n/)
+      indent = lines.map{|v| v.match(/^ +/).to_a[0].to_s.length}.min
+      lines.map{|v| v[indent..-1].rstrip}.join("\n")
+    end
+    
+    def summary(parser, name, description, pos)
+      result = ' '*100
+      result[0] = name.to_s
+      result[pos+1] = self.desc(description)
+      result = parser.summary_indent + result.rstrip
+      parser.separator result
     end
     
-    def register_global_options(opt)
-      opt.on('-d <path>','--base-dir=<path>','Firefox profiles.ini directory') do |v|
-        self.arguments[:config][:base_dir] = v
+    def option_parser
+      parser = OptionParser.new
+      parser.version = Firebrew::VERSION
+      parser.summary_indent = ' '*3
+      parser.summary_width = 25
+      
+      yield parser
+      
+      parser.separator ''
+      parser.separator 'global options:'
+      begin
+        parser.on('-d <path>','--base-dir=<path>', String, self.desc(<<-DESC)) do |v|
+          Firefox profiles.ini directory
+        DESC
+          self.arguments[:config][:base_dir] = v
+        end
+        
+        parser.on('-p <name>','--profile=<name>', String, self.desc(<<-DESC)) do |v|
+          Firefox profile name
+        DESC
+          self.arguments[:config][:profile] = v
+        end
+        
+        parser.on('-f <path>','--firefox=<path>', String, self.desc(<<-DESC)) do |v|
+          Firefox command path
+        DESC
+          self.arguments[:config][:firefox] = v
+        end
       end
       
-      opt.on('-p <name>','--profile=<name>','Firefox profile name') do |v|
-        self.arguments[:config][:profile] = v
+      parser.separator ''
+      begin
+        parser.on('-h', '--help', self.desc(<<-DESC)) do
+          Show this message
+        DESC
+          puts parser.help
+          exit
+        end
+        
+        parser.on('-v', '--version', self.desc(<<-DESC)) do
+          Show version
+        DESC
+          puts parser.ver
+          exit
+        end
       end
       
-      opt.on('-f <path>','--firefox=<path>','Firefox command path') do |v|
-        self.arguments[:config][:firefox] = v
+      parser.separator ''
+      parser.separator 'return value:'
+      begin
+        pos = 3
+        
+        self.summary(parser, '0', <<-DESC, pos)
+          Success
+        DESC
+        
+        self.summary(parser, '1', <<-DESC, pos)
+          Error
+        DESC
+        
+        self.summary(parser, '2', <<-DESC, pos)
+          No operation
+        DESC
       end
+      
+      return parser
     end
   end
 end

data/lib/firebrew/entity.rb

@@ -27,6 +27,12 @@ module Firebrew
       end
     end
     
+    def initialize(attributes={})
+      attributes.each do |(k,v)|
+        self.send("#{k}=", v)
+      end
+    end
+    
     def ==(rop)
       self.class.attributes.each do |attr|
         return false unless self.send(attr) == rop.send(attr)

data/lib/firebrew/firefox/basic_extension.rb

@@ -1,9 +1,7 @@
 require 'firebrew/entity'
-require 'active_model'
 
 module Firebrew::Firefox
   class BasicExtension
-    include ActiveModel::Model
     include Firebrew::Entity
     entity_attr :name, :guid, :version, :uri
   end

data/lib/firebrew/firefox/command.rb

@@ -1,3 +1,5 @@
+require 'shellwords'
+
 module Firebrew::Firefox
   class Command
     class Executer
@@ -10,18 +12,34 @@ module Firebrew::Firefox
       @config = config
       @executer = executer
       begin
-        result = @executer.exec('"%{firefox}" --version' % @config)
-        raise Firebrew::FirefoxCommandError unless result[0] =~ /Mozilla Firefox/
-        raise Firebrew::FirefoxCommandError unless result[1] == 0
+        result = if ENV['OS'].nil? then
+          @executer.exec('%{firefox} --version' % self.escaped_config)
+        else
+          @executer.exec('"%{firefox}" --version' % @config)
+        end
+        raise Firebrew::FirefoxCommandError, 'Command is not Firefox: %{firefox}' % @config unless result[0] =~ /Mozilla Firefox/
+        raise Firebrew::FirefoxCommandError, 'Command is not Firefox: %{firefox}' % @config unless result[1] == 0
       rescue SystemCallError
-        raise Firebrew::FirefoxCommandError
+        raise Firebrew::FirefoxCommandError, 'Firefox command not found: %{firefox}' % @config
       end
     end
     
     def version
-      return @version if @version.present?
-      result = @executer.exec('"%{firefox}" --version' % @config)[0]
+      return @version unless @version.nil?
+      result = if ENV['OS'].nil? then
+        @executer.exec('%{firefox} --version' % self.escaped_config)[0]
+      else
+        @executer.exec('"%{firefox}" --version' % @config)[0]
+      end
       @version = result.match(/[0-9.]+/)[0]
     end
+    
+    protected
+    
+    def escaped_config
+      result = @config.clone
+      result[:firefox] = Shellwords.escape result[:firefox]
+      result
+    end
   end
 end

data/lib/firebrew/firefox/extension.rb

@@ -1,8 +1,8 @@
 require 'fileutils'
 require 'open-uri'
 require 'json'
-require 'zip'
 require 'rexml/document'
+require 'zip'
 require 'firebrew/firefox/basic_extension'
 
 module Firebrew::Firefox
@@ -35,7 +35,7 @@ module Firebrew::Firefox
       
       def find!(name)
         result = self.find(name)
-        raise Firebrew::ExtensionNotFoundError if result.nil?
+        raise Firebrew::ExtensionNotFoundError, "Extension not found: #{name}" if result.nil?
         result
       end
       
@@ -91,7 +91,7 @@ module Firebrew::Firefox
       end
       
       def fetch
-        return @data if @data.present?
+        return @data unless @data.nil?
         @data = JSON.load(File.read(self.data_path))
       end
       

data/lib/firebrew/firefox/profile.rb

@@ -1,16 +1,16 @@
-require 'active_model'
 require 'inifile'
+require 'firebrew/entity'
 require 'firebrew/firefox/extension'
 
 module Firebrew::Firefox
   class Profile
-    include ActiveModel::Model
+    include Firebrew::Entity
     
     class Manager
       def initialize(params={})
         @base_dir = params[:base_dir]
         @data_file = params[:data_file] || 'profiles.ini'
-        raise Firebrew::ProfilesFileNotFoundError unless File.exists? self.data_path
+        raise Firebrew::ProfilesFileNotFoundError, %["profiles.ini" not found: #{self.data_path}] unless File.exists? self.data_path
       end
       
       def all
@@ -31,7 +31,7 @@ module Firebrew::Firefox
       
       def find!(name)
         result = self.find(name)
-        raise Firebrew::ProfileNotFoundError if result.nil?
+        raise Firebrew::ProfileNotFoundError, "Profile not found: #{name}" if result.nil?
         result
       end
       
@@ -47,7 +47,7 @@ module Firebrew::Firefox
       end
     end
     
-    attr_accessor :name, :path, :is_default
+    entity_attr :name, :path, :is_default
     
     def extensions
       Extension::Manager.new(profile: self)

data/lib/firebrew/runner.rb

@@ -1,6 +1,7 @@
 require 'firebrew/amo_api/search'
 require 'firebrew/firefox/profile'
 require 'firebrew/firefox/extension'
+require 'firebrew/firefox/command'
 
 module Firebrew
   class Runner
@@ -53,16 +54,16 @@ module Firebrew
     
     def install(params={})
       extension = self.profile.extensions.find(params[:term])
-      raise Firebrew::OperationAlreadyCompletedError if extension.present?
+      raise Firebrew::OperationAlreadyCompletedError, "Already installed: #{params[:term]}" unless extension.nil?
       result = self.fetch_api(term: params[:term], max: 1).first
-      self.profile.extensions.install(result.extension)
+      self.profile.extensions.install(result)
     end
     
     def uninstall(params={})
       begin
         self.profile.extensions.find!(params[:term]).delete
       rescue Firebrew::ExtensionNotFoundError
-        raise Firebrew::OperationAlreadyCompletedError
+        raise Firebrew::OperationAlreadyCompletedError, "Already uninstalled: #{params[:term]}"
       end
     end
     

data/lib/firebrew/version.rb

@@ -1,3 +1,3 @@
 module Firebrew
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

data/spec/firebrew/amo_api/search_spec.rb

@@ -3,34 +3,35 @@ require 'spec_helper'
 module Firebrew::AmoApi
   describe Firebrew::AmoApi::Search do
     before do
-      response = File.read("spec/fixtures/amo_api/search/#{self.fixture}")
-      
-      ActiveResource::HttpMock.respond_to do |mock|
-        mock.get Search.path(self.params), {}, response
-      end
+      Search.connection = double(:connection)
+      allow(Search.connection).to self.stub
     end
     
     after do
-      ActiveResource::HttpMock.reset!
+      Search.connection = nil
+    end
+    
+    let(:stub) do
+      response = File.read("spec/fixtures/amo_api/search/#{self.fixture}")
+      receive(:get).and_return(OpenStruct.new body: response, status: 200)
     end
     
-    let(:params){{term: 'hoge'}}
     let(:fixture){'base.xml'}
     
     describe '::fetch(params)' do
-      subject{Search.fetch self.params}
+      subject{Search.fetch term: ''}
       
       it { is_expected.to be_instance_of(Array) }
       it { expect(subject.size).to eq(3) }
       
       it 'should construct objects' do
-        expect(subject[0].id).to eq('100')
+        expect(subject[0].guid).to eq('hoge-ja@example.org')
         expect(subject[0].name).to eq('hoge')
         
-        expect(subject[1].id).to eq('101')
+        expect(subject[1].guid).to eq('hoge-fuga-ja@example.org')
         expect(subject[1].name).to eq('hoge_fuga')
         
-        expect(subject[2].id).to eq('102')
+        expect(subject[2].guid).to eq('hoge-hoge-ja@example.org')
         expect(subject[2].name).to eq('hoge_hoge')
       end
       
@@ -47,14 +48,30 @@ module Firebrew::AmoApi
         it { expect(subject.size).to eq(1) }
         
         it 'should construct objects' do
-          expect(subject[0].id).to eq('100')
+          expect(subject[0].guid).to eq('hoge-ja@example.org')
           expect(subject[0].name).to eq('hoge')
         end
       end
+      
+      context 'when occurred a network error' do
+        let(:stub) do
+          receive(:get).and_raise(Faraday::ConnectionFailed, 'message')
+        end
+        
+        it { expect{subject}.to raise_error(Firebrew::NetworkError, 'Message') }
+      end
+      
+      context 'when a response HTTP status was not 200' do
+        let(:stub) do
+          receive(:get).and_return(OpenStruct.new body: '', status: 404)
+        end
+        
+        it { expect{subject}.to raise_error(Firebrew::NetworkError, 'Invalid HTTP status: 404') }
+      end
     end
     
     describe '::fetch!(params)' do
-      subject {Search.fetch! self.params}
+      subject {Search.fetch! term: 'aa'}
       
       it { is_expected.to be_instance_of(Array) }
       it { expect(subject.size).to eq(3) }
@@ -62,7 +79,7 @@ module Firebrew::AmoApi
       
       context 'when results were empty' do
         let(:fixture){'empty.xml'}
-        it { expect{subject}.to raise_error(Firebrew::ExtensionNotFoundError) }
+        it { expect{subject}.to raise_error(Firebrew::ExtensionNotFoundError, 'Extension not found: like "aa"') }
       end
     end
   end

data/spec/firebrew/command_line_spec.rb

@@ -10,12 +10,19 @@ module Firebrew
     
     context 'when the command was invalid' do
       let(:args){'invalid-command'}
-      it { expect{subject}.to raise_error(Firebrew::CommandLineError) }
+      it { expect{subject}.to raise_error(Firebrew::CommandLineError, 'Invalid command: invalid-command') }
     end
     
     context 'when the options was invalid' do
-      let(:args){'install --invalid-option'}
-      it { expect{subject}.to raise_error(Firebrew::CommandLineError) }
+      describe 'invalid option' do
+        let(:args){'install --invalid-option'}
+        it { expect{subject}.to raise_error(Firebrew::CommandLineError, 'Invalid option: --invalid-option') }
+      end
+      
+      describe 'MissingArgument' do
+        let(:args){'install --firefox'}
+        it { expect{subject}.to raise_error(Firebrew::CommandLineError, 'Missing argument: --firefox') }
+      end
     end
     
     describe '#arguments()' do
@@ -104,6 +111,35 @@ module Firebrew
           )
         end
       end
+      
+      describe 'profile command' do
+        let(:args){'profile'}
+        it 'should parse' do
+          is_expected.to eq(
+            command: :profile,
+            params: {},
+            config: {}
+          )
+        end
+        
+        context 'with options' do
+          let(:args){'profile -a name --attribute=is_default'}
+          it 'should parse' do
+            is_expected.to eq(
+              command: :profile,
+              params: {
+                attribute: 'is_default'
+              },
+              config: {}
+            )
+          end
+          
+          context 'with invalid options' do
+            let(:args){'profile -a hoge'}
+            it { expect{subject}.to raise_error(Firebrew::CommandLineError, 'Invalid argument: -a hoge') }
+          end
+        end
+      end
     end
     
     describe '::execute(&block)' do
@@ -130,19 +166,25 @@ module Firebrew
       
       context 'when the `Firebrew::Error` was thrown' do
         let(:exeption){raise Firebrew::CommandLineError, 'CommandLineError message'}
-        it { expect(subject[0]).to eq(6) }
+        it { expect(subject[0]).to eq(1) }
         it { expect(subject[1]).to eq('CommandLineError message') }
       end
       
+      context 'when the `Firebrew::OperationAlreadyCompletedError` was thrown' do
+        let(:exeption){raise Firebrew::OperationAlreadyCompletedError, 'OperationAlreadyCompletedError message'}
+        it { expect(subject[0]).to eq(2) }
+        it { expect(subject[1]).to eq('OperationAlreadyCompletedError message') }
+      end
+      
       context 'when the `SystemExit` was thrown' do
         let(:exeption){abort 'abort message'}
-        it { expect(subject[0]).to eq(1) }
+        it { expect(subject[0]).to eq(0) }
         it { expect(subject[1]).to eq('abort message') }
       end
       
       context 'when the unknown exception was thrown' do
         let(:exeption){raise StandardError, 'StandardError message'}
-        it { expect(subject[0]).to eq(255) }
+        it { expect(subject[0]).to eq(1) }
         it { expect(subject[1]).to match(/^#<StandardError: StandardError message>/) }
       end
     end

data/spec/firebrew/firefox/command_spec.rb

@@ -11,20 +11,20 @@ module Firebrew::Firefox
     
     context 'when the indicated firefox command by the `config[:firefox]` not existed' do
       let(:config){super().merge firefox: 'firefox/not/existed/path'}
-      it { expect{subject}.to raise_error(Firebrew::FirefoxCommandError) }
+      it { expect{subject}.to raise_error(Firebrew::FirefoxCommandError, 'Firefox command not found: firefox/not/existed/path') }
     end
     
     context 'when the indicated command by the `config[:firefox]` was not firefox' do
       let(:executer) do
         double('executer', exec: ['Other program', 0])
       end
-      it { expect{subject}.to raise_error(Firebrew::FirefoxCommandError) }
+      it { expect{subject}.to raise_error(Firebrew::FirefoxCommandError, 'Command is not Firefox: %{firefox}' % self.config) }
       
       describe 'command status' do
         let(:executer) do
           double('executer', exec: ['Fake Mozilla Firefox', 1])
         end
-        it { expect{subject}.to raise_error(Firebrew::FirefoxCommandError) }
+        it { expect{subject}.to raise_error(Firebrew::FirefoxCommandError, 'Command is not Firefox: %{firefox}' % self.config) }
       end
     end
     

data/spec/firebrew/firefox/extension_spec.rb

@@ -84,7 +84,7 @@ module Firebrew::Firefox
         
         context 'when the extension corresponding to the `name` not existed' do
           let(:name){'hoge'}
-          it { expect{subject}.to raise_error(Firebrew::ExtensionNotFoundError) }
+          it { expect{subject}.to raise_error(Firebrew::ExtensionNotFoundError, 'Extension not found: hoge') }
         end
       end
       

data/spec/firebrew/firefox/profile_spec.rb

@@ -16,7 +16,7 @@ module Firebrew::Firefox
       context 'when "profiles.ini" not existed' do
         let(:base_dir){'not/existed/directory'}
         let(:data_file){'not_found.ini'}
-        it { expect{subject}.to raise_error(Firebrew::ProfilesFileNotFoundError) }
+        it { expect{subject}.to raise_error(Firebrew::ProfilesFileNotFoundError, %["profiles.ini" not found: #{File.expand_path File.join(self.base_dir, self.data_file)}]) }
       end
       
       describe '#all()' do
@@ -61,7 +61,7 @@ module Firebrew::Firefox
         
         context 'when not existed the `name` in the profiles.' do
           let(:name){'not_existed_profile_name'}
-          it { expect{subject}.to raise_error(Firebrew::ProfileNotFoundError) }
+          it { expect{subject}.to raise_error(Firebrew::ProfileNotFoundError, "Profile not found: #{self.name}") }
         end
       end
     end

data/spec/firebrew/runner_spec.rb

@@ -150,14 +150,13 @@ module Firebrew
       before do
         FileUtils.cp './spec/fixtures/firefox/profile/base.ini', './tmp/profiles.ini'
         response = File.read("./spec/fixtures/amo_api/search/base.xml")
-        ActiveResource::HttpMock.respond_to do |mock|
-          mock.get AmoApi::Search.path(self.search_params), {}, response
-        end
+        AmoApi::Search.connection = double(:connection)
+        allow(AmoApi::Search.connection).to receive(:get).and_return(OpenStruct.new body: response, status: 200)
       end
       
       after do
         FileUtils.rm_f './tmp/*'
-        ActiveResource::HttpMock.reset!
+        AmoApi::Search.connection = nil
       end
       
       describe '#install(params)' do
@@ -171,12 +170,14 @@ module Firebrew
         
         context 'when the `params[:term]` existed' do
           subject do
-            extensions_double = double('extensions', install: nil, find: Firefox::BasicExtension.new)
+            extensions_double = double('extensions', install: nil, find: Firefox::BasicExtension.new(name: self.extension_name))
             self.instance.profile = double('profile', extensions: extensions_double)
             self.instance.install(self.search_params)
           end
           
-          it { expect{subject}.to raise_error(Firebrew::OperationAlreadyCompletedError) }
+          let(:extension_name){'hoge'}
+          
+          it { expect{subject}.to raise_error(Firebrew::OperationAlreadyCompletedError, "Already installed: #{self.extension_name}") }
         end
       end
       
@@ -184,9 +185,11 @@ module Firebrew
         subject do
           extensions_double = double('extensions', find!: double('ext', delete: nil))
           self.instance.profile = double('profile', extensions: extensions_double)
-          self.instance.uninstall(term: 'not-existed-extension')
+          self.instance.uninstall(term: self.extension_name)
         end
         
+        let(:extension_name){'existed-extension'}
+        
         it { expect{subject}.to_not raise_error }
         
         context 'when the `params[:term]` not existed' do
@@ -194,10 +197,12 @@ module Firebrew
             extensions_double = double('extensions')
             allow(extensions_double).to receive(:find!).and_raise(Firebrew::ExtensionNotFoundError)
             self.instance.profile = double('profile', extensions: extensions_double)
-            self.instance.uninstall(term: 'not-existed-extension')
+            self.instance.uninstall(term: self.extension_name)
           end
           
-          it { expect{subject}.to raise_error(Firebrew::OperationAlreadyCompletedError) }
+          let(:extension_name){'not-existed-extension'}
+          
+          it { expect{subject}.to raise_error(Firebrew::OperationAlreadyCompletedError, "Already uninstalled: #{self.extension_name}") }
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: firebrew
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Yuichi Murata
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-19 00:00:00.000000000 Z
+date: 2014-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -53,75 +53,47 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.1'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.1'
-- !ruby/object:Gem::Dependency
-  name: activeresource
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.0'
-- !ruby/object:Gem::Dependency
-  name: activemodel
+  name: inifile
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: inifile
+  name: rubyzip
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '1.1'
 - !ruby/object:Gem::Dependency
-  name: rubyzip
+  name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '0.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '0.9'
 description: Firefox add-ons manager for CUI.
 email:
 - mrk21info+rubygems@gmail.com