impermium 1.0.0

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.DS_Store

data/.rspec

@@ -0,0 +1 @@
+--colour -f d

data/.rvmrc

@@ -0,0 +1 @@
+rvm --create ruby-1.9.3-p0@whi

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in impermium.gemspec
+gemspec

data/MIT-LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 WHI Inc, Juanjo Bazán, Bosko Ivanisevic and Neil Berkman
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,118 @@
+# Impermium #
+
+Ruby wrapper for the [Impermium API](http://impermium.com).
+
+* gem version 1.0.0 supports the Impermium API version 3.1
+
+## Usage ##
+
+In order to use Impermium gem you must get an Impermium API key.
+
+### Instantiate and configure a client ###
+
+The Impermium client can be instantiated and configured in several ways. A new client can be created with
+
+    client = Impermium.new(:api_key => <your_api_key>)
+
+which is actually short way of 
+
+    client = Impermium::Client.new(:api_key => <your_api_key>)
+
+Constructor accepts a hash of options that can be used to configure the Impermium client. Valid hash keys are
+
+* `:adapter` (sets Faraday adapter)
+* `:api_version` (sets Impermium API version - default 3.1)
+* `:api_key` (sets API key)
+* `:client_name` (sets client name)
+* `:client_id` (sets client ID)
+* `:endpoint` (sets URL to Impermium server - default http://api.impermium.com)
+
+Either of these values can be set directly too:
+
+* client = Impermium.new
+* client.api_key = <your_api_key>
+* client.endpoint = "http://api-test.impermium.com"
+
+Finally, Impermium client can be configured through a block with:
+
+    Impermium.configure do |conf|
+      conf.api_key = <your_api_key>
+      conf.endpoint = "http://api-test.impermium.com"
+    end
+
+    client = Impermium.new
+
+### Calling API methods  ###
+
+Each method accepts the mandatory arguments of the correspondent API call, and have an options hash and a block as optional arguments. Here is the list of all supported methods and their mandatory arguments:
+ 
+* __USER__
+    + __Account:__
+      - `client.account(user_id, enduser_ip)`
+      - `client.account_attempt(enduser_ip)`
+      - `client.account_login(user_id, enduser_ip)`
+      - `client.account_analyst_feedback(analyst_id, user_id, desired_result)`
+      - `client.account_user_feedback(rep_usr_id, rep_usr_type, reporter_ip, user_id, desired_result)`
+      
+    + __Profile:__
+      - `client.profile(user_id, profile_id, enduser_ip)`
+      - `client.profile_analyst_feedback(profile_id, analyst_id, desired_result)`
+      - `client.profile_user_feedback(profile_id, rep_usr_id, rep_usr_type, reporter_ip, desired_result)`
+
+* __CONTENT__
+    + __Blog post:__
+      - `client.blog_post(user_id, blog_post_id, content, blog_post_permalink, blog_url, enduser_ip)`
+      - `client.blog_post_analyst_feedback(analyst_id, blog_post_id, desired_result)`
+      - `client.blog_post_user_feedback(rep_usr_id, rep_usr_type, reporter_ip, blog_post_id, desired_result)`
+  
+    + __Bookmark:__
+      - `client.bookmark(user_id, bookmark_id, bookmark_url, enduser_ip)`
+      - `client.bookmark_like(user_id, bookmark_id, bookmark_url, like_value, enduser_ip)`
+      - `client.bookmark_analyst_feedback(analyst_id, bookmark_id, desired_result)`
+      - `client.bookmark_user_feedback(rep_usr_id, rep_usr_type, reporter_ip, bookmark_id, desired_result)`
+      
+    + __Comment:__
+      - `client.comment(user_id, comment_id, content, comment_permalink, article_permalink, enduser_ip)`
+      - `client.comment_analyst_feedback(analyst_id, comment_id, desired_result)`
+      - `client.comment_user_feedback(rep_usr_id, rep_usr_type, reporter_ip, comment_id, desired_result)`
+      
+    + __Connection:__
+      - `client.connection(operation, connection_type, connection_id, requester_user_id, responder_user_id, enduser_ip)`
+      - `client.connection_analyst_feedback(analyst_id, connection_type, connection_id, desired_result)`
+      - `client.connection_user_feedback(rep_usr_id, rep_usr_type, reporter_ip, connection_type, connection_id, desired_result)`
+      
+    + __Listing:__
+      - `client.listing(user_id, listing_id, content, listing_permalink, enduser_ip)`
+      - `client.listing_analyst_feedback(analyst_id, listing_id, desired_result)`
+      - `client.listing_user_feedback(rep_usr_id, rep_usr_type, reporter_ip, listing_id, desired_result)`
+
+Additional arguments can be passed through the hash which is the last argument for every method
+
+    client.account('33', '255.255.255.255', {:alias => "user33", :password_hash=>'7d222a5d269a'})
+
+If request headers have to be set it can be done through block
+
+    Impermium.account('33', '255.255.255.255') do |req|
+      req.headers = {:http_user_agent => "Impermium gem 1.0.0"}
+    end
+
+You can find the complete arguments lists and types in the official Impermium API docs site.
+
+### Responses ###
+
+Any method call receiving a successful response from impermium API will return a Hash like structure containing the body of the response, typically including `response_id`, `timestamp` and posibly `spam_classifier` and any other additional classifiers.
+
+Any 4XX response will raise an Impermium Exception with the body of the response in the error message.
+
+* A 400 status response from the impermium API will raise an `Impermium::BadRequest`
+* A 401 status response from the impermium API will raise an `Impermium::UnauthorizedRequest`
+* A 403 status response from the impermium API will raise an `Impermium::ForbiddenRequest`
+* A 404 status response from the impermium API will raise an `Impermium::NotFoundRequest`
+
+## Credits ##
+
+Here is the [list of contributors](https://github.com/weheartit/impermium/contributors)\.
+
+## License ##
+
+Copyright 2012 WHI Inc. \([weheartit.com](http://weheartit.com)\), released under the MIT license.

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler'
+require 'rspec/core/rake_task'
+
+Bundler::GemHelper.install_tasks
+
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/impermium.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "impermium/version"
+
+Gem::Specification.new do |s|
+  s.name        = "impermium"
+  s.version     = Impermium::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.date = Time.now.strftime('%Y-%m-%d')
+  
+  s.authors     = ["Juanjo Bazán", "Bosko Ivanisevic", "Neil Berkman"]
+  s.email       = ["jjbazan@gmail.com"]
+  s.homepage    = "https://github.com/weheartit/impermium"
+  s.summary     = "Impermium API wrapper"
+  s.description = "Ruby wrapper for the Impermium social spam API"
+
+  s.add_dependency "faraday", "~> 0.7.4"
+  s.add_dependency "faraday_middleware", "~> 0.7.0"
+  s.add_dependency "hashie", "~> 1.1.0"
+  s.add_dependency "yajl-ruby", "~> 0.8.3"
+  s.add_dependency "multi_json"
+
+  s.add_development_dependency "rspec", "~> 2.8.0"
+  s.add_development_dependency "webmock", "~> 1.8.1"
+  s.add_development_dependency "vcr", "~> 2.0.0"
+ 
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/faraday/raise_4xx.rb

@@ -0,0 +1,18 @@
+require 'faraday'
+
+module Faraday
+  class Response::Raise4xx < Response::Middleware
+    def on_complete(env)
+      case env[:status].to_i
+      when 400
+        raise Impermium::BadRequest.new(env[:method].to_s.upcase, env[:url].to_s, env[:body])
+      when 401
+        raise Impermium::UnauthorizedRequest.new(env[:method].to_s.upcase, env[:url].to_s, env[:body])
+      when 403
+        raise Impermium::ForbiddenRequest.new(env[:method].to_s.upcase, env[:url].to_s, env[:body])
+      when 404
+        raise Impermium::NotFoundRequest.new(env[:method].to_s.upcase, env[:url].to_s, env[:body])
+      end
+    end
+  end
+end

data/lib/impermium/client.rb

@@ -0,0 +1,57 @@
+require "uri"
+require "faraday"
+require "faraday_middleware"
+require "impermium/configuration"
+require "impermium/content"
+require "impermium/errors"
+require "impermium/user"
+require "faraday/raise_4xx"
+
+module Impermium
+  class Client
+    include Configuration
+    include Content
+    include User
+    
+    def initialize(options = {})
+      options = Impermium.options.merge(options)
+      Configuration::VALID_CONFIG_KEYS.each do |key|
+        send("#{key}=", options[key])
+      end
+    end
+
+    def api_connection
+      @api_connection ||= Faraday.new(:url => endpoint, :headers => default_headers) do |builder|
+        builder.use Faraday::Response::Mashify
+        builder.use Faraday::Response::ParseJson
+        builder.use Faraday::Response::Raise4xx
+        builder.request :json
+
+        builder.adapter adapter
+      end
+    end
+
+    def post(url, options={})
+      api_connection.post do |req|
+        req.url api_url(url)
+        req.body = options
+        req.headers['Content-Type'] = 'application/json'
+        yield req if block_given?
+      end.body
+    end
+
+    def api_url(request_path)
+      url = URI.join(endpoint,
+        request_path[-1] == '/' ? request_path  : request_path + "/",
+        api_version + "/",
+        api_key + "/").to_s
+    end
+
+    private
+
+    def default_headers
+      { :http_user_agent => "Impermium Ruby Gem",
+        :http_accept => "application/json"}
+    end
+  end
+end

data/lib/impermium/configuration.rb

@@ -0,0 +1,44 @@
+module Impermium
+  module Configuration
+    VALID_CONFIG_KEYS = [
+      :adapter,
+      :api_version,
+      :api_key,
+      :client_name,
+      :client_id,
+      :endpoint
+    ].freeze
+
+    DEFAULT_ADAPTER = :net_http
+    DEFAULT_API_VERSION = "3.1"
+    DEFAULT_API_KEY = nil
+    DEFAULT_CLIENT_NAME = nil
+    DEFAULT_CLIENT_ID = nil
+    DEFAULT_ENDPOINT = "http://api.impermium.com"
+    
+    attr_accessor *VALID_CONFIG_KEYS
+
+    def self.extended(base)
+      base.reset
+    end
+
+    def configure
+      yield self
+    end
+
+    def options
+      options = {}
+      VALID_CONFIG_KEYS.each { |key| options[key] = send(key) }
+      options
+    end
+    
+    def reset
+      self.adapter = DEFAULT_ADAPTER
+      self.api_version = DEFAULT_API_VERSION
+      self.api_key = DEFAULT_API_KEY
+      self.client_name = DEFAULT_CLIENT_NAME
+      self.client_id = DEFAULT_CLIENT_ID
+      self.endpoint = DEFAULT_ENDPOINT
+    end
+  end
+end

data/lib/impermium/content/blog_post.rb

@@ -0,0 +1,38 @@
+module Impermium
+  module BlogPost
+    REPORTER_USER_TYPE_VALUES = ["ENDUSER", "MODERATOR"] # => default first
+
+    def blog_post(user_id, blog_post_id, content, blog_post_permalink, blog_url, enduser_ip, options={}, &block)
+      options.merge!(
+        :user_id => user_id,
+        :blog_post_id => blog_post_id,
+        :content => content,
+        :blog_post_permalink => blog_post_permalink,
+        :blog_url => blog_url,
+        :enduser_ip => enduser_ip
+        )
+      post("blog_post", options, &block)
+    end
+    
+    def blog_post_analyst_feedback(analyst_id, blog_post_id, desired_result, options={}, &block)
+      options.merge!(
+        :analyst_id => analyst_id,
+        :blog_post_id => blog_post_id,
+        :desired_result => desired_result
+        )
+      post("blog_post/analyst_feedback", options, &block)
+    end
+    
+    def blog_post_user_feedback(rep_usr_id, rep_usr_type, reporter_ip, blog_post_id, desired_result, options={}, &block)
+      options.merge!(
+        :reporter_user_id => rep_usr_id,
+        :reporter_user_type => REPORTER_USER_TYPE_VALUES.include?(rep_usr_type) ? rep_usr_type : REPORTER_USER_TYPE_VALUES.first,
+        :reporter_ip => reporter_ip,
+        :blog_post_id => blog_post_id,
+        :desired_result => desired_result
+        )
+      post("blog_post/user_feedback", options, &block)
+    end
+    
+  end
+end

data/lib/impermium/content/bookmark.rb

@@ -0,0 +1,47 @@
+module Impermium
+  module Bookmark
+    REPORTER_USER_TYPE_VALUES = ["ENDUSER", "MODERATOR"] # => default first
+    
+    def bookmark(user_id, bookmark_id, bookmark_url, enduser_ip, options={}, &block)
+      options.merge!(
+        :user_id => user_id,
+        :bookmark_id => bookmark_id,
+        :bookmark_url => bookmark_url,
+        :enduser_ip => enduser_ip
+        )
+      post("bookmark", options, &block)
+    end
+    
+    def bookmark_like(user_id, bookmark_id, bookmark_url, like_value, enduser_ip, options={}, &block)
+      options.merge!(
+        :user_id => user_id,
+        :bookmark_id => bookmark_id,
+        :bookmark_url => bookmark_url,
+        :like_value => like_value,
+        :enduser_ip => enduser_ip
+        )
+      post("bookmark/like", options, &block)
+    end
+    
+    def bookmark_analyst_feedback(analyst_id, bookmark_id, desired_result, options={}, &block)
+      options.merge!(
+        :analyst_id => analyst_id,
+        :bookmark_id => bookmark_id,
+        :desired_result => desired_result
+        )
+      post("bookmark/analyst_feedback", options, &block)
+    end
+    
+    def bookmark_user_feedback(rep_usr_id, rep_usr_type, reporter_ip, bookmark_id, desired_result, options={}, &block)
+      options.merge!(
+        :reporter_user_id => rep_usr_id,
+        :reporter_user_type => REPORTER_USER_TYPE_VALUES.include?(rep_usr_type) ? rep_usr_type : REPORTER_USER_TYPE_VALUES.first,
+        :reporter_ip => reporter_ip,
+        :bookmark_id => bookmark_id,
+        :desired_result => desired_result
+        )
+      post("bookmark/user_feedback", options, &block)
+    end
+    
+  end
+end

data/lib/impermium/content/comment.rb

@@ -0,0 +1,38 @@
+module Impermium
+  module Comment
+    REPORTER_USER_TYPE_VALUES = ["ENDUSER", "MODERATOR"] # => default first
+
+    def comment(user_id, comment_id, content, comment_permalink, article_permalink, enduser_ip, options={}, &block)
+      options.merge!(
+        :user_id => user_id,
+        :comment_id => comment_id,
+        :content => content,
+        :comment_permalink => comment_permalink,
+        :article_permalink => article_permalink,
+        :enduser_ip => enduser_ip
+        )
+      post("comment", options, &block)
+    end
+    
+    def comment_analyst_feedback(analyst_id, comment_id, desired_result, options={}, &block)
+      options.merge!(
+        :analyst_id => analyst_id,
+        :comment_id => comment_id,
+        :desired_result => desired_result
+        )
+      post("comment/analyst_feedback", options, &block)
+    end
+    
+    def comment_user_feedback(rep_usr_id, rep_usr_type, reporter_ip, comment_id, desired_result, options={}, &block)
+      options.merge!(
+        :reporter_user_id => rep_usr_id,
+        :reporter_user_type => REPORTER_USER_TYPE_VALUES.include?(rep_usr_type) ? rep_usr_type : REPORTER_USER_TYPE_VALUES.first,
+        :reporter_ip => reporter_ip,
+        :comment_id => comment_id,
+        :desired_result => desired_result
+        )
+      post("comment/user_feedback", options, &block)
+    end
+    
+  end
+end

data/lib/impermium/content/connection.rb

@@ -0,0 +1,42 @@
+module Impermium
+  module Connection
+    REPORTER_USER_TYPE_VALUES = ["ENDUSER", "MODERATOR"] # => default first
+    OPERATION_VALUES          = ['request', 'response'] # => default first
+    CONNECTION_TYPE_VALUES    = ['follow', 'friend']
+
+    def connection(operation, connection_type, connection_id, requester_user_id, responder_user_id, enduser_ip, options={}, &block)
+      options.merge!(
+        :operation => OPERATION_VALUES.include?(operation) ? operation : OPERATION_VALUES.first,
+        :connection_type => connection_type,
+        :connection_id => connection_id,
+        :requester_user_id => requester_user_id,
+        :responder_user_id => responder_user_id,
+        :enduser_ip => enduser_ip
+        )
+      post("connection", options, &block)
+    end
+    
+    def connection_analyst_feedback(analyst_id, connection_type, connection_id, desired_result, options={}, &block)
+      options.merge!(
+        :analyst_id => analyst_id,
+        :connection_type => connection_type,
+        :connection_id => connection_id,
+        :desired_result => desired_result
+        )
+      post("connection/analyst_feedback", options, &block)
+    end
+    
+    def connection_user_feedback(rep_usr_id, rep_usr_type, reporter_ip, connection_type, connection_id, desired_result, options={}, &block)
+      options.merge!(
+        :reporter_user_id => rep_usr_id,
+        :reporter_user_type => REPORTER_USER_TYPE_VALUES.include?(rep_usr_type) ? rep_usr_type : REPORTER_USER_TYPE_VALUES.first,
+        :reporter_ip => reporter_ip,
+        :connection_type => connection_type,
+        :connection_id => connection_id,
+        :desired_result => desired_result
+        )
+      post("connection/user_feedback", options, &block)
+    end
+    
+  end
+end

data/lib/impermium/content/listing.rb

@@ -0,0 +1,37 @@
+module Impermium
+  module Listing
+    REPORTER_USER_TYPE_VALUES = ["ENDUSER", "MODERATOR"] # => default first
+
+    def listing(user_id, listing_id, content, listing_permalink, enduser_ip, options={}, &block)
+      options.merge!(
+        :user_id => user_id,
+        :listing_id => listing_id,
+        :content => content,
+        :listing_permalink => listing_permalink,
+        :enduser_ip => enduser_ip
+        )
+      post("listing", options, &block)
+    end
+    
+    def listing_analyst_feedback(analyst_id, listing_id, desired_result, options={}, &block)
+      options.merge!(
+        :analyst_id => analyst_id,
+        :listing_id => listing_id,
+        :desired_result => desired_result
+        )
+      post("listing/analyst_feedback", options, &block)
+    end
+    
+    def listing_user_feedback(rep_usr_id, rep_usr_type, reporter_ip, listing_id, desired_result, options={}, &block)
+      options.merge!(
+        :reporter_user_id => rep_usr_id,
+        :reporter_user_type => REPORTER_USER_TYPE_VALUES.include?(rep_usr_type) ? rep_usr_type : REPORTER_USER_TYPE_VALUES.first,
+        :reporter_ip => reporter_ip,
+        :listing_id => listing_id,
+        :desired_result => desired_result
+        )
+      post("listing/user_feedback", options, &block)
+    end
+    
+  end
+end

data/lib/impermium/content.rb

@@ -0,0 +1,15 @@
+require "impermium/content/blog_post"
+require "impermium/content/bookmark"
+require "impermium/content/comment"
+require "impermium/content/connection"
+require "impermium/content/listing"
+
+module Impermium
+  module Content
+    include BlogPost
+    include Bookmark
+    include Comment
+    include Connection
+    include Listing
+  end
+end

data/lib/impermium/errors.rb

@@ -0,0 +1,25 @@
+module Impermium
+  class BaseError < StandardError
+    attr_reader :request_type
+    attr_reader :request_url
+    
+    def initialize(request_type, request_url, message)
+      @request_type = request_type
+      @request_url = request_url
+      super message
+    end
+  end
+
+  class BadRequest < BaseError
+  end
+
+  class UnauthorizedReqeust < BaseError
+  end
+
+  class ForbiddenRequest < BaseError
+  end
+
+  class NotFoundRequest < BaseError
+  end
+
+end

data/lib/impermium/user/account.rb

@@ -0,0 +1,50 @@
+module Impermium
+  module Account
+    REPORTER_USER_TYPE_VALUES = ["ENDUSER", "MODERATOR"] # => default first
+
+    def account(user_id, enduser_ip, options={}, &block)
+      options.merge!(
+        :user_id => user_id,
+        :enduser_ip => enduser_ip
+        )
+      post("account", options, &block)
+    end
+    
+    def account_attempt(enduser_ip, options={}, &block)
+      options.merge!(
+        :enduser_ip => enduser_ip
+        )
+      post("account/attempt", options, &block)
+    end
+    
+    def account_login(user_id, enduser_ip, options={}, &block)
+      options.merge!(
+        :user_id => user_id,
+        :enduser_ip => enduser_ip
+        )
+      post("account/login", options, &block)
+    end
+
+    def account_analyst_feedback(analyst_id, user_id, desired_result, options={}, &block)
+      options.merge!(
+        :analyst_id => analyst_id,
+        :user_id => user_id,
+        :desired_result => desired_result
+        )
+      post("account/analyst_feedback", options, &block)
+    end
+
+    def account_user_feedback(rep_usr_id, rep_usr_type, reporter_ip, user_id, desired_result, options={}, &block)
+      options.merge!(
+        :reporter_user_id => rep_usr_id,
+        :reporter_user_type => REPORTER_USER_TYPE_VALUES.include?(rep_usr_type) ? rep_usr_type : REPORTER_USER_TYPE_VALUES.first,
+        :reporter_ip => reporter_ip,
+        :user_id => user_id,
+        :desired_result => desired_result
+        )
+      post("account/user_feedback", options, &block)
+    end
+    
+    
+  end
+end

data/lib/impermium/user/profile.rb

@@ -0,0 +1,35 @@
+module Impermium
+  module Profile
+    REPORTER_USER_TYPE_VALUES = ["ENDUSER", "MODERATOR"] # => default first
+
+    def profile(user_id, profile_id, enduser_ip, options={}, &block)
+      options.merge!(
+        :user_id => user_id,
+        :profile_id => profile_id,
+        :enduser_ip => enduser_ip
+        )
+      post("profile", options, &block)
+    end
+    
+    def profile_analyst_feedback(profile_id, analyst_id, desired_result, options={}, &block)
+      options.merge!(
+        :profile_id => profile_id,
+        :analyst_id => analyst_id,
+        :desired_result => desired_result
+        )
+      post("profile/analyst_feedback", options, &block)
+    end
+    
+    def profile_user_feedback(profile_id, rep_usr_id, rep_usr_type, reporter_ip, desired_result, options={}, &block)
+      options.merge!(
+        :profile_id => profile_id,
+        :reporter_user_id => rep_usr_id,
+        :reporter_user_type => REPORTER_USER_TYPE_VALUES.include?(rep_usr_type) ? rep_usr_type : REPORTER_USER_TYPE_VALUES.first,
+        :reporter_ip => reporter_ip,
+        :desired_result => desired_result
+        )
+      post("profile/user_feedback", options, &block)
+    end
+    
+  end
+end

data/lib/impermium/user.rb

@@ -0,0 +1,9 @@
+require "impermium/user/account"
+require "impermium/user/profile"
+
+module Impermium
+  module User    
+    include Account
+    include Profile
+  end
+end

data/lib/impermium/version.rb

@@ -0,0 +1,3 @@
+module Impermium
+  VERSION = "1.0.0"
+end