lymbix 0.3.1

data/Changelog

@@ -0,0 +1,26 @@
+v0.3.1 - rechanged dominant_words to use dominant_words on gyrus
+v0.3.0 - changed dominant_words to post to dominants in gyrus instead of dominant_words, removed dominant_words_limit, removed promote method since we won't use it
+v0.2.9 - fix response to_s
+v0.2.8 - tonecheck beta functionality
+v0.2.7 - added archive_user_data
+v0.2.6 - changes for Medulla ratings reviewing
+v0.2.5 - changes for Medulla release
+v0.2.4 - gold data and new user fields (demographic information)
+v0.2.3 - added last_checkout_date param to bad_ratings_count method
+v0.2.2 - added method to get bad ratings count for toneaday users
+v0.2.1 - changed the response for DataPoint.create method, added :phrase param to be able to rate words with gem
+v0.2.0 - included the :worker_id parameter for data_points, added dominant_words_limit method, you can specify how many words you want back
+v0.2.0 - changed response to json for contribution_count
+v0.2.0 - added create method DataPoint
+v0.1.7 - expunge method added
+v0.1.6 - passing lymbix_user_id on authorize
+v0.1.5 - authentication returns xml or json
+v0.1.4 - Added open bar authentication
+v0.0.8 - Added user fields for update and authenticate
+v0.0.7 - error messages
+v0.0.6 - production urlsponse 
+v0.0.5 - added files in gemspec
+v0.0.4 - Working prototype, more classes
+v0.0.3 - Put functionality in different files, request and base for now
+v0.0.2 - Changing the gem to connect to fornix for authentication
+v0.0.1 - Built gem

data/LICENSE

@@ -0,0 +1 @@
+# Lymbix

data/README

@@ -0,0 +1,36 @@
+= Lymbix
+
+Lymbix gives you the ability to determine the tone of any phrase or passage.
+
+  @lymbix.tonalize_phrase "This is a test passage"
+
+To be able to access this resource - please go to http://www.toneapi.com and create an account. You need to agree to the licensing terms, and your account needs to be approved.
+
+Some resources to help you along the way:
+
+#Add resources
+
+== Example usage
+
+Authentication:
+
+  @lymbix = Lymbix::Base.authenticate('user@example.com','secretpassword', application_id)
+
+Get the tone of words/phrases:
+
+  @lymbix.tonalize_phrase "This is a test passage"
+
+Connotative Categories:
+
+  @lymbix.all_connotative_categories
+
+Database Size:
+ 
+  @lymbix.word_count
+
+
+== Authors and credits
+
+Authors::                Pat Roy, Josh Merchant
+Copyright::				 Lymbix Inc
+License::				 Subject to licensing terms - see http://www.toneapi.com

data/lib/lymbix.rb

