logical_model 0.4.10 → 0.5.0

data/README.rdoc

@@ -1,6 +1,6 @@
 = logical_model
 
-LogicalModel allows to use a restfull resources as models.
+LogicalModel allows to use a RESTfull resources as models.
 
 It was written following this tutorial: http://www.slideshare.net/ihower/serviceoriented-design-and-implement-with-rails3
 
@@ -51,6 +51,21 @@ In your Gemfile:
 
     gem "logical_model"
 
+In a model file:
+
+    class RemoteResource < LogicalModel
+
+      set_resource_host "remote.server"
+      set_resource_path "/api/remote/path"
+      # equivalente: set_resource_url "remote.server", "/api/path"
+
+      attribute :id
+      attribute :attribute_a
+      attribute :attribute_b
+
+      validates_presence_of :id
+    end
+
 == Testing
 
 To run spec:
@@ -70,7 +85,7 @@ To run spec:
 
 == Copyright
 
-Copyright (c) 2011,2012 Dwayne Macgowan. See LICENSE.txt for
+Copyright (c) 2011,2012,2013 Dwayne Macgowan. See LICENSE.txt for
 further details.
 
 === TODO

data/VERSION

@@ -1 +1 @@
-0.4.10
+0.5.0

data/client.rb

@@ -10,13 +10,19 @@ class User < LogicalModel
   self.hydra = Typhoeus::Hydra.new
   self.use_ssl = false #(Rails.env=="production")
 
-  self.resource_path = "/api/v1/users"
-  self.attribute_keys = [:id, :name, :email, :password, :bio]
+  set_resource_url("localhost:3000","/api/v1/users")
+
+  attribute :id
+  attribute :name
+  attribute :email
+  attribute :password
+  attribute :bio
+
   self.use_api_key = false
   #self.api_key_name = "token"
   #self.api_key = "8c330b5d70f86ebfa6497c901b299b79afc6d68c60df6df0bda0180d3777eb4a5528924ac96cf58a25e599b4110da3c4b690fa29263714ec6604b6cb2d943656"
-  self.host  = "localhost:3000"
-  self.log_path = "logs/development.log" 
+
+  self.log_path = "logs/development.log"
   
   TIMEOUT = 5500 # miliseconds
   PER_PAGE = 9999

data/lib/logical_model.rb

@@ -2,11 +2,14 @@ require 'timeout'
 require 'active_model'
 require 'typhoeus'
 require 'active_support/all' # todo migrate to yajl
-require 'logger'
 require 'kaminari'
-require 'ssl_support'
-require 'safe_log'
+
+require 'logical_model/rest_actions'
+require 'logical_model/url_helper'
+require 'logical_model/safe_log'
 require 'logical_model/has_many_keys'
+require 'logical_model/api_key'
+require 'logical_model/attributes'
 
 # Logical Model, not persistant on DB, works through API. (replaces ActiveResource)
 #
@@ -26,9 +29,11 @@ require 'logical_model/has_many_keys'
 #
 # Usage:
 #  class RemoteResource < LogicalModel
-#    self.host = "http://remote.server"
-#    self.resource_path = "/api/remote/path"
-#    self.attribute_keys = [:id, :attribute_a, :attribute_b]
+#    set_resource_url "remote.server", "/api/remote/path"
+#
+#    attribute :id
+#    attribute :attribute_a
+#    attribute :attribute_b
 #
 #    validates_presence_of :id
 #  end
@@ -44,10 +49,12 @@ require 'logical_model/has_many_keys'
 #  RemoteResource#destroy
 class LogicalModel
 
-  include SslSupport
-  extend SafeLog
-
-  extend LogicalModel::HasManyKeys
+  include LogicalModel::Attributes
+  include LogicalModel::RESTActions
+  include LogicalModel::UrlHelper
+  include LogicalModel::ApiKey
+  include LogicalModel::SafeLog
+  include LogicalModel::HasManyKeys
 
   # include ActiveModel Modules that are usefull
   extend ActiveModel::Naming
@@ -61,32 +68,21 @@ class LogicalModel
 
   self.include_root_in_json = false
 
-  # TODO clean this file refactoring into modules
-
   attr_accessor :last_response_code
 
-  def self.attribute_keys=(keys)
-    @attribute_keys = keys
-    attr_accessor *keys
-  end
-
-  def self.attribute_keys
-    @attribute_keys
-  end
-
   DEFAULT_TIMEOUT = 10000
   DEFAULT_RETRIES = 3
 
+  def initialize(attributes={})
+    self.attributes = attributes
+  end
+
   class << self
