built.io 0.7 → 0.8

data/lib/built/upload.rb

@@ -0,0 +1,202 @@
+require "uri"
+
+module Built
+  class Upload < DirtyHashy
+    include Built::Timestamps
+
+    # Get the uid for this upload
+    def uid
+      self["uid"]
+    end
+
+    # Set the uid for this upload
+    # @param [String] uid A valid upload uid
+    def uid=(uid)
+      self["uid"] = uid
+    end
+
+    # Set a new file
+    # @param [File] file The file object to set
+    def file=(file)
+      Util.type_check("file", file, File)
+
+      self["upload"]  = file
+      @file_set       = file
+
+      self
+    end
+
+    # URL for the upload
+    # @return [String] url
+    def url
+      self["url"]
+    end
+
+    # Fetch the latest instance of this upload from built
+    # @raise BuiltError If the uid is not set
+    # @return [Upload] self
+    def sync
+      if !uid
+        # uid is not set
+        raise BuiltError, I18n.t("objects.uid_not_set")
+      end
+
+      instantiate(
+        Built.client.request(uri)
+          .json["upload"]
+      )
+
+      self
+    end
+
+    # Save / persist the upload to built.io
+    # @param [Hash] options Options
+    # @raise BuiltAPIError
+    # @return [Object] self
+    def save(options={})
+      header = {"Content-Type" => "multipart/form-data"}
+
+      if is_new?
+        unless @file_set
+          raise BuiltError, I18n.t("uploads.file_not_provided")
+        end
+
+        # create
+        instantiate(
+          Built.client.request(uri, :post, wrap, nil, header)
+            .json["upload"]
+        )
+      else
+        # update
+        instantiate(
+          Built.client.request(uri, :put, wrap, nil, header)
+            .json["upload"]
+        )
+      end
+
+      if @file_set
+        @file_set = nil
+      end
+
+      self
+    end
+
+    # Delete this upload
+    # @raise BuiltError If the uid is not set
+    # @return [Upload] self
+    def destroy
+      if !uid
+        # uid is not set
+        raise BuiltError, I18n.t("objects.uid_not_set")
+      end
+
+      Built.client.request(uri, :delete)
+
+      self.clear
+
+      self
+    end
+
+    # Get tags for this upload
+    def tags
+      self["tags"] || []
+    end
+
+    # Add new tags
+    # @param [Array] tags An array of strings. Can also be a single tag.
+    def add_tags(tags)
+      tags = tags.is_a?(Array) ? tags : [tags]
+      self["tags"] ||= []
+      self["tags"].concat(tags)
+      self
+    end
+
+    # Remove tags
+    # @param [Array] tags An array of strings. Can also be a single tag.
+    def remove_tags(tags)
+      tags = tags.is_a?(Array) ? tags : [tags]
+      self["tags"] ||= []
+      self["tags"] = self["tags"] - tags
+      self
+    end
+
+    # Initialize a new upload
+    # @param [String] uid The uid of an existing upload, if this is an existing upload
+    def initialize(uid=nil)
+      if uid
+        self.uid = uid
+      end
+
+      clean_up!
+      self
+    end
+
+    # @api private
+    def instantiate(data)
+      replace(data)
+      clean_up!
+      self
+    end
+
+    # Get ACL
+    # @return [ACL]
+    def ACL
+      Built::ACL.new(self["ACL"])
+    end
+
+    # Set ACL
+    # @param [ACL] acl
+    def ACL=(acl)
+      self["ACL"] = {
+        "disable" => acl.disabled,
+        "others" => acl.others,
+        "users" => acl.users,
+        "roles" => acl.roles
+      }
+
+      self
+    end
+
+    private
+
+    def uri
+      uid ? 
+        [self.class.uri, uid].join("/") : 
+        self.class.uri
+    end
+
+    def wrap
+      data = {
+        "PARAM" => {"upload" => self.select {|key| key != "upload"}}.to_json
+      }
+
+      if @file_set
+        data["upload[upload]"] = self["upload"]
+      end
+
+      data
+    end
+
+    def to_s
+      "#<Built::Upload uid=#{uid}>"
+    end
+
+    # Is this a new, unsaved object?
+    # @return [Boolean]
+    def is_new?
+      Util.blank?(uid)
+    end
+
+    class << self
+      def instantiate(data)
+        doc = new
+        doc.instantiate(data)
+      end
+
+      # @api private
+      def uri
+        "/uploads"
+      end
+    end
+  end
+end

data/lib/built/user.rb

