frenetic 0.0.20.alpha.6 → 1.0.0.alpha.1

data/lib/frenetic/concerns/briefly_memoizable.rb

@@ -1,34 +0,0 @@
-require 'active_support/concern'
-
-# Memoizes method calls, but only for a specific period of time.
-# Useful for supporting HTTP Cache-Control without an external caching layer
-# like Rack::Cache
-module BrieflyMemoizable
-  extend ActiveSupport::Concern
-
-  module ClassMethods
-    def briefly_memoize( symbol )
-      original_method = "_unmemoized_#{symbol}".to_sym
-      memoized_ivar   = "@#{symbol}"
-      age_ivar        = "@#{symbol}_age"
-
-      class_eval <<-EOS
-        if method_defined?(:#{original_method})                                  # if method_defined?(:_unmemoized_mime_type)
-          raise "Already memoized #{symbol}"                                     #   raise "Already memoized mime_type"
-        end                                                                      # end
-        alias #{original_method} #{symbol}                                       # alias _unmemoized_mime_type mime_type
-
-        def #{symbol}(*args)                                                     # def mime_type(*args)
-          #{memoized_ivar} = nil if #{age_ivar} && Time.now > #{age_ivar}        #   @mime_type = nil if @mime_type_age && Time.now > @mime_type_age
-                                                                                 #
-          #{memoized_ivar} ||= #{original_method}(*args)                         #   @mime_type ||= _unmemoized_mime_type(*args)
-        end                                                                      # end
-
-        def reload_#{symbol}!                                                    # def reload_mime_type!
-          #{memoized_ivar} = nil                                                 #   @mime_type = nil
-        end                                                                      # end
-      EOS
-    end
-  end
-
-end

data/lib/frenetic/concerns/configurable.rb

@@ -1,59 +0,0 @@
-require 'active_support/configurable'
-require 'active_support/concern'
-
-require 'frenetic/configuration'
-
-class Frenetic
-  module Configurable
-    extend ActiveSupport::Concern
-
-    included do
-      include ActiveSupport::Configurable
-      # Don't allow the class to be configured
-      class << self
-        undef :configure
-      end
-    end
-
-    def initialize( cfg = {} )
-      config.merge! Frenetic::Configuration.new(cfg).attributes
-
-      @builder_config = Proc.new if block_given?
-    end
-
-    def configure
-      yield config
-    end
-
-  private
-
-    def validate_configuration!
-      raise( ConfigError, 'A URL must be defined' ) unless config.url
-    end
-
-    def configure_authentication( builder )
-      if config.username
-        builder.request :basic_auth, config.username, config.password
-      end
-
-      if config.api_token
-        builder.request :token_auth, config.api_token
-      end
-    end
-
-    def configure_caching( builder )
-      if config.cache[:metastore]
-        dependency 'rack-cache'
-
-        builder.use FaradayMiddleware::RackCompatible, Rack::Cache::Context, config.cache
-      end
-    end
-
-    def dependency( lib = nil )
-      lib ? require(lib) : yield
-    rescue NameError, LoadError => err
-      raise ConfigError, "Missing dependency for #{self}: #{err.message}"
-    end
-
-  end
-end

data/lib/frenetic/concerns/resource_mockery.rb

@@ -1,48 +0,0 @@
-require 'ostruct'
-require 'active_support/concern'
-
-class Frenetic
-  module ResourceMockery
-    extend ActiveSupport::Concern
-
-    included do
-      # I'm sure this violates some sort of CS principle or best practice,
-      # but it solves the problem for now.
-      superclass.send :instance_variable_set, '@mock_class', self
-    end
-
-    def attributes
-      @params
-    end
-
-    def properties
-      @params.each_with_object({}) do |(k,v), props|
-        props[k] = v.class.to_s.underscore
-      end
-    end
-
-    # Provides a place for a Resources that are mocked to declare reasonable
-    # default values for Mock Resources
-    def default_attributes
-      {}
-    end
-
-    module ClassMethods
-      def api_client
-        superclass.api_client
-      end
-    end
-
-  private
-
-    def build_params( p )
-      defaults = default_attributes.with_indifferent_access
-      @params  = defaults.merge( (p || {}).with_indifferent_access )
-    end
-
-    def build_structure
-      @structure = OpenStruct.new( @attrs )
-    end
-
-  end
-end

data/lib/frenetic/configuration.rb

@@ -1,88 +0,0 @@
-require 'addressable/uri'
-require 'active_support/core_ext/hash/indifferent_access'
-
-class Frenetic
-  class Configuration
-
-    @@defaults = {
-      headers:   {
-        accept:     'application/hal+json',
-        user_agent: "Frenetic v#{Frenetic::VERSION}; #{Socket.gethostname}"
-      }
-    }
-
-    def initialize( cfg = {} )
-      @_cfg = cfg.symbolize_keys
-    end
-
-    def adapter
-      @_cfg[:adapter] || Faraday.default_adapter
-    end
-
-    def api_token
-      @_cfg[:api_token]
-    end
-
-    def attributes
-      {
-        adapter:   adapter,
-        api_token: api_token,
-        cache:     cache,
-        default_root_cache_age: default_root_cache_age,
-        headers:   headers,
-        password:  password,
-        ssl:       ssl,
-        test_mode: test_mode,
-        url:       url,
-        username:  username
-      }
-    end
-
-    def cache
-      if @_cfg[:cache] == :rack
-        {
-          metastore:     'file:tmp/rack/meta',
-          entitystore:   'file:tmp/rack/body',
-          ignore_headers: %w{Authorization Set-Cookie X-Content-Digest}
-        }
-      else
-        {}
-      end
-    end
-
-    def default_root_cache_age
-      @_cfg[:default_root_cache_age]
-    end
-
-    def headers
-      @@defaults[:headers].merge( @_cfg[:headers] || {} ).tap do |h|
-        if @_cfg[:headers] && @_cfg[:headers][:user_agent]
-          if h[:user_agent] != @@defaults[:headers][:user_agent]
-            h[:user_agent] = "#{h[:user_agent]} (#{@@defaults[:headers][:user_agent]})"
-          end
-        end
-      end
-    end
-
-    def password
-      @_cfg[:password] || @_cfg[:api_key]
-    end
-
-    def ssl
-      @_cfg[:ssl] || { verify:true }
-    end
-
-    def test_mode
-      @_cfg[:test_mode] || false
-    end
-
-    def url
-      Addressable::URI.parse @_cfg[:url]
-    end
-
-    def username
-      @_cfg[:username] || @_cfg[:app_id]
-    end
-
-  end
-end

data/spec/concerns/configurable_spec.rb

@@ -1,50 +0,0 @@
-describe Frenetic::Configurable do
-  let(:test_cfg) do
-    {
-      url:'http://example.org'
-    }
-  end
-
-  subject(:instance) { Frenetic.new( test_cfg ) }
-
-  describe '#config' do
-    subject { instance.config }
-
-    it { should_not be_empty }
-  end
-
-  describe '#configure' do
-    subject do
-      cfg = nil
-      instance.configure { |c| cfg = c }
-      cfg
-    end
-
-    it 'should yield the configuration' do
-      subject.should be_a Hash
-    end
-  end
-
-  describe '.configure' do
-    subject { Frenetic.configure{|c|} }
-
-    it 'should not exist' do
-      expect{ subject }.to raise_error NoMethodError
-    end
-  end
-
-  describe '#initialize' do
-    let(:callback) do
-      Proc.new { |b| }
-    end
-
-    subject do
-      Frenetic.new( &callback ).instance_variable_get( "@builder_config" )
-    end
-
-    it 'retain block arguments' do
-      subject.should eq callback
-    end
-  end
-
-end

data/spec/concerns/resource_mockery_spec.rb

@@ -1,56 +0,0 @@
-require 'spec_helper'
-
-require 'frenetic/resource_mockery'
-
-describe Frenetic::ResourceMockery do
-  let(:my_temp_resource) do
-    Class.new(Frenetic::Resource)
-  end
-
-  let(:my_mocked_resource) do
-    Class.new(my_temp_resource) do
-      def default_attributes
-        { qux:'qux' }
-      end
-    end
-  end
-
-  before do
-    stub_const 'MyNamespace::MyMockedResource', my_mocked_resource
-
-    MyNamespace::MyMockedResource.send :include, described_class
-  end
-
-  let(:params) { { foo:1, bar:'baz' } }
-
-  subject { MyNamespace::MyMockedResource.new params }
-
-  it 'should violate some basic CS principles by telling the parent-class of its existence' do
-    expect(my_temp_resource.instance_variables).to include :@mock_class
-  end
-
-  describe '#properties' do
-    subject { super().properties }
-
-    it 'should return a hash of available properties' do
-      subject.should include 'foo' => 'fixnum'
-      subject.should include 'bar' => 'string'
-    end
-  end
-
-  describe '#attributes' do
-    subject { super().attributes }
-
-    it 'should return a hash of the resources attributes' do
-      subject.should include 'foo' => 1
-      subject.should include 'bar' => 'baz'
-      subject.should include 'qux' => 'qux'
-    end
-  end
-
-  describe '#default_attributes' do
-    it 'should allow implementors to specify sane defaults' do
-      subject.qux.should == 'qux'
-    end
-  end
-end

data/spec/configuration_spec.rb

@@ -1,134 +0,0 @@
-describe Frenetic::Configuration do
-  let(:cfg) { Hash.new }
-
-  subject(:instance) { described_class.new cfg }
-
-  describe '#adapter' do
-    subject { instance.adapter }
-
-    it { should == :net_http }
-  end
-
-  describe '#attributes' do
-    subject { instance.attributes }
-
-    it { should include :adapter }
-    it { should include :api_token }
-    it { should include :cache }
-    it { should include :default_root_cache_age }
-    it { should include :headers }
-    it { should include :password }
-    it { should include :ssl }
-    it { should include :test_mode }
-    it { should include :url }
-    it { should include :username }
-  end
-
-  describe '#api_token' do
-    let(:cfg) do
-      { api_token:'API_TOKEN' }
-    end
-
-    subject { instance.api_token }
-
-    it { should == 'API_TOKEN' }
-  end
-
-  describe '#cache' do
-    subject { instance.cache }
-
-    context 'with a value of :rack' do
-      let(:cfg) do
-        { cache: :rack }
-      end
-
-      it 'should return Rack::Cache options' do
-        subject.should include metastore:'file:tmp/rack/meta'
-        subject.should include entitystore:'file:tmp/rack/body'
-        subject.should include ignore_headers:%w{Authorization Set-Cookie X-Content-Digest}
-      end
-    end
-  end
-
-  describe '#default_root_cache_age' do
-    let(:cfg) do
-      { default_root_cache_age:3600 }
-    end
-
-    subject { instance.default_root_cache_age }
-
-    it { should == 3600 }
-  end
-
-  describe '#headers' do
-    let(:cfg) do
-      { headers:{ accept:'MIME', x_foo:'BAR' } }
-    end
-
-    subject { instance.headers }
-
-    it 'should properly merge in nested header values' do
-      subject.should include :user_agent
-      subject.should include accept:'MIME'
-      subject.should include x_foo:'BAR'
-    end
-
-    context 'with a custom User-Agent' do
-      let(:cfg) do
-        { headers:{ user_agent:'Foo v1.1' } }
-      end
-
-      it 'should append the Frenentic User-Agent' do
-        subject[:user_agent].should match %r{\AFoo v1.1 \(Frenetic v.[^;]*; [^)]*\)\Z}
-      end
-    end
-  end
-
-  describe '#password' do
-    subject { instance.password }
-
-    context 'with a specifed Api key' do
-      let(:cfg) do
-        { api_key:'API_KEY' }
-      end
-
-      it { should == 'API_KEY' }
-    end
-  end
-
-  describe '#ssl' do
-    subject { instance.ssl }
-
-    it { should include verify:true }
-  end
-
-  describe '#test_mode' do
-    subject { instance.test_mode }
-
-    it { should be_false }
-  end
-
-  describe '#url' do
-    let(:cfg) do
-      { url:'http://example.org' }
-    end
-
-    subject { instance.url }
-
-    it { should be_a Addressable::URI }
-
-    its(:to_s) { should == 'http://example.org' }
-  end
-
-  describe '#username' do
-    subject { instance.username }
-
-    context 'with a specifed App Id' do
-      let(:cfg) do
-        { app_id:'APP_ID' }
-      end
-
-      it { should == 'APP_ID' }
-    end
-  end
-end