frenetic 0.0.12 → 0.0.20.alpha.0

data/lib/frenetic/concerns/collection_rest_methods.rb

@@ -0,0 +1,13 @@
+require 'active_support/concern'
+
+class Frenetic
+  module CollectionRestMethods
+    extend ActiveSupport::Concern
+
+    def get( id )
+      if response = api.get( member_url(id) ) and response.success?
+        @resource_class.new response.body
+      end
+    end
+  end
+end

data/lib/frenetic/concerns/configurable.rb

@@ -0,0 +1,59 @@
+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/hal_linked.rb

@@ -0,0 +1,59 @@
+require 'active_support/concern'
+require 'addressable/template'
+
+class Frenetic
+  module HalLinked
+    extend ActiveSupport::Concern
+
+    def links
+      @params['_links']
+    end
+
+    def member_url( params = {} )
+      resource = @resource_type || self.class.to_s.demodulize.underscore
+
+      link = links[resource] || links['self'] or raise HypermediaError, %Q{No Hypermedia GET Url found for the resource "#{resource}"}
+
+      self.class.parse_link link, params
+    end
+
+    module ClassMethods
+      def links
+        api.description['_links']
+      end
+
+      def member_url( params = {} )
+        link = links[namespace] or raise HypermediaError, %Q{No Hypermedia GET Url found for the resource "#{namespace}"}
+
+        parse_link link, params
+      end
+
+      def parse_link( link, params = {} )
+        if link['templated']
+          expand_link link, params
+        else
+          link['href']
+        end
+      end
+
+    private
+
+      def expand_link( link, params )
+        tmpl = Addressable::Template.new link['href']
+
+        if params && !params.is_a?(Hash)
+          params = infer_url_template_values tmpl, params
+        end
+
+        tmpl.expand( params ).to_s
+      end
+
+      def infer_url_template_values( tmpl, params )
+        key = tmpl.variables.first
+
+        { key => params }
+      end
+
+    end
+  end
+end

data/lib/frenetic/concerns/member_rest_methods.rb

@@ -0,0 +1,15 @@
+require 'active_support/concern'
+
+class Frenetic
+  module MemberRestMethods
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def find( id = nil )
+        if response = api.get( member_url(id) ) and response.success?
+          new response.body
+        end
+      end
+    end
+  end
+end

data/lib/frenetic/concerns/structured.rb

@@ -0,0 +1,53 @@
+class Frenetic
+  module Structured
+
+    # Stores the unique signature of each Resource Structure
+    # Used to determine when a Structure has changed and thus
+    # needs to be redefined.
+    @@signatures = {}
+
+    def struct_key
+      "#{self.class}::FreneticResourceStruct".gsub '::', ''
+    end
+
+    def signature
+      @attrs.keys.sort.join('')
+    end
+
+    def structure
+      if structure_expired?
+        rebuild_structure!
+      else
+        fetch_structure
+      end
+    end
+
+    def fetch_structure
+      Struct.const_get struct_key
+    end
+
+    def rebuild_structure!
+      destroy_structure!
+
+      @@signatures[struct_key] = signature
+
+      Struct.new( struct_key, *@attrs.keys )
+    end
+
+    def structure_expired?
+      @@signatures[struct_key] != signature
+    end
+
+    def structure_defined?
+      Struct.constants.include? struct_key.to_sym
+    end
+
+    def destroy_structure!
+      return unless structure_defined?
+
+      @@signatures.delete struct_key
+
+      Struct.send :remove_const, struct_key
+    end
+  end
+end

data/lib/frenetic/configuration.rb

@@ -1,102 +1,66 @@
-require 'socket'
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/hash/keys'
-require 'active_support/core_ext/hash/deep_merge'
+require 'addressable/uri'
+require 'active_support/core_ext/hash/indifferent_access'
 
 class Frenetic
   class Configuration
 
     @@defaults = {
-      adapter:  nil,
-      cache:    nil,
-      url:      nil,
-      username: nil,
-      password: nil,
-      headers:  {
-        accept: 'application/hal+json'
-      },
-      request:  {},
-      response: {}
+      headers:   {
+        accept:     'application/hal+json',
+        user_agent: "Frenetic v#{Frenetic::VERSION}; #{Socket.gethostname}"
+      }
     }
 
