kegbot_api 0.0.1

data/lib/kegbot_api/nouns/image.rb

@@ -0,0 +1,22 @@
+require 'kegbot_api/nouns/rest_noun'
+
+module KegbotApi
+  class Image < RestNoun
+    id      :id
+    time    :time
+    url     :url
+    url     :thumbnail_url
+
+    def to_s
+      "#<#{self.class.to_s}:#{"0x%x" % object_id} @id=#{self.id.inspect}>"
+    end
+
+    def self.to_s
+      self.client ? "KegbotApi::Image<#{self.client.base_url}>" : super
+    end
+
+    def self.inspect
+      to_s
+    end
+  end
+end

data/lib/kegbot_api/nouns/keg.rb

@@ -0,0 +1,45 @@
+require 'kegbot_api/nouns/remote_rest_noun'
+
+module KegbotApi
+  class Keg < RemoteRestNoun
+    extend Forwardable
+
+    id      :id
+    float   :percent_full
+    float   :volume_ml_remain, :alias => :volume_ml_remaining
+    float   :spilled_ml
+    time    :start_time
+    time    :end_time
+    boolean :online
+    has_one :beverage, :attribute_name => :type, :alias => :type
+    has_one :size, :class_name => 'KegSize'
+
+    def_delegators :beverage, :name
+    def_delegators :size, :volume_ml
+
+
+    def size_name
+      self.size.name
+    end
+
+    def self.all
+      list(get("#{self.client.base_url}/kegs"))
+    end
+
+    def self.find(id, *args)
+      one(get("#{self.client.base_url}/kegs/#{id}"))
+    end
+
+    def to_s
+      "#<#{self.class.to_s}:#{"0x%x" % object_id} @id=#{self.id.inspect}>"
+    end
+
+    def self.to_s
+      self.client ? "KegbotApi::Keg<#{self.client.base_url}>" : super
+    end
+
+    def self.inspect
+      to_s
+    end
+  end
+end

data/lib/kegbot_api/nouns/keg_size.rb

@@ -0,0 +1,21 @@
+require 'kegbot_api/nouns/rest_noun'
+
+module KegbotApi
+  class KegSize < RestNoun
+    id      :id
+    string  :name
+    float   :volume_ml
+
+    def to_s
+      "#<#{self.class.to_s}:#{"0x%x" % object_id} @id=#{self.id.inspect}>"
+    end
+
+    def self.to_s
+      self.client ? "KegbotApi::KegSize<#{self.client.base_url}>" : super
+    end
+
+    def self.inspect
+      to_s
+    end
+  end
+end

data/lib/kegbot_api/nouns/remote_rest_noun.rb

@@ -0,0 +1,49 @@
+require 'active_support/concern'
+require 'kegbot_api/nouns/rest_noun'
+
+module KegbotApi
+  # Rest noun that supports remote access via {#all} and {#find}
+  class RemoteRestNoun < RestNoun
+
+    #
+    # Class Methods
+    #
+
+    class << self
+      def list(response)
+        if response.success?
+          response.objects.map { |hash| self.new hash }
+        else
+          raise *response.raise_arguments
+        end
+      end
+
+      def one(response)
+        if response.success?
+          self.new response.object
+        else
+          raise *response.raise_arguments
+        end
+      end
+
+      def first
+        all.first
+      end
+
+      def get(url, options = {})
+        uri = URI(url)
+
+        Net::HTTP.start(uri.host, uri.port, :use_ssl => (uri.scheme == 'https')) do |http|
+          http_response = http.request_get uri.request_uri
+
+          case http_response
+            when Net::HTTPRedirection
+              raise NotImplementedError, "HTTP redirecting isn't supported"
+            else
+              RestResponse.new http_response
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kegbot_api/nouns/rest_noun.rb

