vertebrae 0.1.6 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7301e0ce2d4d44f8ef03d76adcbed3e63dbfafa1
-  data.tar.gz: 8aac4e0d3b3c8249bc84fd125446e98a4c681d64
+  metadata.gz: 53a761abff5b9feda04b6f00fb12fbfcb50691b6
+  data.tar.gz: cf986de1d3ae7e4796d0e1865eeb2ccd90bea05e
 SHA512:
-  metadata.gz: 1e7d28426d484aaa3a6c79c07a4336f4b4eacd14e8e4c8b32d4d834ced69c122f3f6a0d2b779bc8038ebeffa1153252f6a412aa1a49a86c56c9d47a5b0c2d5af
-  data.tar.gz: f1d227611bb84986328dcce328f8874228c9507131505c4783b876e2ff1a206f7adf53598af6f09f7d3a07be019c61f9f5531de1fb1cddaf3675f2c742f90259
+  metadata.gz: a4b589b38d229a5b08f700a5618049ea48be1b39038cd78186a83703bf4bfed3b748a3418eb1c174cd8d682253a175dadb3bc98985f67dcc15257f5bf99d9ee9
+  data.tar.gz: cb9ce156956196a0bf6feceaa1067611064e6bb1cf20c0548d830d7b35868f73275e06b1ae67a0ae9893b3742669769aba1936010fba7644fb764ecfe72d383f

data/VERSION

@@ -1 +1 @@
-0.1.6
+0.2.0

data/lib/api.rb

@@ -1,154 +1,31 @@
 module Vertebrae
   class API
-
-    include Connection
     include Request
-    include Authorization
-
-    attr_reader *Configuration.keys
-
-    attr_accessor :current_options
 
-    # Callback to update current configuration options
-    class_eval do
-      Configuration.keys.each do |key|
-        define_method "#{key}=" do |arg|
-          self.instance_variable_set("@#{key}", arg)
-          self.current_options.merge!({:"#{key}" => arg})
-        end
-      end
-    end
+    attr_accessor :connection
 
     # Create new API
     #
     def initialize(options={}, &block)
-      setup(options)
-      yield_or_eval(&block) if block_given?
-    end
+      options.merge!(default_options)
 
-
-    def yield_or_eval(&block)
-      return unless block
-      block.arity > 0 ? yield(self) : self.instance_eval(&block)
-    end
-
-    # Configure options and process basic authorization
-    #
-    def setup(options={})
-      options = Vertebrae::Base.options.merge(options)
-      self.current_options = options
-      Configuration.keys.each do |key|
-        send("#{key}=", options[key])
-      end
-      process_basic_auth(options[:basic_auth])
-    end
-
-    # Extract login and password from basic_auth parameter
-    #
-    def process_basic_auth(auth)
-      case auth
-        when String
-          self.username, self.password = auth.split(':', 2)
-        when Hash
-          self.username = auth[:username]
-          self.password = auth[:password]
-      end
-    end
-
-    # Responds to attribute query or attribute clear
-    def method_missing(method, *args, &block) # :nodoc:
-      case method.to_s
-        when /^(.*)\?$/
-          return !!self.send($1.to_s)
-        when /^clear_(.*)$/
-          self.send("#{$1.to_s}=", nil)
-        else
-          super
-      end
-    end
-
-    # Acts as setter and getter for api requests arguments parsing.
-    #
-    # Returns Arguments instance.
-    #
-    def arguments(args=(not_set = true), options={}, &block)
-      if not_set
-        @arguments
-      else
-        @arguments = Arguments.new(self, options).parse(*args, &block)
-      end
-    end
-
-    # Scope for passing request required arguments.
-    #
-    def with(args)
-      case args
-        when Hash
-          set args
-        when /.*\/.*/i
-          user, repo = args.split('/')
-          set :user => user, :repo => repo
-        else
-          ::Kernel.raise ArgumentError, 'This api does not support passed in arguments'
-      end
-    end
-
-    # Set an option to a given value
-    def set(option, value=(not_set=true), ignore_setter=false, &block)
-      raise ArgumentError, 'value not set' if block and !not_set
-      return self if !not_set and value.nil?
-
-      if not_set
-        set_options option
-        return self
-      end
-
-      if respond_to?("#{option}=") and not ignore_setter
-        return __send__("#{option}=", value)
-      end
-
-      define_accessors option, value
-      self
-    end
-
-    private
-
-    def extract_id_from_response(resp)
-      extract_id_from_location(resp.response.headers["location"])
-    end
-
-    def extract_id_from_location(location)
-      location.scan(/\/(\d+)\/$/).first.first
+      yield_or_eval(&block) if block_given?
+      self.connection = Connection.new(options)
+      self.connection.configuration.process_basic_auth(options[:basic_auth])
+      setup
     end
 
