restly 0.0.1.alpha.1

data/lib/restly/base/instance.rb

@@ -0,0 +1,76 @@
+module Restly::Base::Instance
+  extend ActiveSupport::Autoload
+  extend ActiveSupport::Concern
+  autoload :Actions
+  autoload :Attributes
+  autoload :Persistence
+
+  include Restly::Base::GenericMethods
+  include Actions
+  include Attributes
+  include Persistence
+
+  included do
+    attr_reader :init_options, :response
+    delegate :spec, to: :klass
+  end
+
+  def initialize(attributes = nil, options = {})
+
+    @init_options = options
+    @attributes = HashWithIndifferentAccess.new
+    @association_cache = {}
+    @aggregation_cache = {}
+    @attributes_cache = {}
+    @previously_changed = {}
+    @changed_attributes = {}
+
+    run_callbacks :initialize do
+
+      @readonly = options[:readonly] || false
+      set_response options[:response] if options[:response]
+      @loaded = options.has_key?(:loaded) ? options[:loaded] : true
+      self.attributes = attributes if attributes
+      self.connection = options[:connection] if options[:connection].is_a?(OAuth2::AccessToken)
+      self.path = if response && response.response.env[:url]
+                    response.response.env[:url].path.gsub(/\.\w+$/,'')
+                  elsif respond_to?(:id) && id
+                    [path, id].join('/')
+                  else
+                    klass.path
+                  end
+    end
+
+  end
+
+  def pry_in
+    binding.pry
+  end
+
+  def set_response(response)
+    raise Restly::Error::InvalidResponse unless response.is_a? OAuth2::Response
+    @response = response
+    if response.try(:body)
+      set_attributes_from_response
+      stub_associations_from_response
+    end
+  end
+
+  def connection
+    @connection || self.class.connection
+  end
+
+  def connection=(val)
+    @connection
+  end
+
+  # Todo: Needed?
+  def instance
+    self
+  end
+
+  def klass
+    self.class
+  end
+
+end

data/lib/restly/base/mass_assignment_security.rb

@@ -0,0 +1,19 @@
+module Restly::Base::MassAssignmentSecurity
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+
+    def attr_accessible(*args)
+      options = args.dup.extract_options!
+      if options[:from_spec]
+        before_initialize do
+          self._accessible_attributes = spec[:actions].map { |action| action['parameters'] }.flatten
+        end
+      else
+        super(*args)
+      end
+    end
+
+  end
+
+end

data/lib/restly/base/resource/finders.rb

@@ -0,0 +1,32 @@
+module Restly::Base::Resource::Finders
+
+  def find(*args)
+    options = args.extract_options!
+
+    #params[pagination_options[:params][:page]] = options[:page] if pagination
+    instance_from_response connection.get(path_with_format(args.first), params: params)
+  end
+
+  def all
+    collection_from_response connection.get(path_with_format, params: params)
+  end
+
+  def create(attributes = nil, options = {})
+    instance = self.new(attributes, options)
+    instance.save
+  end
+
+  private
+
+  def collection_from_response(response)
+    raise Restly::Error::InvalidResponse unless response.is_a? OAuth2::Response
+    Restly::Collection.new self, nil, response: response
+  end
+
+  def instance_from_response(response)
+    new(nil, response: response, connection: connection)
+  end
+
+  alias_method :from_response, :instance_from_response
+
+end

data/lib/restly/base/resource.rb

@@ -0,0 +1,19 @@
+module Restly::Base::Resource
+  extend ActiveSupport::Autoload
+  autoload :Finders
+
+  include Restly::Base::GenericMethods
+  include Finders
+
+  # OPTIONS FOR /:path
+  # Fetches the spec of a remote resource
+  def spec(path=self.path)
+    begin
+      parsed_response = authorize(client_token).connection.request(:options, path, params: params).parsed
+      (parsed_response || {}).with_indifferent_access
+    rescue OAuth2::Error
+      raise Restly::Error::InvalidSpec, "Unable to load the specification for #{self.class}"
+    end
+  end
+
+end

data/lib/restly/base/write_callbacks.rb

