restly 0.0.1.alpha.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.idea/
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in restly.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Jason Waldrip
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Restly
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'restly'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install restly
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/restly/associations/base.rb

@@ -0,0 +1,35 @@
+class Restly::Associations::Base
+
+  attr_reader :name, :association_class, :namespace, :polymorphic, :options
+
+  def initialize(owner, name, options={})
+    @name = name
+    @namespace = options.delete(:namespace) || owner.name.gsub(/::\w+$/, '')
+    @polymorphic = options.delete(:polymorphic)
+    options[:class_name] ||= name.to_s.classify
+    @owner = owner
+    @association_class = [@namespace, options.delete(:class_name)].compact.join('::').constantize
+    @options = options
+  end
+
+  def collection?
+    false
+  end
+
+  def build(*args)
+    new_instance = @association_class.new(*args)
+    new_instance.write_attribute("#{@owner.resource_name}_id") if @association_class.respond_to?("#{@owner.resource_name}_id") && !self.class.send(:reflect_on_resource_association, :custom_pages).embedded?
+    new_instance
+  end
+
+  private
+
+  def authorize(klass, authorization = nil)
+    if (!klass.authorized? && @owner.respond_to?(:authorized?) && @owner.authorized?) || authorization
+      klass.authorize(authorization || @owner.connection)
+    else
+      klass
+    end
+  end
+
+end

data/lib/restly/associations/belongs_to.rb

@@ -0,0 +1,15 @@
+class Restly::Associations::BelongsTo < Restly::Associations::Base
+
+  def find_with_parent(parent, options)
+    options.reverse_merge!(self.options)
+    association_class = polymorphic ? [@namespace, instance.send("#{name}_type")] : self.association_class
+    association_class = authorize(association_class, options[:authorize])
+    instance = association_class.find(parent.attributes["#{name}_id"])
+    Restly::Proxies::Associations::Instance.new(instance, parent)
+  end
+
+  def collection?
+    false
+  end
+
+end

data/lib/restly/associations/builder.rb

@@ -0,0 +1,30 @@
+module Restly::Associations::Builder
+
+  def build(relationship, opts)
+
+    # Base Model
+    model = opts[:class_name] || relationship.to_s.singularize.camelize
+
+    # Namespace
+    namespace = opts[:namespace] || self.class.name.gsub(/::\w+$/, '')
+    model = [namespace, model].compact.join('::')
+
+    # Polymorphic Relationships
+    if opts[:polymorphic]
+      polymorphic_type = send(:"#{resource}_type")
+      model = [namespace, polymorphic_type].compact.join('::')
+    end
+
+    # Constantize
+    model = model.constantize
+
+    # Auto-authorization, fail with error!
+    if (!model.authorized? && self.respond_to?(:authorized?) && self.authorized?) || (opts[:authorize])
+      model.authorize(opts[:authorize] || self.connection)
+    else
+      model
+    end
+
+  end
+
+end

data/lib/restly/associations/embeddable_resources/embeds_many.rb

@@ -0,0 +1,7 @@
+class Restly::Associations::EmbeddableResources::EmbedsMany < Restly::Associations::Base
+
+  def collection?
+    true
+  end
+
+end

data/lib/restly/associations/embeddable_resources/embeds_one.rb

@@ -0,0 +1,7 @@
+class Restly::Associations::EmbeddableResources::EmbedsOne < Restly::Associations::Base
+
+  def collection?
+    false
+  end
+
+end

data/lib/restly/associations/embeddable_resources.rb

@@ -0,0 +1,28 @@
+module Restly::Associations::EmbeddableResources
+  extend ActiveSupport::Autoload
+
+  autoload :EmbeddedIn
+  autoload :EmbedsMany
+  autoload :EmbedsOne
+
+  # Embeds One
+  def embeds_resource(name, options = {})
+    exclude_field(name) if ancestors.include?(Restly::Base)
+    self.resource_associations[name] = association = EmbedsOne.new(self, name, options)
+
+    define_method name do
+      association.build(attributes[name])
+    end
+  end
+
+  # Embeds Many
+  def embeds_resources(name, options = {})
+    exclude_field(name) if ancestors.include?(Restly::Base)
+    self.resource_associations[name] = association = EmbedsMany.new(self, name, options)
+
+    define_method name do
+      ( self.attributes[name] || [] ).map!{ |i| association.build(i) }
+    end
+  end
+
+end