-    attr_accessor :host, :resource_path, :api_key, :api_key_name,
-                  :timeout, :retries,
-                  :use_api_key, :enable_delete_multiple,
-                  :json_root, :log_path
+    attr_accessor :timeout, :retries,
+                  :json_root
 
     def timeout; @timeout ||= DEFAULT_TIMEOUT; end
     def retries; @retries ||= DEFAULT_RETRIES; end
-    def log_path; @log_path ||= "log/logical_model.log"; end
-    def use_api_key; @use_api_key ||= false; end
     def delete_multiple_enabled?; @enable_delete_multiple ||= false; end
 
     def hydra
@@ -117,464 +113,10 @@ class LogicalModel
     @json_root ||= self.class.to_s.underscore
   end
 
-  def self.resource_uri(id=nil)
-    sufix  = (id.nil?)? "" : "/#{id}"
-    "#{url_protocol_prefix}#{host}#{resource_path}#{sufix}"
-  end
-
-  def initialize(attributes={})
-    self.attributes = attributes
-  end
-
-  def attributes
-    attrs = self.class.attribute_keys.inject(ActiveSupport::HashWithIndifferentAccess.new) do |result,key|
-      result[key] = read_attribute_for_validation(key)
-      result
-    end
-
-    unless self.class.has_many_keys.blank?
-      self.class.has_many_keys.inject(attrs) do |result,key|
-        result["#{key}_attributes"] = send(key).map {|a| a.attributes}
-        result
-      end
-    end
-    attrs.reject {|key, value| key == "_id" && value.blank?}
-  end
-
-  def attributes=(attrs)
-    sanitize_for_mass_assignment(attrs).each{|k,v| send("#{k}=",v) if respond_to?("#{k}=")}
-  end
-
-
-  def self.from_json(json_string)
-    parsed = ActiveSupport::JSON.decode(json_string)
-    collection = parsed["collection"].map{|i|self.new(i)}
-    return { :collection => collection, :total => parsed["total"].to_i }
-  end
-
-  def self.log_ok(response)
-    self.logger.info("LogicalModel Log: #{response.code} #{mask_api_key(response.effective_url)} in #{response.time}s")
-    self.logger.debug("LogicalModel Log RESPONSE: #{response.body}")
-  end
-
-  def log_ok(response)
-    self.class.log_ok(response)
-  end
-
-  def self.log_failed(response)
-    begin
-      error_message = ActiveSupport::JSON.decode(response.body)["message"]
-    rescue => e
-      error_message = "error"
-    end
-    msg = "LogicalModel Log: #{response.code} #{mask_api_key(response.effective_url)} in #{response.time}s FAILED: #{error_message}"
-    self.logger.warn(msg)
-    self.logger.debug("LogicalModel Log RESPONSE: #{response.body}")
-  end
-
-  def log_failed(response)
-    self.class.log_failed(response)
-  end
-
-  def self.logger
-    Logger.new(self.log_path || "log/logical_model.log")
-  end
-
-  # if needed willmerge api_key into given hash
-  # returns merged hash
-  def self.merge_key(params = {})
-    if self.use_api_key
-      params.merge({self.api_key_name => self.api_key})
-    else
-      params
-    end
-  end
-
-  def create(params={})
-    run_callbacks :save do
-      run_callbacks :create do
-        _create(params)
-      end
-    end
-  end
-
-  # @param params [Hash] parameters to be sent to service
-  def update(params)
-    run_callbacks :save do
-      run_callbacks :update do
-        _update(params)
-      end
-    end
-
-  end
-
-  def save
-    run_callbacks :save do
-      run_callbacks new_record?? :create : :update do
-        _save
-      end
-    end
-  end
-
-  def destroy(params={})
-    run_callbacks :destroy do
-      _destroy(params)
-    end
-  end
-
-  #  ============================================================================================================
-  #  Following methods are API specific.
-  #  They assume we are using a RESTfull API.
-  #  for get, put, delete :id is expected
-  #  for post, put attributes are excepted under class_name directly. eg. put( {:id => 1, :class_name => {:attr => "new value for attr"}} )
-  #
-  #  On error (400) a "errors" is expected.
-  #  ============================================================================================================
-
-  # Asynchronic Pagination
-  #  This pagination won't block excecution waiting for result, pagination will be enqueued in Objectr#hydra.
-  #
-  # Parameters:
-  #   @param options [Hash].
-  #   Valid options are:
-  #   * :page - indicated what page to return. Defaults to 1.
-  #   * :per_page - indicates how many records to be returned per page. Defauls to 20
-  #   * all other options will be sent in :params to WebService
-  #
-  # Usage:
-  #   Person.async_paginate(:page => params[:page]){|i| result = i}
-  def self.async_paginate(options={})
-    options[:page] ||= 1
-    options[:per_page] ||= 20
-
-    options = self.merge_key(options)
-
-    request = Typhoeus::Request.new(resource_uri, :params => options)
-    request.on_complete do |response|
-      if response.code >= 200 && response.code < 400
-        log_ok(response)
-
-        result_set = self.from_json(response.body)
-
-        # this paginate is will_paginate's Array pagination
-        collection = Kaminari.paginate_array(
-                                             result_set[:collection],
-                                             {
-                                               :total_count=>result_set[:total],
-                                               :limit => options[:per_page],
-                                               :offset => options[:per_page] * ([options[:page], 1].max - 1)
-                                             }
-                                            )
-
-        yield collection
-      else
-        log_failed(response)
-      end
-    end
-    self.hydra.queue(request)
-  end
-
-  #synchronic pagination
-  def self.paginate(options={})
-    result = nil
-    self.retries.times do
-      begin
-        async_paginate(options){|i| result = i}
-        Timeout::timeout(self.timeout/1000) do
-          self.hydra.run
-        end
-        break unless result.nil?
-      rescue Timeout::Error
-        self.logger.warn("timeout")
-        result = nil
-      end
-    end
-    result
-  end
-
-  # Asynchronic Count
-  #  This count won't block excecution waiting for result, count will be enqueued in Objectr#hydra.
-  #
-  # Parameters:
-  #   @param options [Hash].
-  #   Valid options are:
-  #   @option options [Integer] :page - indicated what page to return. Defaults to 1.
-  #   @option options [Integer] :per_page - indicates how many records to be returned per page. Defauls to 20
-  #   @option options [Hash] all other options will be forwarded in :params to WebService
-  #
-  # @example 'Count bobs'
-  #   Person.async_count(:when => {:name => 'bob'}}){|i| result = i}
-  def self.async_count(options={})
-    options[:page] = 1
-    options[:per_page] = 1
-
-    options = self.merge_key(options)
-
-    request = Typhoeus::Request.new(resource_uri, :params => options)
-    request.on_complete do |response|
-      if response.code >= 200 && response.code < 400
-        log_ok(response)
-
-        result_set = self.from_json(response.body)
-
-        yield result_set[:total]
-      else
-        log_failed(response)
-      end
-    end
-    self.hydra.queue(request)
-  end
-
-  # synchronic count
-  def self.count(options={})
-    result = nil
-    async_count(options){|i| result = i}
-    Timeout::timeout(self.timeout/1000) do
-      self.hydra.run
-    end
-    result
-  rescue Timeout::Error
-    self.logger.warn("timeout")
-    return nil
-  end
-
-  # Asynchronic Find
-  #  This find won't block excecution waiting for result, excecution will be enqueued in Objectr#hydra.
-  #
-  # Parameters:
-  #   - id, id of object to find
-  # @param [String/Integer] id
-  # @param [Hash] params
-  #
-  # Usage:
-  #   Person.async_find(params[:id])
-  def self.async_find(id, params = {})
-    params = self.merge_key(params)
-    request = Typhoeus::Request.new( resource_uri(id), :params => params )
-
-    request.on_complete do |response|
-      if response.code >= 200 && response.code < 400
-        log_ok(response)
-        yield self.new.from_json(response.body) # this from_json is defined in ActiveModel::Serializers::JSON
-      else
-        log_failed(response)
-      end
-    end
-
-    self.hydra.queue(request)
-  end
-
-  # synchronic find
-  def self.find(id, params = {})
-    result = nil
-    async_find(id, params){|i| result = i}
-    Timeout::timeout(self.timeout/1000) do
-      self.hydra.run
-    end
-    result
-  rescue Timeout::Error
-    self.logger.warn("timeout")
-    return nil
-  end
-
-  #
-  # creates model.
-  #
-  # returns:
-  # @return false if model invalid
-  # @return nil if there was a connection problem
-  # @return created model ID if successfull
-  #
-  # @example Usage:
-  #   @person = Person.new(params[:person])
-  #   @person.create( non_attribute_param: "value" )
-  def _create(params = {})
-    return false unless valid?
-
-    params = { self.json_root => self.attributes }.merge(params)
-    params = self.class.merge_key(params)
-
-    response = nil
-    Timeout::timeout(self.class.timeout/1000) do
-      response = Typhoeus::Request.post( self.class.resource_uri, :body => params, :timeout => self.class.timeout )
-    end
-    self.last_response_code = response.code
-    if response.code == 201 || response.code == 202
-      log_ok(response)
-      if self.respond_to?('id=')
-        self.id = ActiveSupport::JSON.decode(response.body)["id"]
-			else
-				true
-      end
-    elsif response.code == 400
-      log_failed(response)
-      ws_errors = ActiveSupport::JSON.decode(response.body)["errors"]
-      ws_errors.each_key do |k|
-        self.errors.add k, ws_errors[k]
-      end
-      return false
-    else
-      log_failed(response)
-      return nil
-    end
-  rescue Timeout::Error
-    self.class.logger.warn "timeout"
-    return nil
-  end
-
-  # Updates Objects attributes, this will only send attributes passed as arguments
-  #
-  #
-  # Returns false if Object#valid? is false.
-  # Returns updated object if successfull.
-  # Returns nil if update failed
-  #
-  # Usage:
-  #   @person.update(params[:person])
-  def _update(params)
-
-    self.attributes = params[self.json_root]
-
-    return false unless valid?
-
-    params = self.class.merge_key(params)
-
-    response = nil
-    Timeout::timeout(self.class.timeout/1000) do
-      response = Typhoeus::Request.put( self.class.resource_uri(id),
-                                        :params => params,
-                                        :timeout => self.class.timeout )
-    end
-
-    if response.code == 200
-      log_ok(response)
-      return self
-    else
-      log_failed(response)
-      return nil
-    end
-
-  rescue Timeout::Error
-    self.class.logger.warn("request timed out")
-    return nil
-  end
-
-  # Saves Objects attributes
-  #
-  #
-  # Returns false if Object#valid? is false.
-  # Returns updated object if successfull.
-  # Returns nil if update failed
-  #
-  # Usage:
-  #   @person.save
-  def _save
-    self.attributes = attributes
-
-    return false unless valid?
-
-    sending_params = self.attributes
-    sending_params.delete(:id)
-
-    params = { self.json_root => sending_params }
-    params = self.class.merge_key(params)
-    response = nil
-    Timeout::timeout(self.class.timeout/1000) do
-      response = Typhoeus::Request.put( self.class.resource_uri(id), :params => params, :timeout => self.class.timeout )
-    end
-    if response.code == 200
-      log_ok(response)
-      return self
-    else
-      log_failed(response)
-      return nil
-    end
-  rescue Timeout::Error
-    self.class.logger.warn "timeout"
-    return nil
-  end
-
-  # Deletes Object#id
-  #
-  # Returns nil if delete failed
-  #
-  # @param [String] id - id of contact to be deleted
-  # @param [Hash] params - other params to be sent to WS on request
-  #
-  # Usage:
-  #   Person.delete(params[:id])
-  def self.delete(id, params={})
-
-    params = self.merge_key(params)
-
-    response = nil
-    Timeout::timeout(self.timeout/1000) do
-      response = Typhoeus::Request.delete( self.resource_uri(id),
-                                         :params => params,
-                                         :timeout => self.timeout
-                                       )
-    end
-    if response.code == 200
-      log_ok(response)
-      return self
-    else
-      log_failed(response)
-      return nil
-    end
-  rescue Timeout::Error
-    self.logger.warn "timeout"
-    return nil
-  end
-
-  # Destroy object
-  #
-  # Usage:
-  #   @person.destroy
-  def _destroy(params={})
-    self.class.delete(self.id,params)
-  end
-
-  # Deletes all Objects matching given ids
-  #
-  # This method will make a DELETE request to resource_uri/destroy_multiple
-  #
-  # Returns nil if delete failed
-  #
-  # @param [Array] ids - ids of contacts to be deleted
-  # @param [Hash] params - other params to be sent to WS on request
-  #
-  # Usage:
-  #   Person.delete_multiple([1,2,4,5,6])
-  def self.delete_multiple(ids, params={})
-    raise "not-enabled" unless self.delete_multiple_enabled?
-
-    params = self.merge_key(params)
-    params = params.merge({:ids => ids})
-
-    response = nil
-    Timeout::timeout(self.timeout/1000) do
-      response = Typhoeus::Request.delete( self.resource_uri+"/destroy_multiple",
-                                           :params => params,
-                                           :timeout => self.timeout
-      )
-    end
-    if response.code == 200
-      log_ok(response)
-      return self
-    else
-      log_failed(response)
-      return nil
-    end
-  rescue Timeout::Error
-    self.logger.warn "timeout"
-    return nil
-  end
-
   def persisted?
     false
   end
 
-
   # Returns true if a record has not been persisted yet.
   #
   # Usage: