cloud_spokes_api_model 0.1.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 YOURNAME
+
+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.rdoc

@@ -0,0 +1,3 @@
+= CloudSpokesApiModel
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,38 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'CloudSpokesApiModel'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task :default => :test

data/app/config/config.yml

@@ -0,0 +1,16 @@
+defaults: &defaults
+  :cs_api:
+    :challenges: 'http://cs-api-sandbox.herokuapp.com/v1/challenges'
+    :categories: 'http://cs-api-sandbox.herokuapp.com/v1/categories'
+    :members: 'http://cs-api-sandbox.herokuapp.com/v1/members'
+    :key: ''
+  :expiry: 5
+
+development:
+  <<: *defaults
+
+test:
+  <<: *defaults
+
+production:
+  <<: *defaults

data/app/models/active_model/model.rb

@@ -0,0 +1,99 @@
+# shamelessly stolen from https://github.com/rails/rails/tree/master/activemodel :P
+
+module ActiveModel
+
+  # == Active \Model Basic \Model
+  #
+  # Includes the required interface for an object to interact with
+  # <tt>ActionPack</tt>, using different <tt>ActiveModel</tt> modules.
+  # It includes model name introspections, conversions, translations and
+  # validations. Besides that, it allows you to initialize the object with a
+  # hash of attributes, pretty much like <tt>ActiveRecord</tt> does.
+  #
+  # A minimal implementation could be:
+  #
+  #   class Person
+  #     include ActiveModel::Model
+  #     attr_accessor :name, :age
+  #   end
+  #
+  #   person = Person.new(name: 'bob', age: '18')
+  #   person.name # => 'bob'
+  #   person.age  # => 18
+  #
+  # Note that, by default, <tt>ActiveModel::Model</tt> implements <tt>persisted?</tt>
+  # to return +false+, which is the most common case. You may want to override
+  # it in your class to simulate a different scenario:
+  #
+  #   class Person
+  #     include ActiveModel::Model
+  #     attr_accessor :id, :name
+  #
+  #     def persisted?
+  #       self.id == 1
+  #     end
+  #   end
+  #
+  #   person = Person.new(id: 1, name: 'bob')
+  #   person.persisted? # => true
+  #
+  # Also, if for some reason you need to run code on <tt>initialize</tt>, make
+  # sure you call +super+ if you want the attributes hash initialization to
+  # happen.
+  #
+  #   class Person
+  #     include ActiveModel::Model
+  #     attr_accessor :id, :name, :omg
+  #
+  #     def initialize(attributes={})
+  #       super
+  #       @omg ||= true
+  #     end
+  #   end
+  #
+  #   person = Person.new(id: 1, name: 'bob')
+  #   person.omg # => true
+  #
+  # For more detailed information on other functionalities available, please
+  # refer to the specific modules included in <tt>ActiveModel::Model</tt>
+  # (see below).
+  module Model
+    def self.included(base) #:nodoc:
+      base.class_eval do
+        extend  ActiveModel::Naming
+        extend  ActiveModel::Translation
+        include ActiveModel::Validations
+        include ActiveModel::Conversion
+      end
+    end
+
+    # Initializes a new model with the given +params+.
+    #
+    #   class Person
+    #     include ActiveModel::Model
+    #     attr_accessor :name, :age
+    #   end
+    #
+    #   person = Person.new(name: 'bob', age: '18')
+    #   person.name # => "bob"
+    #   person.age  # => 18
+    def initialize(params={})
+      params.each do |attr, value|
+        self.public_send("#{attr}=", value)
+      end if params
+    end
+
+    # Indicates if the model is persisted. Default is +false+.
+    #
+    #  class Person
+    #    include ActiveModel::Model
+    #    attr_accessor :id, :name
+    #  end
+    #
+    #  person = Person.new(id: 1, name: 'bob')
+    #  person.persisted? # => false
+    def persisted?
+      false
+    end
+  end
+end

data/app/models/cloud_spokes/model/base_api.rb

