Starting to piece the gem together, extracting existing models and specs from the developer.wordnik.com rails app.

Author: zeke

.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in wordnik.gemspec
+gemspec

Gemfile.lock

@@ -0,0 +1,57 @@
+PATH
+  remote: .
+  specs:
+    wordnik (0.0.1)
+      activemodel (= 3.0.3)
+      addressable (= 2.2.4)
+      htmlentities (= 4.2.4)
+      json (= 1.4.6)
+      nokogiri (= 1.4.4)
+      typhoeus (= 0.2.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.3)
+      activesupport (= 3.0.3)
+      builder (~> 2.1.2)
+      i18n (~> 0.4)
+    activesupport (3.0.3)
+    addressable (2.2.4)
+    builder (2.1.2)
+    crack (0.1.8)
+    diff-lcs (1.1.2)
+    htmlentities (4.2.4)
+    i18n (0.5.0)
+    json (1.4.6)
+    mime-types (1.16)
+    nokogiri (1.4.4)
+    rspec (2.4.0)
+      rspec-core (~> 2.4.0)
+      rspec-expectations (~> 2.4.0)
+      rspec-mocks (~> 2.4.0)
+    rspec-core (2.4.0)
+    rspec-expectations (2.4.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.4.0)
+    typhoeus (0.2.1)
+      mime-types
+    vcr (1.5.1)
+    webmock (1.6.2)
+      addressable (>= 2.2.2)
+      crack (>= 0.1.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activemodel (= 3.0.3)
+  addressable (= 2.2.4)
+  htmlentities (= 4.2.4)
+  json (= 1.4.6)
+  nokogiri (= 1.4.4)
+  rspec (= 2.4.0)
+  typhoeus (= 0.2.1)
+  vcr (= 1.5.1)
+  webmock (= 1.6.2)
+  wordnik!

Rakefile

@@ -0,0 +1,9 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+# If you want to make this the default task
+task :default => :spec

lib/wordnik.rb

@@ -0,0 +1,23 @@
+require 'wordnik/endpoint'
+require 'wordnik/operation'
+require 'wordnik/operation_parameter'
+require 'wordnik/request'
+require 'wordnik/resource'
+require 'wordnik/response'
+
+class Wordnik
+  
+  # See http://tinyurl.com/5t3rhy6 for info on setting up this configuration magic
+  def self.configure
+    yield configuration
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  class Configuration
+    attr_accessor :api_key
+  end
+  
+end

lib/wordnik/endpoint.rb

@@ -0,0 +1,31 @@
+# To jog the memory: Resource > Endpoint > Operation > OperationParameter
+require 'active_model'
+class Endpoint
+
+  include ActiveModel::Validations
+  include ActiveModel::Conversion
+  extend ActiveModel::Naming
+  
+  attr_accessor :path, :description, :operations
+  
+  validates_presence_of :path, :description, :operations
+  
+  def initialize(attributes = {})
+    attributes.each do |name, value|
+      send("#{name.to_s.underscore.to_sym}=", value)
+    end
+    
+    # Generate Operations instances from JSON
+    if self.operations
+      self.operations = self.operations.map do |operationData|
+        Operation.new(operationData)
+      end
+    end
+  end
+
+  # It's an ActiveModel thing..
+  def persisted?
+    false
+  end
+
+end

lib/wordnik/operation.rb

@@ -0,0 +1,42 @@
+# To jog the memory: Resource > Endpoint > Operation > OperationParameter
+
+class Operation
+  include ActiveModel::Validations
+  include ActiveModel::Conversion
+  extend ActiveModel::Naming
+  
+  attr_accessor :http_method, :summary, :notes, :parameters, :response, :open
+  
+  validates_presence_of :http_method, :summary, :notes, :parameters, :response, :open
+  
+  def initialize(attributes = {})
+    attributes.each do |name, value|
+      send("#{name.to_s.underscore.to_sym}=", value)
+    end
+    
+    self.http_method = self.http_method.to_s.downcase
+    
+    # Generate OperationParameter instances from JSON
+    if self.parameters
+      self.parameters = self.parameters.map do |parameterData|
+        OperationParameter.new(parameterData)
+      end
+    end
+
+  end
+  
+  def get?
+    self.http_method.downcase == "get"
+  end
+  
+  # Can this operation be run in the sandbox?
+  def sandboxable?
+    self.get?
+  end
+
+  # It's an ActiveModel thing..
+  def persisted?
+    false
+  end
+
+end

lib/wordnik/operation_parameter.rb

@@ -0,0 +1,36 @@
+# To jog the memory: Resource > Endpoint > Operation > OperationParameter
+
+class OperationParameter
+  include ActiveModel::Validations
+  include ActiveModel::Conversion
+  extend ActiveModel::Naming
+  
+  attr_accessor :name, :description, :required, :param_type, :default_value, :allowable_values
+  
+  validates_presence_of :name, :description, :required, :param_type, :default_value, :allowable_values
+  
+  def initialize(attributes = {})
+    attributes.each do |name, value|
+      send("#{name.to_s.underscore.to_sym}=", value)
+    end
+  end
+
+  def human_name
+    return "request body" if self.param_type == 'body'    
+    self.name
+  end
+  
+  def has_allowable_array?
+    self.allowable_values.present? && self.allowable_values.include?(",")
+  end
+  
+  def required?
+    self.required
+  end
+  
+  # It's an ActiveModel thing..
+  def persisted?
+    false
+  end
+
+end

lib/wordnik/request.rb

@@ -0,0 +1,158 @@
+class Request
+  require 'uri'
+  require 'addressable/uri'
+  include ActiveModel::Validations
+  include ActiveModel::Conversion
+  extend ActiveModel::Naming
+  
+  attr_accessor :host, :port, :path, :format, :params, :body, :http_method, :headers
+  
+  validates_presence_of :host, :path, :format, :http_method
+  
+  def initialize(http_method, path, attributes={})
+    attributes[:format] ||= "json"
+    attributes[:host] ||= configatron.api.base_uri
+    attributes[:params] ||= {}
+
+    # Set default headers, but allow them to be overridden
+    default_headers = {
+      'Content-Type' => "application/#{attributes[:format].downcase}",
+    }
+    attributes[:headers] = default_headers.merge(attributes[:headers] || {})
+    
+    self.http_method = http_method.to_sym
+    self.path = path
+    attributes.each do |name, value|
+      send("#{name.to_s.underscore.to_sym}=", value)
+    end
+  end
+  
+  # Construct a base URL
+  def url
+    u = Addressable::URI.new
+    u.host = self.host.sub(/\/$/, '')
+    u.port = self.port if self.port.present?
+    u.path = self.interpreted_path
+    u.scheme = "http" # For some reason this must be set _after_ host, otherwise Addressable gets upset
+    u.to_s
+  end
+  
+  # Iterate over the params hash, injecting any path values into the path string
+  # e.g. /word.{format}/{word}/entries => /word.json/cat/entries
+  def interpreted_path
+    p = self.path
+    self.params.each_pair do |key, value|
+      p = p.gsub("{#{key}}", value.to_s)
+    end
+    
+    # Stick a .{format} placeholder into the path if there isn't
+    # one already or an actual format like json or xml
+    # e.g. /words/blah => /words.{format}/blah
+    unless ['.json', '.xml', '{format}'].any? {|s| p.downcase.include? s }
+      p = p.sub(/^(\/?\w+)/, "\\1.#{format}")
+    end
+
+    p = p.sub("{format}", self.format)
+    URI.encode(p)
+  end
+  
+  def interpreted_body
+    return unless self.body.present?
+    return self.body.to_json if self.body.is_a?(Hash)
+    self.body
+  end
+  
+  # Iterate over all params,
+  # .. removing the ones that are part of the path itself.
+  # .. stringifying values so Addressable doesn't blow up.
+  # .. obfuscating the API key if needed.
+  def query_string_params(obfuscated=false)
+    qsp = {}
+    self.params.each_pair do |key, value|
+      next if self.path.include? "{#{key}}"
+      next if value.blank?
+      value = "YOUR_API_KEY" if key.to_sym == :api_key && obfuscated
+      qsp[key] = value.to_s
+    end
+    qsp
+  end
+  
+  # Construct a query string from the query-string-type params
+  def query_string(options={})
+    
+    # We don't want to end up with '?' as our query string
+    # if there aren't really any params
+    return "" if query_string_params.blank?
+    
+    default_options = {:obfuscated => false}
+    options = default_options.merge(options)
+    
+    qs = Addressable::URI.new
+    qs.query_values = self.query_string_params(options[:obfuscated])
+    qs.to_s
+  end
+  
+  # Returns full request URL with query string included
+  def url_with_query_string(options={})
+    default_options = {:obfuscated => false}
+    options = default_options.merge(options)
+    
+    [url, query_string(options)].join('')
+  end
+  
+  def make
+    response = case self.http_method.to_sym
+    when :get
+      Typhoeus::Request.get(
+        self.url_with_query_string,
+        :headers => self.headers.stringify_keys
+      )
+
+    when :post
+      Typhoeus::Request.post(
+        self.url_with_query_string,
+        :body => self.interpreted_body,
+        :headers => self.headers.stringify_keys
+      )
+
+    when :put
+      Typhoeus::Request.put(
+        self.url_with_query_string,
+        :body => self.interpreted_body,
+        :headers => self.headers.stringify_keys
+      )
+      
+    when :delete
+      Typhoeus::Request.delete(
+        self.url_with_query_string,
+        :body => self.interpreted_body,
+        :headers => self.headers.stringify_keys
+      )
+    end
+
+    @response_obj = Response.new(response)
+  end
+  
+  # If the request has been made, return the existing response
+  # If not, make the request and return the response
+  def response
+    @response_obj || self.make
+  end
+  
+  def response_code_pretty
+    return unless @response.present?
+    @response.code.to_s    
+  end
+  
+  def response_headers_pretty
+    return unless @response.present?
+    # JSON.pretty_generate(@response.headers).gsub(/\n/, '<br/>').html_safe # <- This was for RestClient
+    @response.headers.gsub(/\n/, '<br/>').html_safe # <- This is for Typhoeus
+  end
+
+  # It's an ActiveModel thing..
+  def persisted?
+    false
+  end
+
+end