-    # Set multiple options
-    #
-    def set_options(options)
-      unless options.respond_to?(:each)
-        raise ArgumentError, 'cannot iterate over value'
-      end
-      options.each { |key, value| set(key, value) }
+    def setup
     end
 
-    def define_accessors(option, value)
-      setter = proc { |val|  set option, val, true }
-      getter = proc { value }
 
-      define_singleton_method("#{option}=", setter) if setter
-      define_singleton_method(option, getter) if getter
+    def default_options
+      {}
     end
 
-    # Dynamically define a method for setting request option
-    #
-    def define_singleton_method(method_name, content=Proc.new)
-      (class << self; self; end).class_eval do
-        undef_method(method_name) if method_defined?(method_name)
-        if String === content
-          class_eval("def #{method_name}() #{content}; end")
-        else
-          define_method(method_name, &content)
-        end
-      end
+    def yield_or_eval(&block)
+      return unless block
+      block.arity > 0 ? yield(self) : self.instance_eval(&block)
     end
 
   end

data/lib/authorization.rb

@@ -1,5 +1,12 @@
 module Vertebrae
   module Authorization
+    def username?
+      username.present?
+    end
+
+    def password?
+      password.present?
+    end
 
     # Check whether authentication credentials are present
     def authenticated?

data/lib/base.rb

@@ -1,8 +1,5 @@
 module Vertebrae
   module Base
-    extend Configuration
-
-
     def logger
       @@logger ||= Logger.new(STDOUT)
     end

data/lib/configuration.rb

@@ -1,6 +1,8 @@
 module Vertebrae
-  module Configuration
+  class Configuration
     include Vertebrae::Constants
+    include ActiveSupport::Inflector
+    include Authorization
 
     VALID_OPTIONS_KEYS = [
         :adapter,
@@ -45,64 +47,64 @@ module Vertebrae
     DEFAULT_CONTENT_TYPE = 'application/json'.freeze
 
 
-    attr_accessor *VALID_OPTIONS_KEYS
+    VALID_OPTIONS_KEYS.each do | key |
+      define_method("default_#{key}".intern) { default_options[key] }
+    end
 
-    # Convenience method to allow for global setting of configuration options
-    def configure
-      yield self
+    VALID_OPTIONS_KEYS.each do | key |
+      define_method(key) do
+        options[key] || self.send("default_#{key}")
+      end
     end
 
-    def self.extended(base)
-      base.reset!
+    VALID_OPTIONS_KEYS.each do | key |
+      define_method("#{key}=".intern) do |value|
+        options[key] = value
+      end
     end
 
-    class << self
-      def keys
-        VALID_OPTIONS_KEYS
+    attr_accessor :options
+    attr_accessor :default_options
+
+    def initialize(options)
+      self.options = options
+      self.default_options = {}
+
+      VALID_OPTIONS_KEYS.each do |key|
+        default_options[key] = "Vertebrae::Configuration::DEFAULT_#{key.to_s.upcase}".constantize
       end
     end
 
 
-    def faraday_options(ops)
+    def faraday_options
       {
-          :headers => {
-              ACCEPT           => "application/json;q=0.1",
-              ACCEPT_CHARSET   => "utf-8",
-              USER_AGENT       => user_agent,
-              CONTENT_TYPE     => content_type
-          },
-          :ssl => ops.fetch(:ssl) { ssl },
-          :url => ops.fetch(:endpoint) { self.endpoint(ops) }
-      }.merge(options)
+        :headers => {
+          ACCEPT           => "application/json;q=0.1",
+          ACCEPT_CHARSET   => "utf-8",
+          USER_AGENT       => user_agent,
+          CONTENT_TYPE     => content_type
+        },
+        :ssl =>  ssl,
+        :url => endpoint
+      }
     end
 
-    def endpoint(ops)
-      h = ops[:host]   ? ops[:host]   : self.host
-      p = ops[:prefix] ? ops[:prefix] : self.prefix
 
-      "https://#{h}#{p}"
+    # Extract login and password from basic_auth parameter
+    #
+    def process_basic_auth(auth)
+      case auth
+        when String
+          self.username, self.password = auth.split(':', 2)
+        when Hash
+          self.username = auth[:username]
+          self.password = auth[:password]
+      end
     end
 
-    def options
-      options = {}
-      VALID_OPTIONS_KEYS.each { |k| options[k] = send(k) }
-      options
-    end
 