data/lib/restly/associations/has_many.rb

@@ -0,0 +1,23 @@
+class Restly::Associations::HasMany < Restly::Associations::Base
+
+  attr_reader :joiner
+
+  def initialize(owner, name, options={})
+    @joiner = options.delete(:through)
+    super
+  end
+
+  def scope_with_parent(parent, options)
+    options.reverse_merge!(self.options)
+    association_class = polymorphic ? [@namespace, instance.send("#{name}_type")] : self.association_class
+    association_class = authorize(association_class, options[:authorize])
+    collection = association_class.with_params("with_#{parent.resource_name}_id" => parent.id).all # (parent.attributes["#{name}_id"])
+    collection.select{|i| i.attributes["#{parent.resource_name}_id"] == parent.id }
+    Restly::Proxies::Associations::Collection.new(collection, parent)
+  end
+
+  def collection?
+    true
+  end
+
+end

data/lib/restly/associations/has_one.rb

@@ -0,0 +1,23 @@
+class Restly::Associations::HasOne < Restly::Associations::Base
+
+  attr_reader :joiner
+
+  def initialize(owner, name, options={})
+    @joiner = options.delete(:through)
+    super
+  end
+
+  def scope_with_parent(parent, options)
+    options.reverse_merge!(self.options)
+    association_class = polymorphic ? [@namespace, instance.send("#{name}_type")] : self.association_class
+    association_class = authorize(association_class, options[:authorize])
+    collection = association_class.with_params("with_#{parent.resource_name}_id" => parent.id).all(parent.attributes["#{name}_id"])
+    collection.select{|i| i.attributes["#{parent.resource_name}_id"] == parent.id }.first
+    Restly::Proxies::Associations::Instance.new(instance, parent)
+  end
+
+  def collection?
+    true
+  end
+
+end

data/lib/restly/associations.rb

@@ -0,0 +1,90 @@
+module Restly::Associations
+  extend ActiveSupport::Concern
+  extend ActiveSupport::Autoload
+
+  autoload :Base
+  autoload :BelongsTo
+  autoload :HasMany
+  autoload :HasManyThrough
+  autoload :HasOne
+  autoload :HasOneThrough
+  autoload :EmbeddableResources
+
+  class AssociationHash < HashWithIndifferentAccess
+  end
+
+  included do
+
+    extend EmbeddableResources if self == Restly::Base
+    include Restly::NestedAttributes
+
+    delegate :resource_name, to: :klass
+    class_attribute :resource_associations, instance_reader: false, instance_writer: false
+    self.resource_associations = AssociationHash.new
+
+    inherited do
+      self.resource_associations = resource_associations.dup
+    end
+
+  end
+
+  def stub_associations_from_response(response=self.response)
+    parsed = response.parsed || {}
+    parsed = parsed[resource_name] if parsed.is_a?(Hash) && parsed[resource_name]
+    associations = parsed.select{ |i| klass.reflect_on_all_resource_associations.keys.include?(i) }
+    associations.each do |relationship|
+      relationship.collection?
+    end
+  end
+
+  def klass
+    self.class
+  end
+
+  module ClassMethods
+
+    def resource_name
+      name.gsub(/.*::/,'').underscore
+    end
+
+    def reflect_on_all_resource_associations
+      resource_associations
+    end
+
+    private
+
+    # Belongs to
+    def belongs_to_resource(name, options = {})
+      exclude_field(name) if ancestors.include?(Restly::Base)
+      self.resource_associations[name] = association = BelongsTo.new(self, name, options)
+      define_method name do |options={}|
+        association.find_with_parent(self, options)
+      end
+    end
+
+    # Has One
+    def has_one_resource(name, options = {})
+      exclude_field(name) if ancestors.include?(Restly::Base)
+      self.resource_associations[name] = association = HasOne.new(self, name, options)
+      define_method name do |options={}|
+        association.scope_with_parent(self, options)
+      end
+    end
+
+    # Has One
+    def has_many_resources(name, options = {})
+      exclude_field(name) if ancestors.include?(Restly::Base)
+      self.resource_associations[name] = association = HasMany.new(self, name, options)
+      define_method name do |options={}|
+        association.scope_with_parent(self, options)
+      end
+    end
+
+
+    def reflect_on_resource_association(association_name)
+      reflect_on_all_resource_associations[association_name]
+    end
+
+  end
+
+end