@@ -0,0 +1,147 @@
+module Built
+  class User < Built::Object
+    # Create a new user object
+    # @param [String] uid The uid of an existing user, if this is an existing user
+    def initialize(uid=nil)
+      super(Built::USER_CLASS_UID, uid)
+    end
+
+    # Assign authtoken for this user
+    def authtoken=(token)
+      @authtoken = token
+      self["authtoken"] = token
+    end
+
+    # Get the authtoken for this user
+    def authtoken
+      @authtoken
+    end
+
+    # Logout a user
+    def logout
+      if !authtoken || (authtoken != Built.client.authtoken)
+        raise BuiltError, I18n.t("users.not_logged_in")
+      end
+
+      Built.client.request(
+        logout_uri,
+        :delete
+      )
+
+      authtoken                 = nil
+      Built.client.authtoken    = nil
+      Built.client.current_user = nil
+
+      self
+    end
+
+    # Update the user profile
+    def update_user
+      data = {
+        self.class.user_wrapper => wrap.delete("object")
+      }
+
+      response = Built.client.request(uri, :put, data).json[self.class.user_wrapper]
+
+      instantiate(response)
+
+      self
+    end
+
+    # Delete / Deactivate the user. USE WITH CAUTION!
+    def deactivate
+      Built.client.request(uri, :delete)
+
+      self.clear
+
+      self
+    end
+
+    private
+
+    def uri
+      self.class.uri + '/#{uid}'
+    end
+
+    class << self
+      # Login a user with an email and password
+      # Once logged in, the user's authtoken will be used for all further requests
+      # @param [String] email The user's email
+      # @param [String] password The user's password
+      def login(email, password)
+        Util.type_check("email", email, String)
+        Util.type_check("password", password, String)
+
+        response = Built.client.request(
+          login_uri,
+          :post,
+          {user_wrapper => {"email" => email, "password" => password}}
+        ).json[user_wrapper]
+
+        user                      = instantiate(response)
+        user.authtoken            = response["authtoken"]
+        Built.client.authtoken    = user.authtoken
+        Built.client.current_user = user
+
+        user
+      end
+
+      # TODO
+      def login_with_google
+      end
+
+      # TODO
+      def login_with_facebook
+      end
+
+      # TODO
+      def login_with_tibbr
+      end
+
+      # TODO
+      def login_with_twitter
+      end
+
+      # Fetch the current logged in user
+      def current_user
+        return Built.client.current_user if Built.client.current_user
+
+        if Built.client.authtoken
+          # we have the authtoken, but not the user
+          # we'll fetch the user corresponding to the authtoken
+          user = instantiate(Built.client.request(current_uri).json[user_wrapper])
+          Built.client.current_user = user
+        end
+
+        Built.client.current_user
+      end
+
+      private
+
+      def user_wrapper
+        "application_user"
+      end
+
+      def wrap_in_user
+        changed_keys = self.changes.keys
+        {"application_user" => self.select {|o| changed_keys.include?(o)}}
+      end
+
+      def users_uri
+        "/application/users"
+      end
+
+      def login_uri
+        users_uri + "/login"
+      end
+
+      def logout_uri
+        users_uri + "/logout"
+      end
+
+      def current_uri
+        users_uri + '/current'
+      end
+    end
+  end
+end

data/lib/built/util.rb

@@ -1,7 +1,22 @@
 module Built
   class Util
-    def self.blank?(value)
-      value.respond_to?(:empty?) ? value.empty? : !value
+    class << self
+      def blank?(value)
+        value.respond_to?(:empty?) ? value.empty? : !value
+      end
+
+      def type_check(key, value, type)
+        unless value.is_a?(type)
+          raise BuiltError, I18n.t("datatypes.not_match", {
+            :key => key,
+            :type => type
+          })
+        end
+      end
+
+      def is_i?(value)
+        !!(value =~ /^[-+]?[0-9]+$/)
+      end
     end
   end
 end

data/lib/built.rb

@@ -1,5 +1,5 @@
 require "i18n"
-require "httmultiparty"
+require "rest-client"
 require "dirty_hashy"
 
 module Built
@@ -19,8 +19,8 @@ module Built
     def init(options)
       options ||= {}
 
-      host        = options[:host]    || API_URI
-      version     = options[:version] || API_VERSION
+      host        = options[:host]    || Built::API_URI
+      version     = options[:version] || Built::API_VERSION
       master_key  = options[:master_key]
       api_key     = options[:application_api_key]
       authtoken   = options[:authtoken]
@@ -66,4 +66,10 @@ require "built/timestamps"
 require "built/application"
 require "built/class"
 require "built/object"
-require "built/query"
+require "built/query"
+require "built/location"
+require "built/acl"
+require "built/user"
+require "built/role"
+require "built/installation"
+require "built/upload"

data/lib/locales/en.yml

@@ -5,5 +5,12 @@ en:
   objects:
     class_uid: "class_uid needs to be provided when initializing an object"
     uid_not_set: "uid for this object needs to be set before attempting to fetch it"
+    pull_require: "`pull_value` requires either `index` or `value` to be provided"
   querying:
-    class_uid: "class_uid needs to be provided to query for objects"
+    class_uid: "class_uid needs to be provided to query for objects"
+  datatypes:
+    not_match: "%{key} is not of the type %{type}"
+  users:
+    not_logged_in: "The user needs to be logged in order to log out"
+  uploads:
+    file_not_provided: "Before creating an upload, you need to set a file."

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: built.io
 version: !ruby/object:Gem::Version
-  version: '0.7'
+  version: '0.8'
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-25 00:00:00.000000000 Z
+date: 2014-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n
@@ -28,13 +28,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.6.1
 - !ruby/object:Gem::Dependency
-  name: httmultiparty
+  name: rest-client
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.3.10
+        version: 1.6.7
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -42,7 +42,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.3.10
+        version: 1.6.7
 - !ruby/object:Gem::Dependency
   name: dirty_hashy
   requirement: !ruby/object:Gem::Requirement
@@ -98,15 +98,21 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/built/upload.rb
 - lib/built/constants.rb
 - lib/built/util.rb
+- lib/built/user.rb
 - lib/built/error.rb
 - lib/built/timestamps.rb
 - lib/built/application.rb
+- lib/built/role.rb
+- lib/built/acl.rb
 - lib/built/i18n.rb
+- lib/built/installation.rb
 - lib/built/client.rb
 - lib/built/class.rb
 - lib/built/query.rb
+- lib/built/location.rb
 - lib/built/object.rb
 - lib/locales/en.yml
 - lib/built.rb