aloha_analyzer 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 78d30dc67ba7dcabf72a73d0c42cd001437b7e7d
-  data.tar.gz: 449554af381111619d24a8a6a0ea696be43c18ca
+  metadata.gz: d60bfa2c43a2c496f98d2aadedd42036ca8e36fc
+  data.tar.gz: 4d6b145caa9f49366cf2d23ec9459b780d9722dd
 SHA512:
-  metadata.gz: adcc8feeddd92b9a914aca0e065e6d80064a4bcf790a692a579c7a39ca4df42865dbbf2bd49b20cd9ca7dc85f0d3a274b0449fa4062f1ee1a2d3eb8779b1f5fb
-  data.tar.gz: 9bc83a94c2e2ca71cd4ab167474b82b44f4dcb487ba889027ac28ef36d650e4b3ded69678cfbc06ce8534bd066450877d788260f7a2279109d0fe21715509a89
+  metadata.gz: 090644018e122c692324448b0903941d4144a065cf2d929413b10868cc98497c0e9e13dd407a6c408ba3db0a3f38c934814eecba20f026d31da43b0daf79f316
+  data.tar.gz: f23c8f3fd71bcd6b5bd894b07e7141877e02aba738d8b7da619e67fdbe4877c8a01231cb206a08911f03e26846b78326573f938b536cd34f5f8a768398488364

data/README.md

@@ -19,7 +19,7 @@ Or install it yourself as:
 ## Usage
 
 ```ruby
-aloha = AlohaAnalyser::Follower.new(username, { credentials: credentials })
+aloha = AlohaAnalyser::User.new(username, { credentials: credentials })
 aloha.analyze!
 ```
 

data/aloha_analyzer.gemspec

@@ -19,9 +19,9 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency 'bundler', '~> 1.3'
-  spec.add_development_dependency 'rake', '~> 10.1'
+  spec.add_development_dependency 'rake', '~> 10.3'
   spec.add_development_dependency 'rspec', '~> 2.14'
   spec.add_development_dependency 'webmock', '~> 1.17'
   spec.add_development_dependency 'debugger', '~> 1.6'
-  spec.add_dependency 'twitter', '~> 5.6'
+  spec.add_dependency 'twitter', '~> 5.8'
 end

data/config/language.yml

@@ -0,0 +1,81 @@
+- abbreviation: fr
+  name:       French
+  population: 14_000_000
+- abbreviation: en
+  name:       English
+  population: 238_000_000
+- abbreviation: ar
+  name:       Arabic
+  population: 42_000_000
+- abbreviation: ja
+  name:       Japanese
+  population: 106_580_000
+- abbreviation: es
+  name:       Spanish
+  population: 95_000_000
+- abbreviation: de
+  name:       'German'
+  population: 5_000_000
+- abbreviation: it
+  name:       Italian
+  population: 8_000_000
+- abbreviation: id
+  name:       Indonesian
+  population: 20_000_000
+- abbreviation: pt
+  name:       Portuguese
+  population: 42_000_000
+- abbreviation: ko
+  name:       Korean
+  population: 7_000_000
+- abbreviation: tr
+  name:       Turkish
+  population: 14_000_000
+- abbreviation: ru
+  name:       Russian
+  population: 5_000_000
+- abbreviation: nl
+  name:       Dutch
+  population: 8_000_000
+- abbreviation: fil
+  name:       Filipino
+  population: 8_000_000
+- abbreviation: msa
+  name:       Malay
+  population: 50_000_000
+- abbreviation: zh
+  name:       Chinese
+  population: 20_000
+- abbreviation: hi
+  name:       Hindi
+  population: 12_000_000
+- abbreviation: 'no'
+  name:       Norwegian
+  population: 300_000
+- abbreviation: sv
+  name:       Swedish
+  population: 500_000
+- abbreviation: fi
+  name:       Finnish
+  population: 100_000
+- abbreviation: da
+  name:       Danish
+  population: 200_000
+- abbreviation: pl
+  name:       Polish
+  population: 300_000
+- abbreviation: hu
+  name:       Hungarian
+  population: 1_000_000
+- abbreviation: fa
+  name:       Farsi
+  population: 1_000_000
+- abbreviation: he
+  name:       Hebrew
+  population: 1_000_000
+- abbreviation: ur
+  name:       Urdu
+  population: 1_000_000
+- abbreviation: th
+  name:       Thai
+  population: 7_0000_000

data/lib/aloha_analyzer/language.rb