@@ -0,0 +1,36 @@
+require 'net/https'
+require 'kegbot_api/rest_response'
+require 'kegbot_api/nouns/rest_noun_attributes'
+
+module KegbotApi
+  # Base class of all REST nouns (types) in the Kegbot REST API.
+  class RestNoun
+    include RestNounAttributes
+
+    def initialize(attributes = {})
+      self.attributes = attributes
+    end
+
+    # Returns a {Client} client configured for this class
+    # @return [Client]
+    def client
+      self.class.client
+    end
+
+    # Class Methods
+
+    class << self
+      # @return [Client]
+      attr_accessor :client
+      attr_accessor :noun
+
+      def client=(client)
+        @client = client
+      end
+
+      def client
+        @client
+      end
+    end
+  end
+end

data/lib/kegbot_api/nouns/rest_noun_attributes.rb

@@ -0,0 +1,119 @@
+require 'active_support/concern'
+
+module KegbotApi
+  # Provides methods for specifying, storing, and retriving REST noun attributes and relationships.
+  # @see RestNoun
+  module RestNounAttributes
+    extend ActiveSupport::Concern
+
+    included do
+      attr_accessor :attributes
+    end
+
+    module ClassMethods
+      # Defines an id field for this REST noun
+      def id(name, *args)
+        define_accessor  name
+      end
+
+      # Defines a {String} field for this REST noun
+      def string(name, *args)
+        define_accessor  name
+      end
+
+      # Defines a {Float} field for this REST noun
+      def float(name, *args)
+        define_accessor name, *args
+      end
+
+      # Defines a {Fixnum} field for this REST noun
+      def integer(name, *args)
+        define_accessor name
+      end
+
+      # Defines a 1-1 relationship between this Noun and another.
+      # @overload has_one(name, options = {})
+      def has_one(name, *args)
+        options = args.slice!(0) || {}
+        class_name = options[:class_name] || name.capitalize
+        attribute_name = options[:attribute_name] || name
+        key = attribute_name.to_s
+        aliases = options[:alias]
+
+        define_method(name) do
+          if self.attributes.include? key
+            self.client.noun_class(class_name).new self.attributes[key]
+          else
+            nil
+          end
+        end
+        alias_method aliases.to_sym, name.to_sym if aliases
+      end
+
+      # Defines a boolean field for this REST noun, available at name?
+      # @overload boolean(name, options = {})
+      def boolean(name, *args)
+        options = args.slice!(0) || {}
+        attribute_name = options[:attribute_name] || name
+        key = attribute_name.to_s
+
+        define_method("#{name}?") do
+          self.attributes[key]
+        end
+      end
+
+      # Defines a Time field for this REST noun.
+      # The time must be defined as a string in the REST JSON in ISO8601 format
+      def time(name, *args)
+        define_method(name) do
+          if self.attributes.include? name.to_s
+            DateTime.iso8601(self.attributes[name.to_s]).to_time
+          else
+            nil
+          end
+
+        end
+      end
+
+      # Defines a NOUN attribute of a URL
+      # In the REST JSON, the URL my be relative or absolute.  If relative, it will get appended to the client's base_url host.
+      # @overload url(name, options = {})
+      def url(name, *args)
+        options = args.slice!(0) || {}
+        attribute_name = options[:attribute_name] || name
+        key = attribute_name.to_s
+
+        define_method("#{name}") do
+          path = self.attributes[key]
+
+          if path
+            uri = URI(path)
+
+            if uri.absolute?
+              uri.to_s
+            else
+              # merge this URI with the client path
+              base_uri = URI(self.client.base_url)
+
+              klass = base_uri.scheme == 'http' ? URI::HTTP : URI::HTTPS
+              klass.build(:host => base_uri.host, :path => path).to_s
+            end
+          else
+            nil
+          end
+        end
+      end
+
+      # Defines an attribute accessor with the specified name, returning the value of {#attribute} value with key +name+
+      def define_accessor(name, *args)
+        options = args.slice!(0) || {}
+        aliases = options[:alias]
+
+        define_method(name) do
+          self.attributes[name.to_s]
+        end
+        alias_method aliases.to_sym, name.to_sym if aliases
+      end
+    end
+  end
+end

data/lib/kegbot_api/nouns/session.rb

