polleverywhere 0.0.1 → 0.0.2

data/.rvmrc

@@ -0,0 +1 @@
+rvm 1.9.2@polleverywhere_gem

data/Gemfile

@@ -5,6 +5,10 @@ gemspec
 
 group :development, :test do
   gem 'rb-fsevent', :require => false if RUBY_PLATFORM =~ /darwin/i
-  gem 'rspec'
   gem 'guard-rspec'
+  gem 'growl'
+  gem 'rspec'
+  gem 'haml'
+  gem 'rake'
+  gem 'ruby-debug19'
 end

data/Guardfile

@@ -1,7 +1,7 @@
 # A sample Guardfile
 # More info at https://github.com/guard/guard#readme
 
-guard 'rspec', :version => 2, :cli => '--colour' do
+guard 'rspec', :version => 2, :cli => '--colour --debugger' do
   watch(%r{^spec/.+_spec\.rb})
   watch(%r{^lib/(.+)\.rb})     { |m| "spec/lib/#{m[1]}_spec.rb" }
   watch('spec/spec_helper.rb') { "spec" }

data/README.md

@@ -1,12 +1,44 @@
 # Poll Everywhere API Gem
 
-Integrate Poll Everywhere into your Ruby applications.
+The Poll Everywhere gem is the best way to integrate Poll Everywhere with your applications.
+
+# Getting Started
+
+Install the Poll Everywhere rubygem:
+
+    sudo gem install polleverywhere
+
+If you're using bundler, add the following line to your Gemfile:
+
+    gem "polleverywhere"
+
+# Accessing your polls
+
+    require 'polleverywhere'
+    
+    # Specify your username and password here
+    PollEverywhere.config do
+      username  "my_username"
+      password  "my_password"
+    end
+    
+    # Now start playing!
+    polls = PollEverywhere::Poll.all
+    poll = poll.first
+    poll.close
+    poll.title = "Hey there, I like changing titles around"
+    poll.options = %w[uno dos tres]
+    poll.save
+    poll.open
+
+You can do all sorts of fun stuff with polls!
 
 # TODO
+
 A roadmap for our API:
 
-* Build an app layer that we can put on top of a sync/async backend.
-* Build out a serialization layer for the model class (to_json,from_json,etc)
-* Implement specs that validate app layer
-* Implement specs that validate protocol/API layer
+* API models and documentation for more pieces of our application
+* Asyn/Evented HTTP adapter
+* App layer specs
+* Protocol/API layer specs
 * Implement documentation system around protocol/API layer specs so that we can run our specs againts a staging environment and validate that it works.

data/Rakefile

@@ -1,2 +1,16 @@
 require 'bundler'
 Bundler::GemHelper.install_tasks
+require 'haml'
+require 'polleverywhere'
+
+namespace :doc do
+  desc "Generate API documentation"
+  task :api do
+    PollEverywhere.config do
+      username "test"
+      password "test"
+    end
+
+    puts PollEverywhere::API::Documentation.generate
+  end
+end

data/docs/api.haml

