indico 0.2.0 → 0.2.2

data/README.md

@@ -1,8 +1,9 @@
 # IndicoIo-ruby
 
-A Ruby wrapper for indico's APIs.
+A ruby wrapper for the [indico API](http://indico.io).
 
-## Installation
+Installation
+-------------
 
 Add this line to your application's Gemfile:
 
@@ -10,17 +11,23 @@ Add this line to your application's Gemfile:
 
 And then execute:
 
-    $ bundle
+    $ bundle install
 
 Or install it yourself as:
 
     $ gem install indico
 
-Documentation
+
+API Keys + Setup
+----------------
+For API key registration and setup, checkout our [quickstart guide](http://docs.indico.io/v2.0/docs/api-keys).
+
+Full Documentation
 ------------
-Found [here](http://indico.readme.io/v1.0/docs)
+Detailed documentation and further code examples are available at [indico.reame.io](http://indico.readme.io/v2.0/docs/ruby)
 
-## Usage
+Examples
+---------
 
 ```ruby
 > require 'indico'
@@ -45,44 +52,25 @@ Found [here](http://indico.readme.io/v1.0/docs)
 
 ```
 
-###Batch API Access
-
-If you'd like to use our batch api interface, please check out the [pricing page](https://indico.io/pricing) on our website to find the right plan for you.
-
-```ruby
-> require 'indico'
-
-=> true
+Batch API
+---------
 
-> data = ["I believe in capital punishment", "The president is wrong"]
+Each `Indico` method has a corresponding batch method for analyzing many examples with a single request. Simply pass in an array of inputs and receive an array of results in return.
 
-=> ["I believe in capital punishment", "The president is wrong"]
-
-> Indico.batch_political(data, "username", "password")
-
-=> [ {"Libertarian"=>0.3511057701654774, "Liberal"=>0.06709112089656208, "Green"=>0.03830472376983833, "Conservative"=>0.5434983851681222}, {"Libertarian"=>0.08762905907467175, "Liberal"=>0.18965142341591298, "Green"=>0.02612359787701222, "Conservative"=>0.696595919632403}]
-````
-
-###Private cloud API Access
-
-If you're looking to use indico's API for high throughput applications, please check out the [pricing page](https://indico.io/pricing) on our website to find the right plan for you.
 
 ```ruby
 > require 'indico'
 
 => true
 
-> data = ["I believe in capital punishment", "The president is wrong"]
+> Indico.api_key = "YOUR_API_KEY"
 
-=> ["I believe in capital punishment", "The president is wrong"]
+=> "YOUR_API_KEY"
 
-> Indico.batch_political(data, "username", "password", cloud)
-
-=> [ {"Libertarian"=>0.3511057701654774, "Liberal"=>0.06709112089656208, "Green"=>0.03830472376983833, "Conservative"=>0.5434983851681222}, {"Libertarian"=>0.08762905907467175, "Liberal"=>0.18965142341591298, "Green"=>0.02612359787701222, "Conservative"=>0.696595919632403}]
-````
-
-The `cloud` parameter redirects API calls to your private cloud hosted at `[cloud].indico.domains`
+> Indico.batch_sentiment(['Best day ever', 'Worst day ever'])
 
+=> [0.9899001220871786, 0.005709885173415242]
+```
 
 ## Contributing
 

data/Rakefile

@@ -1,2 +1 @@
-require "bundler/gem_tasks"
-
+require 'bundler/gem_tasks'

data/indico.gemspec

@@ -4,21 +4,23 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'indico/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "indico"
+  spec.name          = 'indico'
   spec.version       = Indico::VERSION
-  spec.authors       = ["Slater Victoroff", "Amit Ambardekar"]
-  spec.email         = ["slater@indico.io", "amitamb@gmail.com"]
-  spec.summary       = %q{A simple Ruby Wrapper for the indico set of APIs.}
-  spec.description   = %q{A simple Ruby Wrapper for the indico set of APIs.}
-  spec.homepage      = "https://github.com/IndicoDataSolutions/IndicoIo-ruby"
-  spec.license       = "MIT"
+  spec.authors       = ['Slater Victoroff', 'Amit Ambardekar', 'Madison May', 'Annie Carlson']
+  spec.email         = ['slater@indico.io', 'amitamb@gmail.com', 'madison@indico.io', 'annie@indico.io']
+  spec.summary       = 'A simple Ruby Wrapper for the indico set of APIs.'
+  spec.description   = 'A simple Ruby Wrapper for the indico set of APIs.'
+  spec.homepage      = 'https://github.com/IndicoDataSolutions/IndicoIo-ruby'
+  spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.executables   = spec.files.grep('^bin\\/') { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep('^(test|spec|features)\\/')
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'inifile', '~> 3.0.0'
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
 
-  spec.add_development_dependency "bundler", "~> 1.6"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec"
 end

data/lib/indico/helper.rb

@@ -1,30 +1,44 @@
-require "base64"
+require 'base64'
 
 module Indico
   private
 
   def self.url_join(root, api)
-    if root.nil?
-      "http://apiv1.indico.io/%s" % api
+    if !root
+      'http://apiv2.indico.io/' + api
     else
-      "http://" + root + ".indico.domains/" + api
+      Indico.cloud_protocol + root + '.indico.domains/' + api
     end
   end
 
-  def self.api_handler(data, server, api, username=nil, password=nil)
+  def self.api_handler(data, api, config)
+    server = nil
+    api_key = nil
+    unless config.nil?
+      server = config[:cloud]
+      api_key = config[:api_key]
+    end
     d = {}
     d['data'] = data
     data_dict = JSON.dump(d)
-    if username.nil?
-      response = make_request(url_join(server, api), data_dict, HEADERS)
-    else
-      response = make_request(url_join(server, api), data_dict, encode_credentials(username, password))
+
+    if api_key.nil?
+      api_key = Indico.config['auth']
+    end
+
+    if server.nil?
+      server = Indico.config['cloud']
     end
+
+    response = make_request(url_join(server, api), data_dict,
+                            add_api_key_to_header(api_key))
+
+
     results = JSON.parse(response.body)
-    if results.key?("error")
-      raise results["error"]
+    if results.key?('error')
+      fail results['error']
     else
-      results = results["results"]
+      results['results']
     end
   end
 
@@ -43,11 +57,12 @@ module Indico
     http.request(request)
   end
 
-  def self.encode_credentials(username, password)
-    headers = { "Content-Type" => "application/json", "Accept" => "text/plain" }
-    credentials = username + ":" + password
-    headers["Authorization"] = "Basic " + Base64.strict_encode64(credentials)
+  def self.add_api_key_to_header(api_key)
+    if api_key.nil?
+      raise ArgumentError, 'api key is required'
+    end
+    headers = { 'Content-Type' => 'application/json', 'Accept' => 'text/plain' }
+    headers['X-ApiKey'] = api_key
     headers
   end
-
 end

data/lib/indico/settings.rb

@@ -0,0 +1,93 @@
+require 'inifile'
+
+module Indico
+  private
+
+  class << self; attr_accessor :config; end
+  class << self; attr_accessor :cloud_protocol; end
+
+  Indico.cloud_protocol = 'https://'
+
+  def self.valid_auth(config)
+    # Does a config hashmap have a valid auth definition?
+    return config['auth'] &&
+           config['auth']['api_key']
+  end
+
+  def self.valid_cloud(config)
+    # Does a config hashmap have a valid private cloud definition?
+    return config['private_cloud'] &&
+           config['private_cloud']['cloud']
+  end
+
+  def self.merge_config(prev_config, new_config)
+    # Merge two configurations, giving precedence to the second
+    if self.valid_auth(new_config)
+      prev_config['auth'] = new_config['auth']
+    end
+
+    if self.valid_cloud(new_config)
+      prev_config['private_cloud'] = new_config['private_cloud']
+    end
+
+    return prev_config
+  end
+
+  def self.load_config_files(filenames)
+    # Given a list of filenames, build up an ini file config
+    master_ini = self.new_config()
+
+    for filename in filenames
+      ini = IniFile.load(filename)
+      if not ini then
+        next
+      end
+      master_ini = self.merge_config(master_ini, ini)
+    end
+    return master_ini
+  end
+
+  def self.find_config_files()
+    # Provides a list of paths to search for indicorc files
+    localPath = File.join(Dir.pwd, ".indicorc")
+    globalPath = File.join(Dir.home, ".indicorc")
+    return [globalPath, localPath]
+  end
+
+  def self.load_environment_vars()
+    # Load environment variables into same format as INI file reader
+    return {'auth' => {'api_key' => ENV["INDICO_API_KEY"]},
+              'private_cloud' => {'cloud' => ENV["INDICO_CLOUD"]}}
+  end
+
+  def self.new_config()
+    # Makes a new, empty config object
+    new_config = Hash.new
+    new_config['auth'] = false
+    new_config['cloud'] = false
+    return new_config
+  end
+
+  def self.simplify_config(config)
+    # Goes from nested representation to flatter version
+    new_config = self.new_config()
+    if self.valid_auth(config)
+      new_config['auth'] = config['auth']['api_key']
+    end
+    if self.valid_cloud(config)
+      new_config['cloud'] = config['private_cloud']['cloud']
+    end
+    return new_config
+  end
+
+  def self.load_config()
+    # Finds, loads, and simplifies all configuration types
+    paths = self.find_config_files()
+    config_file = self.load_config_files(paths)
+    env_vars = self.load_environment_vars()
+    config = self.merge_config(config_file, env_vars)
+    return self.simplify_config(config)
+  end
+end
+
+Indico.config = Indico.load_config()

data/lib/indico/version.rb

@@ -1,3 +1,3 @@
 module Indico
-  VERSION = "0.2.0"
+  VERSION = '0.2.2'
 end

data/lib/indico.rb

@@ -1,75 +1,90 @@
-require "indico/version"
-require "indico/helper"
-require "uri"
-require "json"
-require "net/https"
+require 'indico/version'
+require 'indico/helper'
+require 'indico/settings'
+require 'uri'
+require 'json'
+require 'net/https'
 
 module Indico
+  HEADERS = { 'Content-Type' => 'application/json', 'Accept' => 'text/plain' }
 
-  HEADERS = { "Content-Type" => "application/json", "Accept" => "text/plain" }
+  def self.api_key
+    config['auth']
+  end
+
+  def self.api_key=(api)
+    config['auth'] = api
+  end
+
+  def self.private_cloud
+    config['cloud']
+  end
+
+  def self.private_cloud=(cloud)
+    config['cloud'] = cloud
+  end
 
-  def self.political(test_text, username=nil, password=nil, private_cloud=nil)
-    api_handler(test_text, private_cloud, "political", username, password)
+  def self.political(test_text, config = nil)
+    api_handler(test_text, 'political', config)
   end
 
-  def self.batch_political(test_text, username, password, private_cloud=nil)
-    api_handler(test_text, private_cloud, "political/batch", username, password)
+  def self.batch_political(test_text, config = nil)
+    api_handler(test_text, 'political/batch', config)
   end
 
-  def self.posneg(test_text, username=nil, password=nil, private_cloud=nil)
-    api_handler(test_text, private_cloud, "sentiment", username, password)
+  def self.posneg(test_text, config = nil)
+    api_handler(test_text, 'sentiment', config)
   end
 
-  def self.batch_posneg(test_text, username, password, private_cloud=nil)
-    api_handler(test_text, private_cloud, "sentiment/batch", username, password)
+  def self.batch_posneg(test_text, config = nil)
+    api_handler(test_text, 'sentiment/batch', config)
   end
 
   def self.sentiment(*args)
-    self.posneg(*args)
+    posneg(*args)
   end
 
   def self.batch_sentiment(*args)
-    self.batch_posneg(*args)
+    batch_posneg(*args)
   end
 
-  def self.language(test_text, username=nil, password=nil, private_cloud=nil)
-    api_handler(test_text, private_cloud, "language", username, password)
+  def self.language(test_text, config = nil)
+    api_handler(test_text, 'language', config)
   end
 
-  def self.batch_language(test_text, username, password, private_cloud=nil)
-    api_handler(test_text, private_cloud, "language/batch", username, password)
+  def self.batch_language(test_text, config = nil)
+    api_handler(test_text, 'language/batch', config)
   end
 
-  def self.text_tags(test_text, username=nil, password=nil, private_cloud=nil)
-    api_handler(test_text, private_cloud, "texttags", username, password)
+  def self.text_tags(test_text, config = nil)
+    api_handler(test_text, 'texttags', config)
   end
 
-  def self.batch_text_tags(test_text, username, password, private_cloud=nil)
-    api_handler(test_text, private_cloud, "texttags/batch", username, password)
+  def self.batch_text_tags(test_text, config = nil)
+    api_handler(test_text, 'texttags/batch', config)
   end
 
-  def self.fer(face, username=nil, password=nil, private_cloud=nil)
-    api_handler(face, private_cloud, "fer", username, password)
+  def self.fer(face, config = nil)
+    api_handler(face, 'fer', config)
   end
 
-  def self.batch_fer(test_text, username, password, private_cloud=nil)
-    api_handler(test_text, private_cloud, "fer/batch", username, password)
+  def self.batch_fer(test_text, config = nil)
+    api_handler(test_text, 'fer/batch', config)
   end
 
-  def self.facial_features(face, username=nil, password=nil, private_cloud=nil)
-    api_handler(face, private_cloud, "facialfeatures", username, password)
+  def self.facial_features(face, config = nil)
+    api_handler(face, 'facialfeatures', config)
   end
 
-  def self.batch_facial_features(test_text, username, password, private_cloud=nil)
-    api_handler(test_text, private_cloud, "facialfeatures/batch", username, password)
+  def self.batch_facial_features(test_text, config = nil)
+    api_handler(test_text, 'facialfeatures/batch', config)
   end
 
-  def self.image_features(face, username=nil, password=nil, private_cloud=nil)
-    api_handler(face, private_cloud, "imagefeatures", username, password)
+  def self.image_features(face, config = nil)
+    api_handler(face, 'imagefeatures', config)
   end
 
-  def self.batch_image_features(test_text, username, password, private_cloud=nil)
-    api_handler(test_text, private_cloud, "imagefeatures/batch", username, password)
+  def self.batch_image_features(test_text, config = nil)
+    api_handler(test_text, 'imagefeatures/batch', config)
   end
-
 end

data/spec/config/.indicorc.test

@@ -0,0 +1,5 @@
+[auth]
+api_key=testapikey
+
+[private_cloud]
+cloud=testcloud

data/spec/config/.indicorc.test.2

@@ -0,0 +1,2 @@
+[auth]
+api_key=testapikey

data/spec/indico_batch_spec.rb

@@ -1,37 +1,42 @@
 require 'spec_helper'
 require 'set'
 
-$username = ENV['INDICO_USERNAME']
-$password = ENV['INDICO_PASSWORD']
-$private_cloud = 'indico-test'
-
 describe Indico do
+  before do
+    api_key = ENV['INDICO_API_KEY']
+    private_cloud = 'indico-test'
+    @config_private_cloud = { api_key: api_key, cloud: private_cloud}
+    @config = { api_key: api_key}
+  end
 
-  it "should tag text with correct political tags" do
-    expected_keys = Set.new(["Conservative", "Green", "Liberal", "Libertarian"])
-    data = ["Guns don't kill people."," People kill people."]
-    response = Indico.batch_political(data, $username, $password) # Guns don't kill people. People kill people.
+  it 'should tag text with correct political tags' do
+    expected_keys = Set.new(%w(Conservative Green Liberal Libertarian))
+    data = ['Guns don\'t kill people.', ' People kill people.']
+    response = Indico.batch_political(data, @config)
 
     expect(Set.new(response[0].keys)).to eql(expected_keys)
     expect(Set.new(response[1].keys)).to eql(expected_keys)
   end
 
-  it "should access a private cloud" do
-    expected_keys = Set.new(["Conservative", "Green", "Liberal", "Libertarian"])
-    data = ["Guns don't kill people."," People kill people."]
-    response = Indico.batch_political(data, $username, $password, $private_cloud) # Guns don't kill people. People kill people.
+  it 'should access a private cloud' do
+    expected_keys = Set.new(%w(Conservative Green Liberal Libertarian))
+    data = ['Guns don\'t kill people.', ' People kill people.']
+    
+    # for mocking: use http instead of https to route requests to our public cloud
+    Indico.cloud_protocol = 'http://'
+    response = Indico.batch_political(data, @config_private_cloud)
+    Indico.cloud_protocol = 'https://'
 
     expect(Set.new(response[0].keys)).to eql(expected_keys)
     expect(Set.new(response[1].keys)).to eql(expected_keys)
   end
 
-  it "should tag text with correct sentiment tags" do
-    response = Indico.batch_sentiment(["Worst movie ever."], $username, $password)
-
+  it 'should tag text with correct sentiment tags' do
+    response = Indico.batch_sentiment(['Worst movie ever.'], @config)
     expect(response[0] < 0.5).to eql(true)
   end
 
-  it "should tag text with correct language tags" do
+  it 'should tag text with correct language tags' do
     expected_keys = Set.new([
       'English',
       'Spanish',
@@ -70,64 +75,63 @@ describe Indico do
     ])
 
     data = ['Quis custodiet ipsos custodes', 'Clearly english, foo!']
-    response = Indico.batch_language(data, $username, $password)
+    response = Indico.batch_language(data, @config)
 
     expect(Set.new(response[0].keys)).to eql(expected_keys)
     expect(Set.new(response[1].keys)).to eql(expected_keys)
   end
 
-  it "should tag text with correct text tags" do
-    expected_keys = Set.new(['fashion', 'art', 'energy', 'economics', 'entrepreneur',
-                             'books', 'politics', 'gardening', 'nba', 'conservative',
-                             'technology', 'startups', 'relationships', 'education',
-                             'humor', 'psychology', 'bicycling', 'investing', 'travel',
-                             'cooking', 'christianity', 'environment', 'religion', 'health',
-                             'hockey', 'pets', 'music', 'soccer', 'guns', 'gaming', 'jobs',
-                             'business', 'nature', 'food', 'cars', 'photography', 'philosophy',
-                             'geek', 'sports', 'baseball', 'news', 'television', 'entertainment',
-                             'parenting', 'comics', 'science', 'nfl','programming',
-                             'personalfinance', 'atheism', 'movies', 'anime', 'fitness',
-                             'military', 'realestate', 'history'])
-
-    data = ["Guns don't kill people.", "People kill people."]
-    response = Indico.batch_text_tags(data, $username, $password) # Guns don't kill people. People kill people.
+  it 'should tag text with correct text tags' do
+    expected_keys = Set.new(%w(fashion art energy economics entrepreneur
+                               books politics gardening nba conservative
+                               technology startups relationships education
+                               humor psychology bicycling investing travel
+                               cooking christianity environment religion health
+                               hockey pets music soccer guns gaming jobs
+                               business nature food cars photography philosophy
+                               geek sports baseball news television
+                               entertainment parenting comics science nfl
+                               programming personalfinance atheism movies anime
+                               fitness military realestate history))
+
+    data = ['Guns don\'t kill people.', 'People kill people.']
+    response = Indico.batch_text_tags(data, @config)
 
     expect Set.new(response[0].keys).subset?(Set.new(expected_keys))
     expect Set.new(response[1].keys).subset?(Set.new(expected_keys))
   end
 
-  it "should tag face with correct facial expression" do
-    expected_keys = Set.new(["Angry", "Sad", "Neutral", "Surprise", "Fear", "Happy"])
-    test_face = Array.new(48){Array.new(48){rand(100)/100.0} }
-    response = Indico.batch_fer([test_face, test_face], $username, $password)
+  it 'should tag face with correct facial expression' do
+    expected_keys = Set.new(%w(Angry Sad Neutral Surprise Fear Happy))
+    test_face = Array.new(48) { Array.new(48) { rand(100) / 100.0 } }
+    response = Indico.batch_fer([test_face, test_face], @config)
 
     expect(Set.new(response[0].keys)).to eql(expected_keys)
     expect(Set.new(response[1].keys)).to eql(expected_keys)
   end
 
-  it "should tag face with correct facial features" do
-    test_face = Array.new(48){Array.new(48){rand(100)/100.0} }
-    response = Indico.batch_facial_features([test_face, test_face], $username, $password)
-
+  it 'should tag face with correct facial features' do
+    test_face = Array.new(48) { Array.new(48) { rand(100) / 100.0 } }
+    response = Indico.batch_facial_features([test_face, test_face], @config)
     expect(response[0].length).to eql(48)
     expect(response[1].length).to eql(48)
   end
 
-  it "should tag image with correct image features" do
-    test_image = Array.new(48){Array.new(48){rand(100)/100.0} }
-    response = Indico.batch_image_features([test_image, test_image], $username, $password)
-
+  it 'should tag image with correct image features' do
+    test_image = Array.new(48) { Array.new(48) { rand(100) / 100.0 } }
+    response = Indico.batch_image_features([test_image, test_image], @config)
     expect(response[0].length).to eql(2048)
     expect(response[1].length).to eql(2048)
   end
 
   # Uncomment when frontend updated to accept image urls
   # it "should accept image urls" do
-  #   test_image = "http://icons.iconarchive.com/icons/oxygen-icons.org/oxygen/48/Emotes-face-smile-icon.png"
-  #   response = Indico.batch_image_features([test_image, test_image], $username, $password)
+  #   test_image = 'http://icons.iconarchive.com/icons/oxygen-icons.org/' +
+  #                'oxygen/48/Emotes-face-smile-icon.png'
+  #   response = Indico.batch_image_features([test_image, test_image],
+  #                                          @config)
 
   #   expect(response[0].length).to eql(2048)
   #   expect(response[1].length).to eql(2048)
   # end
-
 end

data/spec/indico_spec.rb

@@ -1,34 +1,38 @@
 require 'spec_helper'
 require 'set'
 
-$username = ENV['INDICO_USERNAME']
-$password = ENV['INDICO_PASSWORD']
-$private_cloud = 'indico-test'
-
 describe Indico do
+  before do
+    api_key = ENV['INDICO_API_KEY']
+    private_cloud = 'indico-test'
+    @config = { api_key: api_key, cloud: private_cloud}
+  end
 
-  it "should tag text with correct political tags" do
-    expected_keys = Set.new(["Conservative", "Green", "Liberal", "Libertarian"])
-    response = Indico.political("Guns don't kill people. People kill people.") # Guns don't kill people. People kill people.
+  it 'should tag text with correct political tags' do
+    expected_keys = Set.new(%w(Conservative Green Liberal Libertarian))
+    response = Indico.political('Guns don\'t kill people. People kill people.')
 
     expect(Set.new(response.keys)).to eql(expected_keys)
   end
 
-  it "should tag text with correct political tags" do
-    expected_keys = Set.new(["Conservative", "Green", "Liberal", "Libertarian"])
-    data = "Guns don't kill people. People kill people."
-    response = Indico.political(data, $username, $password, $private_cloud) # Guns don't kill people. People kill people.
-
+  it 'should tag text with correct political tags' do
+    expected_keys = Set.new(%w(Conservative Green Liberal Libertarian))
+    data = 'Guns don\'t kill people. People kill people.'
+    
+    # for mocking: use http to redirect requests to our public cloud endpoint
+    Indico.cloud_protocol = 'http://'
+    response = Indico.political(data, @config)
+    Indico.cloud_protocol = 'https://'
     expect(Set.new(response.keys)).to eql(expected_keys)
   end
 
-  it "should tag text with correct sentiment tags" do
-    response = Indico.sentiment("Worst movie ever.")
+  it 'should tag text with correct sentiment tags' do
+    response = Indico.sentiment('Worst movie ever.')
 
     expect(response < 0.5).to eql(true)
   end
 
-  it "should tag text with correct language tags" do
+  it 'should tag text with correct language tags' do
     expected_keys = Set.new([
       'English',
       'Spanish',
@@ -70,51 +74,59 @@ describe Indico do
     expect(Set.new(response.keys)).to eql(expected_keys)
   end
 
-  it "should tag text with correct text tags" do
-    expected_keys = Set.new(['fashion', 'art', 'energy', 'economics', 'entrepreneur',
-                             'books', 'politics', 'gardening', 'nba', 'conservative',
-                             'technology', 'startups', 'relationships', 'education',
-                             'humor', 'psychology', 'bicycling', 'investing', 'travel',
-                             'cooking', 'christianity', 'environment', 'religion', 'health',
-                             'hockey', 'pets', 'music', 'soccer', 'guns', 'gaming', 'jobs',
-                             'business', 'nature', 'food', 'cars', 'photography', 'philosophy',
-                             'geek', 'sports', 'baseball', 'news', 'television', 'entertainment',
-                             'parenting', 'comics', 'science', 'nfl','programming',
-                             'personalfinance', 'atheism', 'movies', 'anime', 'fitness',
-                             'military', 'realestate', 'history'])
-    response = Indico.text_tags("Guns don't kill people. People kill people.") # Guns don't kill people. People kill people.
+  it 'should tag text with correct text tags' do
+    expected_keys = Set.new(%w(fashion art energy economics entrepreneur
+                               books politics gardening nba conservative
+                               technology startups relationships education
+                               humor psychology bicycling investing travel
+                               cooking christianity environment religion health
+                               hockey pets music soccer guns gaming jobs
+                               business nature food cars photography philosophy
+                               geek sports baseball news television
+                               entertainment parenting comics science nfl
+                               programming personalfinance atheism movies anime
+                               fitness military realestate history))
+    response = Indico.text_tags('Guns don\'t kill people. People kill people.')
 
     expect Set.new(response.keys).subset?(Set.new(expected_keys))
   end
 
-  it "should tag face with correct facial expression" do
-    expected_keys = Set.new(["Angry", "Sad", "Neutral", "Surprise", "Fear", "Happy"])
-    test_face = Array.new(48){Array.new(48){rand(100)/100.0} }
+  it 'should tag face with correct facial expression' do
+    expected_keys = Set.new(%w(Angry Sad Neutral Surprise Fear Happy))
+    test_face = Array.new(48) { Array.new(48) { rand(100) / 100.0 } }
 
     response = Indico.fer(test_face)
 
     expect(Set.new(response.keys)).to eql(expected_keys)
   end
 
-  it "should tag face with correct facial features" do
-    test_face = Array.new(48){Array.new(48){rand(100)/100.0} }
+  it 'should tag face with correct facial features' do
+    test_face = Array.new(48) { Array.new(48) { rand(100) / 100.0 } }
     response = Indico.facial_features(test_face)
 
     expect(response.length).to eql(48)
   end
 
-  it "should tag image with correct image features" do
-    test_image = Array.new(48){Array.new(48){rand(100)/100.0} }
+  it 'should tag image with correct image features' do
+    test_image = Array.new(48) { Array.new(48) { rand(100) / 100.0 } }
+    response = Indico.image_features(test_image)
+
+    expect(response.length).to eql(2048)
+  end
+
+  it "should tag rgb image with correct image features" do
+    test_image = Array.new(48){Array.new(48){Array.new(3){rand(100)/100.0}}}
     response = Indico.image_features(test_image)
 
     expect(response.length).to eql(2048)
   end
 
   # Uncomment when frontend updated to accept image urls
-  # it "should accept image urls" do
-  #   response = Indico.image_features("http://icons.iconarchive.com/icons/oxygen-icons.org/oxygen/48/Emotes-face-smile-icon.png")
+  # it 'should accept image urls' do
+  #   response = Indico.image_features('http://icons.iconarchive.com/icons/' +
+  #                                    'oxygen-icons.org/oxygen/48/' +
+  #                                    'Emotes-face-smile-icon.png')
 
   #   expect(response.length).to eql(2048)
   # end
-
 end

data/spec/settings_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe Indico do
+    it 'should correctly parse an ini file without raising an error' do
+        Indico.load_config_files(Indico.find_config_files())
+    end
+
+    it 'should find the correct config files' do
+        files = Indico.find_config_files()
+        expect(files[0]).to eql("#{Dir.home}/.indicorc")
+        expect(files[1]).to eql("#{Dir.pwd}/.indicorc")
+    end
+
+    it 'should read in config files properly' do
+        files = [
+            File.expand_path('../config/.indicorc.test', __FILE__),
+            File.expand_path('../config/.indicorc.test.2', __FILE__)
+        ]
+        config = Indico.load_config_files(files)
+        expected_auth = Hash.new
+        expected_auth['api_key'] = 'testapikey'
+        expect(config['auth']).to eql(expected_auth)
+    end
+
+    it 'should read in variables from the user\'s environment' do
+        api_key = 'testapikey'
+        cloud = 'cloud'
+        ENV['INDICO_API_KEY'] = api_key
+        ENV['INDICO_CLOUD'] = cloud
+
+        config = Indico.load_environment_vars()
+        expected_auth = Hash.new
+        expected_auth['api_key'] = 'testapikey'
+
+        expected_cloud = Hash.new
+        expected_cloud['cloud'] = cloud
+
+        expect(config['auth']).to eql(expected_auth)
+        expect(config['private_cloud']).to eql(expected_cloud)
+    end
+
+    it 'should combine file and env variable configuration' do
+        api_key = 'testapikey'
+        cloud = 'cloud'
+        ENV['INDICO_API_KEY'] = api_key
+        ENV['INDICO_CLOUD'] = cloud
+
+        expected = Hash.new
+        expected['auth'] = api_key
+        expected['cloud'] = cloud
+
+        config = Indico.load_config()
+        expect(config).to eql(expected)
+    end
+
+    it 'should merge configurations properly' do
+
+        file_api_key = 'file-api-key'
+        file_cloud = 'file-cloud'
+        file_config = Hash.new
+        file_config['auth'] = Hash.new
+        file_config['private_cloud'] = Hash.new
+        file_config['auth']['api_key'] = file_api_key
+        file_config['private_cloud']['cloud'] = file_cloud
+
+        env_api_key = 'env-api-key'
+        env_cloud = 'env-cloud'
+        ENV['INDICO_API_KEY'] = env_api_key
+        ENV['INDICO_CLOUD'] = env_cloud
+
+        env_config = Indico.load_environment_vars()
+        merged = Indico.merge_config(file_config, env_config)
+        expect(merged['auth']['api_key']).to eql(env_api_key)
+        expect(merged['private_cloud']['cloud']).to eql(env_cloud)
+    end
+
+    it 'should set api key with a call to set_api_key' do
+        Indico.api_key = nil
+        begin
+            Indico.political('Guns don\'t kill people. People kill people.')
+        rescue ArgumentError => exception
+            expect(exception.message).to eql('api key is required')
+        else
+            fail('api_key was not null')
+        end
+
+        begin
+            Indico.political('Guns don\'t kill people. People kill people.')
+        rescue ArgumentError => exception
+            expect(exception.message).to eql('api key is required')
+        else
+            fail('api_key was not null')
+        end
+    end
+end

data/spec/spec_helper.rb

@@ -2,7 +2,7 @@ require 'indico'
 
 # This file was generated by the `rspec --init` command. Conventionally, all
 # specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
-# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# The generated `.rspec` file contains `--require spec_helper` which causes this
 # file to always be loaded, without a need to explicitly require it in any files.
 #
 # Given that it is always loaded, you are encouraged to keep this file as

metadata

@@ -1,17 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: indico
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.2
   prerelease: 
 platform: ruby
 authors:
 - Slater Victoroff
 - Amit Ambardekar
+- Madison May
+- Annie Carlson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-20 00:00:00.000000000 Z
+date: 2015-04-08 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: inifile
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -64,6 +82,8 @@ description: A simple Ruby Wrapper for the indico set of APIs.
 email:
 - slater@indico.io
 - amitamb@gmail.com
+- madison@indico.io
+- annie@indico.io
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -77,9 +97,13 @@ files:
 - indico.gemspec
 - lib/indico.rb
 - lib/indico/helper.rb
+- lib/indico/settings.rb
 - lib/indico/version.rb
+- spec/config/.indicorc.test
+- spec/config/.indicorc.test.2
 - spec/indico_batch_spec.rb
 - spec/indico_spec.rb
+- spec/settings_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/IndicoDataSolutions/IndicoIo-ruby
 licenses:
@@ -106,7 +130,4 @@ rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: A simple Ruby Wrapper for the indico set of APIs.
-test_files:
-- spec/indico_batch_spec.rb
-- spec/indico_spec.rb
-- spec/spec_helper.rb
+test_files: []