@@ -0,0 +1,198 @@
+class CloudSpokes::Model::BaseApi
+  include ActiveModel::Model
+
+  ENDPOINT_EXPIRY = ENV['CS_API_EXPIRY'].to_i || CloudSpokes::APP_CONFIG[:expiry]
+
+  cattr_accessor :access_token
+
+  # Implements the has_many relationship
+  # Passing :parent as an option allows modification of the calling class
+  # This is used mostly for has and belongs to many relationships, where
+  # a model collection will have a different endpoint
+  # Case in point: Members and Challenges
+  def self.has_many(entity, options={})
+    # add in this relationship to the column_names table
+    @column_names << entity.to_sym
+    rel_column_names << entity.to_sym
+    parent = options[:parent]
+
+    # dynamically create a method on this instance that will reference the collection
+    define_method("#{entity.to_sym}=") do |accessor_value|
+      instance_variable_set("@#{entity.to_sym}", accessor_value)
+    end
+
+    define_method(entity.to_sym) do
+      klass = entity.to_s.classify.constantize
+      (parent || klass).raw_get([to_param, entity.to_s]).map do |e|
+        next if e.respond_to?(:last) # we got an array instead of a Hashie::Mash
+        klass.new e
+      end
+    end
+  end
+
+  # Overrides the attr_accesssor class method so we are able to capture and
+  # then save the defined fields as column_names
+  def self.attr_accessor(*vars)
+    @column_names ||= []
+    @column_names.concat( vars )
+    super
+  end
+
+  # Returns the previously defined attr_accessor fields
+  def self.column_names
+    @column_names
+  end
+
+  def self.rel_column_names
+    @rel_column_names ||= []
+  end
+
+  # Returns the api_endpoint. Note that you need to implement this method
+  # in the child object
+  def self.api_endpoint
+    raise 'Please implement ::api_endpoint in the child object'
+  end
+
+  # Returns all the records from the CloudSpokes API
+  def self.all
+    request(:get, '', {}).map {|item| new item}
+  end
+
+  # Returns the first record
+  # TODO: when the API supports it, simply request for the first record.
+  # There should be no need to request for all the records first.
+  def self.first
+    all.first
+  end
+
+  # Finds an entity
+  def self.find(entity)
+    Rails.logger.info "========== running find for #{entity} for #{self.name}"
+    Kernel.const_get(self.name).new(raw_get entity)
+  end
+
+  # Wrap initialize with a sanitation clause
+  def initialize(params={})
+    Rails.logger.info "=====calling init with #{params}"
+    @raw_data = params.dup
+    params.delete_if {|k, v| !self.class.column_names.include? k.to_sym}
+    super(params)
+  end
+
+  # Returns the raw data that created this object
+  def raw_data
+    @raw_data
+  end
+
+  # Returns if this record has the id attribute set (used by url_for for routing)
+  def persisted?
+    !!id
+  end
+
+  def save
+    new_record? ? create : update
+  end
+
+  def update_attributes(attrs={})
+    attrs.each do |attr, value|
+      self.public_send("#{attr}=", value)
+    end
+    save
+  end
+
+  def new_record?
+    id.blank?
+  end
+
+  def self.create(attrs)
+    obj = new(attrs)
+    obj.save
+    obj
+  end
+
+  def self.api_request_headers
+    {
+      'oauth_token' => access_token,
+      'Authorization' => 'Token token="'+(ENV['CS_API_KEY']|| CloudSpokes::APP_CONFIG[:cs_api][:key])+'"',
+      'Content-Type' => 'application/json'
+    }
+  end
+
+  # Convenience method to request an entity from the CloudSpokes RESTful source
+  # Accepts an array or a string
+  # If given an array, will join the elements with '/'
+  # If given a string, will use the argument as is
+  def self.raw_get(entities = [])
+    endpoint = endpoint_from_entities(entities)
+    Rails.logger.info "=====$$$$$ CALLING RAW GET #{entities} for #{endpoint}"
+    #Rails.cache.fetch("#{endpoint}", expires_in: ENDPOINT_EXPIRY.minutes) do
+      get_response(RestClient.get(endpoint, api_request_headers))
+    #end
+  end
+
+  # Sanitized response to only the attributes we've defined
+  def self.get(entity = '')
+    raw_get(entity).delete_if {|k, v| !column_names.include? k.to_sym}
+  end
+
+  def self.endpoint_from_entities(entities = [])
+    entities = entities.respond_to?(:join) ? entities.join("/") : entities.to_s
+    entities.present? ? "#{api_endpoint}/#{entities}" : api_endpoint
+  end
+
+  def self.get_response(data)
+    Hashie::Mash.new(JSON.parse(data)).response
+  end
+
+  def self.request(method, entities, data)
+    Rails.logger.info "===== access_token: #{access_token}"
+    Rails.logger.info "===== method: #{method}"
+    endpoint = endpoint_from_entities(entities)
+    Rails.logger.info "===== endpoint: #{endpoint}"
+    if method.to_sym == :get
+      endpoint += "?#{data.to_param}"
+      resp = RestClient.send method, endpoint, api_request_headers
+    else
+      data = data.to_json unless data.is_a?(String)
+      resp = RestClient.send method, endpoint, data, api_request_headers
+    end
+    get_response(resp)
+  end
+
+  def self.post(entities, data)
+    request :post, entities, data
+  end
+
+  def self.put(entities, data)
+    request :put, entities, data
+  end
+
+  private
+
+    def save_data
+      columns = self.class.column_names - self.class.rel_column_names - [:id]
+      columns.inject({}) do |ret, column|
+        val = self.public_send(column)
+        ret[column] = val if val.present?
+        ret
+      end
+    end
+
+    # define update_endpoint to subclass if you want to use another url for update
+    def update_endpoint
+      id
+    end
+
+    # define create_endpoint to subclass if you want to use another url for create
+    def create_endpoint
+      ""
+    end
+
+    def update
+      self.class.put update_endpoint, save_data
+    end
+
+    def create
+      self.class.post create_endpoint, save_data
+    end
+end

