usergrid_ironhorse 0.0.2

data/.gitignore

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

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/.rvmrc

@@ -0,0 +1,2 @@
+rvm_gemset_create_on_use_flag=1
+rvm gemset use 'usergrid_ironhorse'

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Scott Ganyo
+
+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,121 @@
+# Usergrid_ironhorse
+
+Usergrid_ironhorse is based on Usergrid_iron and enables Ruby or Rails applications
+native Rails-style access to Apigee's App Services (aka Usergrid) REST API.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'usergrid_ironhorse'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install usergrid_ironhorse
+
+
+## Usage
+
+### Not familiar with Usergrid / Apigee's App Services?
+
+#### It's great stuff! Check it out, here:
+
+  Docs: <http://apigee.com/docs/usergrid/>  
+  Open source: <https://github.com/apigee/usergrid-stack>
+
+### Getting started with the Usergrid_ironhorse SDK is super simple!
+
+* Add 'gem usergrid_ironhorse' to your Gemfile
+* Create a 'config/usergrid.yml' file that looks something like this (the
+auth_token is your application admin token):
+<pre>
+development:
+  :application_url: http://localhost:8080/my-organization/my-application
+  :auth_token: YWMtc4WjqhcbEeK6UhQQn9SVgQAAATpryjMnLy9oFaPbP-0qIxoUx_4vtaOmpmE
+
+development:
+  :application_url: http://localhost:8080/my-organization/my-application
+  :auth_token: YWMtc4WjqhcbEeK6UhQQn9SVgQAAATpryjMnLy9oFaPbP-0qIxoUx_4vtaOmpmE
+
+production:
+  :application_url: http://api.usergrid.com/my-organization/my-application
+  :auth_token: YWMtc4WjqhcbEeK6UhQQn9SVgQAAATpryjMnLy9oFaPbP-0qIxoUx_4vtaOmpmE
+</pre>
+* Your User model should subclass Usergrid::Ironhorse::Base and extend
+Usergrid::Ironhorse::UserContext like so:
+<pre>
+class User < Usergrid::Ironhorse::Base
+  extend Usergrid::Ironhorse::UserContext
+
+end
+</pre>
+* Set up your authentication
+	* Use `User.authenticate(username, password, session)` to login.
+	* Use `User.clear_authentication(session)` to log out.
+* Propogate the authentication in your ApplicationController:
+<pre>
+  before_filter :set_thread_context
+  def set_thread_context
+    User.set_thread_context session
+  end
+</pre>
+* Optionally, if you need to access the User from your view, you may add something
+like the following to your ApplicationController:
+<pre>
+  helper_method :current_user
+  def current_user
+    User.current_user
+  end
+</pre>
+
+
+## Contributing
+
+We welcome your enhancements!
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Write some broken rspecs.
+4. Fix the rspecs with your new code.
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push your changes to the upstream branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+We've got 100% rspec coverage and we're looking to keep it that way!*
+(*Not yet, but soon)
+In order to run the tests, check out the Usergrid open source project
+(https://github.com/apigee/usergrid-stack), build, and launch it locally.
+
+(Note: If you change your local Usergrid settings from the default, be sure to update
+usergrid_ironhorse/spec/spec_settings.yaml to match.)
+
+
+## Release notes
+
+### 0.0.2
+* New Features
+  1. Authentication and user propagation features
+### 0.0.1
+* Initial commit
+  1. Support for most ActiveModel stuff including Validations
+  1. No scoping support
+
+
+## Copyright
+Copyright (c) 2012 Scott Ganyo 
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use the included files except in compliance with the License.
+
+You may obtain a copy of the License at
+
+  <http://www.apache.org/licenses/LICENSE-2.0>
+  
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+either express or implied. See the License for the specific language governing permissions and
+limitations under the License.

data/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+RSpec::Core::RakeTask.new("spec:coverage")

data/lib/extensions/hash.rb

@@ -0,0 +1,7 @@
+class Hash
+
+  def nested_under_indifferent_access
+    self
+  end
+
+end

data/lib/usergrid_ironhorse.rb

@@ -0,0 +1,24 @@
+require 'logger'
+require 'active_model'
+require 'rest-client'
+require 'active_support'
+require 'usergrid_iron'
+require 'active_record/errors'
+
+module Usergrid
+  module Ironhorse
+
+    Dir[Pathname.new(File.dirname(__FILE__)).join("extensions/**/*.rb")].each { |f| require f }
+
+    USERGRID_PATH = File.join File.dirname(__FILE__), 'usergrid_ironhorse'
+
+    def self.usergrid_path *path
+      File.join USERGRID_PATH, *path
+    end
+
+    require usergrid_path('base')
+    require usergrid_path('query')
+
+    autoload :UserContext, usergrid_path('user_context')
+  end
+end

data/lib/usergrid_ironhorse/base.rb

@@ -0,0 +1,360 @@
+require 'active_record/validations'
+require 'active_record/errors'
+require 'active_record/callbacks'
+
+module Usergrid
+  module Ironhorse
+
+    class Base
+      include ActiveModel::AttributeMethods
+      include ActiveModel::Conversion
+      include ActiveModel::Validations
+      include ActiveModel::Dirty
+      include ActiveModel::Serialization
+      extend  ActiveModel::Naming
+      extend  ActiveModel::Callbacks
+
+      RESERVED_ATTRIBUTES = %w(metadata created modified uuid type uri)
+
+      define_model_callbacks :create, :destroy, :save, :update
+
+      # todo: determine the subset to support...
+      # unsupported: :group, :joins, :preload, :eager_load, :includes, :from, :lock,
+      #              :having, :create_with, :uniq, :references, :none, :count,
+      #              :average, :minimum, :maximum, :sum, :calculate, :ids
+      #              :find_each, :find_in_batches, :offset, :readonly
+
+      #delegate :find, :take, :take!, :first, :first!, :last, :last!, :exists?, :any?, :many?, :to => :all
+      #delegate :first_or_create, :first_or_create!, :first_or_initialize, :to => :all
+      #delegate :find_by, :find_by!, :to => :all
+      #delegate :destroy, :destroy_all, :delete, :delete_all, :update, :update_all, :to => :all
+      #delegate :find_each, :find_in_batches, :to => :all
+      #delegate :select, :group, :order, :except, :reorder, :limit, :offset,
+      #         :where, :preload, :eager_load, :includes, :from, :lock, :readonly,
+      #         :having, :create_with, :uniq, :references, :none, :to => :all
+      #delegate :count, :average, :minimum, :maximum, :sum, :calculate, :pluck, :ids, :to => :all
+
+      @@settings ||= nil
+
+      attr_accessor :attributes
+
+      HashWithIndifferentAccess = ActiveSupport::HashWithIndifferentAccess
+      RecordNotSaved = ActiveRecord::RecordNotSaved
+
+      def initialize(attrs=nil)
+        attrs = HashWithIndifferentAccess.new attrs
+        unless attrs.has_key? :uuid
+          assign_attributes attrs
+        end
+        @attributes = attrs
+      end
+
+      def self.configure!(application_url, auth_token)
+        @@settings = HashWithIndifferentAccess.new application_url: application_url, auth_token: auth_token
+      end
+
+      def self.settings
+        return @@settings if @@settings
+        path = "config/usergrid.yml"
+        environment = defined?(Rails) && Rails.respond_to?(:env) ? Rails.env : ENV['RACK_ENV']
+        @@settings = HashWithIndifferentAccess.new YAML.load(ERB.new(File.new(path).read).result)[environment]
+      end
+
+      # forward to all
+      def self.method_missing(method, *args, &block)
+        all.send method, *args, &block
+      end
+
+      # forward to all
+      def method_missing(method, *args, &block)
+        if args.size == 0
+          attributes[method]
+        elsif args.size == 1 && method[-1] == '='
+          attr = method[0..-2]
+          if attributes[attr] != args[0]
+            attribute_will_change!(attr)
+            attributes[attr] = args[0]
+          end
+        else
+          all.send method, *args, &block
+        end
+      end
+
+      # todo: scopes
+      def self.all
+        unscoped
+      end
+
+      #def self.scope(symbol, scope)
+      #  @scopes[symbol] = scope
+      #end
+
+      #def self.current_scope
+      #  @current_scope ||= default_scope
+      #end
+      #
+      #def self.current_scope=(scope)
+      #  @current_scope = scope
+      #end
+      #
+      #def self.default_scope
+      #  @default_scope ||= unscoped
+      #end
+
+      def self.unscoped
+        Query.new(self)
+      end
+
+      def self.create(attributes=nil, options=nil, &block)
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| create(attr, options, &block) }
+        else
+          object = new(attributes, &block)
+          object.save
+          object
+        end
+      end
+
+      def self.create!(attributes=nil, options=nil, &block)
+        if attributes.is_a?(Array)
+          attributes.collect {|attr| create!(attr, options, &block)}
+        else
+          object = new(attributes)
+          yield(object) if block_given?
+          object.save!
+          object
+        end
+      end
+
+      def self.class_attributes
+        @class_attributes ||= {}
+      end
+
+      # Returns true if the record is persisted, i.e. it's not a new record and it was
+      # not destroyed, otherwise returns false.
+      def persisted?
+        !(new_record? || destroyed?)
+      end
+
+      def new_record?
+        !self.uuid
+      end
+
+      def self.group
+        model_name.plural.downcase
+      end
+
+      # Creates a Usergrid::Resource
+      def self.resource
+        app = Usergrid::Application.new settings[:application_url]
+        if Thread.current[:auth_token]
+          app.auth_token = Thread.current[:auth_token]
+        else
+          app.auth_token = settings[:auth_token]
+        end
+        app[group]
+      end
+
+      # Saves the model.
+      #
+      # If the model is new a record gets created in the database, otherwise
+      # the existing record gets updated.
+      #
+      # By default, save always run validations. If any of them fail the action
+      # is cancelled and +save+ returns +false+. However, if you supply
+      # :validate => false, validations are bypassed altogether. See
+      # ActiveRecord::Validations for more information.
+      #
+      # There's a series of callbacks associated with +save+. If any of the
+      # <tt>before_*</tt> callbacks return +false+ the action is cancelled and
+      # +save+ returns +false+. See ActiveRecord::Callbacks for further
+      # details.
+      def save
+        begin
+          create_or_update
+        rescue ActiveRecord::RecordInvalid
+          false
+        end
+      end
+
+      # Saves the model.
+      #
+      # If the model is new a record gets created in the database, otherwise
+      # the existing record gets updated.
+      #
+      # With <tt>save!</tt> validations always run. If any of them fail
+      # ActiveRecord::RecordInvalid gets raised. See ActiveRecord::Validations
+      # for more information.
+      #
+      # There's a series of callbacks associated with <tt>save!</tt>. If any of
+      # the <tt>before_*</tt> callbacks return +false+ the action is cancelled
+      # and <tt>save!</tt> raises ActiveRecord::RecordNotSaved. See
+      # ActiveRecord::Callbacks for further details.
+      def save!
+        create_or_update or raise RecordNotSaved
+      end
+
+      # Deletes the record in the database and freezes this instance to
+      # reflect that no changes should be made (since they can't be
+      # persisted). Returns the frozen instance.
+      #
+      # The row is simply removed with an SQL +DELETE+ statement on the
+      # record's primary key, and no callbacks are executed.
+      #
+      # To enforce the object's +before_destroy+ and +after_destroy+
+      # callbacks, Observer methods, or any <tt>:dependent</tt> association
+      # options, use <tt>#destroy</tt>.
+      def delete
+        self.class.delete(id) if persisted?
+        @destroyed = true
+        freeze
+      end
+
+      # Deletes the record in the database and freezes this instance to reflect
+      # that no changes should be made (since they can't be persisted).
+      #
+      # There's a series of callbacks associated with <tt>destroy</tt>. If
+      # the <tt>before_destroy</tt> callback return +false+ the action is cancelled
+      # and <tt>destroy</tt> returns +false+. See
+      # ActiveRecord::Callbacks for further details.
+      def destroy
+        raise ReadOnlyRecord if readonly?
+        # todo: callbacks?
+        instance_resource.delete if persisted?
+        @destroyed = true
+        freeze
+      end
+
+      # Deletes the record in the database and freezes this instance to reflect
+      # that no changes should be made (since they can't be persisted).
+      #
+      # There's a series of callbacks associated with <tt>destroy!</tt>. If
+      # the <tt>before_destroy</tt> callback return +false+ the action is cancelled
+      # and <tt>destroy!</tt> raises ActiveRecord::RecordNotDestroyed. See
+      # ActiveRecord::Callbacks for further details.
+      def destroy!
+        destroy || raise(ActiveRecord::RecordNotDestroyed)
+      end
+
+      # Returns true if this object has been destroyed, otherwise returns false.
+      def destroyed?
+        !!@destroyed
+      end
+
+      # Reloads the attributes of this object from the database.
+      def reload
+        return false if !persisted?
+        fresh_object = self.class.find(id)
+        refresh_data fresh_object.instance_variable_get('@attributes')
+        self
+      end
+
+      # Updates the attributes of the model from the passed-in hash and saves the
+      # record, all wrapped in a transaction. If the object is invalid, the saving
+      # will fail and false will be returned.
+      def update_attributes(attributes)
+        assign_attributes attributes
+        save
+      end
+
+      # Updates its receiver just like +update_attributes+ but calls <tt>save!</tt> instead
+      # of +save+, so an exception is raised if the record is invalid.
+      def update_attributes!(attributes)
+        assign_attributes attributes
+        save!
+      end
+
+      # Note that whenever you include ActiveModel::AttributeMethods in your class,
+      # it requires you to implement an +attributes+ method which returns a hash
+      # with each attribute name in your model as hash key and the attribute value as
+      # hash value.
+      #
+      # Hash keys must be strings.
+      def attributes
+        @attributes ||= self.class.class_attributes.clone
+      end
+
+      def id; self.uuid end
+      def created_at; self.created end
+      def updated_at; self.modified end
+
+
+      protected
+
+
+      def assign_attributes(attrs)
+        attrs.each do |attr,value|
+          attr = attr.to_s
+          unless attributes[attr] == value
+            attribute_will_change!(attr) unless RESERVED_ATTRIBUTES.include? attr
+            attributes[attr] = value
+          end
+        end
+      end
+
+      def create_or_update
+        raise ReadOnlyRecord if readonly?
+        if valid?
+          run_callbacks :save do
+            return new_record? ? do_create : do_update
+          end
+        end
+        false
+      end
+
+      def do_create
+        group_resource.post(unsaved_attributes) do |resp, req, res, &block|
+          if resp.code.to_s == "200" || resp.code.to_s == "201"
+            refresh_data resp.entity_data
+            return true
+          else
+            errors.add(resp.code.to_s, resp)
+            return false
+          end
+        end
+      end
+
+      def do_update
+        return false unless changed?
+
+        instance_resource.put(unsaved_attributes) do |resp, req, res, &block|
+          if resp.code.to_s == "200" || resp.code.to_s == "201"
+            refresh_data resp.entity_data
+            return true
+          else
+            errors.add(resp.code, resp)
+            return false
+          end
+        end
+      end
+
+      def unsaved_attributes
+        HashWithIndifferentAccess[changed.collect {|k| [k, attributes[k]]}]
+      end
+
+      def group_resource
+        self.class.resource
+      end
+
+      def instance_resource
+        self.class.resource["#{self.id}"]
+      end
+
+      def refresh_data(entity_data)
+        @previously_changed = changes
+        @changed_attributes.clear
+        @attributes = HashWithIndifferentAccess.new entity_data
+      end
+
+      def attribute_will_change!(attr)
+        begin
+          value = __send__(attr)
+          value = value.duplicable? ? value.clone : value
+        rescue TypeError, NoMethodError
+        end
+
+        changed_attributes[attr] = value unless changed_attributes.include?(attr)
+      end
+    end
+  end
+end