pmp 0.1.0

data/lib/pmp/connection.rb

@@ -0,0 +1,54 @@
+# -*- encoding: utf-8 -*-
+
+require 'faraday_middleware'
+require 'active_support'
+
+module PMP
+  module Connection
+
+    ALLOWED_CONNECTION_OPTIONS = [
+      :headers,
+      :url,
+      :params,
+      :request,
+      :adapter,
+      :ssl,
+      :oauth_token,
+      :debug
+    ].freeze
+
+    def connection(options={})
+      opts = process_options(options)
+      Faraday::Connection.new(opts) do |faraday|
+        faraday.request :authorization, 'Bearer', opts[:oauth_token] unless opts[:oauth_token].nil?
+        faraday.request :url_encoded
+        faraday.request :multipart
+
+        faraday.response :mashify
+        faraday.response :logger if opts[:debug]
+        faraday.response :json
+
+        faraday.adapter opts[:adapter]
+      end
+    end
+
+    def process_options(opts={})
+      headers = opts.delete(:headers) || {}
+      options = {
+        :headers => {
+          # generic http headers
+          'User-Agent'   => opts[:user_agent],
+          'Accept'       => "application/vnd.pmp.collection.doc+json",
+          'Content-Type' => "application/vnd.pmp.collection.doc+json"
+        },
+        :ssl => {:verify => false},
+        :url => opts[:endpoint]
+      }.merge(opts)
+      options[:headers] = options[:headers].merge(headers)
+
+      # clean out any that don't belong
+      options.select{|k,v| ALLOWED_CONNECTION_OPTIONS.include?(k.to_sym)}
+    end
+
+  end
+end

data/lib/pmp/link.rb

@@ -0,0 +1,64 @@
+# -*- encoding: utf-8 -*-
+
+require 'uri_template'
+require 'ostruct'
+
+# # it's a struct, we don't have to set these, up, but have a list of what we define particular logic for
+# :href,          # "https://api-sandbox.pmp.io/docs/af676335-21df-4486-ab43-e88c1b48f026"
+# :href_template, # "https://api-sandbox.pmp.io/users{?limit,offset,tag,collection,text,searchsort,has}"
+# :href_vars,     # { "collection": "https://github.com/publicmediaplatform/pmpdocs/wiki/Content-Retrieval" }
+# :hreflang,      # Language of the linked document
+# :hints,         # Hints about interacting with the link, such as HTTP methods, e.g. "hints": { "allow": ["GET", "PUT", "DELETE"] }
+# :rels,          # [ "urn:pmp:query:users" ]
+# :method,        # http method - get, post, put, etc.
+# :type,          # 'image/png' - mime type of linked resource
+# :title,         # name/title of thing linked in
+# :operation,     # used by permissions link - read, write
+# :blacklist,     # used by permissions link
+
+module PMP
+  class Link < OpenStruct
+
+    include Parser
+
+    attr_accessor :parent
+
+    attr_accessor :params
+
+    def initialize(parent, link)
+      super()
+      self.parent = parent || PMP::CollectionDocument.new
+      self.params = link.delete('params') || {}
+      parse_attributes(link)
+    end
+
+    def attributes
+      HashWithIndifferentAccess.new(marshal_dump)
+    end
+
+    def where(params={})
+      self.class.new(parent, attributes.merge({'params'=>params}))
+    end
+
+    def as_json
+      extract_attributes
+    end
+
+    def url
+      URITemplate.new(href_template || href).expand(params)
+    end
+
+    def retrieve
+      @_retrieved ||= parent.request((method || 'get').to_sym, url)
+    end
+
+    def method_missing(method, *args)
+      begin
+        super
+      rescue NoMethodError => err
+        self.retrieve.send(method, *args)
+      end
+    end
+
+  end
+end

data/lib/pmp/links.rb

@@ -0,0 +1,21 @@
+# class to handle/manage and keep track of list of links in this doc
+
+module PMP
+  class Links < HashWithIndifferentAccess
+
+    include Utils
+
+    attr_accessor :parent
+
+    def initialize(parent)
+      super()
+      self.parent = parent
+    end
+
+    def []=(k, link)
+      super
+      parent.send("#{to_ruby_safe_name(k)}=", link)
+    end
+
+  end
+end

data/lib/pmp/parser.rb