data/lib/restly/base/fields.rb

@@ -0,0 +1,79 @@
+module Restly::Base::Fields
+  extend ActiveSupport::Concern
+
+  included do
+    extend  SharedMethods
+    include SharedMethods
+    extend  ClassMethods
+
+    class_attribute :fields
+    self.fields = FieldSet.new
+    field :id
+
+    inherited do
+      self.fields = fields.dup
+    end
+
+  end
+
+  module SharedMethods
+
+    def set_field(attr)
+      base = self.is_a?(Class) ? self : singleton_class
+      unless base.send :instance_method_already_implemented?, attr
+        base.send :define_attribute_method, attr
+        self.fields += [attr]
+      end
+    end
+
+  end
+
+  module ClassMethods
+
+    def field(attr)
+      if attr.is_a?(Hash) && attr[:from_spec]
+        before_initialize do
+          spec[:attributes].each{ |attr| set_field(attr) }
+        end
+      elsif attr.is_a?(Symbol) || attr.is_a?(String)
+        set_field(attr)
+      else
+        raise Restly::Error::InvalidField, "field must be a symbol or string."
+      end
+    end
+
+    def exclude_field(name)
+
+      # Remove from the class
+      self.fields -= [name]
+
+      # Remove from the instance
+      before_initialize do
+        self.fields -= [name]
+      end
+
+    end
+
+  end
+
+  class FieldSet < Set
+
+    def include?(value)
+      super(value.to_sym)
+    end
+
+    def <<(value)
+      super(value.to_sym)
+    end
+
+    def +(other_arry)
+      super(other_arry.map(&:to_sym))
+    end
+
+    def -(other_arry)
+      super(other_arry.map(&:to_sym))
+    end
+
+  end
+
+end

data/lib/restly/base/generic_methods.rb

@@ -0,0 +1,24 @@
+module Restly::Base::GenericMethods
+
+  def authorize(token_object)
+    Restly::Proxies::Auth.new self, token_object
+  end
+
+  def with_params(params={})
+    Restly::Proxies::Params.new self, params
+  end
+
+  def path_with_format(*args)
+    path = [self.path, args].flatten.compact.join('/')
+    [path, format].compact.join('.') if path
+  end
+
+  def format
+    client.format
+  end
+
+  def authorized?
+    connection.token.present?
+  end
+
+end

data/lib/restly/base/includes.rb

@@ -0,0 +1,53 @@
+module Restly::Base::Includes
+  extend ActiveSupport::Concern
+
+  included do
+    extend ClassMethods
+
+    class_attribute :inherited_callbacks
+    self.inherited_callbacks  =   []
+
+    inherited do
+      self.inherited_callbacks = inherited_callbacks
+    end
+
+  end
+
+  module ClassMethods
+
+    # Delegate stuff to client
+    delegate :site, :site=, :format, :format=, to: :client
+
+    def client
+      @client ||= Restly::Client.new
+    end
+
+    def connection
+      connection = @connection || Restly::Connection.tokenize(client, current_token)
+      connection.cache ||= cache
+      connection.cache_options ||= cache_options
+      connection
+    end
+
+    def connection=(connection)
+      raise InvalidConnection, "#{connection} is not a valid Restly::Connection" unless connection.is_a?(Restly::Connection)
+      @connection = connection
+    end
+
+    def param_key
+      resource_name
+    end
+
+    private
+
+    def inherited(subclass = nil, &block)
+      self.inherited_callbacks << block and return if block_given?
+
+      inherited_callbacks.each do |call_block|
+        subclass.class_eval(&call_block)
+      end
+    end
+
+  end
+
+end