-    # Reset configuration options to their defaults
-    #
-    def reset!
-      self.adapter            = DEFAULT_ADAPTER
-      self.prefix             = DEFAULT_PREFIX
-      self.ssl                = DEFAULT_SSL
-      self.mime_type          = DEFAULT_MIME_TYPE
-      self.user_agent         = DEFAULT_USER_AGENT
-      self.host               = DEFAULT_HOST
-      self.username           = DEFAULT_USERNAME
-      self.password           = DEFAULT_PASSWORD
-      self.connection_options = DEFAULT_CONNECTION_OPTIONS
-      self.content_type       = DEFAULT_CONTENT_TYPE
-      self
+    def endpoint
+      "https://#{self.host}#{self.prefix}"
     end
-  end # Configuration
+  end
 end

data/lib/connection.rb

@@ -2,12 +2,15 @@ require 'faraday'
 require 'faraday_middleware'
 require 'request/basic_auth'
 require 'response/raise_error'
+require 'authorization'
 
 module Vertebrae
-  module Connection
-
-    extend self
+  class Connection
     include Vertebrae::Constants
+    include Vertebrae::Authorization
+
+    attr_accessor :options
+    attr_accessor :configuration
 
     ALLOWED_OPTIONS = [
         :headers,
@@ -17,18 +20,21 @@ module Vertebrae
         :ssl
     ].freeze
 
-    def default_options(options={})
-      Vertebrae::Base.faraday_options(options)
+    def initialize(options)
+      @options = options
+      @configuration = Vertebrae::Configuration.new(options)
+      @connection = nil
+      @stack = nil
     end
 
     # Default middleware stack that uses default adapter as specified at
     # configuration stage.
     #
-    def default_middleware(options={})
+    def default_middleware
       Proc.new do |builder|
         builder.use Faraday::Request::Multipart
         builder.use Faraday::Request::UrlEncoded
-        builder.use Vertebrae::Request::BasicAuth, authentication if authenticated?
+        builder.use Vertebrae::Request::BasicAuth, configuration.authentication if configuration.authenticated?
 
         builder.use Faraday::Response::Logger if ENV['DEBUG']
         unless options[:raw]
@@ -36,45 +42,31 @@ module Vertebrae
           builder.use FaradayMiddleware::ParseJson
         end
         builder.use Vertebrae::Response::RaiseError
-        builder.adapter adapter
+        builder.adapter configuration.adapter
       end
     end
 
-    @connection = nil
-
-    @stack = nil
-
-    def clear_cache
-      @connection = nil
-    end
-
-    def caching?
-      !@connection.nil?
-    end
-
     # Exposes middleware builder to facilitate custom stacks and easy
     # addition of new extensions such as cache adapter.
     #
-    def stack(options={}, &block)
+    def stack(&block)
       @stack ||= begin
         if block_given?
           Faraday::Builder.new(&block)
         else
-          Faraday::Builder.new(&default_middleware(options))
+          Faraday::Builder.new(&default_middleware)
         end
       end
     end
 
     # Returns a Fraday::Connection object
     #
-    def connection(options={})
-      conn_options = default_options(options)
-      clear_cache unless options.empty?
-      Vertebrae::Base.logger.debug "OPTIONS:#{conn_options.inspect}"
-
-      @connection ||= Faraday.new(conn_options.merge(:builder => stack(options)))
+    def connection
+      if @connection
+        @connection
+      else
+        @connection ||= Faraday.new(configuration.faraday_options.merge(:builder => stack))
+      end
     end
-
-
   end
 end

data/lib/model.rb

@@ -0,0 +1,13 @@
+module Vertebrae
+  class Model
+    attr_accessor :client
+
+    def initialize(attrs = {})
+      attrs.each do |key,value|
+        if self.respond_to?("#{key}=")
+          self.send("#{key}=", value)
+        end
+      end
+    end
+  end
+end

data/lib/vertebrae.rb

@@ -1,13 +1,15 @@
+require 'active_support/all'
+
 require 'constants'
+require 'authorization'
 require 'configuration'
 require 'connection'
-require 'authorization'
 require 'request'
 require 'api'
 require 'base'
+require 'model'
 
 
-require 'active_support/all'
 require 'railties' if defined? Rails
 
 

data/spec/api_spec.rb

@@ -4,29 +4,8 @@ describe Vertebrae::API do
 
   subject { described_class.new(options) }
 
-  it { described_class.included_modules.should include Vertebrae::Authorization }
-  it { described_class.included_modules.should include Vertebrae::Connection }
   it { described_class.included_modules.should include Vertebrae::Request }
 
-
-  describe '#extract_id_from_location' do
-    let(:options) { {} }
-    it "should extract the id" do
-      subject.send(:extract_id_from_location, "https://roboticdogs.actionkit.com/rest/v1/importpage/1093/").should == "1093"
-    end
-  end
-
-
-  context 'process_basic_auth' do
-    let(:options) { { :basic_auth => 'login:password' } }
-
-    its(:username) { should eq 'login' }
-
-    its(:password) { should eq 'password' }
-
-    its(:basic_auth) { should eq 'login:password' }
-  end
-
   describe 'dummy' do
     describe 'should delegate to the client class' do
       specify{ Dummy.new.should respond_to(:api)  }