@@ -0,0 +1,102 @@
+# -*- encoding: utf-8 -*-
+
+module PMP
+  module Parser
+
+    include Utils
+
+    def as_json(options={})
+      result = {}
+      result['version']    = self.version
+      result['links']      = extract_links
+      result['attributes'] = extract_attributes
+
+      # more elegant?
+      result['attributes'].delete('items')
+
+      result
+    end
+
+    def extract_attributes(obj=self)
+      obj.attributes.inject({}) do |result, pair|
+        value = pair.last
+        name = to_json_key_name(pair.first)
+        result[name] = value
+        result
+      end
+    end
+
+    def extract_links(obj=self)
+      obj.links.inject({}) do |result, pair|
+        value = pair.last
+        name = to_json_key_name(pair.first)
+
+        links = if value.is_a?(PMP::Link)
+          [extract_attributes(value)]
+        elsif value.is_a?(Array)
+          value.map{|v| extract_attributes(v)}
+        elsif value.is_a?(Hash)
+          value.values.map{|v| extract_attributes(v)}
+        end
+
+        result[name] = links
+
+        result
+      end
+    end
+
+    def parse(doc)
+      return if (!doc)
+      parse_version(doc['version'])
+      parse_attributes(doc['attributes'])
+      parse_links(doc['links'])
+      parse_items(doc['items'])
+      # parse_error(doc)
+    end
+
+    def parse_version(document)
+      self.version = document || '1.0'
+    end
+
+    def parse_attributes(document)
+      Array(document).each do |k,v|
+        self.send("#{to_ruby_safe_name(k)}=", v)
+      end
+    end
+
+    def parse_links(document)
+      Array(document).each do |k,v|
+        link = parse_link(k,v)        
+        if link
+          self.links[k] = link
+        end
+      end
+    end
+
+    def parse_link(name, info)
+
+      return parse_query_links(info) if (name.to_s == 'query')
+
+      if !info.is_a?(Array)
+        Link.new(self, info)
+      elsif info.size == 1
+        Link.new(self, info.first)
+      elsif info.size > 0
+        v.map{|l| Link.new(self, l)}
+      end
+    end
+
+    def parse_query_links(links)
+      links.inject({}) do |results, query|
+        rel = query['rels'].first
+        results[rel] = Link.new(self, query)
+        results
+      end
+    end
+
+    def parse_items(document)
+      self.items = Array(document).collect{|i| PMP::CollectionDocument.new(document:i)}
+    end
+
+  end
+end

data/lib/pmp/response.rb

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+
+module PMP
+  class Response
+    attr_accessor :raw, :request
+
+    def initialize(raw, request)
+      @raw     = raw
+      @request = request
+
+      check_for_error(raw)
+    end
+
+    def check_for_error(response)
+      status_code_type = response.status.to_s[0]
+      case status_code_type
+      when "2"
+        # puts "all is well, status: #{response.status}"
+      when "4", "5"
+        raise "Whoops, error back from PMP: #{response.status}"
+      else
+        raise "Unrecongized status code: #{response.status}"
+      end
+    end
+
+    def body
+      self.raw.body
+    end
+
+  end
+end

data/lib/pmp/token.rb

@@ -0,0 +1,53 @@
+# -*- encoding: utf-8 -*-
+
+require 'oauth2'
+
+module PMP
+  class Token
+
+    include Configuration
+
+    def initialize(options={}, &block)
+      apply_configuration(options)
+
+      yield(self) if block_given?
+    end
+
+    def token_url
+      options['token_url'] || '/auth/access_token'
+    end
+
+    def get_token
+      oauth_options = {
+        site:            endpoint,
+        token_url:       token_url,
+        connection_opts: connection_options(options)
+      }
+
+      client = OAuth2::Client.new(client_id, client_secret, oauth_options) do |faraday|
+        faraday.request  :url_encoded
+        faraday.response :logger if debug
+        faraday.adapter  adapter
+      end
+
+      client.client_credentials.get_token
+    end
+
+    def connection_options(opts={})
+      headers = opts.delete(:headers) || {}
+      options = {
+        :headers => {
+          'User-Agent'   => opts[:user_agent],
+          'Accept'       => 'application/json',
+          'Content-Type' => 'application/x-www-form-urlencoded'
+        },
+        :ssl => {:verify => false},
+        :url => opts[:endpoint]
+      }.merge(opts)
+      options[:headers] = options[:headers].merge(headers)
+
+      options
+    end
+
+  end
+end

