kippt 1.1.0 → 2.0.0

data/lib/kippt/comment.rb

@@ -0,0 +1,25 @@
+require "kippt/resource"
+require "kippt/user"
+require "kippt/clip"
+
+class Kippt::Comment
+  include Kippt::Resource
+
+  attributes :body, :id, :resource_uri,
+             :created => Time, :user => Kippt::User
+
+  writable_attributes :body
+
+  attr_reader :clip
+
+  def initialize(attributes = {}, client = nil, clip = nil)
+    super(attributes, client)
+    @clip = clip
+  end
+
+  private
+
+  def collection_resource
+    @collection_resource ||= client.collection_resource_for(Kippt::Comments, clip)
+  end
+end

data/lib/kippt/comment_collection.rb

@@ -0,0 +1,10 @@
+require "kippt/collection"
+require "kippt/comment"
+
+class Kippt::CommentCollection
+  include Kippt::Collection
+
+  def object_class
+    Kippt::Comment
+  end
+end

data/lib/kippt/comments.rb

@@ -0,0 +1,43 @@
+require "kippt/comment_collection"
+require "kippt/comment"
+
+class Kippt::Comments
+  include Kippt::CollectionResource
+
+  attr_reader :clip
+
+  def initialize(client, clip)
+    @client = client
+    @clip   = clip
+  end
+
+  def self.valid_filter_parameters
+    [:limit, :offset]
+  end
+
+  def object_class
+    Kippt::Comment
+  end
+
+  def collection_class
+    Kippt::CommentCollection
+  end
+
+  def base_uri
+    "clips/#{clip.id}/comments"
+  end
+
+  def all(options = {})
+    validate_collection_options(options)
+
+    if options.empty? && @clip.all_comments_embedded?
+      collection_class.new({"objects" => @clip.comments_data}, client)
+    else
+      collection_class.new(client.get(base_uri, options).body, client)
+    end
+  end
+
+  def build(attributes = {})
+    object_class.new(attributes, client, clip)
+  end
+end

data/lib/kippt/connection.rb

@@ -2,6 +2,8 @@ require "multi_json"
 require "faraday_middleware/response_middleware"
 
 module Kippt::Connection
+  HOST = "kippt.com"
+
   class ParseMultiJson < FaradayMiddleware::ResponseMiddleware
     define_parser do |body|
       begin
@@ -31,22 +33,26 @@ module Kippt::Connection
   private
 
   def connection
-    @connection ||= Faraday.new("https://kippt.com/api") do |builder|
+    @connection ||= Faraday.new("https://#{HOST}/api") do |builder|
       builder.use Kippt::Connection::ParseMultiJson
-      # builder.use Faraday::Response::Logger
+      builder.use Faraday::Response::Logger if debug?
       builder.adapter Faraday.default_adapter
     end
   end
 
   def request(method, url, options)
+    if @password
+      connection.basic_auth(@username, @password)
+    end
+
     response = connection.send(method) do |req|
       set_default_headers(req)
 
-      if @password
-        connection.basic_auth(@username, @password)
-      else
-        req.headers["X-Kippt-Username"]  = @username
-        req.headers["X-Kippt-API-Token"] = @token
+      unless @password
+        if @username && @token
+          req.headers["X-Kippt-Username"]  = @username
+          req.headers["X-Kippt-API-Token"] = @token
+        end
       end
 
       if method == :get
@@ -56,7 +62,7 @@ module Kippt::Connection
         req.body = MultiJson.dump(options[:data])
       end
     end
-    
+
     if response.status == 401
       raise Kippt::APIError.new(response.body["message"])
     end

data/lib/kippt/follow_relationship.rb

@@ -0,0 +1,50 @@
+class Kippt::FollowRelationship
+  attr_reader :user
+
+  def initialize(client, user)
+    @client = client
+    @user   = user
+  end
+
+  def following?
+    response = client.get("users/#{user.id}/relationship/")
+
+    if response.success?
+      response.body["following"]
+    else
+      raise Kippt::APIError.new("Resource could not be loaded: #{response.body["message"]}")
+    end
+  end
+
+  def follow
+    response = update_following(true)
+
+    if response.success?
+      true
+    else
+      raise Kippt::APIError.new("Problem with following: #{response.body["message"]}")
+    end
+  end
+
+  def unfollow
+    response = update_following(false)
+
+    if response.success?
+      true
+    else
+      raise Kippt::APIError.new("Problem with unfollowing: #{response.body["message"]}")
+    end
+  end
+
+  private
+
+  def update_following(value)
+    follow_value = value ? "follow" : "unfollow"
+
+    client.post("users/#{user.id}/relationship/", :data => {:action => follow_value})
+  end
+
+  def client
+    @client
+  end
+end

