traitify 1.1.0 → 1.1.1

data/lib/traitify/assessments.rb

@@ -1,36 +0,0 @@
-module Traitify
-  class Assessment
-    attr_accessor :id, :deck_id, :user_id, :created_at, :completed_at
-
-    def initialize(options = {})
-      self.id            = options[:id]
-      self.deck_id       = options[:deck_id]
-      self.user_id       = options[:user_id]
-      self.created_at    = options[:created_at]
-      self.completed_at  = options[:completed_at]
-    end
-
-    def self.parse_json(assessment)
-      created_at = assessment["created_at"] ? Time.at(assessment["created_at"]) : nil
-      completed_at = assessment["completed_at"] ? Time.at(assessment["completed_at"]) : nil
-
-      Assessment.new(
-        id:           assessment["id"],
-        deck_id:      assessment["deck_id"],
-        user_id:      assessment["user_id"],
-        created_at:   created_at,
-        completed_at: completed_at
-      )
-    end
-
-    def to_hash
-      {
-        id:           id,
-        deck_id:      deck_id,
-        user_id:      user_id,
-        created_at:   created_at,
-        completed_at: completed_at
-      }
-    end
-  end
-end

data/lib/traitify/badges.rb

@@ -1,43 +0,0 @@
-module Traitify
-  class Badge
-    attr_accessor :image_small, :image_medium, :image_large, :font_color, :color_1, :color_2, :color_3
-
-    def initialize(options = {})
-      self.image_small  = options[:image_small]
-      self.image_medium = options[:image_medium]
-      self.image_large  = options[:image_large]
-      self.font_color   = options[:font_color]
-      self.color_1      = options[:color1]
-      self.color_2      = options[:color2]
-      self.color_3      = options[:color3]
-    end
-
-    def self.parse_json(badge)
-      if badge
-        Badge.new(
-          image_small:  badge["image_small"],
-          image_medium: badge["image_medium"],
-          image_large:  badge["image_large"],
-          font_color:   badge["font_color"],
-          color_1:      badge["color_1"],
-          color_2:      badge["color_2"],
-          color_3:      badge["color_3"]
-        )
-      else
-        nil
-      end
-    end
-
-    def to_hash
-      {
-        image_small:  image_small,
-        image_medium: image_medium,
-        image_large:  image_large,
-        font_color:   font_color,
-        color_1:      color1,
-        color_2:      color2,
-        color_3:      color3
-      }
-    end
-  end
-end

data/lib/traitify/client/users.rb

@@ -1,17 +0,0 @@
-module Traitify
-  class Client
-    module User
-      def create_user(user_params)
-        response = post("/users", user: user_params)
-
-        Traitify::User.parse_json(response)
-      end
-
-      def find_user(user_id)
-        response = get("/users/#{user_id}")
-
-        Traitify::User.parse_json(response)
-      end
-    end
-  end
-end

data/lib/traitify/personality_blends.rb

@@ -1,55 +0,0 @@
-module Traitify
-  class PersonalityBlend
-    attr_accessor :personality_type_1, :personality_type_2, :name, :description, :compliments, :conflicts, :compatible_work_environment_1, :compatible_work_environment_2, :compatible_work_environment_3, :compatible_work_environment_4
-
-    def initialize(options = {})
-      self.personality_type_1             = options[:personality_type_1]
-      self.personality_type_2             = options[:personality_type_2]
-      self.name                           = options[:name]
-      self.description                    = options[:description]
-      self.compliments                    = options[:compliments]
-      self.conflicts                      = options[:conflicts]
-      self.compatible_work_environment_1 = options[:compatible_work_environment_1]
-      self.compatible_work_environment_2 = options[:compatible_work_environment_2]
-      self.compatible_work_environment_3 = options[:compatible_work_environment_3]
-      self.compatible_work_environment_4 = options[:compatible_work_environment_4]
-    end
-
-    def self.parse_json(personality_blend)
-      if personality_blend
-        personality_type_1 = PersonalityType.parse_json(personality_blend["personality_type_1"])
-        personality_type_2 = PersonalityType.parse_json(personality_blend["personality_type_2"])
-
-      PersonalityBlend.new(
-        personality_type_1:            personality_type_1,
-        personality_type_2:            personality_type_2,
-        name:                          personality_blend["name"],
-        description:                   personality_blend["description"],
-        compliments:                   personality_blend["compliments"],
-        conflicts:                     personality_blend["conflicts"],
-        compatible_work_environment_1: personality_blend["compatible_work_environment_1"],
-        compatible_work_environment_2: personality_blend["compatible_work_environment_2"],
-        compatible_work_environment_3: personality_blend["compatible_work_environment_3"],
-        compatible_work_environment_4: personality_blend["compatible_work_environment_4"]
-      )
-      else
-        nil
-      end
-    end
-
-    def to_hash
-      {
-        personality_type_1:            personality_type_1.to_hash,
-        personality_type_2:            personality_type_2.to_hash,
-        name:                          name,
-        description:                   description,
-        compliments:                   compliments,
-        conflicts:                     conflicts,
-        compatible_work_environment_1: compatible_work_environment_1,
-        compatible_work_environment_2: compatible_work_environment_2,
-        compatible_work_environment_3: compatible_work_environment_3,
-        compatible_work_environment_4: compatible_work_environment_4
-      }
-    end
-  end
-end