@@ -0,0 +1,94 @@
+!!! html
+%html
+  %head
+    %title Poll Everywhere API
+  %body
+    %header
+      %h1 Poll Everywhere API Documentation
+      %em Disclaimer: this documentation is only intended for an internal preview. Hold off on using this stuff until we announce it on our blog.
+
+    %section
+      %p This API assumes that you are familar with the low-level semantics of HTTP, including the use of tools like cURL, and JSON.
+      
+      %h1 Authentication
+      %p HTTP Basic authentication is currently used for logging into Poll Everywhere accounts.  
+
+      %h1 We use JSON
+      %p Simple JSON key-value data structures are used throughout the API application to persist and modify data to the web application. Typically resources will include a root key that corresponds with the name of the name of the resource; from example, multiple choice polls all have the root key 'multiple_choice_poll'.
+      
+      %h1 Polls
+      %h2 Multiple choice polls
+      %h3 JSON Attributes
+      %dl
+        %dt=PollEverywhere::MultipleChoicePoll.root_key
+        %dd Root key for multiple choice poll data.
+        %dd
+          %dl
+            -PollEverywhere::MultipleChoicePoll.props.each do |_, prop|
+              %dt=prop.name
+              %dd=prop.description
+              -if prop.name == :options
+                %dd
+                  %dl
+                    -PollEverywhere::MultipleChoicePoll::Option.props.each do |_, prop|
+                      %dt=prop.name
+                      %dd=prop.description
+
+      %h3 Creating a multiple choice poll
+      -@mcp = PollEverywhere::MultipleChoicePoll.from_hash(:title => 'Hey dude!', :options => %w[red blue green]).save
+      %code=examples @mcp  
+
+      %h3 Changing the title of the multiple choice poll
+      -@mcp.title = "I like different titles"
+      -@mcp.save
+      %code=examples @mcp  
+
+      %h3 Closing and opening multiple choice polls
+      %p To close a poll, change the state to "closed"
+      -@mcp.stop
+      %code=examples @mcp
+      
+      %p To open it back up (and allow responses to come on through) change the state to "opened"
+      -@mcp.start
+      %code=examples @mcp
+
+      %h3 Delete a multiple choice poll
+      %p When you're totally finished with the poll and you want to tidy things up a bit, you can delete polls
+      -@mcp.destroy
+      %code=examples @mcp  
+
+      %h2 Free text polls
+      %h3 JSON Attributes
+      %dl
+        %dt=PollEverywhere::FTP.root_key
+        %dd Root key for free text poll data.
+        %dd
+          %dl
+            -PollEverywhere::FTP.props.each do |_, prop|
+              %dt=prop.name
+              %dd=prop.description
+
+      %h3 Create free text polls
+      %p Creating a free text poll is similar to building a multiple choice poll, just without the options attribute.
+      -@ftp = PollEverywhere::FreeTextPoll.from_hash(:title => "What is the meaning of life?").save
+      %code=examples @ftp  
+      
+      %h3 Modify a free text poll
+      %p Change the title attribute to change the poll
+      -@ftp.state = "opened"
+      -@ftp.save
+      %code=examples @ftp
+      
+      %h3 Delete a free text poll
+      -@ftp.destroy
+      %code=examples @ftp
+    %footer
+      %p
+        This documentation was automatically generated by the Poll Everywhere rubygem at
+        =succeed '.' do
+          %a(href="http://github.com/polleverywhere/polleverywhere") http://github.com/polleverywhere/polleverywhere
+        Community support for the API is available on the
+        %a(href="http://groups.google.com/group/polleverywhere-dev") Poll Everywhere Developer mailing list
+        and paid professional support at
+        =succeed '.' do
+          %a(href="http://www.polleverywhere.com/professional-support") Poll Everywhere

data/lib/polleverywhere.rb

@@ -1,3 +1,24 @@
-module Polleverywhere
-  # Your code goes here...
-end
+module PollEverywhere
+  autoload :Configuration,  'polleverywhere/configuration'
+  autoload :HTTP,           'polleverywhere/http'
+  autoload :API,            'polleverywhere/api'
+  autoload :CoreExt,        'polleverywhere/core_ext'
+  autoload :Serializable,   'polleverywhere/serializable'
+  autoload :Configurable,   'polleverywhere/configurable'
+  autoload :Models,         'polleverywhere/models'
+
+  # Lets make life easier for developers and provide shortcuts to module and class names. 
+  # PollEverywhere::Model::MultipleChoicePoll now becomes PollEverywhere::MCP. Cool eh? Thank me later.
+  MCP = MultipleChoicePoll = Models::MultipleChoicePoll
+  FTP = FreeTextPoll = Models::FreeTextPoll
+
+  def self.config(&block)
+    @config ||= Configuration.new
+    @config.configure(&block) if block
+    @config
+  end
+
+  def self.http
+    HTTP::RequestBuilder.new
+  end
+end

data/lib/polleverywhere/api.rb