@@ -0,0 +1,37 @@
+module Restly::Base::WriteCallbacks
+  extend ActiveSupport::Concern
+
+  included do
+    before_save :format_request
+  end
+
+  private
+
+  def format_request
+    @request_body = case format.to_sym
+                      when :json
+                        savable_resource.to_json
+                      when :xml
+                        savable_resource.to_xml
+                      else
+                        savable_resource.to_param
+                    end
+  end
+
+  def savable_resource
+    {resource_name => attributes_with_present_values}
+  end
+
+  def attributes_with_present_values(attributes=self.attributes)
+    attributes.as_json.reduce({}) do |hash, (key, val)|
+      if val.is_a?(Hash)
+        hash[key] = attributes_with_present_values(val)
+      elsif val.present? && key.to_sym != :id
+        hash[key] = val
+      end
+      hash
+    end
+  end
+
+
+end

data/lib/restly/base.rb

@@ -0,0 +1,82 @@
+module Restly
+  class Base
+    # Autoload
+    extend ActiveSupport::Autoload
+    #autoload :Pagination # Todo!
+    autoload :Resource
+    autoload :Instance
+    autoload :Collection
+    autoload :GenericMethods
+    autoload :Includes
+    autoload :WriteCallbacks
+    autoload :MassAssignmentSecurity
+    autoload :Fields
+
+    # Thread Local Accessor
+    extend Restly::ThreadLocal
+
+    # Active Model
+    extend  ActiveModel::Naming
+    extend  ActiveModel::Callbacks
+    extend  ActiveModel::Translation
+    extend  ActiveModel::Callbacks
+    include ActiveModel::MassAssignmentSecurity
+    include ActiveModel::Conversion
+    include ActiveModel::Dirty
+    include ActiveModel::Observing
+    include ActiveModel::Validations
+    include ActiveModel::Serialization
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Serializers::Xml
+
+    # Set Up Callbacks
+    define_model_callbacks :create, :save, :delete, :update, :initialize
+
+    # Actions & Callbacks
+    extend  Resource
+    include Includes
+    include Instance
+    include Fields
+    include MassAssignmentSecurity
+    include WriteCallbacks
+
+    # Relationships
+    include Restly::Associations
+
+    # Set up the Attributes
+    thread_local_accessor :current_token
+    class_attribute :resource_name,
+                    :path,
+                    :include_root_in_json,
+                    :params,
+                    :cache,
+                    :cache_options,
+                    :client_token
+
+    self.include_root_in_json =   Restly::Configuration.include_root_in_json
+    self.cache                =   Restly::Configuration.cache
+    self.cache_options        =   Restly::Configuration.cache_options
+    self.params               =   {}
+    self.current_token        =   {}
+    self.client_token         =   client.client_credentials.get_token rescue nil
+
+    # Set Defaults on Inheritance
+    inherited do
+      field :id
+      self.resource_name          = name.gsub(/.*::/,'').underscore
+      self.path                   = resource_name.pluralize
+      self.params                 = params.dup
+    end
+
+    # Run Active Support Load Hooks
+    ActiveSupport.run_load_hooks(:restly, self)
+
+    delegate :client, to: :klass
+
+    # Alias the class for delegation
+    def klass
+      self.class
+    end
+
+  end
+end

data/lib/restly/client.rb

@@ -0,0 +1,34 @@
+class Restly::Client < OAuth2::Client
+
+  attr_accessor :id, :secret, :site
+  attr_reader :format
+
+  def initialize(*args, &block)
+    opts = args.extract_options!
+    self.id =     args[0] || Restly::Configuration.client_id
+    self.secret = args[1] || Restly::Configuration.client_secret
+    self.site = opts.delete(:site) || Restly::Configuration.site
+    self.options = Restly::Configuration.client_options.merge(opts)
+    self.ssl = opts.delete(:ssl) || Restly::Configuration.ssl
+    self.format = @format = opts.delete(:format) || Restly::Configuration.default_format
+    self.options[:connection_build] = block
+  end
+
+  def ssl=(val)
+    self.options[:connection_opts][:ssl] = val if val
+  end
+
+  def format=(val)
+    self.options[:connection_opts][:headers] = {
+        "Accept" => "application/#{format}",
+        "Content-Type" => "application/#{format}"
+    }
+  end
+
+  Restly::Configuration.client_options.keys.each do |m|
+    define_method "#{m}=" do |val|
+      self.options[m] = val
+    end
+  end
+
+end