data/lib/traitify/personality_types.rb

@@ -1,39 +0,0 @@
-module Traitify
-  class PersonalityType
-    attr_accessor :id, :name, :description, :badge, :score
-
-    def initialize(options = {})
-      self.id          = options[:id]
-      self.name        = options[:name]
-      self.description = options[:description]
-      self.badge       = options[:badge]
-      self.score       = options[:score]
-    end
-
-    def self.parse_json(personality_type)
-      if personality_type
-        badge = Badge.parse_json(personality_type["badge"])
-
-        PersonalityType.new(
-          id:          personality_type["id"],
-          name:        personality_type["name"],
-          description: personality_type["description"],
-          badge:       badge,
-          score:       personality_type["score"]
-        )
-      else
-        nil
-      end
-    end
-
-    def to_hash
-      {
-        id:          id,
-        name:        name,
-        description: description,
-        badge:       badge.to_hash,
-        score:       score
-      }
-    end
-  end
-end

data/lib/traitify/results.rb

@@ -1,31 +0,0 @@
-module Traitify
-  class Result
-    attr_accessor :personality_blend, :personality_types
-
-    def initialize(options = {})
-      self.personality_blend = options[:personality_blend]
-      self.personality_types = options[:personality_types]
-    end
-
-    def self.parse_json(result)
-      if result
-        personality_blend = PersonalityBlend.parse_json(result["personality_blend"])
-        personality_types = result["personality_types"].collect { |p| p && p["personality_type"] ? PersonalityType.parse_json(p["personality_type"].merge!("score" => p["score"])) : nil }
-
-        Result.new(
-          personality_blend: personality_blend,
-          personality_types: personality_types
-        )
-      else
-        nil
-      end
-    end
-
-    def to_hash
-      {
-        personality_blend: personality_blend.to_hash,
-        personality_types: personality_types.collect { |p| p.to_hash }
-      }
-    end
-  end
-end

data/lib/traitify/slides.rb