@@ -0,0 +1,28 @@
+require 'haml'
+
+module PollEverywhere
+  module API
+    # Generates API integration documentation from HAML
+    class Documentation
+      attr_reader :template
+
+      def initialize(template)
+        @template = template
+      end
+
+      # Generates API documentation
+      def generate
+        Haml::Engine.new(template, :format => :html5).render(self)
+      end
+
+      # Generate the HAML documentation from the default docs path
+      def self.generate(path=File.expand_path('../../../docs/api.haml', __FILE__))
+        new(File.read(path)).generate
+      end
+
+      def examples(model)
+        model.http.adapter.request.to_curl
+      end
+    end
+  end
+end

data/lib/polleverywhere/configurable.rb

@@ -0,0 +1,32 @@
+module PollEverywhere # :nodoc
+  # The configurable mixin is a tiny DSL that instance evals words in
+  # a class variable for terse configuration code.
+  module Configurable
+    def self.included(base)
+      base.send :extend,  ClassMethods
+      base.send :include, InstanceMethods
+    end
+
+    module InstanceMethods
+      # Pass a block into the instance to configure the attributes on the class
+      def configure(&block)
+        instance_eval(&block)
+      end
+    end
+
+    module ClassMethods
+      # Setup an instance method on the target class that allows the setting
+      # of an attribute both via Class.new.attr = "fun" and Class.new.attr "fun"
+      def configurable(*attrs)
+        attrs.each do |attr|
+          class_eval %{
+            attr_writer :#{attr}
+
+            def #{attr}(val=nil)
+              val ? self.#{attr} = val : @#{attr}
+            end}
+        end
+      end
+    end
+  end
+end

data/lib/polleverywhere/configuration.rb

@@ -0,0 +1,33 @@
+require 'uri'
+require 'base64'
+
+module PollEverywhere
+  # Configuration information for the Poll Everywhere gem.
+  class Configuration
+    include Configurable
+    configurable :url, :username, :password, :http_adapter
+
+    # Setup default values for configuration class as instance variables.
+    def initialize
+      self.url = "http://api.polleverywhere.com"
+      self.http_adapter = :sync
+    end
+
+    # Make sure that a set URL is always an URI object.
+    def url=(val)
+      @url = URI.parse(val)
+    end
+
+    # Setup the HTTP adapter that will execute HTTP requests.
+    def http_adapter=(name)
+      @http_adapter = HTTP.adapter(name.to_sym)
+    end
+
+    # Builds an HTTP Basic header for our authentication. Eventually
+    # this form of authorization will be replaced with a token authorization 
+    # so that a password is not required.
+    def http_basic_credentials
+      "Basic #{Base64.encode64("#{username}:#{password}")}"
+    end
+  end
+end

data/lib/polleverywhere/core_ext.rb

@@ -0,0 +1,74 @@
+module PollEverywhere
+  module CoreExt #:nodoc:
+
+    # A hash with indifferent access and magic predicates.
+    #
+    #   hash = Thor::CoreExt::HashWithIndifferentAccess.new 'foo' => 'bar', 'baz' => 'bee', 'force' => true
+    #
+    #   hash[:foo]  #=> 'bar'
+    #   hash['foo'] #=> 'bar'
+    #   hash.foo?   #=> true
+    #
+    class HashWithIndifferentAccess < ::Hash #:nodoc:
+      def initialize(hash={})
+        super()
+        hash.each do |key, value|
+          self[convert_key(key)] = value
+        end
+      end
+
+      def [](key)
+        super(convert_key(key))
+      end
+
+      def []=(key, value)
+        super(convert_key(key), value)
+      end
+
+      def delete(key)
+        super(convert_key(key))
+      end
+
+      def values_at(*indices)
+        indices.collect { |key| self[convert_key(key)] }
+      end
+
+      def merge(other)
+        dup.merge!(other)
+      end
+
+      def merge!(other)
+        other.each do |key, value|
+          self[convert_key(key)] = value
+        end
+        self
+      end
+
+      protected
+
+        def convert_key(key)
+          key.is_a?(Symbol) ? key.to_s : key
+        end
+
+        # Magic predicates. For instance:
+        #
+        #   options.force?                  # => !!options['force']
+        #   options.shebang                 # => "/usr/lib/local/ruby"
+        #   options.test_framework?(:rspec) # => options[:test_framework] == :rspec
+        #
+        def method_missing(method, *args, &block)
+          method = method.to_s
+          if method =~ /^(\w+)\?$/
+            if args.empty?
+              !!self[$1]
+            else
+              self[$1] == args.first
+            end
+          else
+            self[method]
+          end
+        end
+
+    end
+  end
+end