data/lib/restly/collection/pagination.rb

@@ -0,0 +1,36 @@
+module Restly::Base::Collection::Pagination
+
+  def page(num)
+    with_params(page: num, per_page: per_page).all.paginate(page: num, per_page: per_page)
+  end
+
+  def current_page
+    pagination[:current_page] || pagination[:page]
+  end
+
+  def per_page
+    @pagination_opts[:per_page] || pagination[:per_page]
+  end
+
+  def response_per_page
+    pagination[:per_page]
+  end
+
+  def total_pages
+    pagination[:total_pages]
+  end
+
+  def total_entries
+    pagination[:total_entries]
+  end
+
+  private
+
+  def pagination
+    parsed = @response.parsed || {}
+    pagination = parsed[:pagination] || parsed
+    pagination.select!{ |k,v| /page|current_page|entries|total_entries|per_page|total_pages|total/ =~ k.to_s }
+    pagination.with_indifferent_access
+  end
+
+end

data/lib/restly/collection.rb

@@ -0,0 +1,47 @@
+class Restly::Collection < Array
+  extend ActiveSupport::Autoload
+
+  delegate :resource_name, :connection, to: :resource
+
+  autoload :Pagination
+
+  attr_reader :resource
+
+  def initialize(resource, array, opts={})
+    @resource = resource
+    @response = opts[:response]
+    array = items_from_response if @response.is_a?(OAuth2::Response)
+    super(array)
+  end
+
+  def paginate(opts={})
+    @pagination_opts = opts
+    collection = self.dup
+    collection.extend(Restly::Collection::Pagination)
+    return page(opts[:page]) unless opts[:page] == current_page && opts[:per_page] == response_per_page
+    collection
+  end
+
+  def <<(instance)
+    raise Restly::Error::InvalidObject, "Object is not an instance of #{resource}" unless instance.is_a?(resource)
+    super(instance)
+  end
+
+  def serializable_hash(options = nil)
+    self.collect do |i|
+      i.serializable_hash(options)
+    end
+  end
+
+  private
+
+  def items_from_response
+    parsed = @response.parsed || {}
+    parsed = parsed[resource_name.pluralize] if parsed.is_a?(Hash) && parsed[resource_name.pluralize]
+    parsed.collect do |instance|
+      instance = instance[resource_name] if instance[resource_name]
+      resource.new(instance, connection: connection)
+    end
+  end
+
+end

data/lib/restly/configuration.rb

@@ -0,0 +1,43 @@
+module Restly::Configuration
+
+  def self.config
+    defaults = {
+      session_key: :access_token,
+      load_middleware: true,
+      :authorize_url    => '/oauth/authorize',
+      :token_url        => '/oauth/token',
+      :token_method     => :post,
+      :connection_opts  => {},
+      :max_redirects    => 5,
+      :raise_errors     => true
+    }
+    defaults.merge(@config || {})
+  end
+
+  def self.client_options
+    config.select do |k,v|
+      [ :authorize_url,
+        :token_url,
+        :token_method,
+        :connection_opts,
+        :max_redirects,
+        :raise_errors
+      ].include?(k.to_sym)
+    end
+  end
+
+  def self.load_config(hash)
+    @config = hash
+  end
+
+  def self.method_missing(m, *args, &block)
+    config.with_indifferent_access[m]
+  end
+
+  def respond_to_missing?
+    true
+  end
+
+  load_config YAML.load_file(File.join(Rails.root, 'config', 'restly.yml'))[Rails.env] if defined? Rails
+
+end

data/lib/restly/connection.rb

