wordnik 0.0.1 → 0.0.2

data/lib/wordnik/endpoint.rb

@@ -1,32 +1,33 @@
-# To jog the memory: Resource > Endpoint > Operation > OperationParameter
-require 'active_model'
+module Wordnik
 
-class Endpoint
+  class Endpoint
+    require 'active_model'
+    include ActiveModel::Validations
+    include ActiveModel::Conversion
+    extend ActiveModel::Naming
 
-  include ActiveModel::Validations
-  include ActiveModel::Conversion
-  extend ActiveModel::Naming
+    attr_accessor :path, :description, :operations
 
-  attr_accessor :path, :description, :operations
+    validates_presence_of :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
+    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)
+      # Generate Operations instances from JSON
+      if self.operations
+        self.operations = self.operations.map do |operationData|
+          Operation.new(operationData)
+        end
       end
     end
-  end
 
-  # It's an ActiveModel thing..
-  def persisted?
-    false
-  end
+    # It's an ActiveModel thing..
+    def persisted?
+      false
+    end
 
+  end
+  
 end

data/lib/wordnik/operation.rb

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

data/lib/wordnik/operation_parameter.rb

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

data/lib/wordnik/request.rb

@@ -1,159 +1,163 @@
-class Request
-  require 'uri'
-  require 'addressable/uri'
-  require 'typhoeus'
-  include ActiveModel::Validations
-  include ActiveModel::Conversion
-  extend ActiveModel::Naming
+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
+    attr_accessor :host, :port, :path, :format, :params, :body, :http_method, :headers
   
-  validates_presence_of :host, :path, :format, :http_method
+    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] ||= {}
+    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] || {})
+      # 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)
+      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
-  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)
+    # 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
+      # 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
+      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
+    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
+    # 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
-    qsp
-  end
   
-  # Construct a query string from the query-string-type params
-  def query_string(options={})
+    # 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?
+      # 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)
+      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
+      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)
+    # 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
+      [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
-      )
+    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 :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 :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
+      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
+      @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
+    # 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_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
+    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
+    # It's an ActiveModel thing..
+    def persisted?
+      false
+    end
 
+  end
 end

data/lib/wordnik/resource.rb

@@ -1,50 +1,53 @@
 # To jog the memory: Resource > Endpoint > Operation > OperationParameter
 
-class Resource
-
-  include ActiveModel::Validations
-  include ActiveModel::Conversion
-  extend ActiveModel::Naming
+module Wordnik
+  class Resource
+    require 'active_model'
+    include ActiveModel::Validations
+    include ActiveModel::Conversion
+    extend ActiveModel::Naming
   
-  attr_accessor :name, :raw_data, :endpoints, :models
+    attr_accessor :name, :raw_data, :endpoints, :models
   
-  validates_presence_of :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
+    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)
+      # 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
-  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}"
+    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
-    pairs
-  end
 
-  # It's an ActiveModel thing..
-  def persisted?
-    false
-  end
+    # It's an ActiveModel thing..
+    def persisted?
+      false
+    end
 
+  end
+  
 end

data/lib/wordnik/response.rb

@@ -1,69 +1,73 @@
-class Response
-  include ActiveModel::Validations
-  include ActiveModel::Conversion
-  extend ActiveModel::Naming
+module Wordnik
+
+  class Response
+    require 'active_model'
+    include ActiveModel::Validations
+    include ActiveModel::Conversion
+    extend ActiveModel::Naming
   
-  attr_accessor :raw
+    attr_accessor :raw
   
-  validates_presence_of :raw
+    validates_presence_of :raw
   
-  def initialize(raw)
-    self.raw = raw
-  end
+    def initialize(raw)
+      self.raw = raw
+    end
 
-  def code
-    raw.code
-  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
+    # 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
+    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
+    # 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 json?
+      format == :json
+    end
   
-  def xml?
-    format == :xml
-  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)
+    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
-  end
   
-  def pretty_headers
-    JSON.pretty_generate(headers).gsub(/\n/, '<br/>').html_safe
-  end
+    def pretty_headers
+      JSON.pretty_generate(headers).gsub(/\n/, '<br/>').html_safe
+    end
   
-  # It's an ActiveModel thing..
-  def persisted?
-    false
-  end
+    # It's an ActiveModel thing..
+    def persisted?
+      false
+    end
 
+  end
 end

data/lib/wordnik/version.rb

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

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Zeke Sikelianos