@@ -0,0 +1,32 @@
+require 'kegbot_api/nouns/remote_rest_noun'
+
+module KegbotApi
+  class Session < RemoteRestNoun
+    id      :id
+    string  :name
+    time    :start_time
+    time    :end_time
+    boolean :active, :attribute_name => 'is_active'
+    float   :volume_ml
+
+    def self.all
+      list(get("#{self.client.base_url}/sessions"))
+    end
+
+    def self.find(id, *args)
+      one(get("#{self.client.base_url}/sessions/#{id}"))
+    end
+
+    def to_s
+      "#<#{self.class.to_s}:#{"0x%x" % object_id} @id=#{self.id.inspect}>"
+    end
+
+    def self.to_s
+      self.client ? "KegbotApi::Session<#{self.client.base_url}>" : super
+    end
+
+    def self.inspect
+      to_s
+    end
+  end
+end

data/lib/kegbot_api/nouns/tap.rb

@@ -0,0 +1,31 @@
+require 'kegbot_api/nouns/remote_rest_noun'
+require 'kegbot_api/nouns/keg'
+
+module KegbotApi
+  class Tap < RemoteRestNoun
+    extend Forwardable
+
+    id        :id
+    string    :name
+    string    :meter_name
+    float     :ml_per_tick
+    has_one   :keg, :class_name => 'Keg', :attribute_name => 'current_keg', :alias => 'current_keg'
+    def_delegators :keg, :online?
+
+    def self.all
+      list(get("#{self.client.base_url}/taps"))
+    end
+
+    def to_s
+      "#<#{self.class.to_s}:#{"0x%x" % object_id} @id=#{self.id.inspect}>"
+    end
+
+    def self.to_s
+      self.client ? "KegbotApi::Tap<#{self.client.base_url}>" : super
+    end
+
+    def self.inspect
+      to_s
+    end
+  end
+end

data/lib/kegbot_api/rest_response.rb

@@ -0,0 +1,76 @@
+require 'json'
+
+module KegbotApi
+  # Encapsulates a REST response ({Net::HTTPResponse})
+  #
+  # @visibility private
+  class RestResponse
+    # HTTP status code returned
+    attr_accessor :status_code
+
+    # result (as a string)
+    attr_accessor :body
+
+    # result (parsed into a {Hash})
+    attr_accessor :body_hash
+
+    # @overload initialize(http_response)
+    #   @param http_reponse [Net::HTTPResponse]
+    def initialize(*args)
+      http_response = args.slice!(0)
+
+      self.status_code = http_response.code.to_i
+      self.body = http_response.read_body
+    end
+
+    def success?
+      self.status_code == 200 && self.meta_result == 'ok'
+    end
+
+    # Raises an instance of {KegbotApi::Error} appropriate to the error code returned in the response
+    def raise_arguments
+      error_name = self.error_code
+      klass = KegbotApi.const_defined?(error_name) ? KegbotApi.const_get(error_name) : KegbotApi::Error
+
+      [klass, self.error_message]
+    end
+
+    # Parses the http result body into a {Hash}
+    def body_hash
+      @body_hash ||= JSON::load(self.body)
+    end
+
+    def metadata
+      hash_attribute_or_fail(self.body_hash, 'meta')
+    end
+
+    def meta_result
+      hash_attribute_or_fail(self.metadata, 'result')
+    end
+
+    def error
+      hash_attribute_or_fail(self.body_hash, 'error')
+    end
+
+    def error_code
+      hash_attribute_or_fail(self.error, 'code')
+    end
+
+    def error_message
+      hash_attribute_or_fail(self.error, 'message')
+      self.error['message']
+    end
+
+    def objects
+      hash_attribute_or_fail(self.body_hash, 'objects')
+    end
+
+    def object
+      hash_attribute_or_fail(self.body_hash, 'object')
+    end
+
+    def hash_attribute_or_fail(hash, attribute)
+      (found = hash[attribute]) ? found : raise(InvalidInputError, "Server JSON response didn't include the expected '#{attribute}' field.  #{hash.inspect}")
+    end
+  end
+end

data/lib/kegbot_api/version.rb

@@ -0,0 +1,3 @@
+module KegbotApi
+  VERSION = "0.0.1"
+end