firebrew 0.1.0

data/lib/firebrew/entity.rb

@@ -0,0 +1,39 @@
+module Firebrew
+  module Entity
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethod
+      end
+    end
+    
+    module ClassMethod
+      attr_accessor :attributes
+      
+      def self.extended(base)
+        base.attributes = []
+      end
+      
+      def inherited(base)
+        base.attributes = self.attributes.clone
+      end
+      
+      def entity_attr(*attrs)
+        attrs.uniq!
+        common = self.attributes & attrs
+        adding = attrs - common
+        self.attributes.push(*adding)
+        attr_accessor *adding
+        adding
+      end
+    end
+    
+    def ==(rop)
+      self.class.attributes.each do |attr|
+        return false unless self.send(attr) == rop.send(attr)
+      end
+      return true
+    end
+    
+    alias :eql? :==
+  end
+end

data/lib/firebrew/firefox/basic_extension.rb

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

data/lib/firebrew/firefox/command.rb

@@ -0,0 +1,27 @@
+module Firebrew::Firefox
+  class Command
+    class Executer
+      def exec(command)
+        [%x[#{command}], $?]
+      end
+    end
+    
+    def initialize(config={}, executer = Executer.new)
+      @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
+      rescue SystemCallError
+        raise Firebrew::FirefoxCommandError
+      end
+    end
+    
+    def version
+      return @version if @version.present?
+      result = @executer.exec('%{firefox} --version' % @config)[0]
+      @version = result.match(/[0-9.]+/)[0]
+    end
+  end
+end

data/lib/firebrew/firefox/extension.rb

@@ -0,0 +1,104 @@
+require 'fileutils'
+require 'open-uri'
+require 'json'
+require 'firebrew/firefox/basic_extension'
+
+module Firebrew::Firefox
+  class Extension < BasicExtension
+    class Manager
+      attr_reader :profile
+      
+      def initialize(params={})
+        @profile = params[:profile]
+      end
+      
+      def all
+        profile_extensions = self.fetch['addons'].find_all do |extension|
+          extension['location'] == 'app-profile'
+        end
+        
+        profile_extensions.map do |extension|
+          Extension.new({
+            name: extension['defaultLocale']['name'],
+            guid: extension['id'],
+            version: extension['version'],
+            uri: '%s.xpi' % File.join(self.profile.path, 'extensions', extension['id'])
+          }, self)
+        end
+      end
+      
+      def find(name)
+        self.all.find{|ext| ext.name == name }
+      end
+      
+      def find!(name)
+        result = self.find(name)
+        raise Firebrew::ExtensionNotFoundError if result.nil?
+        result
+      end
+      
+      def install(extension)
+        dir = File.join(self.profile.path, 'extensions')
+        FileUtils.mkdir_p dir
+        install_path = '%s.xpi' % File.join(dir, extension.guid)
+        
+        open(extension.uri, 'rb') do |i|
+          open(install_path, 'wb') do |o|
+            o.write i.read
+          end
+        end
+        
+        self.add(extension)
+        self.push
+      end
+      
+      def uninstall(extension)
+        FileUtils.rm_f extension.uri
+        self.remove(extension)
+        self.push
+      end
+      
+      protected
+      
+      def data_path
+        path = File.join(self.profile.path, 'extensions.json')
+        raise Firebrew::ExtensionsFileNotFoundError unless File.exists? path
+        path
+      end
+      
+      def fetch
+        return @data if @data.present?
+        @data = JSON.load(File.read(self.data_path))
+      end
+      
+      def push
+        json = JSON::pretty_generate(self.fetch, allow_nan: true, max_nesting: false)
+        File.write(self.data_path, json)
+      end
+      
+      def add(extension)
+        self.fetch['addons'].push(
+          'id'=> extension.guid,
+          'location'=> 'app-profile',
+          'version'=> extension.version,
+          'defaultLocale'=> {
+            'name'=> extension.name
+          }
+        )
+      end
+      
+      def remove(extension)
+        self.fetch['addons'].delete_if{|v| v['id'] == extension.guid}
+      end
+    end
+    
+    def initialize(attributes, manager)
+      super(attributes)
+      @manager = manager
+    end
+    
+    def delete
+      @manager.uninstall(self)
+    end
+  end
+end

data/lib/firebrew/firefox/profile.rb

@@ -0,0 +1,56 @@
+require 'active_model'
+require 'inifile'
+require 'firebrew/firefox/extension'
+
+module Firebrew::Firefox
+  class Profile
+    include ActiveModel::Model
+    
+    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
+      end
+      
+      def all
+        sections = IniFile.load(self.data_path).to_h
+        profiles = sections.find_all{|(name,prop)| name.match(/^Profile\d+$/)}
+        profiles.map do |(name,prop)|
+          Profile.new(
+            name: prop['Name'],
+            path: self.profile_path(prop['Path'], prop['IsRelative'] == '1'),
+            is_default: prop['Default'] == '1',
+          )
+        end
+      end
+      
+      def find(name)
+        self.all.find{|p| p.name == name }
+      end
+      
+      def find!(name)
+        result = self.find(name)
+        raise Firebrew::ProfileNotFoundError if result.nil?
+        result
+      end
+      
+      protected
+      
+      def data_path
+        File.expand_path File.join(@base_dir, @data_file)
+      end
+      
+      def profile_path(path, is_relative)
+        path = is_relative ? File.join(@base_dir, path) : path 
+        File.expand_path path
+      end
+    end
+    
+    attr_accessor :name, :path, :is_default
+    
+    def extensions
+      Extension::Manager.new(profile: self)
+    end
+  end
+end

data/lib/firebrew/runner.rb

@@ -0,0 +1,83 @@
+require 'firebrew/amo_api/search'
+require 'firebrew/firefox/profile'
+require 'firebrew/firefox/extension'
+
+module Firebrew
+  class Runner
+    attr_accessor :config, :profile
+    
+    def self.default_config(platform = RUBY_PLATFORM)
+      result = {
+        base_dir: ENV['FIREBREW_FIREFOX_PROFILE_BASE_DIR'],
+        firefox: ENV['FIREBREW_FIREFOX'],
+        profile: ENV['FIREBREW_FIREFOX_PROFILE'] || 'default',
+      }
+      
+      case platform
+      when /darwin/ then
+        result[:base_dir] ||= '~/Library/Application Support/Firefox'
+        result[:firefox] ||= '/Applications/Firefox.app/Contents/MacOS/firefox-bin'
+        
+      when /linux/ then
+        result[:base_dir] ||= '~/.mozilla/firefox'
+        result[:firefox] ||= '/usr/bin/firefox'
+        
+      when /mswin(?!ce)|mingw|cygwin|bccwin/ then
+        result[:base_dir] ||= '~/AppData/Roming/Mozilla/Firefox'
+        result[:firefox] ||= 'C:/Program Files (x86)/Mozilla Firefox/firefox.exe'
+      end
+      
+      result
+    end
+    
+    def initialize(config={})
+      self.config = self.class.default_config.merge(config)
+      
+      @profile_manager = Firefox::Profile::Manager.new(
+        base_dir: self.config[:base_dir],
+        data_file: self.config[:data_file]
+      )
+      @firefox = Firefox::Command.new(self.config)
+      
+      self.select_profile
+    end
+    
+    def select_profile(name = nil)
+      self.profile = @profile_manager.find!(name || self.config[:profile])
+    end
+    
+    def install(params={})
+      extension = self.profile.extensions.find(params[:term])
+      raise Firebrew::OperationAlreadyCompletedError if extension.present?
+      result = self.fetch_api(term: params[:term], max: 1).first
+      self.profile.extensions.install(result.extension)
+    end
+    
+    def uninstall(params={})
+      begin
+        self.profile.extensions.find!(params[:term]).delete
+      rescue Firebrew::ExtensionNotFoundError
+        raise Firebrew::OperationAlreadyCompletedError
+      end
+    end
+    
+    def info(params={})
+      self.fetch_api(term: params[:term], max: 1).first
+    end
+    
+    def list(params={})
+      self.profile.extensions.all
+    end
+    
+    def search(params={})
+      self.fetch_api(term: params[:term])
+    end
+    
+    protected
+    
+    def fetch_api(params={})
+      params.merge!(version: @firefox.version)
+      AmoApi::Search.fetch!(params)
+    end
+  end
+end

data/lib/firebrew/version.rb

@@ -0,0 +1,3 @@
+module Firebrew
+  VERSION = "0.1.0"
+end

data/spec/double/firefox.rb

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+puts 'Mozilla Firefox 30.0'

data/spec/firebrew/amo_api/search_spec.rb

@@ -0,0 +1,69 @@
+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
+    end
+    
+    after do
+      ActiveResource::HttpMock.reset!
+    end
+    
+    let(:params){{term: 'hoge'}}
+    let(:fixture){'base.xml'}
+    
+    describe '::fetch(params)' do
+      subject{Search.fetch self.params}
+      
+      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].name).to eq('hoge')
+        
+        expect(subject[1].id).to eq('101')
+        expect(subject[1].name).to eq('hoge_fuga')
+        
+        expect(subject[2].id).to eq('102')
+        expect(subject[2].name).to eq('hoge_hoge')
+      end
+      
+      context 'when results were empty' do
+        let(:fixture){'empty.xml'}
+        it { is_expected.to be_instance_of(Array) }
+        it { expect(subject.size).to eq(0) }
+      end
+      
+      context 'when the number of results was one' do
+        let(:fixture){'single.xml'}
+        
+        it { is_expected.to be_instance_of(Array) }
+        it { expect(subject.size).to eq(1) }
+        
+        it 'should construct objects' do
+          expect(subject[0].id).to eq('100')
+          expect(subject[0].name).to eq('hoge')
+        end
+      end
+    end
+    
+    describe '::fetch!(params)' do
+      subject {Search.fetch! self.params}
+      
+      it { is_expected.to be_instance_of(Array) }
+      it { expect(subject.size).to eq(3) }
+      it { expect{subject}.to_not raise_error }
+      
+      context 'when results were empty' do
+        let(:fixture){'empty.xml'}
+        it { expect{subject}.to raise_error(Firebrew::ExtensionNotFoundError) }
+      end
+    end
+  end
+end

