wordnik 0.0.2 → 0.1.0

data/Gemfile

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

data/Gemfile.lock

@@ -1,57 +0,0 @@
-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!

data/lib/wordnik/configuration.rb

@@ -1,21 +0,0 @@
-module Wordnik
-
-  class Configuration
-
-    # The API key for your project, found on the project edit form.
-    attr_accessor :api_key
-    
-    # Response format can be :json (default) or :xml
-    attr_accessor :response_format
-    
-    # The URL of the API server
-    attr_accessor :base_uri
-
-    def initialize
-      @response_format = :json
-      @base_uri = 'beta.wordnik.com/v4'
-    end
-
-  end
-
-end

data/lib/wordnik/endpoint.rb

@@ -1,33 +0,0 @@
-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/operation.rb

@@ -1,45 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,163 +0,0 @@
-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 = {
-        '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
-end

data/lib/wordnik/resource.rb

@@ -1,53 +0,0 @@
-# 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 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+\}/, "").gsub("/", "_").nix(' ').nix('.').underscore
-          nickname = nickname_parts.
-            join("_").
-            gsub(/_+/, "_").
-            gsub("_#{self.name.underscore}", "").
-            gsub(/_$/, "")
-          pairs[nickname] = "#{operation.http_method.upcase} #{endpoint.path}"
-        end
-      end
-      pairs
-    end
-
-    # It's an ActiveModel thing..
-    def persisted?
-      false
-    end
-
-  end
-  
-end

data/lib/wordnik/response.rb

@@ -1,73 +0,0 @@
-module Wordnik
-
-  class Response
-    require 'active_model'
-    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