storify 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1079798438c428ba6b4ef587746d20cfa36ab175
-  data.tar.gz: ad39c541755df5151b1af5c24724709466590657
+  metadata.gz: 488d1fb73f0c02593590f124002f103b0ed96fdd
+  data.tar.gz: 008e7f1650cd761627297de605f2fcfb94760e39
 SHA512:
-  metadata.gz: b9d4855d72e86d8415f82e2efeed524c6ee36500fe4fa1b92bd905332e67887fcf70dd5c43d76e36a6be0a0d45cdd64be7e23202563b34fdfc2113c5e3966350
-  data.tar.gz: a651172d7c64799ebc0f950ed471439fb3030f06f68037e283fda0a168f3a98f45027b4c760eb995839aab87e1c274442ebcb7988a0c63b62779ac08b4c90da6
+  metadata.gz: 7b5615dd1ca034c3478c3e41aed0e1f5508ec946c32b3abf58c57325dd3479806104278a9b02880ef00bf1f8a8c3fc56222efbbc54ffb4111e05b5dbd951b93d
+  data.tar.gz: d9db9630e971f4dca1cacf937fc2757fdc564a649d53c6f5430264573836ad5c858fb68ebbe5fc8d7b0d35d94d7a011c4413e09e2cc1267df706962995988f7a

data/lib/storify/client.rb

@@ -1,6 +1,6 @@
 require 'json'
 require 'rest-client'
-#RestClient.log = './restclient.log'    
+#RestClient.log = './restclient.log'
 
 class Storify::Client
   attr_reader :api_key, :username, :token
@@ -10,16 +10,20 @@ class Storify::Client
     @username = username
   end
 
-  def auth(password)
-    endpoint = Storify::auth
+  def auth(password, options: {})
+    endpoint = Storify::endpoint(version: options[:version], method: :auth)
     data = call(endpoint, :POST, {password: password})
     @token = data['content']['_token']
 
     self
   end
 
-  def userstories(username = @username)
-    endpoint = Storify::userstories(username)
+  def userstories(username = @username, options: {})
+    endpoint = Storify::endpoint(version: options[:version],
+                                 protocol: options[:protocol],
+                                 method: :userstories,
+                                 params: {':username' => username})
+
     pager = add_pagination
     stories = []
 
@@ -37,8 +41,12 @@ class Storify::Client
     stories
   end
 
-  def story(slug, username = @username)
-    endpoint = Storify::story(username, slug)
+  def story(slug, username = @username, options: {})
+    params = {':username' => username, ':slug' => slug}
+    endpoint = Storify::endpoint(version: options[:version],
+                                 protocol: options[:protocol],
+                                 method: :userstory,
+                                 params: params)
     pager = add_pagination
     story = nil
     elements = []
@@ -89,10 +97,10 @@ class Storify::Client
       end
     rescue => e
       raw = e.response
-      
+
       data = JSON.parse(e.response)
       error = data['error']
-      raise Storify::ApiError.new(data['code'], error['message'], error['type']) 
+      raise Storify::ApiError.new(data['code'], error['message'], error['type'])
     end
 
     JSON.parse(raw)

data/lib/storify.rb

@@ -1,28 +1,30 @@
 module Storify
-  BASE_URL = 'https://api.storify.com'
+  PROTOCOLS = {
+    :secure => 'https://',
+    :insecure => 'http://'
+  }
 
-  def self.api(secure = true)
-    (secure ? 'https' : 'http') + '://api.storify.com'
-  end
-
-  def self.versioned_api(secure: true, version: 1)
-    api(secure) << "/v#{version}"
-  end
+  ENDPOINTS = {
+    :v1 => {
+      :base => 'api.storify.com/v1',
+      :auth => '/auth',
+      :userstories => '/stories/:username',
+      :userstory => '/stories/:username/:slug'
+    }
+  }
 
-  def self.auth
-    versioned_api << "/auth"
-  end
+  # Set protocol and endpoint defaults
+  PROTOCOLS.default = PROTOCOLS[:secure]
+  ENDPOINTS.default = ENDPOINTS[:v1]
+  ENDPOINTS[:v1].default = ENDPOINTS[:v1][:base]
 
-  def self.stories
-    versioned_api << "/stories"
-  end
-
-  def self.userstories(username)
-    stories << "/#{username}"
-  end
+  def self.endpoint(version: :v1, protocol: :secure, method: :base, params: {})
+    uri = (method == :auth) ? PROTOCOLS[:secure] : PROTOCOLS[protocol]
+    uri += ENDPOINTS[version][:base]
+    uri += ENDPOINTS[version][method]
+    params.each_pair {|k,v| uri = uri.gsub(k,v) }
 
-  def self.story(username, slug)
-    userstories(username) << "/#{slug}"
+    uri
   end
 end
 

data/spec/client_auth_spec.rb

@@ -1,17 +1,30 @@
 require 'spec_helper'
 
-describe "Storify::Client -- Authentication" do
+describe Storify::Client do
   before(:each) do
     @client = Storify::Client.new(@api_key, @username)
   end
 
-  it "should retrieve an auth token on success" do
+  context "Authentication" do
+    it "should retrieve an auth token on success" do
+      @client.auth(get_password).token.should_not be_nil
+      @client.authenticated.should be_true
+    end
 
-    @client.auth(get_password).token.should_not be_nil
-    @client.authenticated.should be_true
-  end
+    it "should raise an API error on failure" do
+      expect{@client.auth('invalid_password')}.to raise_error(Storify::ApiError)
+    end
+
+    it "should accept endpoint options (version)" do
+      options = {:version => :v1}
+      @client.auth(get_password, options: options)
+      @client.authenticated.should be_true
+    end
 