data/lib/polleverywhere/http.rb

@@ -0,0 +1,20 @@
+module PollEverywhere
+  module HTTP
+    autoload :RequestBuilder, 'polleverywhere/http/request_builder'
+    autoload :Adapter,        'polleverywhere/http/adapter'
+
+    # Shortcut for getting adapater instances
+    def self.adapter(name, &block)
+      Adapter.registry[name].new(&block)
+    end
+    
+    # Simple HTTP request/response objects for our adapter and DSL
+    class Request < Struct.new(:method, :url, :headers, :body)
+      def to_curl
+        %(curl -X #{method.to_s.upcase} #{headers.map{|h,v| %(-H "#{h}: #{v}")}.join(" ")} -d "#{body.gsub(/[!"`']/){|m| "\\#{m}" }}" "#{url}")
+      end
+    end
+
+    Response = Struct.new(:status, :headers, :body)
+  end
+end

data/lib/polleverywhere/http/adapter.rb

@@ -0,0 +1,62 @@
+require 'rest-client'
+
+module PollEverywhere
+  module HTTP
+    # HTTP adapters make it possible to deal with syncronous or asyncronous HTTP libraries
+    module Adapter
+      def self.registry
+        @adapters ||= Hash.new{|hash,key| h[k.to_sym] }
+      end
+
+      def self.register(name, klass)
+        registry[name] = klass
+      end
+
+      class Sync
+        attr_accessor :request, :response
+
+        def initialize
+          yield self if block_given?
+        end
+        
+        def execute(request, &block)
+          @request = request
+          # TODO get rid of the dependency for RestClient by sucking it up and using the Ruby HTTP client
+          RestClient::Request.execute(:method => request.method, :url => request.url.to_s, :payload => request.body, :headers => request.headers) do |r,_,_,_|
+            @response = block.call Response.new(r.code, r.headers, r.body)
+          end
+        end
+      end
+
+      class Doc < Sync
+        def execute(request, &block)
+          requests << request
+          super request, &block
+        end
+
+        def requests
+          @requests ||= []
+        end
+
+        def last_requests
+          requests[(@last_request ||= 0)..(@last_request=requests.size)]
+        end
+      end
+
+      class Test
+        def execute(request, &block)
+          requests << request
+          block.call(Response.new)
+        end
+
+        def requests
+          @requests ||= []
+        end
+      end
+
+      self.register :sync,  Sync
+      self.register :doc,   Doc
+      self.register :test,  Test
+    end
+  end
+end

data/lib/polleverywhere/http/request_builder.rb

@@ -0,0 +1,78 @@
+require 'uri'
+require 'base64'
+
+module PollEverywhere
+  module HTTP # :nodoc
+    # DSL for building requests within our application that build a Request object and send them to 
+    # an adapter to fulfill the request.
+    class RequestBuilder
+      attr_accessor :method, :body, :headers, :params, :url, :format, :response, :adapter, :base_url
+
+      def initialize(adapter=PollEverywhere.config.http_adapter, base_url=PollEverywhere.config.url)
+        self.adapter = adapter
+        self.base_url = base_url
+        self.headers = { 
+          'Content-Type' => 'application/json',
+          'Accept' => 'application/json',
+          'Authorization' => PollEverywhere.config.http_basic_credentials
+        }
+        
+        yield self if block_given?
+      end
+
+      def put(body=nil)
+        self.method, self.body = :put, body
+        self
+      end
+
+      def post(body=nil)
+        self.method, self.body = :post, body
+        self
+      end
+
+      def get(params={})
+        self.method, self.params = :get, params
+        self
+      end
+
+      def delete(params={})
+        self.method, self.params = :delete, params
+        self
+      end
+
+      # Specify the URL of the request.
+      def to(url)
+        self.url = url
+        self
+      end
+      alias :from :to
+
+      # Specify the mime-type/format of the request.
+      def as(format)
+        self.format = format
+        self
+      end
+
+      def request
+        Request.new(method, url_for(url), headers, body)
+      end
+
+      # Generate a Request object, send it to an adapter, and have it fullfill the response by 
+      # yielding a Response object.
+      def response(&block)
+        adapter.execute request, &block
+      end
+
+    private
+      # If a base_url is given, url_for can detect if a given .to is a path or URL, then
+      # setup the approriate URL for the request.
+      def url_for(uri)
+        if uri.to_s !~ /^http/ and base_url
+          "#{base_url}#{uri}"
+        else
+          uri.to_s
+        end
+      end
+    end
+  end
+end

data/lib/polleverywhere/models.rb

@@ -0,0 +1,166 @@
+module PollEverywhere # :nodoc
+  module Models # :nodoc
+
+    # Poll is an abstract base classe for multiple choice and free text polls
+    class Poll
+      include Serializable
+
+      prop :id
+      
+      prop :updated_at do
+        description %{The date and time the poll was last updated.}
+      end
+
+      prop :title do
+        description %{Name of the poll. The title is visible when viewing charts, tables, and other views.}
+      end
+
+      prop :opened_at do
+        description %{Data and time that the poll was started.}
+      end
+
+      prop :options do
+        description %{The possible choices that people choose for a poll.}
+      end
+
+      prop :permalink do
+        description %{An obscufated ID that's used as a private link for sharing the poll}
+      end
+
+      prop :state do
+        description %{Determines whether or not a poll can recieve responses. If the state is 'closed', the poll won't receive responses from the audience. If the poll is 'opened', the poll can receive responses from the audience. If the state is 'maxed_out', the poll won't receive responses until the account is upgraded to support more poll responses.}
+      end
+
+      attr_accessor :http
+
+      def initialize(http=PollEverywhere.http)
+        self.http = http
+      end
+
+      # Start the poll so that it may receive audience responses
+      def start
+        state = "opened"
+        save
+      end
+
+      # Stop the poll so that it stops receieving responses
+      def stop
+        state = "closed"
+        save
+      end
+
+      def persisted?
+        !!permalink
+      end
+
+      def save
+        if persisted?
+          http.put(to_json).as(:json).to(path).response do |response|
+            from_json response.body
+          end
+        else
+          http.post(to_json).as(:json).to('/multiple_choice_polls').response do |response|
+            from_json response.body
+          end
+        end
+      end
+
+      def self.get(permalink)
+        from_hash(:permalink => permalink).fetch
+      end
+
+      def self.all
+        PollEverywhere.http.get.from("/my/polls").as(:json).response do |response|
+          ::JSON.parse(response.body).map do |hash|
+            case hash.keys.first.to_sym
+            when MCP.root_key
+              MCP.from_hash(hash)
+            when FTP.root_key
+              MCP.from_hash(hash)
+            end
+          end
+        end
+      end
+
+      def destroy
+        http.delete(path).response do |response|
+          self.id = self.permalink = nil
+        end
+      end
+
+      def path
+        "/#{self.class.root_key}s/#{permalink}" if persisted?
+      end
+
+      def possible_states
+        [:opened, :closed, :maxed_out]
+      end
+    end
+
+    class FreeTextPoll < Poll
+      root_key :free_text_poll
+
+      prop :keyword do
+        description "The keyword that's used to submit a response to the poll from participants that use SMS."
+      end
+    end
+
+    class MultipleChoicePoll < Poll
+
+      root_key :multiple_choice_poll
+
+      class Option
+        include Serializable
+
+        prop :id
+
+        prop :value do
+          description "Text that is displayed in the chart that represents what a participant chooses when they response to a poll."
+        end
+
+        prop :keyword do
+          description "The keyword that's used to submit a response to the poll from participants that use SMS."
+        end
+
+        attr_reader :poll
+
+        def initialize(poll)
+          @poll = poll
+        end
+      end
+
+      # Choices for a multiple choice poll
+      def options
+        @options ||= []
+      end
+
+      # Accept an array of options as strings, hashes, or options objects.
+      def options=(options)
+        @options = options.map do |val|
+          case val
+          when Option
+            val.poll = self
+            val
+          when Hash
+            Option.new(self).from_hash(val)
+          else
+            Option.new(self).from_hash(:value => val.to_s)
+          end
+        end
+      end
+
+      def fetch
+        http.get.from(path).as(:json).response do |response|
+          from_json response.body
+        end
+      end
+
+      # Add the serialize options hash to the meix
+      def to_hash
+        hash = super
+        hash[:multiple_choice_poll][:options] = options.map(&:to_hash)
+        hash
+      end
+    end
+  end
+end

data/lib/polleverywhere/serializable.rb

@@ -0,0 +1,127 @@
+require 'json'
+
+module PollEverywhere
+  module Serializable
+    def self.included(base)
+      base.send :extend,  ClassMethods
+      base.send :include, InstanceMethods
+    end
+
+    # Property is somewhat of a metaclass that stores validations, name, etc.
+    # for the fields that belond to a serializable model. Since a Property lives 
+    # at the class level, we have a Value class that 
+    class Property
+      include Configurable
+
+      attr_accessor :name, :validations
+
+      configurable :description
+
+      def initialize(name, configuration={})
+        self.name = name.to_sym
+        # Set attributes on the class from a given hash
+        configuration.each do |attr, args|
+          self.send("#{attr}=", *args) if self.respond_to? "#{attr}="
+        end
+      end
+
+      def value
+        Value.new(self)
+      end
+
+      # Contains the value of the property, runs validations, and
+      # tracks property changes
+      class Value
+        attr_reader :property, :original
+        attr_accessor :current
+
+        def initialize(property)
+          @property = property
+        end
+      end
+    end
+
+    module ClassMethods
+      # Set or get the root key of the model
+      def root_key(name=nil)
+        name ? @name = name.to_sym : @name
+      end
+
+      # Define a property at the class level
+      def prop(name, &block)
+        prop = props[name]
+        prop.instance_eval(&block) if block
+        prop
+      end
+
+      # Setup attributes hash and delegate setters/getters to the base class.
+      def props
+        @props ||= Hash.new do |props,name|
+          # Define the methods at the instance level
+          class_eval %{
+            def #{name}=(val)
+              props[:#{name}].current = val
+            end
+
+            def #{name}
+              props[:#{name}].current
+            end}
+          
+          # Setup the attribute class
+          props[name] = Property.new(name)
+
+        end.merge superclass_props
+      end
+
+      # Instanciate a class from a hash
+      def from_hash(hash)
+        new.from_hash(hash)
+      end
+
+    protected
+      # Grab attributes from the superclass, clone them, and then we can modify them locally.
+      def superclass_props
+        (superclass.respond_to?(:props) && superclass.props.clone) || {}
+      end
+    end
+
+    module InstanceMethods
+      def props
+        @props ||= self.class.props.inject CoreExt::HashWithIndifferentAccess.new do |hash, (name, property)|
+          hash[property.name] = property.value
+          hash
+        end
+      end
+
+      def to_hash
+        hash = props.inject CoreExt::HashWithIndifferentAccess.new do |hash, (name, value)|
+          hash[name] = self.send(name)
+          hash
+        end
+        # Add a root key if one is specified
+        self.class.root_key ? { self.class.root_key => hash } : hash
+      end
+
+      # Set the attributes from a hash
+      def from_hash(hash)
+        hash = CoreExt::HashWithIndifferentAccess.new(hash)
+        # Pop off the root key if one is specified and given
+        self.class.root_key and hash[self.class.root_key] and hash = hash[self.class.root_key]
+        # Then set the attributes on the klass if they're present
+        hash.each do |name, value|
+          self.send("#{name}=", value) if self.respond_to? name
+        end
+        self
+      end
+
+      def to_json
+        JSON.pretty_generate(to_hash)
+      end
+
+      def from_json(json)
+        from_hash JSON.parse(json)
+      end
+    end
+  end
+
+end

data/lib/polleverywhere/version.rb

@@ -1,3 +1,3 @@
 module Polleverywhere
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/polleverywhere.gemspec

@@ -13,9 +13,11 @@ Gem::Specification.new do |s|
   s.description = %q{An easy way to integrate Poll Everywhere into your Ruby applications.}
 
   s.rubyforge_project = "polleverywhere"
+  s.add_dependency "json"
+  s.add_development_dependency "rest-client", "~> 1.6.3"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
-end
+end

data/spec/integration/api_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe "API" do
+  context "polls" do
+    it "should get collection from my poll" do
+      PollEverywhere::Models::Poll.all.should have_at_least(1).items
+    end
+
+    context "multiple choice" do
+      before(:all) do
+        @mcp = PollEverywhere::MultipleChoicePoll.from_hash(:title => 'Hey dude!', :options => %w[red blue green])
+      end
+
+      context "creation" do
+        before(:all) do
+          @mcp.save
+        end
+
+        it "should have id" do
+          @mcp.id.should_not be_nil
+        end
+
+        it "should have permalink" do
+          @mcp.permalink.should_not be_nil
+        end
+
+        context "options" do
+          it "should have ids" do
+            @mcp.options.each do |o|
+              o.id.should_not be_nil
+            end
+          end
+
+          it "should have values" do
+            @mcp.options.each do |o|
+              o.value.should_not be_nil
+            end
+          end
+        end
+      end
+
+      context "get" do
+        it "should get poll" do
+          @gotten_mcp = PollEverywhere::MultipleChoicePoll.get(@mcp.permalink)
+          @gotten_mcp.title.should eql(@mcp.title)
+        end
+      end
+      
+      context "updates" do
+        before(:all) do
+          @mcp.title = "My pita bread is moldy"
+          @mcp.options.first.value = "MOLD SUCKS!"
+          @mcp.save
+        end
+
+        it "should update options" do
+          @mcp.options.first.value.should eql("MOLD SUCKS!")
+        end
+        
+        it "should update title" do
+          @mcp.title.should eql("My pita bread is moldy")
+        end
+      end
+
+      it "should destroy" do
+        @mcp.destroy
+        @mcp.id.should be_nil
+      end
+    end
+
+  end
+end

data/spec/lib/polleverywhere_spec.rb

@@ -1,5 +1,102 @@
 require 'spec_helper'
 
-describe "Poll Everywhere" do
-  it "shall be an awesome gem"
+describe "Configuration" do
+  before(:all) do
+    @config = PollEverywhere::Configuration.new
+  end
+
+  %w[username password].each do |attr|
+    it "should have '#{attr}' configurable attribute" do
+      @config.send(attr, "test_val")
+      @config.send(attr).should eql("test_val")
+    end
+  end
+
+  context "url" do
+    it "should default to 'http://api.polleverywhere.com'" do
+      @config.url.to_s.should eql("http://api.polleverywhere.com")
+    end
+
+    it "should have URI instance for url configurable attribute" do
+      @config.url = "http://loser.com"
+      @config.url.to_s.should eql("http://loser.com")
+      @config.url.should be_instance_of(URI::HTTP)
+    end
+  end
+
+  it "should have a root configuration class" do
+    PollEverywhere.config.should be_instance_of(PollEverywhere::Configuration)
+  end
+end
+
+describe "documentation" do
+  it "should show curl format" do
+    poll = PollEverywhere::MultipleChoicePoll.new
+    poll.title = 'cool'
+    poll.options = %w[1 2 3]
+    poll.save
+  end
+end
+
+describe "Multiple Choice Poll" do
+  context "serialize" do
+    before(:all) do
+      @hash = {:title => 'Hey dude!', :options => %w[red blue green]}
+      @poll = PollEverywhere::MultipleChoicePoll.from_hash(@hash)
+    end
+
+    context "serialization" do
+      it "should serialize options" do
+        @hash[:options].each do |value|
+          @poll.to_hash[:multiple_choice_poll][:options].find{|o| o[:value] == value}.should_not be_nil
+        end
+      end
+    end
+
+    context "deserialization" do
+      it "should have options" do
+        @hash[:options].each do |value|
+          @poll.options.find{|o| o.value == value }
+        end
+      end
+
+      it "should set title" do
+        @poll.title.should eql(@hash[:title])
+      end
+    end
+  end
+end
+
+describe "http" do
+  context "request builder" do
+
+    # it "should post" do
+    #   PollEverywhere::HTTP::RequestBuilder.new.post('some data').to('/this/url').response do |response|
+    #     response.body.should eql('hello my pretty')
+    #     response.status.should eql(200)
+    #   end
+    # end
+
+    # it "should put" do
+    #   PollEverywhere::HTTP::RequestBuilder.new.put('some data').to('/this/url').response do |response|
+    #     response.body.should eql('hello my pretty')
+    #     response.status.should eql(200)
+    #   end
+    # end
+
+    # it "should delete" do
+    #   PollEverywhere::HTTP::RequestBuilder.new.delete.from('/this/url').response do |response|
+    #     response.body.should eql('hello my pretty')
+    #     response.status.should eql(200)
+    #   end
+    # end
+
+    # it "should get" do
+    #   PollEverywhere::HTTP::RequestBuilder.new.get(:page => 1).from('/this/url').response do |response|
+    #     response.body.should eql('hello my pretty')
+    #     response.status.should eql(200)
+    #   end
+    # end
+
+  end
 end

data/spec/spec_helper.rb

@@ -1,3 +1,11 @@
 require 'rubygems'
 require 'bundler/setup'
-require 'rspec'
+require 'rspec'
+require 'polleverywhere'
+
+PollEverywhere.config do
+  username      "test"
+  password      "test"
+  url           "http://localhost:3000"
+  http_adapter  :sync
+end

metadata

@@ -1,13 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: polleverywhere
 version: !ruby/object:Gem::Version 
-  hash: 29
   prerelease: 
-  segments: 
-  - 0
-  - 0
-  - 1
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Brad Gessler, Steel Fu
@@ -15,10 +10,31 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-24 00:00:00 -07:00
+date: 2011-06-24 00:00:00 -07:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rest-client
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.6.3
+  type: :development
+  version_requirements: *id002
 description: An easy way to integrate Poll Everywhere into your Ruby applications.
 email: 
 - geeks@polleverywhere.com
@@ -30,13 +46,25 @@ extra_rdoc_files: []
 
 files: 
 - .gitignore
+- .rvmrc
 - Gemfile
 - Guardfile
 - README.md
 - Rakefile
+- docs/api.haml
 - lib/polleverywhere.rb
+- lib/polleverywhere/api.rb
+- lib/polleverywhere/configurable.rb
+- lib/polleverywhere/configuration.rb
+- lib/polleverywhere/core_ext.rb
+- lib/polleverywhere/http.rb
+- lib/polleverywhere/http/adapter.rb
+- lib/polleverywhere/http/request_builder.rb
+- lib/polleverywhere/models.rb
+- lib/polleverywhere/serializable.rb
 - lib/polleverywhere/version.rb
 - polleverywhere.gemspec
+- spec/integration/api_spec.rb
 - spec/lib/polleverywhere_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true
@@ -53,26 +81,21 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: polleverywhere
-rubygems_version: 1.4.2
+rubygems_version: 1.5.2
 signing_key: 
 specification_version: 3
 summary: Integration Poll Everywhere into your Ruby applications
 test_files: 
+- spec/integration/api_spec.rb
 - spec/lib/polleverywhere_spec.rb
 - spec/spec_helper.rb