@@ -0,0 +1,31 @@
+require 'yaml'
+
+module AlohaAnalyzer
+  class Language
+    LANGUAGES        = YAML::load(File.open('config/language.yml'))
+    TOTAL_POPULATION = 750_000_000
+
+    def self.all
+      LANGUAGES
+    end
+
+    def self.total
+      TOTAL_POPULATION
+    end
+
+    def self.aliases
+      {
+        'en-gb' => 'en',
+        'zh-cb' => 'zh',
+        'zh-tw' => 'zh'
+      }
+    end
+
+    def self.find_by_abbreviation(abbreviation)
+      all.each do |language|
+        return language if language['abbreviation'] == abbreviation
+      end
+      nil
+    end
+  end
+end

data/lib/aloha_analyzer/user.rb

@@ -0,0 +1,86 @@
+module AlohaAnalyzer
+  class User
+
+    attr_reader :language
+
+    def initialize(language, users)
+      @language    = language
+      @users       = users
+      @users_count = users.size
+      clean_language!
+      clean_users_languages!
+    end
+
+    def analyze
+      {
+        with_user_language:    with_user_language,
+        without_user_language: without_user_language
+      }
+    end
+
+    private
+
+    def with_user_language
+      @with_user_language ||= Hash.new.tap do |languages|
+        @users.each do |user|
+          abbreviation = user['lang']
+          if languages[abbreviation]
+            languages[abbreviation]['count'] += 1
+          else
+            languages[abbreviation] = {
+              'count'      => 1,
+              'population' => Language.find_by_abbreviation(abbreviation)['population']
+            }
+          end
+          languages[abbreviation]['percentage'] = ((100 / @users_count.to_f) * languages[abbreviation]['count']).round
+        end
+      end
+    end
+
+    def without_user_language
+      @without_user_language ||= Hash.new.tap do |languages|
+        @users.each do |user|
+          abbreviation = user['lang']
+          if abbreviation != @language
+            if languages[abbreviation]
+              languages[abbreviation]['count'] += 1
+            else
+              languages[abbreviation] = {
+                'count'      => 1,
+                'population' => Language.find_by_abbreviation(abbreviation)['population']
+              }
+            end
+            languages[abbreviation]['percentage'] = ((100 / users_total_without_user_language.to_f) * languages[abbreviation]['count']).round
+          end
+        end
+      end
+    end
+
+    def users_total_without_user_language
+      @users_total_without_user_language ||= @users_count - user_language_count
+    end
+
+    def user_language_count
+      @user_language_count ||= if with_user_language[@language]
+        with_user_language[@language]['count']
+      else
+        0
+      end
+    end
+
+    def clean_language!
+      if Language.aliases.keys.include?(@language)
+        @language = Language.aliases[@language]
+      end
+    end
+
+    def clean_users_languages!
+      @users.map! do |user|
+        if Language.aliases.keys.include?(user['lang'])
+          user['lang'] = Language.aliases[user['lang']]
+        end
+        user
+      end
+    end
+  end
+end

data/lib/aloha_analyzer/version.rb

@@ -1,3 +1,3 @@
 module AlohaAnalyzer
-  VERSION = '0.0.4'
+  VERSION = '0.0.5'
 end

data/lib/aloha_analyzer.rb

@@ -1,5 +1,6 @@
 require "aloha_analyzer/version"
-require "aloha_analyzer/follower"
+require "aloha_analyzer/language"
+require "aloha_analyzer/user"
 
 module AlohaAnalyzer
 end

data/spec/aloha_analyzer/language_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe AlohaAnalyzer::Language do
+  describe '.all' do
+    it 'returns an array' do
+      described_class.all.should be_a Array
+    end
+
+    it 'is not empty' do
+      described_class.all.should be_a Array
+    end
+  end
+
+  describe '.total' do
+    it 'returns the total number of language users' do
+      total = 0
+      described_class.all.each do |language|
+        total += language['population']
+      end
+      total.should eq described_class.total
+    end
+  end
+
+  describe '.find_by_abbreviation' do
+    subject(:language) { described_class.find_by_abbreviation(abbreviation) }
+    context 'when it exits' do
+      let(:abbreviation) { 'fr' }
+
+      it 'returns a hash' do
+        subject.should be_a Hash
+      end
+
+      it 'includes the total language population' do
+        subject['population'].should be_a Fixnum
+      end
+
+      it 'includes the language name' do
+        subject['name'].should eq 'French'
+      end
+
+      it 'includes the language abbreviation' do
+        subject['abbreviation'].should eq 'fr'
+      end
+    end
+
+    context 'when it does not exist' do
+      let(:abbreviation) { 'esperanto' }
+      it 'returns nil' do
+        subject.should be_nil
+      end
+    end
+  end
+end