-  it "should raise an API error on failure" do
-    expect{@client.auth('invalid_password')}.to raise_error(Storify::ApiError)
+    it "should ignore endpoint options (protocol, method)" do
+      options = {:method => :unknown, :protocol => :insecure}
+      @client.auth(get_password, options: options)
+      @client.authenticated.should be_true
+    end
   end
 end

data/spec/client_spec.rb

@@ -9,12 +9,26 @@ describe Storify::Client do
     @story = STDIN.gets.chomp
   end
 
-  it "should get all stories for a specific user" do
-    @client.userstories(@username).length.should == 2
+  context "GET /stories/:username" do
+    it "should get all stories for a specific user" do
+      @client.userstories(@username).length.should == 2
+    end
+
+    it "should accept endpoint options (version, protocol)" do
+      options = {:version => :v1, :protocol => :insecure}
+      @client.userstories(@username, options: options).length.should == 2
+    end
   end
 
-  it "should get a specific story for a user (all pages)" do
-    @client.story(@story).elements.length.should == 3
+  context "GET /stories/:username/:slug" do
+    it "should get a specific story for a user (all pages)" do
+      @client.story(@story).elements.length.should == 3
+    end
+
+    it "should accept endpoint options (version, protocol)" do
+      options = {:version => :v1, :protocol => :insecure}
+      @client.story(@story, options: options).elements.length.should == 3
+    end
   end
 
   it "should allow a story to be serialized as text" do

data/spec/storify_spec.rb

@@ -1,36 +1,79 @@
 require 'spec_helper'
 
 describe Storify do
-  it "should default to un-versioned https API access" do
-    Storify::api.should eq 'https://api.storify.com'
-  end
+  context "API Protocols:" do
+    it "should support http" do
+      Storify::PROTOCOLS[:insecure].should == "http://"
+    end
+
+    it "should support secure http" do
+      Storify::PROTOCOLS[:secure].should == "https://"
+    end
 
-  it "should allow explicit un-versioned https or http for API access" do
-    Storify::api(false).should eq 'http://api.storify.com'
-    Storify::api(true).should eq 'https://api.storify.com'
+    it "should default to secure http" do
+      Storify::PROTOCOLS[:unknown].should == "https://"
+    end
   end
 
-  it "should allow dynamic versioned http or https API access" do
-    Storify::versioned_api.should eq 'https://api.storify.com/v1'
-    Storify::versioned_api(:version => 2).should eq 'https://api.storify.com/v2'
+  context "API Versions:" do
+    it "should support Storify API v1" do
+      Storify::ENDPOINTS[:v1].is_a?(Hash).should be_true
+    end
 
-    Storify::versioned_api(:secure => false, 
-                           :version => 2).should eq 'http://api.storify.com/v2'
+    it "should fallback to Storify API v1" do
+      Storify::ENDPOINTS[:unknown].is_a?(Hash).should be_true
+    end
   end
 
-  it "should retrieve the auth API endpoint" do
-    Storify::auth.should eq 'https://api.storify.com/v1/auth'
-  end
+  context "API v1 Endpoints Sub-Paths:" do
+    it "should support a base URL for a version" do
+      Storify::ENDPOINTS[:v1][:base].should == "api.storify.com/v1"
+    end
 
-  it "should retrieve the stories API endpoint" do
-    Storify::stories.should eq 'https://api.storify.com/v1/stories'
-  end
+    it "should default to the base URL" do
+      Storify::ENDPOINTS[:unknown][:unknown].should == "api.storify.com/v1"
+    end
+
+    it "should support the Authentication endpoint" do
+      Storify::ENDPOINTS[:v1][:auth].should == "/auth"
+    end
+
+    it "should support the User Stories endpoint" do
+      Storify::ENDPOINTS[:v1][:userstories].should == "/stories/:username"
+    end
 
-  it "should retrieve the user-specific stories API endpoint" do
-    Storify::userstories(@username).should eq "https://api.storify.com/v1/stories/#{@username}"
+    it "should support the Single Story endpoint" do
+      Storify::ENDPOINTS[:v1][:userstory].should == "/stories/:username/:slug"
+    end
   end
 
-  it "should retrieve a user-specific story API endpoint" do
-    Storify::story(@username, "mystory").should eq "https://api.storify.com/v1/stories/#{@username}/mystory"
+  context "API Endpoint URI Builder:" do
+    it "should allow dynamic protocol selection" do
+      Storify::endpoint(protocol: :secure).include?('https').should be_true
+    end
+
+    it "should allow dynamic version selection" do
+      Storify::endpoint(version: :v1).include?('v1').should be_true
+    end
+
+    it "should allow dynamic endpoint selection" do
+      Storify::endpoint(method: :auth).include?('/auth').should be_true
+    end
+
+    it "should allow dynamic parameter substitution" do
+      params = {':username' => 'rtejpar', ':slug' => 'this-is-my-story'}
+      uri = Storify::endpoint(params: params, method: :userstory)
+      ['rtejpar', 'this-is-my-story'].each {|s| uri.include?(s).should be_true }
+    end
+
+    it "should force secure protocol for Authentication" do
+      Storify::endpoint(protocol: :secure, method: :auth).include?('https').should be_true
+    end
+
+    it "should build the final uri based on dynamic configuration" do
+      params = {':username' => 'rtejpar'}
+      uri = Storify::endpoint(protocol: :insecure, method: :userstories, params: params)
+      uri.should == 'http://api.storify.com/v1/stories/rtejpar'
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: storify
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Rizwan Tejpar