@@ -0,0 +1,218 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'lymbix/user'
+require 'lymbix/request'
+require 'lymbix/response'
+require 'lymbix/word'
+require 'lymbix/base'
+require 'lymbix/connotative_category'
+require 'lymbix/tweet'
+require 'lymbix/data_point'
+
+
+# require 'rest_client'
+# require 'json'
+# require 'benchmark'
+# 
+# module Lymbix
+# 
+#   GYRUS_URL = "http://localhost:4567"
+#   FORNIX_URL = "http://localhost:9393"
+# 
+#   @@auth_token = ''
+#   @@response = nil
+# 
+#   cattr_accessor :auth_token
+# 
+# 
+#   def self.request(resource, action = "get", object = nil, fornix = false)
+#     result = nil
+#     connection = RestClient::Resource.new(fornix ? FORNIX_URL : GYRUS_URL, :headers => { :AUTHENTICATION => @@auth_token })
+#     case(action)
+#     when "get"
+#       result = connection[resource].get
+#     when "post"
+#       result = connection[resource].post object
+#     end
+#     result
+#   end
+# 
+#   #--------------------------------------------------------------------------
+#   # BaseObject
+#   #==========================================================================
+# 
+#   class BaseObject < Struct
+#   end
+# 
+#   #--------------------------------------------------------------------------
+#   # Users
+#   #==========================================================================
+#   
+#   User = BaseObject.new(:id, :login, :email, :gender, :country, :state, :age)
+#   
+#   class User
+# 
+#     def self.authenticate(login, password)
+#       resp = Lymbix::request("login", "post", {:login => login, :password => password}, true)
+#       return nil if resp == "null"
+# 
+#       user = JSON.load(resp)
+# 
+#       User.new(user["id"], user["login"], user["email"], user["gender"], user["country"], user["state"], user["age"])
+#     end
+# 
+#   end
+# 
+#   #--------------------------------------------------------------------------
+#   # Words
+#   #==========================================================================
+# 
+#   Word = BaseObject.new(:id, :word, :is_external, :is_phrase)
+# 
+#   #<struct Lymbix::Word id={:is_external=>false, :id=>34941, :word=>"demand"}, word=nil, is_external=nil>
+# 
+#   class Word
+# 
+#     def self.count
+#       resp = Lymbix::request('word_count')
+#     end
+# 
+#     def self.top_random
+#       resp = Lymbix::request('top_random')
+#       word = JSON.load(resp)
+# 
+#       return nil if word.nil? || word.empty?
+#       Word.new(word["id"], word["word"], word["is_external"], word["is_phrase"])
+#     end
+# 
+#     def self.add_word(word, definition, is_phrase = false)
+#       resp = Lymbix::request('words', 'post', {:word => word, :definition => definition, :is_external => true, :is_phrase => is_phrase})
+#       word = JSON.load(resp)
+#       return nil if word.nil? || word.empty?
+#       Word.new(word["id"], word["word"], word["is_external"], word["is_phrase"])
+#     end
+# 
+#     def self.lookup(word)
+#       resp = Lymbix::request("lookup/#{word}")
+#       return nil if resp == "null"
+# 
+#       word = JSON.load(resp)
+# 
+#       return nil if word.nil? || word.empty?
+#       Word.new(word["id"], word["word"], word["is_external"], word["is_phrase"])
+#     end
+# 
+#     def self.search(word)
+#       resp = Lymbix::request("search/#{word}")
+#       word = JSON.load(resp)
+# 
+#       return nil if word.nil? || word.empty?
+#       Word.new(word["id"], word["word"], word["is_external"], word["is_phrase"])
+#     end
+# 
+#     def self.find(word_id)
+#       resp = Lymbix::request("words/#{word_id}")
+#       word = JSON.load(resp)
+# 
+#       return nil if word.nil? || word.empty?
+#       Word.new(word["id"], word["word"], word["is_external"], word["is_phrase"])
+#     end
+# 
+#     def definitions
+#       Definition::list(self.id)
+#     end
+# 
+#   end
+# 
+#   #--------------------------------------------------------------------------
+#   # Tweets
+#   #==========================================================================
+# 
+#   Tweet = BaseObject.new(:id, :is_user_created, :tweet, :requested_count)
+# 
+#   class Tweet
+# 
+#     def self.top_tweet
+#       resp = Lymbix::request('top_tweet')
+#       resp = JSON.load(resp)
+# 
+#       return nil if resp.nil?
+#       Tweet.new(resp["id"], resp["is_user_created"], resp["tweet"], resp["requested_count"])
+#     end
+# 
+#   end
+# 
+# 
+#   #--------------------------------------------------------------------------
+#   # Definitions
+#   #==========================================================================
+# 
+#   Definition = BaseObject.new(:id, :pos, :category_id, :definition)
+# 
+#   class Definition
+# 
+#     def self.list(word_id)
+#       resp = Lymbix::request("word/#{word_id}/definitions")   #Change to Words
+#       definitions = JSON.load(resp)
+#       definition_list = []
+#       definitions.each do |definition|
+#         definition_list << Definition.new(definition["id"], definition["pos"], definition["category_id"], definition["definition"])
+#       end 
+#       definition_list
+#     end
+# 
+#     def self.find(definition_id)
+#       resp = Lymbix::request("definitions/#{definition_id}")
+#       definition = JSON.load(resp)
+#       Definition.new(definition["id"], definition["pos"], definition["category_id"], definition["definition"])
+#     end
+# 
+#   end
+# 
+#   #--------------------------------------------------------------------------
+#   # ConnotativeCategory
+#   #==========================================================================
+# 
+#   ConnotativeCategory = BaseObject.new(:id, :name, :is_positive)
+# 
+#   class ConnotativeCategory
+#     def self.all
+#       resp = Lymbix::request("connotative_categories")
+#       connotative_categories = JSON.load(resp)
+#       connotative_categories_list = []
+#       connotative_categories.each do |connotative_category|
+#         connotative_categories_list << ConnotativeCategory.new(connotative_category["id"], connotative_category["name"], connotative_category["is_positive"])
+#       end
+#       puts connotative_categories_list.inspect
+#       connotative_categories_list
+#     end
+# 
+#     def self.find(id)
+#       resp = Lymbix::request("connotative_categories/#{id}")
+#       connotative_category = JSON.load(resp)
+#       ConnotativeCategory.new(connotative_category["id"], connotative_category["name"], connotative_category["is_positive"])
+#     end
+#   end
+# 
+#   #--------------------------------------------------------------------------
+#   # DataPoint
+#   #==========================================================================
+# 
+#   DataPoint = BaseObject.new(:id, :word_id, :definition_id, :category_id, :data, :created_at, :updated_at, :user_id)
+# 
+#   class DataPoint
+#     def save
+#       resp = Lymbix::request("data_points", "post", {:word_id => self["word_id"], :definition_id => self["definition_id"], :category_id => self["category_id"], :data => self["data"], :user_id => self["user_id"]})
+#       data_point = JSON.load(resp)
+#       DataPoint.new(data_point["id"], data_point["word_id"], data_point["definition_id"], data_point["category_id"], data_point["data"], data_point["created_at"], data_point["updated_at"], data_point["user_id"])
+#     end
+# 
+#     def self.find(data_point_id)
+#       resp = Lymbix::request("data_points/#{data_point_id}")
+#       data_point = JSON.load(resp)
+#       DataPoint.new(data_point["id"], data_point["word_id"], data_point["definition_id"], data_point["category_id"], data_point["data"], data_point["created_at"], data_point["updated_at"], data_point["user_id"])
+#     end
+# 
+#   end
+# 
+# end

