athena_resource 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+--format documentation

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/Rakefile

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

data/athena_resource.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "athena_resource/version"
+
+Gem::Specification.new do |s|
+  s.name        = "athena_resource"
+  s.version     = AthenaResource::VERSION
+  s.authors     = ["Micah Frost"]
+  s.email       = ["athena@fracturedatlas.org"]
+  s.homepage    = "http://athena.fracturedatlas.org"
+  s.summary     = %q{ ATHENA API Wrapper}
+  s.description = %q{ Easily consume ATHENA resources by subclasses AthenaResource }
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec"
+end

data/lib/athena_resource.rb

@@ -0,0 +1,16 @@
+require 'active_support'
+require 'active_resource'
+
+require "athena_resource/version"
+
+module AthenaResource
+  include ActiveResource
+
+  extend ActiveSupport::Autoload
+  autoload :Base
+  autoload :Encoding
+  autoload :Headers
+  autoload :AuthType
+  autoload :Callbacks
+  autoload :Finders
+end

data/lib/athena_resource/auth_type.rb

@@ -0,0 +1,15 @@
+module AthenaResource
+  module AuthType
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def auth_type
+        if defined?(@auth_type)
+          @auth_type
+        elsif superclass != Object && superclass.auth_type
+          superclass.auth_type
+        end
+      end
+    end
+  end
+end

data/lib/athena_resource/base.rb

@@ -0,0 +1,22 @@
+require 'athena_resource/formats'
+
+module AthenaResource
+  class Base < ActiveResource::Base
+    self.user      = AthenaResource::USER
+    self.password  = AthenaResource::PASSWORD
+    self.auth_type = AthenaResource::AUTH_TYPE
+
+    class << self
+      def patch(records, attributes)
+        response = connection.put(self.site.path + self.collection_name + "/patch/#{records.collect(&:id).join(",")}", attributes.to_json, self.headers)
+        format.decode(response.body).map{ |attributes| new(attributes) }
+      end
+    end
+
+    include Encoding
+    include AuthType
+    include Headers
+    include Callbacks
+    include Finders
+  end
+end

data/lib/athena_resource/callbacks.rb

@@ -0,0 +1,26 @@
+module AthenaResource
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    included do
+      # Enable ActiveModel callbacks for models
+      extend ActiveModel::Callbacks
+      define_model_callbacks :save, :validation
+    end
+
+    module InstanceMethods
+      def save
+        run_callbacks :save do
+          super
+        end
+      end
+
+      # Note, that for the time being, validation callbacks are called after before_save, and before after_save
+      def valid?
+        run_callbacks :validation do
+          super
+        end
+      end
+    end
+  end
+end

data/lib/athena_resource/encoding.rb

@@ -0,0 +1,23 @@
+module AthenaResource
+  module Encoding
+    extend ActiveSupport::Concern
+    module ClassMethods
+      def format
+        read_inheritable_attribute(:format) || AthenaResource::Formats::AthenaFormat
+      end
+
+      def parameterize(params = {})
+        Hash[params.collect{|key, value| [key.camelize(:lower),value] }]
+      end
+    end
+
+    module InstanceMethods
+      def encode(options = {})
+        attrs = options.delete(:attributes) || attributes
+        return self.class.format.encode(attrs, options) if self.class.format.respond_to? :encode
+        super(options)
+      end
+    end
+  end
+end
+

data/lib/athena_resource/finders.rb

@@ -0,0 +1,42 @@
+module AthenaResource
+  module Finders
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def search_index(search_query, organization, limit=10)
+        if search_query.blank?
+          search_query = ''
+        else
+          search_query.concat(' AND ')
+        end
+
+        search_query.concat("organizationId:").concat("#{organization.id}")
+        find(:all, :params => { '_q' => search_query, '_limit' => limit})
+      end
+
+      #Can be used when searching for a range because you can't dupe keys in a hash
+      #For example: datetime=lt2011-03-02&datetime=gt2010-05-05
+      def query(query_str)
+
+        #Neither CGI::Escape nor URI.escape worked here
+        #CGI::escape escaped everything and ATHENA threw 400
+        #URI.escape failed to change the + to %2B which is really the only thing I wanted it to do
+        query_str.gsub!(/\+/,'%2B')
+
+        connection.get(self.collection_path + "?" + query_str, self.headers)
+      end
+
+      # This method will translate find_by_some_object_id into ...?someObjectId=9
+      def method_missing(method_id, *arguments)
+        if method_id.to_s =~ /find_by_(\w+)/
+          arg = arguments[0]
+          term = $1.camelcase(:lower)
+
+          find(:all, :params => { term => arg })
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/athena_resource/formats.rb