data/lib/pmp/utils.rb

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+
+module PMP
+  module Utils
+
+    def to_ruby_safe_name(name)
+      safe = name.to_s.strip
+      safe = safe.gsub(/[^\w_!?=]+/, '_').sub(/^[0-9!?=]/, '')
+      safe[0..-2].gsub(/[!?=]+/, '_') + safe[-1]
+    end
+
+    def to_json_key_name(name)
+      name.to_s.gsub(/_/, '-')
+    end
+
+  end
+end

data/lib/pmp/version.rb

@@ -0,0 +1,5 @@
+# -*- encoding: utf-8 -*-
+
+module PMP
+  VERSION = "0.1.0"
+end

data/pmp.gemspec

@@ -0,0 +1,42 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pmp/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'pmp'
+  gem.version       = PMP::VERSION
+  gem.authors       = ['Andrew Kuklewicz']
+  gem.email         = ['andrew@prx.org']
+  gem.description   = %q{Public Media Platform Ruby Gem}
+  gem.summary       = %q{Public Media Platform Ruby Gem}
+  gem.homepage      = 'https://github.com/PRX/pmp'
+  gem.license       = 'MIT'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_development_dependency('bundler', '~> 1.3')
+  gem.add_development_dependency('rake')
+  gem.add_development_dependency('rake')
+  gem.add_development_dependency('minitest')
+  gem.add_development_dependency('webmock')
+  gem.add_development_dependency('pry')
+  gem.add_development_dependency('guard')
+  gem.add_development_dependency('guard-bundler')
+  gem.add_development_dependency('guard-minitest')
+  gem.add_development_dependency('simplecov')
+  gem.add_development_dependency('simplecov-gem-adapter')
+
+  gem.add_runtime_dependency('faraday')
+  gem.add_runtime_dependency('faraday_middleware')
+  gem.add_runtime_dependency('oauth2')
+  gem.add_runtime_dependency('multi_json')
+  gem.add_runtime_dependency('excon')
+  gem.add_runtime_dependency('hashie')
+  gem.add_runtime_dependency('activesupport')
+  gem.add_runtime_dependency('uri_template')
+
+end

data/spec/client_spec.rb

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe PMP::Client do
+
+  before(:each) {
+    @pmp = PMP::Client.new
+  }
+
+  it "returns a root api object" do
+    @pmp = PMP::Client.new
+    @pmp.root.wont_be_nil
+    @pmp.root.wont_be :loaded?
+    @pmp.root.href.must_equal "https://api.pmp.io/"
+  end
+
+  it "root doc can be loaded" do
+
+    root_doc =  json_file(:collection_root)
+
+    stub_request(:get, "https://api.pmp.io/").
+      with(:headers => {'Accept'=>'application/vnd.pmp.collection.doc+json', 'Content-Type'=>'application/vnd.pmp.collection.doc+json', 'Host'=>'api.pmp.io:443'}).
+      to_return(:status => 200, :body => root_doc, :headers => {})
+
+    @root = @pmp.root
+    @root.creator.must_be_instance_of PMP::Link
+  end
+
+end

data/spec/collection_document_spec.rb