data/lib/lymbix/base.rb

@@ -0,0 +1,215 @@
+module Lymbix
+
+  class Base
+    attr_accessor :auth_key, :app_id, :lymbix_user_id, :error_messages, :user
+    
+    def initialize(options)
+      unless options[:error_messages]
+        @auth_key = options[:auth_key]
+        @app_id = options[:app_id]
+        @lymbix_user_id = options[:lymbix_user_id]
+        @user = User.new(options[:user].merge({:auth_key => options[:auth_key]})) if options[:user]
+        if @user
+          @lymbix_user_id = @user.lymbix_user_id
+        end
+      else
+        @error_messages = options[:error_messages]
+      end
+    end
+    
+    def open_bar_auth_key(options)
+      response = Lymbix::Request.new(:post, 'open_bar_auth_key', {:lymbix_user_id => options[:lymbix_user_id], :auth_key => options[:auth_key], :app_id => options[:app_id]}, :app_id => options[:app_id], :other_app_id => options[:other_app_id]).run
+      response.data["auth_key"]
+    end
+    
+    def self.authenticate(email, password, app_id)
+      response = Lymbix::Request.new(:post, 'authenticate', {:app_id => app_id}, {:app_id => app_id, :email => email, :password => password}).run
+      hash_response = response.data.to_hash
+      self.new(:auth_key => hash_response["auth_key"], :app_id => app_id, :user => {:name => hash_response["name"], :age => hash_response["age"], :country => hash_response["country"], :state => hash_response["state"], :lymbix_user_id => hash_response["id"], :gender => hash_response["gender"], :error_messages => []})
+    rescue RestClient::Unauthorized
+      self.new(:error_messages => "Wrong Password")
+    rescue Exception => ex
+      self.new(:error_messages => "#{ex.message} \n #{ex.backtrace}")
+    end
+    
+    def service_up
+      response = request(:get, 'service_up').data
+    end
+    
+    def word_count      
+      response = request(:get, 'word_count').data
+      response["count"].to_i
+    end
+    
+    def contribution_count      
+      response = request(:get, 'contribution_count').data
+      response["contribution_count"].to_i
+    end
+    
+    def toneaday_daily_best      
+      response = request(:get, 'toneaday_daily_best').data
+      puts response["daily_toneaday_user_id"].to_i
+      [response["daily_toneaday_user_id"].to_i, response["daily_toneaday_contribution_count"].to_i]
+    end
+    
+    def toneaday_weekly_best      
+      response =  request(:get, 'toneaday_weekly_best').data
+      [response["weekly_toneaday_user_id"].to_i, response["weekly_toneaday_contribution_count"].to_i]
+    end
+    
+    def user_contribution_count(user_id)      
+      response = request(:get, "contribution_count/#{user_id}").data
+      response["contribution_count"].to_i
+    end
+    
+    def tonalized_words_count
+      response = request(:get, 'tonalized_words').data
+      response["tonalized_words_count"].to_i
+    end
+    
+    def word_top_random
+      response = request(:get, 'word_top_random')
+      Word.new(:id => response.data["id"], :word => response.data["word"], :is_external => response.data["is_external"], :is_phrase => response.data["is_phrase"])
+    end
+    
+    def gold_word_top_random
+      response = request(:get, 'gold_word_top_random')
+      Word.new(:id => response.data["id"], :word => response.data["word"], :is_external => response.data["is_external"], :is_phrase => response.data["is_phrase"])
+    end
+    
+    
+    def word_lookup(word)
+      response = request(:get, "lookup/#{URI.escape(word)}")
+      if response.data
+        Word.new(:id => response.data["id"], :word => response.data["word"], :is_external => response.data["is_external"], :is_phrase => response.data["is_phrase"])
+      else
+        nil
+      end
+    end
+    
+    def add_word(word, definition, is_phrase = false)
+      ActiveRecord::Base.logger.info "ADD_WORD START"
+      response = request(:post, 'words', {:word => word, :definition => definition, :is_external => true, :is_phrase => is_phrase}) 
+      ActiveRecord::Base.logger.info "ADD_WORD END #{response.inspect}"
+      Word.new(:id => response.data["id"], :word => response.data["word"], :is_external => response.data["is_external"], :is_phrase => response.data["is_phrase"])
+    end
+    
+    def bad_ratings_count(user_id,last_checkout_date)
+      response = request(:get, "bad_ratings_count/#{user_id}/#{last_checkout_date}")
+    end
+    
+    def expunge(word)
+      response = request(:post,'expunge', {:word => word})
+    end
+    
+    # MODERATION
+      
+    def approve_tonecheck_beta(user_id)
+      response = request(:post, 'approve_tonecheck_beta', {:user_id => user_id})
+    end
+        
+    def reset_tonecheck_beta(user_id)
+      response = request(:post, 'reset_tonecheck_beta', {:user_id => user_id})
+    end
+    
+    def tonecheck_beta_count
+      response = request(:get, 'tonecheck_beta_count', {:app_id => @app_id})
+      response.data['tonecheck_beta_count']
+    end
+    
+    def tonecheck_beta
+      response = request(:get, 'tonecheck_beta', {:app_id => @app_id})
+      response.data['tonecheck_beta']
+    end
+    
+    def moderated_count
+      response = request(:get, 'moderated_count', {:app_id => @app_id})
+      response.data['moderated_count']
+    end
+    
+    def unmoderated_count
+      response = request(:get, 'unmoderated_count', {:app_id => @app_id})
+      response.data['unmoderated_count'] 
+    end
+    
+    def moderated
+      response = request(:get, 'moderated', {:app_id => @app_id})
+      response.data['moderated']
+    end
+    
+    def unmoderated
+      response = request(:get, 'unmoderated', {:app_id => @app_id})
+      response.data['unmoderated'] 
+    end
+    
+    def user_data_points(user_id, page = 1, earnings_in_cents = 0)
+      response = request(:get, "user_data_points/#{user_id}/#{page}/#{earnings_in_cents}", {:app_id => @app_id})
+      response.data['data']
+    end
+    
+    def user_search(query)
+      response = request(:post, "user_search", {:app_id => @app_id, :query => query})
+      response.data['users']
+    end
+    
+    def find_user_by_id(user_id)
+      response = request(:post, "find_user_by_id", {:app_id => @app_id, :user_id => user_id})
+      response.data['user']
+    end
+    
+    def find_users_by_ids(user_ids)
+      response = request(:post, "find_users_by_ids", {:app_id => @app_id, :user_ids => user_ids.join(',')})
+      response.data['users']
+    end
+    
+    def archive_user_data(user_id)
+      response = request(:post, "archive_user_data/#{user_id}", {:app_id => @app_id})
+      response
+    end
+    
+    # END
+    
+    def tonalize_words(phrase)
+      response = request(:post, 'tonalize_words', {:phrase => phrase}).data
+    end
+    
+    def tone_alternates(phrase)
+      response = request(:post, 'suggestions',{:phrase => phrase}).data
+    end
+    
+    def suggest_alternates(phrase,alternates)
+      response = request(:post, 'suggest_alternates',{:phrase => phrase, :alternates => alternates}).data
+    end
+    
+    def all_connotative_categories
+      response = request(:get, 'connotative_categories')
+      all_cc = []
+      response.data.each do |cc|
+        all_cc << ConnotativeCategory.new(:id => cc["id"], :name => cc["name"], :is_positive => cc["is_positive"])
+      end
+      all_cc
+    end
+    
+    def top_tweet
+      response = request(:get, 'top_tweet').data
+      tweet = Tweet.new(:id => response["id"], :is_user_created => response["is_user_created"], :tweet => response["tweet"], :requested_count => response["requested_count"])
+      tweet.instance_variable_set(:@phrases_found,response["phrases_found"])
+      return tweet
+    end
+    
+    def dominant_words(phrase)
+      response = request(:post, 'dominant_words',{:phrase => phrase}).data
+    end
+    
+    def swap_groups(lymbix_user_id, group_remove, group_add)
+      response = request(:post, 'swap_groups', {:lymbix_user_id => lymbix_user_id, :group_remove => group_remove, :group_add => group_add})
+    end
+    
+    private
+    def request(action, method, data = nil)
+      Lymbix::Request.new(action, method, {:app_id => @app_id, :auth_key => @auth_key, :lymbix_user_id => @lymbix_user_id}, data).run
+    end
+
+  end
+
+end