-    attr_accessor :adapter, :cache, :url, :username, :password
-    attr_accessor :headers, :request, :response, :middleware
-
-    def initialize( config = {} )
-      config = @@defaults.deep_merge( config.symbolize_keys )
-
-      map_api_key_to_username config
-      append_user_agent       config
-      filter_cache_headers    config
-
-      config.each do |k, v|
-        v.symbolize_keys! if v.is_a? Hash
-
-        instance_variable_set "@#{k}", v
-      end
+    def initialize( cfg = {} )
+      @_cfg = cfg.symbolize_keys
     end
 
-    def attributes
-      validate!
-
-      (instance_variables - [:@middleware]).each_with_object({}) do |k, attrs|
-        key = k.to_s.gsub( '@', '' )
-
-        value = instance_variable_get( k )
-
-        attrs[key.to_sym] = value
-      end
+    def adapter
+      @_cfg[:adapter] || :net_http
     end
-    alias_method :to_hash, :attributes
-
-    def validate!
-      raise(Frenetic::ConfigurationError, 'No API URL defined!') unless @url.present?
 
-      if @cache
-        raise( ConfigurationError, 'No cache :metastore defined!' )               unless @cache[:metastore].present?
-        raise( ConfigurationError, "No cache :entitystore defined!" )             unless @cache[:entitystore].present?
-      end
+    def api_token
+      @_cfg[:api_token]
     end
 
-    def middleware
-      @middleware ||= []
+    def attributes
+      {
+        adapter:   adapter,
+        api_token: api_token,
+        cache:     cache,
+        headers:   headers,
+        password:  password,
+        url:       url,
+        username:  username
+      }
     end
 
-    def use( *args )
-      middleware << args
+    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
 
-  private
-
-    def user_agent
-      "Frenetic v#{Frenetic::VERSION}; #{Socket.gethostname}"
+    def headers
+      @@defaults[:headers].merge( @_cfg[:headers] || {} )
     end
 
-    def map_api_key_to_username( config )
-      if config[:api_key]
-        if config[:app_id]
-          config[:username] = config.delete :app_id
-          config[:password] = config.delete :api_key
-        else
-          config[:username] = config.delete :api_key
-        end
-      end
+    def password
+      @_cfg[:password] || @_cfg[:api_key]
     end
 
-    def append_user_agent( config )
-      if config[:headers][:user_agent]
-        config[:headers][:user_agent] << " (#{user_agent})"
-      else
-        config[:headers][:user_agent] = user_agent
-      end
+    def url
+      Addressable::URI.parse @_cfg[:url]
     end
 
-    def filter_cache_headers( config )
-      if config[:cache]
-        ignore_headers = config[:cache][:ignore_headers] || []
-
-        config[:cache][:ignore_headers] = (ignore_headers + %w[Set-Cookie X-Content-Digest]).uniq
-      end
+    def username
+      @_cfg[:username] || @_cfg[:app_id]
     end
 
   end

data/lib/frenetic/middleware/hal_json.rb

@@ -0,0 +1,23 @@
+require 'faraday_middleware/response_middleware'
+
+class Frenetic
+  module Middleware
+    class HalJson < FaradayMiddleware::ParseJson
+
+      def process_response(env)
+        super
+
+        if (500...599).include? env[:status]
+          raise ServerError, env[:body]['error']
+        elsif (400...499).include? env[:status]
+          raise ClientError, env[:body]['error']
+        end
+      rescue Faraday::Error::ParsingError => err
+        raise ParsingError, err.message
+      end
+
+    end
+  end
+end
+
+Faraday.register_middleware :response, hal_json:lambda { Frenetic::Middleware::HalJson }

data/lib/frenetic/resource.rb

@@ -1,90 +1,105 @@
+require 'delegate'
 require 'active_support/inflector'
+require 'active_support/core_ext/hash/indifferent_access'
 