@@ -0,0 +1,99 @@
+class Restly::Connection < OAuth2::AccessToken
+
+  attr_accessor :cache, :cache_options
+
+  # TODO: Refactor with subclasses that have their own tokenize methods.
+  def self.tokenize(client, object)
+
+    if object.is_a?(Hash)
+      from_hash(client, object)
+
+    elsif object.is_a?(Rack::Request)
+      from_rack_request(client, object)
+
+    elsif object.is_a?(OAuth2::AccessToken)
+      from_token_object(client, object)
+
+    elsif object.is_a?(Restly::Middleware)
+
+      /(?<token>\w+)$/i =~ object.env['HTTP_AUTHORIZATION']
+      return from_rack_request(client, object) if token
+      token_hash = object.env['rack.session'][Restly::Configuration.session_key] || {}
+      from_hash(client, token_hash)
+
+    else
+      new(client, nil)
+
+    end
+
+  end
+
+  def initialize(client, token, opts={})
+    self.cache_options = opts[:cache_options] || {}
+    self.cache = opts[:cache]
+    super
+  end
+
+  def self.from_hash(client, token_hash)
+    super(client, token_hash.dup)
+  end
+
+  def self.from_rack_request(client, rack_request)
+    /(?<token>\w+)$/i =~ rack_request.env['HTTP_AUTHORIZATION']
+    from_hash(client, { access_token: token })
+  end
+
+  def self.from_token_object(client, token_object)
+    from_hash(client, {
+      access_token:   token_object.token,
+      refresh_token:  token_object.refresh_token,
+      expires_at:     token_object.expires_at
+    })
+  end
+
+  def to_hash
+    {
+      access_token: token,
+      refresh_token: refresh_token,
+      expires_at: expires_at
+    }
+  end
+
+  alias_method :forced_request, :request
+
+  def request(verb, path, opts={}, &block)
+    if cache && !opts[:force]
+      cached_request(verb, path, opts, &block)
+    else
+      forced_request(verb, path, opts, &block)
+    end
+  end
+
+  private
+
+  def cached_request(verb, path, opts={}, &block)
+    options_hash = { verb: verb, token: token, opts: opts, block: block }
+    options_packed = [Marshal.dump(options_hash)].pack('m')
+    options_hex = Digest::MD5.hexdigest(options_packed)
+    cache_key = [path.parameterize, options_hex].join('_')
+
+    # Force a cache miss for all methods except get
+    cache_options[:force] = true unless [:get, :options].include?(verb)
+
+    # Set the response
+    response = Rails.cache.fetch cache_key, cache_options.symbolize_keys do
+
+      Rails.cache.delete_matched("#{path.parameterize}*") if ![:get, :options].include?(verb)
+      opts.merge!({force: true})
+      request(verb, path, opts, &block)
+
+    end
+
+    # Clear the cache if there is an error
+    Rails.cache.delete(cache_key) and puts "deleted cache for: #{verb} #{path}" if response.error
+
+    # Return the response
+    response
+
+  end
+end

data/lib/restly/controller_methods.rb

@@ -0,0 +1,16 @@
+module Restly::ControllerMethods
+  extend ActiveSupport::Concern
+
+  included do
+
+    def auth_token
+      @oauth_token ||= session[Restly::Configuration.session_key].try(:dup) || {}
+    end
+
+    def auth_token=(token_object)
+      session[Restly::Configuration.session_key] = Restly::Connection.tokenize(Restly::Base.client, token_object).to_hash
+    end
+
+  end
+
+end

data/lib/restly/error.rb

@@ -0,0 +1,30 @@
+module Restly::Error
+
+  class NotAnRestly < StandardError
+  end
+
+  class RecordNotFound < StandardError
+  end
+
+  class WrongResourceType < StandardError
+  end
+
+  class InvalidParentAssociation < StandardError
+  end
+
+  class InvalidJoinerAssociation < StandardError
+  end
+
+  class InvalidObject < StandardError
+  end
+
+  class InvalidToken < StandardError
+  end
+
+  class InvalidConnection < StandardError
+  end
+
+  class InvalidSpec < StandardError
+  end
+
+end

data/lib/restly/middleware.rb

