flareshow 0.3.1

data/lib/invitation.rb

@@ -0,0 +1,16 @@
+class Invitation < Flareshow::Resource
+  
+  @read_only=true
+  
+  # =================
+  # = Class Methods =
+  # =================
+  class << self
+    # invitations dont have timestamps currently
+    # overriding the default
+    def default_params
+      {}
+    end
+  end
+
+end

data/lib/membership.rb

@@ -0,0 +1,3 @@
+class Membership < Flareshow::Resource
+  
+end

data/lib/mime_parts.rb

@@ -0,0 +1,37 @@
+# Adapted From : http://deftcode.com/code/flickr_upload/multipartpost.rb
+
+class Param
+  attr_accessor :key, :value, :content_type
+  def initialize(key, value, content_type)
+    @key = key; @value = value; @content_type = content_type
+  end
+  
+  def to_multipart
+    return "\r\nContent-Disposition: form-data; name=\"#{CGI::escape(key)}\"\r\n" +
+"Content-Type: #{content_type}; charset=UTF-8" +
+"\r\n\r\n#{value}\r\n"
+  end
+end
+  
+class FileParam
+  attr_accessor :key, :filename, :content
+  def initialize( key, filename, content )
+    @key = key; @filename = filename; @content = content
+  end
+  
+  def to_multipart
+    return "Content-Disposition: form-data; name=\"#{CGI::escape(key)}\"; filename=\"#{filename}\"\r\n" +
+"Content-Transfer-Encoding: binary\r\n" +
+"Content-type: #{MIME::Types.type_for(filename)}\r\n\r\n" + content + "\r\n"
+  end
+end
+
+class MultipartPost
+  BOUNDARY = "flareshow_multipart_boundary_A0n23hja"
+  HEADER = {"Content-type" => "multipart/form-data, boundary=" + BOUNDARY + " "}
+
+  def self.prepare_query(params)
+    query = params.map {|p| "--" + BOUNDARY + "\r\n" + p.to_multipart }.join("") + "--" + BOUNDARY + "--"
+    [query, HEADER]
+  end
+end

data/lib/post.rb

@@ -0,0 +1,65 @@
+class Post < Flareshow::Resource
+  @attr_accessible = [:content, :flow_id, :files]
+  @attr_required = [:flow_id]
+  
+  extend Flareshow::Searchable
+  
+  # permalink to this post
+  def permalink(mobile=false)
+    if mobile
+      "http://#{Flareshow::Service.server.host}/#{Flareshow::Service.server.domain}/shareflow/mobile/post/#{id}"
+    else
+      "http://#{Flareshow::Service.server.host}/#{Flareshow::Service.server.domain}/shareflow/p/#{id}"
+    end
+  end
+  
+  # build a new comment but don't immediately persist it
+  def build_comment(attributes={})
+    c = Comment.new(attributes)
+    c.post_id = self.id
+    c
+  end
+  
+  # create a new comment on the post
+  def create_comment(attributes={})
+    c = build_comment(attributes)
+    c.save
+  end
+  
+  # build a new file object on the client but don't commit to the server immediately
+  def build_file(file_path)
+    self.files ||= []
+    self.files += [{"part_id" => "file_#{UUID.generate}", "file_path" => file_path}]
+  end
+  
+  # upload a file to a post
+  def create_file(file_path)
+    self.files = []
+    self.build_file(file_path)
+    self.save
+    self.files = nil
+  end
+  
+  # persisted files for this post
+  def files
+    FileAttachment.find({:post_id => id})
+  end
+  
+  # comments for this post
+  def comments
+    Comment.find({:post_id => id})
+  end
+  
+  # user for this post
+  def user
+    return User.current unless user_id
+    User.first({:id => user_id})
+  end
+  
+  # get the flow for this post
+  def flow
+    return false unless flow_id
+    Flow.first({:id => flow_id})
+  end
+  
+end

data/lib/resource.rb

@@ -0,0 +1,205 @@
+class Flareshow::Resource
+  
+  class << self
+    attr_accessor :read_only, :attr_accessible, :attr_required
+    
+    def default_params
+      # default parameters that are included with query
+      # requests unless they are explicitly overridden
+      {:order => "created_at desc"}
+    end
+    
+    # return the resource key for this resource
+    def resource_key
+      Flareshow::ClassToResourceMap[self.name]
+    end
+    
+    # find an existing instance of this object in the client or create a new one
+    def get_from_cache(id)
+      store.get_resource(resource_key, id)
+    end
+    
+    # list out the instances in memory
+    def list_cache
+      store.list_resource(resource_key)
+    end
+    
+    # store the response resources in the cache
+    def cache_response(response)
+      Flareshow::CacheManager.assimilate_resources(response["resources"])
+    end
+  
+    # find a resource by querying the server
+    # store the results in the cache and return
+    # the keyed resources for the model performing the query
+    def find(params={})
+      params = default_params.merge(params)
+      response = Flareshow::Service.query({resource_key => params})
+      (cache_response(response) || {})[resource_key]
+    end
+    
+    # find just one resource matching the conditions specified
+    def first(params={})
+      params = default_params.merge(params)
+      params = params.merge({"limit" => 1})
+      response = Flareshow::Service.query({resource_key => params})
+      (cache_response(response) || {})[resource_key].first
+    end
+    
+    # create a resource local and sync it to the server
+    def create(params={})
+      new(params).save
+    end
+    
+    #
+    def store
+      Flareshow::CacheManager.cache
+    end
+  end
+  
+  # constructor
+  # build a new Flareshow::Base resource
+  def initialize(data={}, source = :client)
+    @data = {}
+    Flareshow::Util.log_info("creating #{self.class.name} with data from #{source}")
+    update(data, source)
+    @data["id"] = UUID.generate.upcase if source == :client
+  end
+  
+  # return the resource key for this resource
+  def resource_key
+    Flareshow::ClassToResourceMap[self.class.name]
+  end
+  
+  # store a resource in the cache
+  def cache
+    self.class.store.store.set_resource(resource_key, id, self)
+  end
+  
+  # ==============================
+  # = Server Persistence Actions =
+  # ==============================
+  
+  # reload the resource from the server
+  def refresh
+    results = self.find({"id" => id})
+    mark_destroyed! if results.empty?
+    self
+  end
+  
+  # save a resource to the server
+  def save
+    raise Flareshow::APIAccessException if self.class.read_only
+    key = Flareshow::ClassToResourceMap[self.class.name]
+    raise Flareshow::MissingRequiredField unless !self.class.attr_required || (self.class.attr_required.map{|a|a.to_s} - @data.keys).empty?
+    response = Flareshow::Service.commit({resource_key => [(self.changes || {}).merge({"id" => id})] })
+    cache_response(response)
+    self
+  rescue Exception => e
+    Flareshow::Util.log_error e.message
+    Flareshow::Util.log_error e.backtrace.join("\n")
+    throw e
+    false
+  end
+  
+  # destroy the resource on the server
+  def destroy
+    raise Flareshow::APIAccessException if self.class.read_only
+    response = Flareshow::Service.commit({resource_key => [{"id" => id, "_removed" => true}]})
+    cache_response(response)
+    mark_destroyed!
+    self
+  rescue Exception => e
+    Flareshow::Util.log_error e.message
+    throw e
+    false
+  end
+  
+  # has this resource been destroyed
+  def destroyed?
+    self._removed || self.frozen?
+  end
+  
+  private
+  
+  # clear the element of the cache
+  def mark_destroyed!
+    self.freeze
+    self._removed=true 
+    self.class.store.delete_resource(resource_key, id)
+  end
+  
+  public
+  
+  # ==================================
+  # = Attribute and State Management =
+  # ==================================
+  
+  # return the server id of a resource
+  def id
+    @data["id"]
+  end
+  
+  # update the instance data for this resource
+  # keeping track of dirty state if the update came from
+  # the client
+  def update(attributes, source = :client)
+    raise Flareshow::APIAccessException if self.class.read_only && source == :client
+    attributes.each do |p|
+      key, value = p[0], p[1]
+      self.set(key, value, source)
+    end
+  rescue Exception => e
+    Flareshow::Util.log_error e.message
+    throw e
+    false
+  end
+  
+  # keep track of dirty state on the client by maintaining a copy
+  # of the original state of each intstance variable when it is provided by
+  # the server
+  def set(key, value, source = :client)
+    raise Flareshow::APIAccessException if self.class.read_only && source == :client
+    if self.class.attr_accessible && 
+      !(/_removed/).match(key.to_s) &&
+      !self.class.attr_accessible.include?(key.to_sym) && source == :client
+      Flareshow::Util.log_error "#{self.class.name}.#{key} is not a writable field"
+      raise Flareshow::APIAccessException 
+    end
+    # Flareshow::Util.log_info("setting #{key} : #{value}")
+    @data["original_#{key}"] = value if source == :server
+    @data[key.to_s]=value
+  rescue Exception => e
+    Flareshow::Util.log_error e.message
+    throw e
+    false
+  end
+  
+  # get a data value
+  def get(key)
+    @data[key]
+  end
+  
+  # all the state that has been modified on the client
+  def changes
+    attributes = @data.inject({}) do |memo, pair|
+      key, value = *pair
+      if @data[key] != @data["original_#{key}"] && !key.to_s.match(/original/)
+        memo[key] = value
+      end
+      memo
+    end
+  end
+  
+  # fallback to getter or setter
+  def method_missing(meth, *args)
+    meth = meth.to_s
+    meth.match(/\=/) ? set(meth.gsub(/\=/,''), *args) : get(meth)
+  end
+  
+  # has this model been removed on the server
+  def method_name
+    !!self._removed
+  end
+  
+end

data/lib/searchable.rb

@@ -0,0 +1,9 @@
+module Flareshow
+  module Searchable
+  
+      def search(keywords)
+        self.find({:keywords => keywords})
+      end
+  
+  end
+end

data/lib/server.rb

@@ -0,0 +1,2 @@
+# represents a server connection for a Flareshow resource
+class Server < Struct.new(:host, :domain); end

data/lib/service.rb

@@ -0,0 +1,195 @@
+# provides an interface to the shareflow api
+class Flareshow::Service
+  
+  # =================
+  # = Class Methods =
+  # =================
+  class << self
+    attr_accessor :server, :debug_output, :key
+    
+    # setup the service to use a particular host and domain
+    def configure(subdomain=nil, host='api.zenbe.com')
+      raise Flareshow::ConfigurationException unless subdomain
+      self.server=Server.new(host, subdomain)
+      @auth_endpoint = @api_endpoint = nil
+    end
+    
+    # return the authentication endpoint for a given host and domain
+    def auth_endpoint
+      @auth_endpoint ||= URI.parse("http://#{server.host}/#{server.domain}/shareflow/api/v2/auth.json")
+    end
+    
+    # return the api endpoint for a given host and domain
+    def api_endpoint
+      @api_endpoint ||= URI.parse("http://#{server.host}/#{server.domain}/shareflow/api/v2.json")
+    end
+    
+    # has the server been configured?
+    def server_defined?
+      !!server
+    end
+    
+    # make a post request to an endpoint
+    # returns a hash of
+    #  - status code
+    #  - headers
+    #  - body
+    def post(uri, params, files=[])
+      raise Flareshow::ConfigurationException unless server_defined?
+      # create the request object
+      req = Net::HTTP::Post.new(uri.path)
+      # set request headers
+      req.add_field "Accept", "application/json"
+      req.add_field "User-Agent", "ruby flareshow"
+      req.add_field "Accept-Encoding", "compress, gzip"
+
+      # just json
+      if !files || files.empty?
+        req.add_field "Content-type", "application/json; charset=UTF-8"
+        # set the postbody
+        req.body = params.to_json
+      # handle file params
+      else
+        params = params.map{|p| 
+          val = p[1].is_a?(String) ? p[1] : p[1].to_json
+          Param.new(p[0], val, "application/json")
+        }
+        files.each do |f|
+          params << FileParam.new(f["part_id"], f["file_path"], File.read(f["file_path"]))
+        end
+        body, header = *MultipartPost.prepare_query(params)
+        req.add_field "Content-type", header["Content-type"]
+        req.body = body
+      end
+      
+      # make the request
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.set_debug_output DEFAULT_LOGGER if debug_output
+      response = http.start {|h| h.request(req)}
+      
+      # normalize the response
+      response = process_response(response)
+      log_response(response)
+      response
+    end
+    
+    # do a get request
+    def http_get(uri)
+      uri = URI.parse(uri) unless uri.is_a? URI
+      req = Net::HTTP::Get.new(uri.path + "?key=#{@key}")
+      req.add_field "User-Agent", "ruby flareshow"
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.set_debug_output DEFAULT_LOGGER if debug_output
+      response = http.start{|h|http.request(req)}
+      response = process_response(response)
+      Flareshow::Util.log_error("resource not found") if response["status_code"] == 404
+      response
+    end
+    
+    # log the response
+    def log_response(response)
+      # log a service exception
+      case response["status_code"]
+        when 400
+          log_service_error(response)
+        when 500
+          log_service_error(response)
+        when 403
+          log_service_error(response)
+      end
+    end
+    
+    # authenticate with the server using an http post
+    def authenticate(login, password)
+      params = {:login => login, :password => password}
+      response = post(auth_endpoint, params)
+      # store the auth token returned from the authentication request
+      if response["status_code"] == 200
+        @key = response["resources"]["data"]["auth_token"]
+        response
+      else
+        raise Flareshow::AuthenticationFailed
+      end
+    rescue Exception => e
+      Flareshow::Util.log_error e.message
+      Flareshow::Util.log_error e.backtrace.join("\n")
+    end
+    
+    # query the server with an http post of the query params
+    def query(params={})
+      raise Flareshow::AuthenticationRequired unless @key
+      params = {"key" => @key, "query" => params}
+      post(api_endpoint, params)
+    end
+    
+    # commit changes to the server with an http post
+    def commit(params={}, files=[])
+      raise Flareshow::AuthenticationRequired unless @key
+      params, files = *files_from_params(params) if params["posts"]
+      params = {"key" => @key, "data" => params}
+      post(api_endpoint, params, files)
+    end
+    
+    # get the files out of the params
+    def files_from_params(params)
+      files = []
+      # add any file parts passed in and assign a part id to the 
+      params["posts"] = (params["posts"]).map do |f|
+        if f["files"]
+          f["files"] = (f["files"]).map do |ff|
+            # we only want to send up new files from the client so we'll strip out any existing
+            # files in the params that came down from the server
+            val = nil
+            if ff["part_id"]
+              val = {"part_id" => ff["part_id"], "file_path" => ff["file_path"]} 
+              files << val
+            end
+            val
+          end.compact
+        end
+        f
+      end
+      [params, files]
+    end
+    
+    # get the interesting bits out of the curl response
+    def process_response(response)
+      # read the response headers
+      headers = {}; response.each_header{|k,v| headers[k] = v}
+      # build a response object
+      response_obj = {"status_code" => response.code.to_i, "headers" => headers, "body" => response.plain_body}
+      
+      # automatically handle json response
+      if (/json/i).match(response.content_type)
+        response_obj["resources"] = JSON.parse(response_obj["body"])
+      end
+      
+      # log the response
+      Flareshow::Util.log_info(response_obj["status_code"])
+      Flareshow::Util.log_info(response_obj["body"])
+      response_obj
+    end
+    
+    # log a service error
+    def log_service_error(response)
+      if response["resources"]
+        Flareshow::Util.log_error(response["resources"]["message"])
+        Flareshow::Util.log_error(response["resources"]["details"]) 
+      else
+        Flareshow::Util.log_error(response["body"])
+      end
+    end
+    
+    # clear the authenticated session
+    def logout
+      @key = nil
+    end
+    
+    # are we authenticated
+    def authenticated?
+      !!@key
+    end
+    
+  end
+  
+end