data/lib/kippt/followers.rb

@@ -0,0 +1,26 @@
+require "kippt/collection_resource"
+require "kippt/user_collection"
+require "kippt/user"
+
+class Kippt::Followers
+  include Kippt::CollectionResource
+
+  attr_reader :user
+
+  def initialize(client, user)
+    @client = client
+    @user   = user
+  end
+
+  def object_class
+    Kippt::User
+  end
+
+  def collection_class
+    Kippt::UserCollection
+  end
+
+  def base_uri
+    "users/#{user.id}/followers"
+  end
+end

data/lib/kippt/following.rb

@@ -0,0 +1,26 @@
+require "kippt/collection_resource"
+require "kippt/user_collection"
+require "kippt/user"
+
+class Kippt::Following
+  include Kippt::CollectionResource
+
+  attr_reader :user
+
+  def initialize(client, user)
+    @client = client
+    @user   = user
+  end
+
+  def object_class
+    Kippt::User
+  end
+
+  def collection_class
+    Kippt::UserCollection
+  end
+
+  def base_uri
+    "users/#{user.id}/following"
+  end
+end

data/lib/kippt/like.rb

@@ -0,0 +1,48 @@
+require "kippt/users"
+
+class Kippt::Like
+  def initialize(client, clip)
+    @client = client
+    @errors = []
+    @clip   = clip
+  end
+
+  def id
+    nil
+  end
+
+  def collection_resource_class
+    Kippt::Likes
+  end
+
+  def writable_attributes_hash
+    nil
+  end
+
+  def save
+    @errors = []
+    response = collection_resource.save_resource(self)
+    if response[:error_message]
+      errors << response[:error_message]
+    end
+    response[:success]
+  end
+
+  def destroy
+    collection_resource.destroy_resource(self)
+  end
+
+  private
+
+  def collection_resource
+    @collection_resource ||= client.collection_resource_for(collection_resource_class, clip)
+  end
+
+  def client
+    @client
+  end
+
+  def clip
+    @clip
+  end
+end

data/lib/kippt/likes.rb

@@ -0,0 +1,48 @@
+require "kippt/user_collection"
+require "kippt/user"
+require "kippt/like"
+
+class Kippt::Likes
+  include Kippt::CollectionResource
+
+  attr_reader :clip
+
+  def initialize(client, clip)
+    @client = client
+    @clip   = clip
+  end
+
+  def self.valid_filter_parameters
+    []
+  end
+
+  def object_class
+    Kippt::User
+  end
+
+  def collection_class
+    Kippt::UserCollection
+  end
+
+  def base_uri
+    "clips/#{clip.id}/likes"
+  end
+
+  def all(options = {})
+    validate_collection_options(options)
+
+    if options.empty? && @clip.all_likes_embedded?
+      collection_class.new({"objects" => @clip.likes_data}, client)
+    else
+      collection_class.new(client.get(base_uri, options).body, client)
+    end
+  end
+
+  def build
+    Kippt::Like.new(client, clip)
+  end
+
+  def destroy_resource(resource)
+    client.delete(base_uri).success?
+  end
+end

data/lib/kippt/list.rb

@@ -1,10 +1,35 @@
-require "ostruct"
+require "kippt/user"
 
 class Kippt::List
   include Kippt::Resource
 
-  attributes :id, :rss_url, :updated, :title,
-             :created, :slug, :resource_uri
+  attributes :app_url, :id, :rss_url, :title,
+             :slug, :resource_uri, :description,
+             :updated => Time, :created => Time,
+             :user => Kippt::User
+  boolean_attributes :is_private
 
-  writable_attributes :title
+  writable_attributes :title, :description
+
+  def collection_resource_class
+    Kippt::Lists
+  end
+
+  def collaborators
+    attributes.collaborators["data"].map {|collborator_data|
+      Kippt::User.new(collborator_data, client)
+    }
+  end
+
+  def follow
+    response = client.post("#{resource_uri}relationship", :data => {:action => "follow"})
+    raise Kippt::APIError.new("There was an error with the request: #{response.body["message"]}") unless response.success?
+    response.success?
+  end
+
+  def unfollow
+    response = client.post("#{resource_uri}relationship", :data => {:action => "unfollow"})
+    raise Kippt::APIError.new("There was an error with the request: #{response.body["message"]}") unless response.success?
+    response.success?
+  end
 end

data/lib/kippt/list_collection.rb

@@ -7,4 +7,8 @@ class Kippt::ListCollection
   def object_class
     Kippt::List
   end
+
+  def collection_resource_class
+    Kippt::Lists
+  end
 end

data/lib/kippt/resource.rb