data/lib/lymbix/connotative_category.rb

@@ -0,0 +1,15 @@
+module Lymbix
+
+  class ConnotativeCategory
+
+    attr_accessor :id, :name, :is_positive
+
+    def initialize(options)
+      @id = options[:id]
+      @name = options[:name]
+      @is_positive = options[:is_positive]
+    end
+
+  end
+end
+

data/lib/lymbix/data_point.rb

@@ -0,0 +1,61 @@
+module Lymbix
+
+  class DataPoint
+
+    attr_accessor :id, :word_id, :definition_id, :category_id, :data, :created_at, :updated_at, :user_id, :auth_key, :app_id, :lymbix_user_id
+
+    def initialize(data = nil)
+      if data
+        @id = data[:id]
+        @word_id = data[:word_id]
+        @definition_id = data[:definition_id]
+        @category_id = data[:category_id]
+        @data = data[:data]
+        @created_at = data[:created_at]
+        @updated_at = data[:updated_at]
+        @user_id = data[:user_id]
+        @app_id = data[:app_id]
+        @auth_key = data[:auth_key]
+        @lymbix_user_id = data[:lymbix_user_id]
+      end
+    end
+    
+    def self.create(data)
+      categories_data = "{"
+      data[:data_points].each do |dp|
+        categories_data << ":category_id_#{dp[:category_id]} => #{dp[:data]},"
+      end
+      categories_data.chop!
+      categories_data << "}"
+      response = Lymbix::Request.new(:post, "data_points",{:app_id => data[:app_id], :auth_key => data[:auth_key], :lymbix_user_id => data[:lymbix_user_id]}, {:worker_id => data[:worker_id], :phrase => data[:phrase], :word_id => data[:word_id], :definition_id => data[:definition_id], :user_id => data[:user_id], :lymbix_user_id => data[:lymbix_user_id]}.merge!(eval(categories_data))).run
+    end
+    
+    def save
+      response = Lymbix::Request.new(:post, "data_points",{:app_id => @app_id, :auth_key => @auth_key, :lymbix_user_id => @lymbix_user_id}, {:word_id => @word_id, :definition_id => @definition_id, :category_id => @category_id, :data => @data, :user_id => @user_id}).run
+      DataPoint.new(:id => response.data["id"], :word_id => response.data["word_id"], :definition_id => response.data["definition_id"], :category_id => response.data["category_id"], :data => response.data["data"], :created_at => response.data["created_at"], :updated_at => response.data["updated_at"], :user_id => response.data["user_id"], :lymbix_user_id => response.data["lymbix_user_id"])
+    end
+
+  end
+end
+
+
+#   #--------------------------------------------------------------------------
+#   # DataPoint
+#   #==========================================================================
+# 
+#   DataPoint = BaseObject.new(:id, :word_id, :definition_id, :category_id, :data, :created_at, :updated_at, :user_id)
+# 
+#   class DataPoint
+#     def save
+#       resp = Lymbix::request("data_points", "post", {:word_id => self["word_id"], :definition_id => self["definition_id"], :category_id => self["category_id"], :data => self["data"], :user_id => self["user_id"]})
+#       data_point = JSON.load(resp)
+#       DataPoint.new(data_point["id"], data_point["word_id"], data_point["definition_id"], data_point["category_id"], data_point["data"], data_point["created_at"], data_point["updated_at"], data_point["user_id"])
+#     end
+# 
+#     def self.find(data_point_id)
+#       resp = Lymbix::request("data_points/#{data_point_id}")
+#       data_point = JSON.load(resp)
+#       DataPoint.new(data_point["id"], data_point["word_id"], data_point["definition_id"], data_point["category_id"], data_point["data"], data_point["created_at"], data_point["updated_at"], data_point["user_id"])
+#     end
+# 
+#   end