data/spec/aloha_analyzer/user_spec.rb

@@ -0,0 +1,251 @@
+require 'spec_helper'
+
+describe AlohaAnalyzer::User do
+  subject(:user) { described_class.new(language, users) }
+  let(:language) { 'en' }
+
+  describe '#new' do
+    let(:users) { [] }
+    context 'when language is british' do
+      let(:language) { 'en-gb' }
+
+      it 'changes to english' do
+        subject.language.should eq 'en'
+      end
+    end
+
+    context 'when language is simplified chinese' do
+      let(:language) { 'zh-cb' }
+
+      it 'changes to chinese' do
+        subject.language.should eq 'zh'
+      end
+    end
+
+    context 'when language is tradiational chinese' do
+      let(:language) { 'zh-tw' }
+
+      it 'changes to chinese' do
+        subject.language.should eq 'zh'
+      end
+    end
+
+    context 'when language is something else' do
+      let(:language) { 'something' }
+
+      it 'does not change it' do
+        subject.language.should eq language
+      end
+    end
+  end
+
+  describe '#analyze' do
+    subject(:analyze) { described_class.new(language, users).analyze }
+    context 'when no users' do
+      let(:users) { [] }
+
+      it 'returns a hash' do
+        subject.should be_a Hash
+      end
+
+      it 'has no results with the user language' do
+        subject[:with_user_language].should eq({})
+      end
+
+      it 'has no results without the user language' do
+        subject[:without_user_language].should eq({})
+      end
+    end
+
+    context 'when users' do
+      context 'and no aliases' do
+        let(:users) {
+          [
+            {'lang' => 'en'},
+            {'lang' => 'fr'},
+            {'lang' => 'en'},
+            {'lang' => 'de'}
+          ]
+        }
+
+        it 'returns a hash' do
+          subject.should be_a Hash
+        end
+
+        it 'returns results based on the user language' do
+          subject[:with_user_language].should == {
+            'en' => {
+              'percentage' => 50,
+              'count'      => 2,
+              'population' => 238_000_000,
+            },
+            'fr' => {
+              'percentage' => 25,
+              'count'      => 1,
+              'population' => 14_000_000,
+            },
+            'de' => {
+              'percentage' => 25,
+              'count'      => 1,
+              'population' => 5_000_000,
+            }
+          }
+        end
+
+        it 'returns results results based on the non user language' do
+          subject[:without_user_language].should eq(
+            'fr' => {
+              'percentage' => 50,
+              'count'      => 1,
+              'population' => 14_000_000,
+            },
+            'de' => {
+              'percentage' => 50,
+              'count'      => 1,
+              'population' => 5_000_000,
+            }
+          )
+        end
+      end
+
+      context 'when only user langugages users' do
+        let(:users) {
+          [
+            {'lang' => 'en'},
+            {'lang' => 'en'}
+          ]
+        }
+
+        it 'returns a hash' do
+          subject.should be_a Hash
+        end
+
+        it 'returns results based on the user language' do
+          subject[:with_user_language].should == {
+            'en' => {
+              'percentage' => 100,
+              'count'      => 2,
+              'population' => 238_000_000,
+            }
+          }
+        end
+
+        it 'returns results results based on the non user language' do
+          subject[:without_user_language].should == {}
+        end
+      end
+
+      context 'when no users language users' do
+        let(:users) {
+          [
+            {'lang' => 'de'},
+            {'lang' => 'fr'}
+          ]
+        }
+
+        it 'returns a hash' do
+          subject.should be_a Hash
+        end
+
+        it 'returns results based on the user language' do
+          subject[:with_user_language].should == {
+            'fr' => {
+              'percentage' => 50,
+              'count'      => 1,
+              'population' => 14_000_000,
+            },
+            'de' => {
+              'percentage' => 50,
+              'count'      => 1,
+              'population' => 5_000_000,
+            }
+          }
+        end
+
+        it 'returns results results based on the non user language' do
+          subject[:without_user_language].should eq(
+            'fr' => {
+              'percentage' => 50,
+              'count'      => 1,
+              'population' => 14_000_000,
+            },
+            'de' => {
+              'percentage' => 50,
+              'count'      => 1,
+              'population' => 5_000_000,
+            }
+          )
+        end
+      end
+
+      context 'when aliases' do
+        context 'and some users british' do
+          let(:users) {
+            [
+              {'lang' => 'en'},
+              {'lang' => 'fr'},
+              {'lang' => 'en-gb'}
+            ]
+          }
+
+          it 'merges english and british' do
+            subject[:with_user_language].should == {
+              'en' => {
+                'percentage' => 67,
+                'count'      => 2,
+                'population' => 238_000_000,
+              },
+              'fr' => {
+                'percentage' => 33,
+                'count'      => 1,
+                'population' => 14_000_000
+              }
+            }
+
+            subject[:without_user_language].should eq(
+              'fr' => {
+                'percentage' => 100,
+                'count'      => 1,
+                'population' => 14_000_000
+              }
+            )
+          end
+        end
+
+        context 'and some users are chinese' do
+          let(:users) {
+            [
+              {'lang' => 'zh-cb'},
+              {'lang' => 'zh-cb'},
+              {'lang' => 'en'},
+              {'lang' => 'zh-tw'}
+            ]
+          }
+
+          it 'merges chinese' do
+            subject[:with_user_language].should == {
+              'zh' => {
+                'percentage' => 75,
+                'count'      => 3,
+                'population' => 20000,
+              },
+              'en' => {
+                'percentage' => 25,
+                'count'      => 1,
+                'population' => 238000000
+              }
+            }
+
+            subject[:without_user_language].should eq(
+              'zh' => {
+                'percentage' => 100,
+                'count'      => 3,
+                'population' => 20000
+              }
+            )
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aloha_analyzer
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Matthieu Aussaguel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-11 00:00:00.000000000 Z
+date: 2014-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.1'
+        version: '10.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.1'
+        version: '10.3'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -86,14 +86,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.6'
+        version: '5.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.6'
+        version: '5.8'
 description: Analyze twitter followers languages
 email:
 - matthieu.aussaguel@gmail.com