@@ -0,0 +1,16 @@
+module ActiveResource
+  module Formats
+    autoload :XmlFormat, 'active_resource/formats/xml_format'
+    autoload :JsonFormat, 'active_resource/formats/json_format'
+    autoload :AthenaFormat, 'athena_resource/formats/athena_format'
+
+    # Lookup the format class from a mime type reference symbol. Example:
+    #
+    #   ActiveResource::Formats[:xml]  # => ActiveResource::Formats::XmlFormat
+    #   ActiveResource::Formats[:json] # => ActiveResource::Formats::JsonFormat
+    def self.[](mime_type_reference)
+      ActiveResource::Formats.const_get(ActiveSupport::Inflector.camelize(mime_type_reference.to_s) + "Format")
+    end
+  end
+end
+

data/lib/athena_resource/formats/athena_format.rb

@@ -0,0 +1,90 @@
+require 'active_support/json'
+
+module ActiveResource
+  module Formats
+    module AthenaFormat
+      extend self
+
+      def extension
+        "json"
+      end
+
+      def mime_type
+        "application/json"
+      end
+
+      def encode(hash, options = {})
+        rejections = options.delete :rejections || []
+        hash = hash.reject { | k , v | rejections.include? k } unless rejections.nil?
+
+        results = encode_athena(hash)
+        results = ActiveSupport::JSON.encode(results, options) unless options.delete(:skip_serialization)
+
+        results
+      end
+
+      def decode(json)
+        decode_athena(ActiveSupport::JSON.decode(json))
+      end
+
+      private
+        def decode_athena(payload)
+          if payload.is_a? Array
+            payload.collect { |element| underscore_keys(element) }
+          else
+            underscore_keys(payload)
+          end
+        end
+
+        def underscore_keys(payload)
+          if payload.is_a? Hash
+            underscored_payload = {}
+            payload.each do |key, value|
+              if value.kind_of? Hash
+                underscored_payload[key.underscore] = underscore_keys(value)
+              elsif value.kind_of? Array
+                underscored_payload[key.underscore] = value.collect { |v| underscore_keys(v) }
+              else
+                underscored_payload[key.underscore] = value
+              end
+            end
+            underscored_payload
+          else
+            if payload.respond_to? :attributes
+              underscore_keyes(payload.attributes)
+            else
+              payload
+            end
+          end
+        end
+
+        def encode_athena(hash)
+          camelize_keys(hash)
+        end
+
+        def camelize_keys(hash_or_model)
+          if hash_or_model.respond_to? :encode and hash_or_model.respond_to? :attributes
+            return hash_or_model.encode(:skip_serialization => true)
+          end
+
+          if hash_or_model.is_a? Hash
+            camelized_hash = {}
+
+            hash_or_model.each do |key, value|
+              if value.kind_of? Hash
+                camelized_hash[key.camelize(:lower)] = camelize_keys(value)
+              elsif value.kind_of? Array
+                camelized_hash[key.camelize(:lower)] = value.collect{ |v| camelize_keys(v) }
+              else
+                camelized_hash[key.camelize(:lower)] = camelize_keys(value)
+              end
+            end
+            camelized_hash
+          else
+            hash_or_model
+          end
+        end
+    end
+  end
+end
+

data/lib/athena_resource/headers.rb

@@ -0,0 +1,17 @@
+module AthenaResource
+  module Headers
+    extend ActiveSupport::Concern
+
+    included do
+      headers["User-agent"] = AthenaResource::USER_AGENT || ""
+    end
+
+    module ClassMethods
+      def headers
+        @headers ||= (superclass.headers.try(:dup) || {})
+      end
+    end
+
+  end
+end
+

data/lib/athena_resource/version.rb

@@ -0,0 +1,3 @@
+module AthenaResource
+  VERSION = "0.0.1"
+end