data/lib/lymbix/request.rb

@@ -0,0 +1,57 @@
+require 'rest_client'
+require 'json'
+
+module Lymbix
+  class Request
+    # GYRUS_URL = ENV["RAILS_ENV"] == "production" ? "http://rack-gyrus.lymbix.com" : "http://localhost:4567"
+    GYRUS_URL = "https://gyrus.lymbix.com"
+    # GYRUS_URL = "http://localhost:4567"
+    # GYRUS_URL = "http://74.205.17.185"
+    # GYRUS_URL = "http://gyrus-staging.lymbix.com"
+    
+    attr_accessor :url, :http_method, :response, :method, :object, :header_hash
+    
+    def initialize(http_method, method, header_hash, object = nil) #:nodoc:
+      self.http_method = http_method
+      self.url = GYRUS_URL
+      self.method = method
+      self.object = object
+      self.header_hash = header_hash
+    end
+    
+    def connection
+      options = {}
+      options[:headers] = {:accept => "application/json", :APP_ID => self.header_hash[:app_id].to_s, :LYMBIX_USER_ID => self.header_hash[:lymbix_user_id], :AUTHENTICATION => self.header_hash[:auth_key]}            
+      RestClient::Resource.new(self.url, options)
+    end
+    
+    def run
+      case(self.http_method)
+      when :get
+        self.connection[self.method].get do |resp|
+          case resp.code 
+            when 200
+              self.response = resp.body
+            when 401
+              raise RestClient::Unauthorized
+            else
+              raise Exception
+            end
+        end
+      when :post
+        self.connection[self.method].post(object) do |resp|
+          case resp.code 
+            when 200
+              self.response = resp.body
+            when 401
+              raise RestClient::Unauthorized
+            else
+              raise Exception
+            end
+        end
+      end
+      Response.new(self.response)
+    end
+    
+  end
+end