@@ -109,10 +109,13 @@ files:
 - README.md
 - Rakefile
 - aloha_analyzer.gemspec
+- config/language.yml
 - lib/aloha_analyzer.rb
-- lib/aloha_analyzer/follower.rb
+- lib/aloha_analyzer/language.rb
+- lib/aloha_analyzer/user.rb
 - lib/aloha_analyzer/version.rb
-- spec/aloha_analyzer/follower_spec.rb
+- spec/aloha_analyzer/language_spec.rb
+- spec/aloha_analyzer/user_spec.rb
 - spec/aloha_analyzer_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/matthieua/aloha_analyzer
@@ -135,11 +138,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Analyze twitter followers languages
 test_files:
-- spec/aloha_analyzer/follower_spec.rb
+- spec/aloha_analyzer/language_spec.rb
+- spec/aloha_analyzer/user_spec.rb
 - spec/aloha_analyzer_spec.rb
 - spec/spec_helper.rb

data/lib/aloha_analyzer/follower.rb

@@ -1,52 +0,0 @@
-module AlohaAnalyzer
-  class Follower
-    attr_reader :screen_name, :cursor, :languages
-
-    def initialize(screen_name, options = {})
-      @screen_name = screen_name
-      @cursor      = options[:cursor] || -1
-      @languages   = options[:languages] || Hash.new(0)
-      @credentials = options[:credentials]
-    end
-
-    def count
-      counter = 0
-      @languages.each do |_, language_count|
-        counter += language_count
-      end
-      counter
-    end
-
-    def analyze!
-      response = client.followers(@screen_name, request_options).to_h
-      response[:users].each do |follower|
-        increment follower[:lang]
-      end
-      @cursor = response[:next_cursor]
-    end
-
-    private
-
-    def request_options
-      {
-        count:       200,
-        skip_status: false,
-        cursor:      @cursor
-      }
-    end
-
-    def client
-      @client ||= ::Twitter::REST::Client.new(
-        consumer_key:         @credentials[:consumer_key],
-        consumer_secret:      @credentials[:consumer_secret],
-        access_token:         @credentials[:access_token],
-        access_token_secret:  @credentials[:access_token_secret]
-      )
-    end
-
-    def increment(language)
-      @languages[language] = @languages[language] || 0
-      @languages[language] += 1
-    end
-  end
-end

data/spec/aloha_analyzer/follower_spec.rb