-class Frenetic
-  class Resource
-
-    def initialize( attributes = {} )
-      self.class.apply_schema
-
-      attributes.each do |key, val|
-        instance_variable_set "@#{key}", val
-      end
+require 'frenetic/concerns/structured'
+require 'frenetic/concerns/hal_linked'
+require 'frenetic/concerns/member_rest_methods'
 
-      @_links ||= {}
+class Frenetic
+  class Resource < Delegator
+    include Structured
+    include HalLinked
+    include MemberRestMethods
 
-      build_associations attributes
+    def api
+      self.class.api
     end
 
-    def links
-      @_links
+    def self.api
+      api_client
     end
 
-    def attributes
-      self.class.schema.keys.each_with_object({}) do |key, attrs|
-        attrs[key] = public_send key
+    def self.api_client( client = nil )
+      if client
+        @api_client = client
+      elsif block_given?
+        @api_client = Proc.new
+      elsif @api_client.is_a? Proc
+        @api_client.call
+      else
+        @api_client
       end
     end
-    alias_method :to_hash, :attributes
-
-    # Attempts to retrieve the Resource Schema from the API based on the name
-    # of the subclass.
-    class << self
-      def api_client( client = nil )
-        metaclass.instance_eval do
-          define_method :api do
-            block_given? ? yield : client
-          end
-        end
+
+    def self.namespace( namespace = nil )
+      if namespace
+        @namespace = namespace.to_s
+      elsif @namespace
+        @namespace
+      else
+        @namespace = self.to_s.demodulize.underscore
       end
+    end
 
-      def schema
-        if self.respond_to? :api
-          class_name = self.to_s.demodulize.underscore
-
-          if class_schema = api.description.resources.schema.send(class_name)
-            class_schema.properties
-          else
-            {}
-          end
-        else
-          raise MissingAPIReference,
-            "This Resource needs a class accessor defined as " \
-            "`.api` that references an instance of Frenetic."
-        end
+    def self.properties
+      (api.schema[namespace]||{})['properties'] or raise HypermediaError, %Q{Could not find schema definition for the resource "#{namespace}"}
+    end
+
+    def initialize( p = {} )
+      @params = (p || {}).with_indifferent_access
+      @attrs  = {}
+
+      properties.keys.each do |k|
+        @attrs[k] = @params[k]
       end
 
-      def apply_schema
-        schema.keys.each do |key|
-          next if key[0] == '_'
+      @structure = structure.new( *@attrs.values )
+    end
 
-          class_eval { attr_reader key.to_sym } unless instance_methods.include? key
-          class_eval { attr_writer key.to_sym } unless instance_methods.include? "#{key}="
+    def attributes
+      @attributes ||= begin
+        @structure.each_pair.each_with_object({}) do |(k,v), attrs|
+          attrs[k.to_s] = v
         end
       end
+    end
 
-      def metaclass
-        class << self; self; end
-      end
+    def __getobj__
+      @structure
     end
 
-    def build_associations( attributes )
-      return unless attributes['_embedded']
+    def __setobj__
+      @structure
+    end
 
-      namespace = self.class.to_s.deconstantize
+    def inspect
+      attrs = @structure.each_pair.collect do |k,v|
+        val = v.is_a?(String) ? "\"#{v}\"" : v || 'nil'
+        "#{k}=#{val}"
+      end.join(' ')
 
-      attributes['_embedded'].each do |key, value|
-        self.class.class_eval do
-          attr_reader key.to_sym
-        end
+      ivars = (instance_variables - [:@structure]).map do |k|
+        val = instance_variable_get k
+        val = val.is_a?(String) ? "\"#{val}\"" : val || 'nil'
 
-        assoc_class = "#{namespace}::#{key.classify}"
+        "#{k}=#{val}"
+      end.join(' ')
 
-        if assoc_class = (assoc_class.constantize rescue nil)
-          value = assoc_class.new value
-        end
+      "#<#{self.class}:0x#{"%x" % self.object_id}" \
+        " #{attrs}" \
+        " #{ivars}" \
+      ">"
+    end
 
-        instance_variable_set "@#{key}", value
-      end
+  private
+
+    def namespace
+      self.class.namespace
+    end
+
+    def properties
+      self.class.properties
     end
 
   end