data/app/models/cloud_spokes/model/category.rb

@@ -0,0 +1,12 @@
+class CloudSpokes::Model::Category < CloudSpokes::Model::BaseApi
+  attr_accessor :id, :attributes,
+    :name, :color
+
+  def self.api_endpoint
+    CloudSpokes::APP_CONFIG[:cs_api][:categories]
+  end
+
+  def self.names
+    all.map {|category| category.name}
+  end
+end

data/app/models/cloud_spokes/model/member.rb

@@ -0,0 +1,32 @@
+class CloudSpokes::Model::Member < CloudSpokes::Model::BaseApi
+  attr_accessor :id, :name, :profile_pic, :attributes,
+    :challenges_entered, :active_challenges, :time_zone,
+    :total_1st_place, :total_2nd_place, :total_3st_place,
+    :total_wins, :total_public_money, :total_points, :valid_submissions,
+    :summary_bio, :payments
+
+  has_many :recommendations
+  has_many :challenges, parent: CloudSpokes::Model::Member
+
+  def self.api_endpoint
+    CloudSpokes::APP_CONFIG[:cs_api][:members]
+  end
+
+  # Used for resourceful routes (instead of id)
+  def to_param
+    name
+  end
+
+  # has_many :payments
+  # Note that the json does not expose this method
+  # TODO (this requires authentication)
+  def payments
+    'nil'
+  end
+
+  def self.search(keyword)
+    request(:get, "search", {:keyword => keyword})
+      .map {|member| CloudSpokes::Model::Member.new member}
+  end
+
+end

data/lib/cloud_spokes_api_model/engine.rb

@@ -0,0 +1,5 @@
+module CloudSpokes
+  class Engine < ::Rails::Engine
+    isolate_namespace CloudSpokes
+  end
+end

data/lib/cloud_spokes_api_model/railtie.rb

@@ -0,0 +1,15 @@
+module CloudSpokes
+  class Railtie < Rails::Railtie
+
+    initializer "cloud_spokes.configure_rails_initialization" do
+      CloudSpokes::APP_CONFIG = 
+      begin
+        YAML.load_file("#{Rails.root}/config/config.yml")[Rails.env]
+      rescue Errno::ENOENT => e
+        gem_config = $LOAD_PATH.find {|dir| dir =~ /app\/config/}
+        YAML.load_file("#{gem_config}/config.yml")[Rails.env]
+      end
+    end
+
+  end
+end

data/lib/cloud_spokes_api_model/version.rb

@@ -0,0 +1,3 @@
+module CloudSpokes
+  VERSION = "0.1.0"
+end

data/lib/cloud_spokes_api_model.rb

@@ -0,0 +1,7 @@
+require "cloud_spokes_api_model/engine"
+require 'cloud_spokes_api_model/railtie' if defined?(Rails)
+require 'hashie'
+require 'rest_client'
+
+module CloudSpokes
+end

data/lib/tasks/cloud_spokes_api_model_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :cloud_spokes_api_model do
+#   # Task goes here
+# end

data/test/cloud_spokes_api_model_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class CloudSpokesApiModelTest < ActiveSupport::TestCase
+  test "truth" do
+    assert_kind_of Module, CloudSpokesApiModel
+  end
+end