wordnik 0.2.1 → 0.3.0

data/lib/wordnik/endpoint.rb

@@ -0,0 +1,33 @@
+module Wordnik
+
+  class Endpoint
+    require 'active_model'
+    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
+
+end

data/lib/wordnik/monkey_patches.rb

@@ -0,0 +1,26 @@
+# The methods below were snatch right outta Rails' ActiveSupport, so we don't have to depend on it..
+# See http://api.rubyonrails.org/classes/ActiveSupport/Inflector.html#method-i-camelize
+
+class String
+
+  # File activesupport/lib/active_support/inflector/methods.rb, line 48
+  def underscore(camel_cased_word)
+    word = camel_cased_word.to_s.dup
+    word.gsub!(/::/, '/')
+    word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+    word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+    word.tr!("-", "_")
+    word.downcase!
+    word
+  end
+  
+  # File activesupport/lib/active_support/inflector/methods.rb, line 28
+  def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+    if first_letter_in_uppercase
+      lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    else
+      lower_case_and_underscored_word.to_s[0].chr.downcase + camelize(lower_case_and_underscored_word)[1..-1]
+    end
+  end
+  
+end

data/lib/wordnik/operation.rb

@@ -0,0 +1,45 @@
+module Wordnik
+  
+  class Operation
+    require 'active_model'
+    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
+  
+end

data/lib/wordnik/operation_parameter.rb

@@ -0,0 +1,39 @@
+module Wordnik
+
+  class OperationParameter
+    require 'active_model'
+    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
+
+end

data/lib/wordnik/request.rb

@@ -0,0 +1,168 @@
+module Wordnik
+
+  class Request
+    require 'uri'
+    require 'addressable/uri'
+    require 'typhoeus'
+    require 'active_model'
+    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] ||= Wordnik.configuration.base_uri
+      attributes[:params] ||= {}
+
+      # Set default headers, but allow them to be overridden
+      default_headers = {
+        'User-Agent' => "Wordnik Ruby Gem #{Wordnik::VERSION}",
+        'Content-Type' => "application/#{attributes[:format].downcase}",
+        :api_key => Wordnik.configuration.api_key
+      }
+      attributes[:headers] = default_headers.merge(attributes[:headers] || {})
+
+      # If a blank/nil api_key was passed in, remove it from the headers
+      attributes[:headers].delete(:api_key) if attributes[:headers][:api_key].blank?
+
+      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
+end

data/lib/wordnik/resource.rb

@@ -0,0 +1,101 @@
+# To jog the memory: Resource > Endpoint > Operation > OperationParameter
+
+module Wordnik
+  class Resource
+    require 'active_model'
+    include ActiveModel::Validations
+    include ActiveModel::Conversion
+    extend ActiveModel::Naming
+  
+    attr_accessor :name, :raw_data, :endpoints, :models
+  
+    validates_presence_of :name, :raw_data, :endpoints, :models
+  
+    def initialize(attributes = {})
+      attributes.each do |name, value|
+        send("#{name.to_s.underscore.to_sym}=", value)
+      end
+
+      # Generate Endpoint instances from JSON
+      if self.raw_data['endPoints']
+        self.endpoints = self.raw_data['endPoints'].map do |endpointData|
+          Endpoint.new(endpointData)
+        end
+      end
+    end
+  
+    def operation_nickname_pairs
+      return @pairs if @pairs
+      return unless self.endpoints.present?
+      @pairs = {}
+      self.endpoints.map do |endpoint|
+        endpoint.operations.map do |operation|
+          nickname_parts = []
+          nickname_parts << operation.http_method
+          nickname_parts << endpoint.path.gsub(/\{\w+\}/, "").tr("/", "_").tr(' .', '').underscore
+          nickname = nickname_parts.
+            join("_").
+            gsub(/_+/, "_").
+            gsub("_#{self.name.to_s.underscore}", "").
+            gsub(/_$/, "")
+          @pairs[nickname] = endpoint.path
+        end
+      end
+      @pairs
+    end
+    
+    # Uses the received method name and arguments to dynamically construct a Request
+    # If the method name is prefixed with 'build_', then the 'unmade' Request
+    # object will be returned instead of the Request Response's body
+    # 
+    # Wordnik.word.get('dingo')
+    # Wordnik.word.get_definitions('dingo', :limit => 20, )
+    def method_missing(sym, *args, &block)
+      nickname = sym.to_s
+
+      # If method nickname starts with 'build_', 
+      # then just build the request but don't run it.
+      if nickname =~ /^build_/
+        nickname.gsub!('build_', '')
+        build_only = true
+      end
+      
+      # Extrapolate HTTP method from beginning of method name
+      # e.g. 'post_words' -> :post
+      http_method = nickname.split("_").first.to_sym
+      
+      # Ruby turns all key-value arguments at the end into a single hash
+      # e.g. Wordnik.word.get_examples('dingo', :limit => 10, :part_of_speech => 'verb')
+      # becomes {:limit => 10, :part_of_speech => 'verb'}
+      params = args.last.is_a?(Hash) ? args.pop : {}
+      
+      # Find the path that corresponds to this method nickname
+      # e.g. post_words -> "/wordList.{format}/{wordListId}/words"
+      path = operation_nickname_pairs[nickname]
+      
+      # Take the '.{format}' portion out of the string so it doesn't interfere with 
+      # the interpolation we're going to do on the path.
+      path.gsub!('.{format}', '')
+      
+      # Stick the remaining (required) arguments into the path string
+      args.each do |arg|
+        path.sub!(/\{\w+\}/, arg)
+      end
+
+      request = Wordnik::Request.new(http_method, path, :params => params)
+      
+      if build_only
+        request 
+      else
+        request.response.body
+      end
+    end
+
+    # It's an ActiveModel thing..
+    def persisted?
+      false
+    end
+
+  end
+  
+end

data/lib/wordnik/response.rb

@@ -0,0 +1,74 @@
+module Wordnik
+
+  class Response
+    require 'active_model'
+    require 'json'
+    include ActiveModel::Validations
+    include ActiveModel::Conversion
+    extend ActiveModel::Naming
+
+    attr_accessor :raw
+
+    validates_presence_of :raw
+
+    def initialize(raw)
+      self.raw = raw
+    end
+
+    def code
+      raw.code
+    end
+
+    # If body is JSON, parse it
+    # TODO: If body is XML, parse it
+    # Otherwise return raw string
+    def body
+      JSON.parse(raw.body)
+    rescue
+      raw.body
+    end
+
+    def headers
+      h = {}
+      raw.headers_hash.each {|k,v| h[k] = v }
+      h
+    end
+
+    # Extract the response format from the header hash
+    # e.g. {'Content-Type' => 'application/json'}
+    def format
+      headers['Content-Type'].split("/").last.to_sym
+    end
+
+    def json?
+      format == :json
+    end
+
+    def xml?
+      format == :xml
+    end
+
+    def pretty_body
+      return unless body.present?
+      case format
+      when :json
+        JSON.pretty_generate(body).gsub(/\n/, '<br/>').html_safe
+      when :xml
+        xsl = Nokogiri::XSLT(File.open(Rails.root.join("config", "pretty_print.xsl")))
+        xml = Nokogiri(body)
+        coder = HTMLEntities.new
+        coder.encode(xsl.apply_to(xml).to_s)
+      end
+    end
+
+    def pretty_headers
+      JSON.pretty_generate(headers).gsub(/\n/, '<br/>').html_safe
+    end
+
+    # It's an ActiveModel thing..
+    def persisted?
+      false
+    end
+
+  end
+end