data/lib/user.rb

@@ -0,0 +1,60 @@
+class User < Flareshow::Resource
+  
+  @read_only=true
+  
+  # =================
+  # = Class Methods =
+  # =================
+  class << self
+    
+    # return the current authenticated user
+    def current
+      @current
+    end
+    
+    # authenticate user credentials
+    def log_in(login, password)
+      response = Flareshow::Service.authenticate(login, password)
+      user_data = response["resources"]["data"]
+      Flareshow::CacheManager.assimilate_resources({resource_key => [user_data]})
+      @current = User.get_from_cache(user_data["id"])
+    end
+    
+    # ==================
+    # = Authentication =
+    # ==================
+    def logout
+      Flareshow::Service.logout
+      @current = nil
+    end
+    
+  end
+  
+  # ====================
+  # = Instance Methods =
+  # ====================
+  
+  # ================
+  # = Associations =
+  # ================
+  def flows
+    Flow.find({"user_id" => ["in", id]})
+  end
+  
+  def posts
+    Post.find({"user_id" => ["in", id]})
+  end
+  
+  def comments
+    Comment.find({"user_id" => ["in", id]})
+  end
+  
+  def files
+    File.find({"user_id" => ["in", id]})
+  end
+  
+  def logged_in?
+    @current
+  end
+  
+end

data/lib/util.rb

@@ -0,0 +1,13 @@
+class Flareshow::Util
+
+  class << self
+    def log_info(message)
+      DEFAULT_LOGGER.info(message)
+    end
+
+    def log_error(message)
+      DEFAULT_LOGGER.error(message)
+    end
+  end
+
+end

data/test/flareshow_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class FlareshowTest < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'flareshow'
+
+class Test::Unit::TestCase
+end