data/lib/restly/base/instance/actions.rb

@@ -0,0 +1,35 @@
+module Restly::Base::Instance::Actions
+
+  def save
+    run_callbacks :save do
+      @previously_changed = changes
+      @changed_attributes.clear
+      new_record? ? create : update
+    end
+    self
+  end
+
+  def delete
+    run_callbacks :delete do
+      response = connection.delete(path_with_format, params: params)
+      false
+      freeze
+    end
+    response.status < 300
+  end
+
+  private
+
+  def update
+    run_callbacks :update do
+      set_attributes_from_response(connection.put path_with_format, body: @request_body, params: params)
+    end
+  end
+
+  def create
+    run_callbacks :create do
+      set_attributes_from_response(connection.post path_with_format, body: @request_body, params: params)
+    end
+  end
+
+end

data/lib/restly/base/instance/attributes.rb

@@ -0,0 +1,88 @@
+module Restly::Base::Instance::Attributes
+
+  def update_attributes(attributes)
+    self.attributes = attributes
+    save
+  end
+
+  def attributes=(attributes)
+    attributes.each do |k, v|
+      write_attribute k, v
+    end
+  end
+
+  def attributes
+    nil_values = fields.inject({}) do |hash, key|
+      hash[key] = nil
+      hash
+    end
+    @attributes.reverse_merge!(nil_values)
+  end
+
+  def write_attribute(attr, val)
+    if fields.include?(attr)
+      send("#{attr}_will_change!".to_sym) unless val == @attributes[attr.to_sym] || !@loaded
+      @attributes[attr.to_sym] = val
+    else
+      puts "WARNING: Attribute `#{attr}` not written. ".colorize(:yellow) +
+               "To fix this add the following the the model. -- field :#{attr}"
+    end
+  end
+
+  def read_attribute(attr)
+    raise NoMethodError, "undefined method #{attr} for #{klass}" unless fields.include?(attr)
+    attributes[attr.to_sym]
+  end
+
+  alias :attribute :read_attribute
+
+  def inspect
+    inspection = if @attributes
+                   fields.collect { |name|
+                     "#{name}: #{attribute_for_inspect(name)}"
+                   }.compact.join(", ")
+                 else
+                   "not initialized"
+                 end
+    "#<#{self.class} #{inspection}>"
+  end
+
+  def has_attribute?(attr)
+    attribute(attr)
+  end
+
+  private
+
+  def attribute_for_inspect(attr_name)
+    value = attribute(attr_name)
+    if value.is_a?(String) && value.length > 50
+      "#{value[0..50]}...".inspect
+    else
+      value.inspect
+    end
+  end
+
+  def set_attributes_from_response(response=self.response)
+    parsed = response.parsed || {}
+    parsed = parsed[resource_name] if parsed.is_a?(Hash) && parsed[resource_name]
+    self.attributes = parsed
+  end
+
+  def method_missing(m, *args, &block)
+    if !!(/(?<attr>\w+)(?<setter>=)?$/ =~ m.to_s) && fields.include?(m)
+      case !!setter
+        when true
+          write_attribute(m, *args)
+        when false
+          read_attribute(m)
+      end
+    else
+      super(m, *args, &block)
+    end
+  end
+
+  def respond_to_missing?(method_name, include_private = false)
+    !!(/(?<attr>\w+)=?$/ =~ method_name.to_s) && fields.include?(method_name)
+  end
+
+end

data/lib/restly/base/instance/persistence.rb

@@ -0,0 +1,20 @@
+module Restly::Base::Instance::Persistence
+
+  def exists?
+    status = @response.try(:status).to_i
+    status < 300 && status >= 200
+  end
+
+  def persisted?
+    exists? && !changed?
+  end
+
+  def new_record?
+    !exists?
+  end
+
+  def reload!
+    self.class.send :instance_from_response, connection.get(path, force: true)
+  end
+
+end