data/lib/lymbix/response.rb

@@ -0,0 +1,27 @@
+require 'json'
+
+module Lymbix
+  class Response
+
+    attr_accessor :data, :success
+
+    def initialize(response)
+      unless response == "null"
+        @data = JSON.parse(response.to_s)
+        unless @data.class == Array
+          if @data["success"] == "false"
+            @success = false
+          else
+            @success = true
+          end
+        else
+          @success = true
+        end
+      else
+        @success = false
+        @data = nil
+      end
+    end
+
+  end
+end

data/lib/lymbix/tweet.rb

@@ -0,0 +1,15 @@
+module Lymbix
+
+  class Tweet
+
+    attr_accessor :id, :is_user_created, :tweet, :requested_count
+
+    def initialize(options)
+      @id = options[:id]
+      @is_user_created = options[:is_user_created]
+      @tweet = options[:tweet]
+      @requested_count = options[:requested_count]
+    end
+
+  end
+end

data/lib/lymbix/user.rb

@@ -0,0 +1,96 @@
+module Lymbix
+  class User
+    attr_accessor :auth_key, :name, :error_messages, :age, :country, :state, :gender, :first_language, :year_of_birth, :education, :level, :strikes, :lymbix_user_id, :activated_at, :email, :is_admin, :app_member
+    
+    def initialize(options)
+      @auth_key = options["auth_key"] || options[:auth_key]
+      @name = options["name"] || options[:name]
+      @age = options["age"] || options[:age]
+      @country = options["country"] || options[:country]
+      @state = options["state"] || options[:state]
+      @gender = options["gender"] || options[:gender]
+      @first_language = options["first_language"] || options[:first_language]
+      @level = options["level"] || options[:level]
+      @strikes = options["strikes"] || options[:strikes]
+      @year_of_birth  = options["year_of_birth"] || options[:year_of_birth]
+      @education = options["education"] || options[:education]
+      @error_messages = options[:error_messages]
+      @lymbix_user_id = options["id"] || options[:lymbix_user_id]
+      @activated_at = options["activated_at"] || options[:activated_at]
+      @email = options["email"] || options[:email]
+      @is_admin = options["is_admin"] || options[:is_admin]
+    end
+    
+    def self.auth_login(auth_key, app_id)
+        response = Lymbix::Request.new(:post, 'auth_login', {:app_id => app_id}, {:auth_key => auth_key}).run
+        self.new(response.data.to_hash)
+      rescue Exception => ex
+        self.new(:error_messages => ["#{ex.message}"])
+    end
+    
+    def self.authenticate(email, password, app_id)
+      response = Lymbix::Request.new(:post, 'authenticate', {:app_id => app_id}, {:email => email, :password => password, :app_id => app_id}).run
+      self.new(response.data.to_hash)
+    rescue RestClient::Unauthorized      
+      self.new(:error_messages => ["Wrong Password"])
+    rescue Exception => ex    
+      self.new(:error_messages => ["#{ex.message}"])
+    end
+    
+    def self.enable_application(params)
+      begin
+        response = Lymbix::Request.new(:post, 'enable_application', {:app_id => params[:app_id]}, {:email => params[:email], :password => params[:password]}).run
+        self.new(response.data.to_hash)
+      rescue Exception => ex
+        self.new(:error_messages => [ex.message])
+      end
+    end
+    
+    def self.find_by_email(params)      
+      begin        
+        response = Lymbix::Request.new(:post, 'user_find_by_email', {:app_id => params[:app_id]}, {:email => params[:email]}).run
+        self.new(response.data.to_hash)
+      rescue Exception => ex
+        self.new(:error_messages => [ex.message])
+      end
+    end
+    
+    def self.find_or_create(params)
+      
+      begin
+        # response = Lymbix::Request.new(:post, 'find_user', {:app_id => @app_id, :auth_key => @auth_key, :lymbix_user_id => @lymbix_user_id}, {:email => params[:user][:email]}).run
+        response = Lymbix::Request.new(:post, 'find_user', {:app_id => params[:app_id]}, {:email => params[:user][:email]}).run
+        
+        ActiveRecord::Base.logger.info "!! REQUEST DONE - #{response.inspect}"
+        
+        unless response.data["email"]          
+          response = Lymbix::Request.new(:post, 'users', {:app_id => params[:app_id]}, params[:user]).run #unless response.data['auth_key']
+          if response.data["error_messages"]
+            return self.new(:error_messages => response.data["error_messages"])
+          end
+        end
+        
+        self.new(response.data.to_hash)
+      rescue Exception => ex
+        ActiveRecord::Base.logger.info "!! REQUEST FAIL - #{ex.message}"
+        
+        self.new(:error_messages => [ex.message])
+      end
+    end
+    
+    def self.update(params)
+      response = Lymbix::Request.new(:post, 'update_user', {:lymbix_user_id => params[:lymbix_user_id], :app_id => params[:app_id], :auth_key => params[:auth_key]}, {:email => params[:email], :name => params[:name], :password => params[:password], :password_confirmation => params[:password_confirmation], :age => params[:age], :country => params[:country], :state => params[:state], :gender => params[:gender], :first_language => params[:first_language], :year_of_birth => params[:year_of_birth], :education => params[:education]}).run
+      if response.success
+        self.new(:auth_key => response.data['auth_key'], :level => response.data['level'], :strikes => response.data['strikes'], :name => response.data['name'],:age => response.data['age'], :country => response.data['country'], :state => response.data['state'],:name => response.data['name'], :gender => response.data['gender'], :first_language => response.data['first_language'], :education => response.data['education'], :year_of_birth => response.data['year_of_birth'] , :error_messages => [])
+      else
+        self.new(:error_messages => response.data.errors)
+      end
+    end
+    
+    def self.request_tonecheck_beta(params)
+      response = Lymbix::Request.new(:post, 'request_tonecheck_beta', {:app_id => params[:app_id], :auth_key => params[:auth_key]}, {:user_id => params[:user_id]}).run      
+      response.data['user']
+    end
+  end
+
+end