@@ -1,95 +0,0 @@
-module Traitify
-  class Slide
-    attr_accessor :id, :position, :caption, :image_desktop, :image_desktop_retina, :image_phone_landscape, :image_phone_portrait, :response, :time_taken, :completed_at, :created_at
-
-    def initialize(options = {})
-      self.id                    = options[:id]
-      self.position              = options[:position]
-      self.caption               = options[:caption]
-      self.image_desktop         = options[:image_desktop]
-      self.image_desktop_retina  = options[:image_desktop_retina]
-      self.image_phone_landscape = options[:image_phone_landscape]
-      self.image_phone_portrait  = options[:image_phone_portrait]
-      self.response              = options[:response]
-      self.time_taken            = options[:time_taken]
-      self.completed_at          = options[:completed_at]
-      self.created_at            = options[:created_at]
-    end
-
-    def self.parse_json(slide)
-      created_at = slide["created_at"] ? Time.at(slide["created_at"]) : nil
-      completed_at = slide["completed_at"] ? Time.at(slide["completed_at"]) : nil
-
-      Slide.new(
-        id:                    slide["id"],
-        position:              slide["position"],
-        caption:               slide["caption"],
-        image_desktop:         slide["image_desktop"],
-        image_desktop_retina:  slide["image_desktop_retina"],
-        image_phone_landscape: slide["image_phone_landscape"],
-        image_phone_portrait:  slide["image_phone_portrait"],
-        response:              slide["response"],
-        time_taken:            slide["time_taken"],
-        completed_at:          completed_at,
-        created_at:            created_at
-      )
-    end
-
-    def to_hash
-      {
-        id:                    id,
-        position:              position,
-        caption:               caption,
-        image_desktop:         image_desktop,
-        image_desktop_retina:  image_desktop_retina,
-        image_phone_landscape: image_phone_landscape,
-        image_phone_portrait:  image_phone_portrait,
-        response:              response,
-        time_taken:            time_taken,
-        completed_at:          completed_at,
-        created_at:            created_at
-      }
-    end
-
-    def to_update_params
-      {
-        id:                    id,
-        response:              response,
-        time_taken:            time_taken
-      }
-    end
-  end
-
-  class Slides
-    attr_accessor :assessment_id, :all
-
-    def initialize(options = {})
-      self.assessment_id = options[:assessment_id]
-      self.all           = options[:all]
-    end
-
-    def self.parse_json(assessment_id, slides)
-      Slides.new(
-        assessment_id: assessment_id,
-        all:           slides.collect { |slide| Traitify::Slide.parse_json(slide) }
-      )
-    end
-
-    def to_hash
-      {
-        assessment_id: assessment_id,
-        all:           all.collect { |slide| slide.to_hash }
-      }
-    end
-
-    def to_update_params
-      all.collect { |slide| slide.to_update_params }
-    end
-
-    # Allows slides to forward Array methods to all
-    def method_missing(method, *args)
-      return all.send(method, *args) if all.respond_to?(method)
-      super
-    end
-  end
-end

data/lib/traitify/users.rb

@@ -1,39 +0,0 @@
-module Traitify
-  class User
-    attr_accessor :id, :first_name, :last_name, :email, :created_at, :updated_at
-
-    def initialize(options = {})
-      self.id         = options[:id]
-      self.first_name = options[:first_name]
-      self.last_name  = options[:last_name]
-      self.email      = options[:email]
-      self.created_at = options[:created_at]
-      self.updated_at = options[:updated_at]
-    end
-
-    def self.parse_json(user)
-      created_at = user["created_at"] ? Time.at(user["created_at"]) : nil
-      updated_at = user["updated_at"] ? Time.at(user["updated_at"]) : nil
-
-      User.new(
-        id:         user["id"],
-        first_name: user["first_name"],
-        last_name:  user["last_name"],
-        email:      user["email"],
-        created_at: created_at,
-        updated_at: updated_at
-      )
-    end
-
-    def to_hash
-      {
-        id:         id,
-        first_name: first_name,
-        last_name:  last_name,
-        email:      email,
-        created_at: created_at,
-        updated_at: updated_at,
-      }
-    end
-  end
-end

data/spec/support/mocks/user.json

@@ -1,8 +0,0 @@
-{
-  "id": "toms-uuid",
-  "first_name": "Tom",
-  "last_name": "Prats",
-  "email": "tom@tomprats.com",
-  "created_at": 1392153790744,
-  "updated_at": 1392153790744
-}

data/spec/traitify-ruby/client/user_spec.rb

@@ -1,41 +0,0 @@
-require "spec_helper"
-
-describe Traitify::Client do
-  before do
-    Traitify.configure do |tom|
-      tom.secret = "secret"
-      tom.api_host = "https://example.com"
-      tom.api_version = "v1"
-    end
-  end
-
-  let(:tom) { Traitify.new }
-
-  describe ".create_user" do
-    let(:user) { tom.create_user(
-      first_name: "Tom",
-      last_name: "Prats",
-      email: "tom@tomprats.com"
-    )}
-
-    before(:each) do
-      stub_it(:post, "/users", "user")
-    end
-
-    it "returns a user" do
-      expect(user.first_name).to eq("Tom")
-    end
-  end
-
-  describe ".find_user" do
-    let(:user) { tom.find_user("toms-uuid") }
-
-    before(:each) do
-      stub_it(:get, "/users/toms-uuid", "user")
-    end
-
-    it "returns a user" do
-      expect(user.id).to eq("toms-uuid")
-    end
-  end
-end