data/spec/firebrew/command_line_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+require 'stringio'
+
+module Firebrew
+  describe Firebrew::CommandLine do
+    subject do
+      CommandLine.new(self.args.split(/\s+/))
+    end
+    let(:args){''}
+    
+    context 'when the command was invalid' do
+      let(:args){'invalid-command'}
+      it { expect{subject}.to raise_error(Firebrew::CommandLineError) }
+    end
+    
+    context 'when the options was invalid' do
+      let(:args){'install --invalid-option'}
+      it { expect{subject}.to raise_error(Firebrew::CommandLineError) }
+    end
+    
+    describe '#arguments()' do
+      subject { super().arguments }
+      
+      describe 'install command' do
+        let(:args){'install addon-name'}
+        
+        it 'should parse' do
+          is_expected.to eq(
+            command: :install,
+            params: {
+              term: 'addon-name'
+            },
+            config: {}
+          )
+        end
+        
+        context 'with options' do
+          let(:args){'--base-dir=/path/to/dir install -p default addon-name --profile=test --firefox=/path/to/firefox'}
+          
+          it 'should parse' do
+            is_expected.to eq(
+              command: :install,
+              params: {
+                term: 'addon-name'
+              },
+              config: {
+                base_dir: '/path/to/dir',
+                profile: 'test',
+                firefox: '/path/to/firefox'
+              }
+            )
+          end
+        end
+      end
+      
+      describe 'uninstall command' do
+        let(:args){'uninstall addon-name'}
+        it 'should parse' do
+          is_expected.to eq(
+            command: :uninstall,
+            params: {
+              term: 'addon-name'
+            },
+            config: {}
+          )
+        end
+      end
+      
+      describe 'info command' do
+        let(:args){'info term'}
+        
+        it 'should parse' do
+          is_expected.to eq(
+            command: :info,
+            params: {
+              term: 'term'
+            },
+            config: {}
+          )
+        end
+      end
+      
+      describe 'search command' do
+        let(:args){'search term'}
+        
+        it 'should parse' do
+          is_expected.to eq(
+            command: :search,
+            params: {
+              term: 'term'
+            },
+            config: {}
+          )
+        end
+      end
+      
+      describe 'list command' do
+        let(:args){'list'}
+        it 'should parse' do
+          is_expected.to eq(
+            command: :list,
+            params: {},
+            config: {}
+          )
+        end
+      end
+    end
+    
+    describe '::execute(&block)' do
+      subject do
+        begin
+          CommandLine.execute do
+            self.exeption
+          end
+        rescue SystemExit => e
+          self.io.rewind
+          return [e.status, self.io.read.strip]
+        end
+      end
+      
+      let(:exeption){nil}
+      let(:io){StringIO.new('','r+')}
+      
+      before { $stderr = self.io }
+      after { $stderr = STDERR }
+      
+      context 'when became successful' do
+        it { expect(subject[0]).to eq(0) }
+      end
+      
+      context 'when the `Firebrew::Error` was thrown' do
+        let(:exeption){raise Firebrew::CommandLineError, 'CommandLineError message'}
+        it { expect(subject[0]).to eq(7) }
+        it { expect(subject[1]).to eq('CommandLineError message') }
+      end
+      
+      context 'when the `SystemExit` was thrown' do
+        let(:exeption){abort 'abort message'}
+        it { expect(subject[0]).to eq(1) }
+        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[1]).to match(/^#<StandardError: StandardError message>/) }
+      end
+    end
+  end
+end