data/spec/configuration_spec.rb

@@ -1,41 +1,43 @@
 require 'spec_helper'
 
 describe Vertebrae::Configuration do
-  let(:klass) {
-    ::Class.new do
-      extend Vertebrae::Configuration
-    end
-  }
-
-  subject { klass }
-
-  its(:adapter) { should == described_class::DEFAULT_ADAPTER }
 
-  its(:ssl) { should == described_class::DEFAULT_SSL }
+  subject { Vertebrae::Configuration.new({}) }
 
-  its(:ssl) { should be_a Hash }
-
-  its(:user_agent) { should == described_class::DEFAULT_USER_AGENT }
+  {:adapter => described_class::DEFAULT_ADAPTER,
+   :ssl => described_class::DEFAULT_SSL,
+   :user_agent => described_class::DEFAULT_USER_AGENT,
+   :username => described_class::DEFAULT_USERNAME,
+   :password => described_class::DEFAULT_PASSWORD }.each do | key, value |
+      its(key) { should == value }
+      its("default_#{key}") { should == value }
+  end
 
   its(:connection_options) { should be_a Hash }
-
   its(:connection_options) { should be_empty }
 
-  its(:username) { should == described_class::DEFAULT_USERNAME }
+  describe "override" do
+    subject{ Vertebrae::Configuration.new({username: 'foo', password: 'bar'}) }
 
-  its(:password) { should == described_class::DEFAULT_PASSWORD }
+    its(:default_username) { should == described_class::DEFAULT_USERNAME }
+    its(:default_password) { should == described_class::DEFAULT_PASSWORD }
 
-  describe ".configure" do
-    it { should respond_to :configure }
+    its(:username) { should == 'foo'}
+    its(:password) { should == 'bar'}
+  end
 
-    described_class.keys.each do |key|
-      it "should set the #{key}" do
-        subject.configure do |config|
-          config.send("#{key}=", key)
-          subject.send(key).should == key
-        end
-      end
+  describe "setter" do
+    before(:each) do
+      subject.username =  'foo'
     end
+    its(:username) { should == 'foo'}
+    its(:default_username) { should == described_class::DEFAULT_USERNAME }
   end
 
+  describe 'endpoint' do
+    subject { Vertebrae::Configuration.new({host: 'test.com', prefix: ''}) }
+
+    specify { subject.host.should == 'test.com' }
+    specify { subject.endpoint.should == 'https://test.com'}
+  end
 end

data/vertebrae.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "vertebrae"
-  s.version = "0.1.6"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Nathan Woodhull"]
-  s.date = "2013-07-17"
+  s.date = "2013-07-30"
   s.description = "A set of low level infrastructure and reusable code for building API clients"
   s.email = "nathan@controlshiftlabs.com"
   s.extra_rdoc_files = [
@@ -34,13 +34,13 @@ Gem::Specification.new do |s|
     "lib/connection.rb",
     "lib/constants.rb",
     "lib/core_ext/array.rb",
+    "lib/model.rb",
     "lib/railties.rb",
     "lib/request.rb",
     "lib/request/basic_auth.rb",
     "lib/response/raise_error.rb",
     "lib/vertebrae.rb",
     "spec/api_spec.rb",
-    "spec/authorization_spec.rb",
     "spec/configuration_spec.rb",
     "spec/dummy/client.rb",
     "spec/dummy/dummy.rb",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vertebrae
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.2.0
 platform: ruby
 authors:
 - Nathan Woodhull
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-17 00:00:00.000000000 Z
+date: 2013-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -134,13 +134,13 @@ files:
 - lib/connection.rb
 - lib/constants.rb
 - lib/core_ext/array.rb
+- lib/model.rb
 - lib/railties.rb
 - lib/request.rb
 - lib/request/basic_auth.rb
 - lib/response/raise_error.rb
 - lib/vertebrae.rb
 - spec/api_spec.rb
-- spec/authorization_spec.rb
 - spec/configuration_spec.rb
 - spec/dummy/client.rb
 - spec/dummy/dummy.rb

data/spec/authorization_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe Vertebrae::Authorization do
-  let(:options) { {} }
-
-  subject(:vb) { Dummy.new options }
-
-  after do
-    reset_authentication_for vb
-  end
-
-  context ".authenticated?" do
-    it { should respond_to(:authenticated?) }
-  end
-
-  context "authentication" do
-
-    context 'username & password' do
-      let(:options) { { :username => 'vb', :password => 'pass' } }
-
-      it "should return hash with username & password params" do
-        vb.basic_auth.should == "#{options[:username]}:#{options[:password]}"
-      end
-    end
-  end
-end # authentication