data/lib/lymbix/word.rb

@@ -0,0 +1,78 @@
+module Lymbix
+
+  class Word
+
+    attr_reader :id, :word, :is_external, :is_phrase
+
+    def initialize(data)
+      @id = data[:id]
+      @word = word = data[:word]
+      @is_external = data[:is_external]
+      @is_phrase = data[:is_phrase]
+    end
+
+  end
+end
+
+
+
+#   #--------------------------------------------------------------------------
+#   # Words
+#   #==========================================================================
+# 
+#   Word = BaseObject.new(:id, :word, :is_external, :is_phrase)
+# 
+#   #<struct Lymbix::Word id={:is_external=>false, :id=>34941, :word=>"demand"}, word=nil, is_external=nil>
+# 
+#   class Word
+# 
+#     def self.count
+#       resp = Lymbix::request('word_count')
+#     end
+# 
+#     def self.top_random
+#       resp = Lymbix::request('top_random')
+#       word = JSON.load(resp)
+# 
+#       return nil if word.nil? || word.empty?
+#       Word.new(word["id"], word["word"], word["is_external"], word["is_phrase"])
+#     end
+# 
+#     def self.add_word(word, definition, is_phrase = false)
+#       resp = Lymbix::request('words', 'post', {:word => word, :definition => definition, :is_external => true, :is_phrase => is_phrase})
+#       word = JSON.load(resp)
+#       return nil if word.nil? || word.empty?
+#       Word.new(word["id"], word["word"], word["is_external"], word["is_phrase"])
+#     end
+# 
+#     def self.lookup(word)
+#       resp = Lymbix::request("lookup/#{word}")
+#       return nil if resp == "null"
+# 
+#       word = JSON.load(resp)
+# 
+#       return nil if word.nil? || word.empty?
+#       Word.new(word["id"], word["word"], word["is_external"], word["is_phrase"])
+#     end
+# 
+#     def self.search(word)
+#       resp = Lymbix::request("search/#{word}")
+#       word = JSON.load(resp)
+# 
+#       return nil if word.nil? || word.empty?
+#       Word.new(word["id"], word["word"], word["is_external"], word["is_phrase"])
+#     end
+# 
+#     def self.find(word_id)
+#       resp = Lymbix::request("words/#{word_id}")
+#       word = JSON.load(resp)
+# 
+#       return nil if word.nil? || word.empty?
+#       Word.new(word["id"], word["word"], word["is_external"], word["is_phrase"])
+#     end
+# 
+#     def definitions
+#       Definition::list(self.id)
+#     end
+# 
+#   end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: lymbix
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  - 1
+  version: 0.3.1
+platform: ruby
+authors: 
+- Patrick Roy
+- Josh Merchant
+- Mathieu Dargavel
+- "Matthew Lagac\xC3\xA9"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-11 00:00:00 -03:00
+default_executable: 
+dependencies: []
+
+description: The Lymbix gem provides an interface to gyrus (connotative logic and database).
+email: developers@lymbix.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- Changelog
+- LICENSE
+- lib/lymbix.rb
+- lib/lymbix/base.rb
+- lib/lymbix/connotative_category.rb
+- lib/lymbix/data_point.rb
+- lib/lymbix/request.rb
+- lib/lymbix/response.rb
+- lib/lymbix/tweet.rb
+- lib/lymbix/user.rb
+- lib/lymbix/word.rb
+has_rdoc: true
+homepage: http://www.lymbix.com/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: The Lymbix gem provides an interface to gyrus (connotative logic and database).
+test_files: []
+