@@ -1,10 +1,12 @@
+require "ostruct"
+
 module Kippt::Resource
   def self.included(base)
     base.instance_eval do
       extend Forwardable
       attr_reader :attributes, :errors
 
-      def_delegators "self.class", :writable_attribute_names, :attribute_names
+      def_delegators "self.class", :writable_attribute_names, :attribute_names, :embedded_attribute_names
     end
 
     base.extend(ClassMethods)
@@ -13,31 +15,116 @@ module Kippt::Resource
   module ClassMethods
     attr_reader :writable_attribute_names, :attribute_names
 
+    def embedded_attribute_names
+      @embedded_attribute_names || []
+    end
+
     def attributes(*attribs)
-      @attribute_names = attribs.map {|attrib| attrib.to_sym }
-      def_delegators :attributes, *@attribute_names
+      @attribute_names ||= []
+      hashes, other = attribs.partition {|attrib| attrib.is_a? Hash }
+
+      attribute_names = convert_to_symbols(other)
+      def_delegators :attributes, *attribute_names
+      @attribute_names += attribute_names
+
+      mappings = hashes.reduce({}, :update)
+      mappings.each do |attrib, object_class|
+        if object_class.to_s == "Time"
+          define_method(attrib) do
+            Time.at(attributes.send(attrib))
+          end
+        else
+          reified_class = _get_class(object_class)
+          define_method(attrib) do
+            value = attributes.send(attrib)
+            reified_class.new(value) unless value.nil?
+          end
+        end
+      end
+      @attribute_names += convert_to_symbols(mappings.keys)
+    end
+
+    def boolean_attributes(*attribs)
+      @attribute_names ||= []
+      attribute_names = convert_to_symbols(attribs)
+      def_delegators :attributes, *attribute_names
+      @attribute_names += attribute_names
+
+      attribs.each do |attribute_name|
+        if result = attribute_name.to_s.match(/\Ais\_(.*)/)
+          define_method "#{result[1]}?" do
+            send(attribute_name) if respond_to?(attribute_name)
+          end
+        end
+      end
     end
 
     def writable_attributes(*attribs)
-      @writable_attribute_names = attribs.map {|attrib| attrib.to_sym }
+      @writable_attribute_names = convert_to_symbols(attribs)
       @writable_attribute_names.freeze
-      def_delegators :attributes, *(@writable_attribute_names.map {|attrib| attrib.to_s + "=" })
+      def_delegators :attributes, *(@writable_attribute_names.map {|attrib| attrib.to_s + "=" }).dup
+    end
+
+    def embedded_attributes(*attribs)
+      mappings = attribs.reduce({}, :update)
+      @embedded_attribute_names = convert_to_symbols(mappings.keys)
+      @embedded_attribute_names.freeze
+
+      mappings.each do |attrib, attribute_class|
+        reified_class = _get_class(attribute_class)
+        define_method(attrib) do
+          value = attributes.send(attrib)
+          if value.is_a? String
+            client.resource_from_url(reified_class, value)
+          elsif value.is_a? reified_class
+            value
+          else
+            reified_class.new(value, client)
+          end
+        end
+      end
+    end
+
+    private
+
+    def convert_to_symbols(list)
+      list.map {|item| item.to_sym }
+    end
+
+    protected
+
+    def _get_class(camel_cased_word)
+      if camel_cased_word.is_a? Class
+        camel_cased_word
+      else
+        names = camel_cased_word.split('::')
+        names.shift if names.empty? || names.first.empty?
+
+        constant = Object
+        names.each do |name|
+          constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+        end
+        constant
+      end
     end
   end
 
-  def initialize(attributes = {}, collection_resource = nil)
+  def initialize(attributes = {}, client = nil)
     @attributes = OpenStruct.new(attributes)
     @errors     = []
-    @collection_resource   = collection_resource
+    @client     = client
   end
 
   def destroy
-    @collection_resource.destroy_resource(self)
+    collection_resource.destroy_resource(self)
   end
 
   def writable_attributes_hash
     writable_attribute_names.inject({}) do |parameters, attribute_name|
       value = self.send(attribute_name)
+      if embedded_attribute_names.include?(attribute_name) && !value.is_a?(String)
+        value = value.resource_uri
+      end
       unless value.nil?
         parameters[attribute_name] = value
       end
@@ -47,7 +134,7 @@ module Kippt::Resource
 
   def save
     @errors = []
-    response = @collection_resource.save_resource(self)
+    response = collection_resource.save_resource(self)
     if response[:error_message]
       errors << response[:error_message]
     else
@@ -60,4 +147,14 @@ module Kippt::Resource
     end
     response[:success]
   end
+
+  private
+
+  def collection_resource
+    @collection_resource ||= client.collection_resource_for(collection_resource_class)
+  end
+
+  def client
+    @client
+  end
 end