data/spec/athena_resource/auth_type_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+class Foo < AthenaResource::Base
+end
+
+class Bar < AthenaResource::Base
+  self.auth_type = "basic"
+end
+
+describe AthenaResource::AuthType do
+  describe "subclasses" do
+    it "allow for separate auth types per subclass" do
+      Foo.auth_type.should eq nil
+      Bar.auth_type.should eq "basic"
+    end
+  end
+end

data/spec/athena_resource/callbacks_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+class CallbackResource < AthenaResource::Base
+  self.site = "http://localhost"
+  before_save :foo
+  after_save :bar
+
+  before_validation :baz
+  after_validation :bat
+
+  def history
+    @history ||= []
+  end
+
+  def foo; history << :foo; end
+  def bar; history << :bar; end
+  def baz; history << :baz; end
+  def bat; history << :bat; end
+end
+
+describe AthenaResource::Callbacks do
+  before(:all) do
+    ActiveResource::HttpMock.respond_to do |mock|
+      mock.post "/callback_resources.json", {"Authorization"=>"Basic dGVzdGVyOnBhc3N3b3Jk", "Content-Type"=>"application/json", "User-agent"=>"TestingAgent"}, ""
+    end
+  end
+
+  describe "#save callbacks" do
+    subject { CallbackResource.new }
+
+    before(:each) do
+      subject.save
+    end
+
+    it "calls before save methods before calling save" do
+      subject.history.first.should eq :foo
+    end
+
+    it "calls after save methods after calling save" do
+      subject.history.last.should eq :bar
+    end
+
+    it "calls calls each method in order" do
+      subject.history.should eq [ :foo, :baz, :bat, :bar ]
+    end
+  end
+
+  describe "#save callbacks" do
+    subject { CallbackResource.new }
+
+    before(:each) do
+      subject.valid?
+    end
+
+    it "calls before save methods before calling save" do
+      subject.history.first.should eq :baz
+    end
+
+    it "calls after save methods after calling save" do
+      subject.history.last.should eq :bat
+    end
+
+    it "calls calls each method in order" do
+      subject.history.should eq [ :baz, :bat ]
+    end
+  end
+end

data/spec/athena_resource/headers_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+class Foo < AthenaResource::Base
+end
+
+class Bar < AthenaResource::Base
+end
+
+describe AthenaResource::Headers do
+
+  subject { AthenaResource::Base.new }
+
+  it "sets the default user User agent" do
+    subject.class.headers['User-agent'].should eq "TestingAgent"
+  end
+
+  describe "subclasses" do
+    it "allow for separate user agents per subclass" do
+      Foo.headers['User-agent'] = "FooAgent"
+      Bar.headers['User-agent'].should eq "TestingAgent"
+      Bar.headers['User-agent'].should_not eq "FooAgent"
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'athena_resource'
+
+AthenaResource::USER_AGENT = "TestingAgent"
+AthenaResource::USER = "tester"
+AthenaResource::PASSWORD = "password"
+AthenaResource::AUTH_TYPE = nil

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification 
+name: athena_resource
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Micah Frost
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-29 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: " Easily consume ATHENA resources by subclasses AthenaResource "
+email: 
+- athena@fracturedatlas.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- Gemfile
+- Rakefile
+- athena_resource.gemspec
+- lib/athena_resource.rb
+- lib/athena_resource/auth_type.rb
+- lib/athena_resource/base.rb
+- lib/athena_resource/callbacks.rb
+- lib/athena_resource/encoding.rb
+- lib/athena_resource/finders.rb
+- lib/athena_resource/formats.rb
+- lib/athena_resource/formats/athena_format.rb
+- lib/athena_resource/headers.rb
+- lib/athena_resource/version.rb
+- spec/athena_resource/auth_type_spec.rb
+- spec/athena_resource/callbacks_spec.rb
+- spec/athena_resource/headers_spec.rb
+- spec/spec_helper.rb
+homepage: http://athena.fracturedatlas.org
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: ATHENA API Wrapper
+test_files: 
+- spec/athena_resource/auth_type_spec.rb
+- spec/athena_resource/callbacks_spec.rb
+- spec/athena_resource/headers_spec.rb
+- spec/spec_helper.rb