@@ -1,197 +0,0 @@
-require 'spec_helper'
-
-describe AlohaAnalyzer::Follower do
-  subject(:follower) { described_class.new(screen_name, options) }
-  let(:screen_name)     { 'mattaussaguel'  }
-
-  let(:options) do
-    {
-      credentials: credentials
-    }
-  end
-
-  let(:credentials) do
-    {
-      consumer_key:        'CK',
-      consumer_secret:     'CS',
-      access_token:        'AT',
-      access_token_secret: 'AS'
-    }
-  end
-
-  describe '#new' do
-    it 'sets the screen_name' do
-      subject.screen_name.should eq screen_name
-    end
-
-    context 'cursor option is passed' do
-      let(:options) { { cursor: cursor } }
-      let(:cursor)  { double }
-
-      it 'sets the cursor to the option value' do
-        subject.cursor.should eq cursor
-      end
-    end
-
-    context 'cursor option is not set' do
-      it 'sets the cursor to -1' do
-        subject.cursor.should eq -1
-      end
-    end
-
-    context 'when languages option are passed' do
-      let(:languages) { double }
-      let(:options) { { languages: languages } }
-
-      it 'sets the languages to the option value' do
-        subject.languages.should eq languages
-      end
-    end
-
-    context 'when languages option is not set' do
-      it 'sets the cursor to an empty hash' do
-        subject.languages.should be_a Hash
-        subject.languages.should be_empty
-      end
-    end
-  end
-
-  describe '#count' do
-    let(:options) { { languages: languages } }
-    let(:languages) do
-      {
-        'en' => 2,
-        'fr' => 3,
-        'es' => 0
-      }
-    end
-
-    it 'includes the total language count' do
-      subject.count.should eq 5
-    end
-  end
-
-  describe '#analyze!' do
-    let(:followers) do
-      {
-        "users" => [
-          {"id" => 1, "lang" => "en"},
-          {"id" => 2, "lang" => "fr"},
-          {"id" => 3, "lang" => "en"},
-          {"id" => 4, "lang" => "de"}
-        ],
-        "next_cursor" => next_cursor
-      }
-    end
-    let(:next_cursor) { 1 }
-    let(:query_args) do
-      {
-        skip_status: false,
-        count: 200,
-        :cursor      => '-1',
-        :screen_name => screen_name}
-    end
-
-    let(:body)    { followers.to_json }
-    let(:headers) { {:content_type => 'application/json; charset=utf-8'} }
-
-    before do
-      stub_get('/1.1/followers/list.json')
-        .with(:query => query_args)
-        .to_return(:body => body, :headers => headers)
-    end
-
-    context 'when first call' do
-      it 'sets the next cursor' do
-        subject.analyze!
-
-        subject.cursor.should eq next_cursor
-      end
-
-      it 'calculates the langauges stats' do
-        subject.analyze!
-
-        subject.languages.should eq(
-          'en' => 2,
-          'fr' => 1,
-          'de' => 1
-        )
-      end
-
-      it 'updates the count value' do
-        subject.analyze!
-
-        subject.count.should eq 4
-      end
-
-      it 'creates a new twitter client' do
-        Twitter::REST::Client.should_receive(:new).and_call_original
-
-        subject.analyze!
-      end
-    end
-
-    context 'when run the second time' do
-      let(:new_query_args) do
-        {
-          skip_status: false,
-          count: 200,
-          :cursor      => '1',
-          :screen_name => screen_name}
-      end
-
-      let(:new_followers) do
-        {
-          "users" => [
-            {"id" => 1, "lang" => "fr"},
-            {"id" => 2, "lang" => "de"},
-            {"id" => 3, "lang" => "es"},
-            {"id" => 4, "lang" => "de"}
-          ],
-          "next_cursor" => new_next_cursor
-        }
-      end
-
-      let(:new_next_cursor) { 1 }
-      let(:new_body) { new_followers.to_json }
-
-      before do
-        subject.analyze!
-
-        stub_get('/1.1/followers/list.json')
-          .with(query: new_query_args)
-          .to_return(body: new_body, headers: headers)
-
-      end
-
-      it 'sets the next cursor' do
-        subject.analyze!
-
-        subject.cursor.should eq new_next_cursor
-      end
-
-      it 'calculates the langauges stats' do
-        subject.analyze!
-
-        subject.languages.should eq(
-          'en' => 2,
-          'fr' => 2,
-          'de' => 3,
-          'es' => 1
-        )
-      end
-
-      it 'updates the count value' do
-        subject.analyze!
-
-        subject.count.should eq 8
-      end
-
-      it 'does not create another twitter client' do
-        Twitter::REST::Client.should_not_receive(:new)
-
-        subject.analyze!
-      end
-    end
-  end
-end