@@ -0,0 +1,15 @@
+class Restly::Middleware
+
+  attr_reader :app, :env
+
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    @env = env
+    Restly::Base.current_token = Restly::Connection.tokenize(Restly::Base.client, self).to_hash
+    self.app.call(self.env)
+  end
+
+end

data/lib/restly/nested_attributes.rb

@@ -0,0 +1,97 @@
+module Restly::NestedAttributes
+
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :resource_nested_attributes_options, :instance_writer => false
+    self.resource_nested_attributes_options = {}
+
+    inherited do
+      self.resource_nested_attributes_options = resource_nested_attributes_options.dup
+    end
+
+  end
+
+  # One To One Association
+  def assign_nested_attributes_for_one_to_one_resource_association(association_name, attributes, assignment_opts = {})
+    options = self.nested_attributes_options[association_name]
+    association_attributes = attributes.delete("#{association_name}_attributes") || {}
+    associated_instance = send(association_name) || self.class.reflect_on_resource_association(association_name).build
+    associated_instance.attributes = association_attributes
+  end
+
+  # Collection Association
+  def assign_nested_attributes_for_collection_resource_association(association_name, attributes_collection, assignment_opts = {})
+
+    unless attributes_collection.is_a?(Hash) || attributes_collection.is_a?(Array)
+      raise ArgumentError, "Hash or Array expected, got #{attributes_collection.class.name} (#{attributes_collection.inspect})"
+    end
+
+    if attributes_collection.is_a? Hash
+      keys = attributes_collection.keys
+      attributes_collection = if keys.include?('id') || keys.include?(:id)
+                                Array.wrap(attributes_collection)
+                              else
+                                attributes_collection.values
+                              end
+    end
+
+    association = self.class.reflect_on_resource_association(association_name)
+    existing_records = send(association_name)
+
+    attributes_collection.each do |attributes|
+      attributes = attributes.with_indifferent_access
+      if attributes[:id].blank?
+        send(association_name) << association.build(attributes.except(:id))
+      elsif existing_record = existing_records.find{ |record| record.id.to_s == attributes['id'].to_s }
+        existing_record.attributes = attributes
+      end
+    end
+
+  end
+
+  def set_nested_attributes_for_save
+    @attributes = @attributes.inject(HashWithIndifferentAccess.new) do |hash, (k, v)|
+      k = [resource_nested_attributes_options[k.to_sym][:write_prefix], k, resource_nested_attributes_options[k.to_sym][:write_suffix]].compact.join('_') if resource_nested_attributes_options[k.to_sym].present?
+      hash[k] = v
+      hash
+    end
+  end
+
+  module ClassMethods
+    REJECT_ALL_BLANK_PROC = proc { |attributes| attributes.all? { |key, value| key == '_destroy' || value.blank? } }
+
+    def accepts_nested_attributes_for_resource(*attr_names)
+      options = { :allow_destroy => false, :update_only => false, :write_prefix => nil, :write_suffix => 'attributes' }
+      options.update(attr_names.extract_options!)
+      options.assert_valid_keys(:allow_destroy, :reject_if, :limit, :update_only, :write_prefix, :write_suffix)
+      options[:reject_if] = REJECT_ALL_BLANK_PROC if options[:reject_if] == :all_blank
+
+      before_save :set_nested_attributes_for_save
+
+      attr_names.each do |association_name|
+        if reflection = reflect_on_resource_association(association_name)
+          reflection.options[:autosave] = true
+
+          resource_nested_attributes_options = self.resource_nested_attributes_options.dup
+          resource_nested_attributes_options[association_name.to_sym] = options
+          self.resource_nested_attributes_options = resource_nested_attributes_options
+
+          type = (reflection.collection? ? :collection : :one_to_one)
+
+          if method_defined?("#{association_name}_attributes=")
+              remove_method("#{association_name}_attributes=")
+          end
+
+          define_method "#{association_name}_attributes=" do |attributes|
+            send("assign_nested_attributes_for_#{type}_resource_association", association_name.to_sym, attributes, mass_assignment_options)
+          end
+
+        else
+          raise ArgumentError, "No association found for name `#{association_name}'. Has it been defined yet?"
+        end
+      end
+    end
+  end
+
+end