@@ -0,0 +1,163 @@
+# -*- encoding: utf-8 -*-
+
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'pmp/collection_document'
+require 'webmock/minitest'
+
+describe PMP::CollectionDocument do
+
+  describe 'make' do
+
+    before(:each) {
+      @doc = PMP::CollectionDocument.new
+    }
+
+    it "can create a new, blank collection doc" do
+      @doc.wont_be_nil
+      @doc.must_be_instance_of PMP::CollectionDocument
+    end
+
+    it "can get options from configuration" do
+      @doc.options.wont_be_nil
+      @doc.options[:adapter].must_equal :excon
+    end
+
+    it "should default href to endpoint" do
+      @doc.href.must_equal "https://api.pmp.io/"
+    end
+  end
+
+  describe 'make from response' do
+
+    it "can create from document" do
+      response = mashify({
+        version: '1.0'
+      })
+
+      doc = PMP::CollectionDocument.new(document: response)
+      doc.version.must_equal '1.0'
+    end
+
+    it "can create from remote result" do
+      raw = Minitest::Mock.new
+      raw.expect(:status, 200)
+      raw.expect(:body, mashify({ version: '1.0' }))
+      response = PMP::Response.new(raw, {})
+
+      doc = PMP::CollectionDocument.new(response: response)
+      doc.version.must_equal '1.0'
+      doc.must_be :loaded
+    end
+
+  end
+
+  describe "parse from doc" do
+
+    before(:each) {
+      @doc = PMP::CollectionDocument.new(document: json_fixture(:collection_basic))
+    }
+
+    it "should assign attributes" do
+      @doc.guid.must_equal "f84e9018-5c21-4b32-93f8-d519308620f0"
+      @doc.valid.from.must_equal "2013-05-10T15:17:00.598Z"
+    end
+
+    it "should set-up links" do
+      @doc.profile.must_be_instance_of PMP::Link
+      @doc.profile.href.must_equal "http://api-sandbox.pmp.io/profiles/story"
+      @doc.self.href.must_equal "http://api-sandbox.pmp.io/docs/f84e9018-5c21-4b32-93f8-d519308620f0"
+      @doc.collection.href.must_equal "http://api-sandbox.pmp.io/docs/"
+    end
+
+    it "should serialize to collection.doc+json" do
+      @doc = PMP::CollectionDocument.new(document: json_fixture(:collection_basic))
+      @doc.to_json.must_equal '{"version":"1.0","links":{"profile":[{"href":"http://api-sandbox.pmp.io/profiles/story"}],"self":[{"href":"http://api-sandbox.pmp.io/docs/f84e9018-5c21-4b32-93f8-d519308620f0"}],"collection":[{"href":"http://api-sandbox.pmp.io/docs/"}]},"attributes":{"guid":"f84e9018-5c21-4b32-93f8-d519308620f0","title":"Peers Find Less Pressure Borrowing From Each Other","published":"2013-05-10T15:17:00.598Z","valid":{"from":"2013-05-10T15:17:00.598Z","to":"2213-05-10T15:17:00.598Z"},"byline":"by SOME PERSON","hreflang":"en","description":"","contentencoded":"...","contenttemplated":"..."}}'
+    end
+
+    it "provides list of attributes (not links)" do
+      @doc.attributes.keys.must_be :include?, 'title'
+      @doc.attributes.keys.wont_be :include?, 'self'
+    end
+
+  end
+
+  describe "loading" do
+
+    before(:each) {
+      root_doc =  json_file(:collection_root)
+
+      stub_request(:get, "https://api.pmp.io/").
+        with(:headers => {'Accept'=>'application/vnd.pmp.collection.doc+json', 'Authorization'=>'Bearer thisisatesttoken', 'Content-Type'=>'application/vnd.pmp.collection.doc+json', 'Host'=>'api.pmp.io:443'}).
+        to_return(:status => 200, :body => root_doc, :headers => {})
+
+      @doc = PMP::CollectionDocument.new(oauth_token: 'thisisatesttoken')
+    }
+
+    it "should use oauth token" do
+      @doc.oauth_token.must_equal 'thisisatesttoken'
+    end
+
+    it "should load" do
+      @doc.wont_be :loaded
+      @doc.load
+      @doc.must_be :loaded
+    end
+
+    it "should not load lazily for assignment" do
+      @doc.foo = 'bar'
+      @doc.wont_be :loaded
+    end
+
+    it "should load lazily when attr not found" do
+      @doc.wont_be :loaded
+      creator = @doc.creator
+      @doc.must_be :loaded
+      creator.must_be_instance_of PMP::Link
+    end
+
+    it "should provide a list of links" do
+      @doc.load
+      @doc.links.keys.sort.must_equal ["creator", "edit", "navigation", "query"]
+      @doc.links['creator'].must_be_instance_of PMP::Link
+    end
+
+  end
+
+  describe "queries" do
+
+    before(:each) {
+      root_doc =  json_file(:collection_root)
+
+      stub_request(:get, "https://api.pmp.io/").
+        with(:headers => {'Accept'=>'application/vnd.pmp.collection.doc+json', 'Authorization'=>'Bearer thisisatesttoken', 'Content-Type'=>'application/vnd.pmp.collection.doc+json', 'Host'=>'api.pmp.io:443'}).
+        to_return(:status => 200, :body => root_doc, :headers => {})
+
+      @doc = PMP::CollectionDocument.new(oauth_token: 'thisisatesttoken')
+    }
+
+    it "should get the list of query links" do
+      queries = @doc.query
+      queries.must_be_instance_of Hash
+    end
+
+    it "should get a query by rels" do
+      queries = @doc.query
+      queries["urn:pmp:query:docs"].must_be_instance_of PMP::Link
+    end
+
+  end
+
+  describe 'persistence' do
+
+    it "can set missing guid" do
+
+    end
+
+    it "can save a new record" do
+
+    end
+
+  end
+
+end