arbor 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ef88472480a661ea860c484d64e75f9884a2d171
+  data.tar.gz: 13885de2ac13295ab06788ece47856b6502cf1af
+SHA512:
+  metadata.gz: a19f952f616fb95da9c16d36bf6a4b67d87bf1051096fedd5bf3c11714bdea34611f2277cab870c369276ecaa2f0a4d9aecd466c1eb8fa8b566ad9635c8adbcd
+  data.tar.gz: ec4b7ba338c051f2d8020bdc4b40e8fc705dc14a3d088aba5724f58fe3eff1e5063c1fa3cfe06fee7218020cf7ce6ad38471794bf2458f9deccc4f6f1a60e00d

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,34 @@
+PATH
+  remote: .
+  specs:
+    arbor (0.0.1)
+      activesupport (>= 3.0.0)
+      httpi
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.1.5)
+      i18n (~> 0.6, >= 0.6.9)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.1)
+      tzinfo (~> 1.1)
+    httpi (2.0.2)
+      rack
+    i18n (0.6.11)
+    json (1.8.1)
+    minitest (5.4.1)
+    rack (1.5.2)
+    rake (10.3.2)
+    thread_safe (0.3.4)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  arbor!
+  bundler (~> 1.3)
+  rake

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2014 Mike Campbell, Meritec Ltd
+
+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,48 @@
+# Ruby Interface for Arbor API
+
+A Ruby interface to [Arbor Education API](http://www.arbor-education.com/developers.html).
+
+## Installation
+
+    gem install arbor
+
+## Usage
+
+```ruby
+require 'arbor'
+
+client = Arbor::Client.new("some-school", "user@email.net", "abc123")
+
+# retrieve all students
+students = client.query(:students)
+
+# resources loaded by `query` (listings) are lazily loaded, and will
+# generate another request for that specific resource when an attribute is
+# requested which isn't already loaded
+students.each do |s|
+  # extra requests to /rest-v2/students/<id> (s.href) occur here for each item
+  puts "#{s.person.legal_first_name} #{s.person.legal_last_name}"
+end
+
+# use `retrieve` to get a single resource
+student = client.retrieve(:student, 1)
+
+# by default, it serialises the API responses in to classes defined for
+# each resource. you can set your own serialiser for a resource type:
+Arbor.serialisers.register(:students, MyStudentSerialiser)
+
+# and/or modify the default serialiser. serialiser classes must respond to
+# `deserialise` and return a single resource
+Arbor.serialisers.default_serialiser = MyDefaultSerialiser
+```
+
+## Still to do
+
+- Write tests
+- Support the other stuff like ordering, paging, changelog etc.
+- Include an API mixin for the resource classes
+- RDoc it up
+
+## Licence
+
+[MIT License](http://opensource.org/licenses/MIT)

data/arbor.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'arbor/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "arbor"
+  spec.version       = Arbor::VERSION
+  spec.authors       = ["Mike Campbell"]
+  spec.email         = ["mike.campbell@meritec.co.uk"]
+  spec.description   = %q{Interface for the Arbor Education REST API.}
+  spec.summary       = %q{Interface for the Arbor Education REST API.}
+  spec.homepage      = "http://github.com/meritec/arbor-rb"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport", ">= 3.0.0"
+  spec.add_dependency "httpi", ">= 2.0.5"
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake", "~> 0"
+end

data/doctor.rb

@@ -0,0 +1,87 @@
+# Usage: ruby doctor.rb [HOST=status.github.com[:PORT=443]]
+require 'rbconfig'
+require 'net/https'
+
+if ARGV[0] =~ /^[^-]/
+  host, port = ARGV[0].split(':', 2)
+else
+  host = 'status.github.com'
+end
+port ||= 443
+
+ruby = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+ruby_version = RUBY_VERSION
+if patch = RbConfig::CONFIG['PATCHLEVEL']
+  ruby_version += "-p#{patch}"
+end
+puts "%s (%s)" % [ruby, ruby_version]
+
+openssl_dir = OpenSSL::X509::DEFAULT_CERT_AREA
+mac_openssl = '/System/Library/OpenSSL' == openssl_dir
+puts "%s: %s" % [OpenSSL::OPENSSL_VERSION, openssl_dir]
+[OpenSSL::X509::DEFAULT_CERT_DIR_ENV, OpenSSL::X509::DEFAULT_CERT_FILE_ENV].each do |key|
+  puts "%s=%s" % [key, ENV[key].to_s.inspect]
+end
+
+ca_file = ENV[OpenSSL::X509::DEFAULT_CERT_FILE_ENV] || OpenSSL::X509::DEFAULT_CERT_FILE
+ca_path = (ENV[OpenSSL::X509::DEFAULT_CERT_DIR_ENV] || OpenSSL::X509::DEFAULT_CERT_DIR).chomp('/')
+
+puts "\nHEAD https://#{host}:#{port}"
+http = Net::HTTP.new(host, port)
+http.use_ssl = true
+
+# Explicitly setting cert_store like this is not needed in most cases but it
+# seems necessary in edge cases such as when using `verify_callback` in some
+# combination of Ruby + OpenSSL versions.
+http.cert_store = OpenSSL::X509::Store.new
+http.cert_store.set_default_paths
+
+http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+failed_cert = failed_cert_reason = nil
+
+if mac_openssl
+  warn "warning: will not be able show failed certificate info on OS X's OpenSSL"
+  # This drives me absolutely nuts. It seems that on Rubies compiled against OS X's
+  # system OpenSSL, the mere fact of defining a `verify_callback` makes the
+  # cert verification fail for requests that would otherwise be successful.
+else
+  http.verify_callback = lambda { |verify_ok, store_context|
+    if !verify_ok
+      failed_cert = store_context.current_cert
+      failed_cert_reason = "%d: %s" % [ store_context.error, store_context.error_string ]
+    end
+    verify_ok
+  }
+end
+
+user_agent = "net/http #{ruby_version}"
+req = Net::HTTP::Head.new('/', 'user-agent' => user_agent)
+
+begin
+  res = http.start { http.request(req) }
+  abort res.inspect if res.code.to_i >= 500
+  puts "OK"
+rescue Errno::ECONNREFUSED
+  puts "Error: connection refused"
+  exit 1
+rescue OpenSSL::SSL::SSLError => e
+  puts "#{e.class}: #{e.message}"
+
+  if failed_cert
+    puts "\nThe server presented a certificate that could not be verified:"
+    puts "  subject: #{failed_cert.subject}"
+    puts "  issuer: #{failed_cert.issuer}"
+    puts "  error code %s" % failed_cert_reason
+  end
+
+  ca_file_missing = !File.exist?(ca_file) && !mac_openssl
+  ca_path_empty = Dir["#{ca_path}/*"].empty?
+
+  if ca_file_missing || ca_path_empty
+    puts "\nPossible causes:"
+    puts "  `%s' does not exist" % ca_file if ca_file_missing
+    puts "  `%s/' is empty" % ca_path if ca_path_empty
+  end
+
+  exit 1
+end

data/lib/arbor/api.rb

@@ -0,0 +1,42 @@
+require 'arbor/model/serialiser'
+
+module Arbor
+  module API
+    def retrieve(type, id)
+      resource = parse_resource(type)
+      data = get("/rest-v2/#{resource}/#{id}")
+
+      unmarshall_data(data, resource)
+    end
+
+    def query(type, query = nil)
+      resource = parse_resource(type)
+      query_string = query.build_query_string if query
+
+      data = get("/rest-v2/#{resource}?#{query_string}")
+
+      unmarshall_data(data, resource)
+    end
+
+    private
+      def unmarshall_data(data, resource)
+        singular_resource = resource.to_s.singularize
+        plural_resource   = resource.to_s
+
+        if (res = data[singular_resource])
+          Model::Serialiser.parse_resource(res).tap { |obj|
+            obj.attach_client(self) if obj.respond_to?(:attach_client)
+            obj.lock_attributes = true
+          }
+        elsif data[plural_resource]
+          data[plural_resource].map do |res|
+            Model::Serialiser.parse_resource(res).tap { |obj|
+              obj.attach_client(self) if obj.respond_to?(:attach_client)
+            }
+          end
+        else
+          raise Errors::SerialisationError, "Unexpected root key in API data."
+        end
+      end
+  end
+end

data/lib/arbor/client.rb

@@ -0,0 +1,37 @@
+require 'arbor/api'
+require 'arbor/utils'
+require 'httpi'
+require 'json'
+
+module Arbor
+  class Client
+    include Arbor::API
+    include Arbor::Utils
+    attr_accessor :host, :username, :password, :settings
+
+    def initialize(*args)
+      @settings = args.last.is_a?(Hash) ? args.pop : {}
+      raise ArgumentError, "must supply a subdomain, username and password" if args.length < 3
+      subdomain, @username, @password = args
+      @host = "https://#{subdomain}.uk.arbor.sc"
+    end
+
+    [:get, :post].each do |verb|
+      define_method(verb) do |*args|
+        request = configure_request(*args)
+        response = HTTPI.request(verb, request, settings[:adapter])
+        JSON.parse(response.body.presence || "{}")
+      end
+    end
+
+    private
+      def configure_request(path, *args)
+        url = "#{host}#{path}"
+        request = HTTPI::Request.new(url, *args)
+        request.headers["Accept"] = "application/json"
+        auth_type = settings[:adapter] == :net_http ? :basic : :digest
+        request.auth.send(auth_type, username, password)
+        request
+      end
+  end
+end

data/lib/arbor/errors.rb

@@ -0,0 +1,6 @@
+module Arbor
+  module Errors
+    SerialisationError = Class.new(StandardError)
+    UnknownAttributeError = Class.new(StandardError)
+  end
+end

data/lib/arbor/filter.rb

@@ -0,0 +1,19 @@
+require 'arbor/utils'
+
+module Arbor
+  class Filter
+    include Arbor::Utils
+    attr_accessor :attribute, :operator, :value
+    OPERATORS = [:equals, :from, :to, :after, :before, :search, :in]
+
+    def initialize(attribute, operator, value)
+      @attribute = attribute
+      @operator = validate(operator, OPERATORS)
+      @value = value
+    end
+
+    def to_s
+      "filters.#{attribute}.#{operator}=#{value}"
+    end
+  end
+end

data/lib/arbor/model/abstract.rb

@@ -0,0 +1,69 @@
+require 'arbor/model/serialiser'
+
+module Arbor
+  module Model
+    class Abstract
+      attr_accessor :api_client, :entity_type, :attribute_names, :attribute_lock
+
+      def initialize(attributes)
+        @attribute_names = []
+        load_attributes(attributes)
+      end
+
+      def method_missing(meth, *args, &block)
+        attribute_lock ? super : begin
+          refresh_data
+          send(meth, *args, &block)
+        end
+      end
+
+      def refresh_data
+        raise "No API client configured for this resource" if api_client.nil?
+        raise "No entity_type set for this resource" if entity_type.nil?
+        raise "No known endpoint for this resource" if href.nil?
+
+        data = api_client.get(href)
+
+        parsed_attributes = Serialiser.parse_attributes(data[entity_type.downcase])
+        load_attributes(parsed_attributes)
+        attach_client(self.api_client)
+
+        @attribute_lock = true
+      end
+
+      def load_attributes(attributes)
+        attributes.each do |name, value|
+          unless self.respond_to?("#{name}=")
+            self.class.instance_eval { define_method(name) { attribute(name) } }
+            self.class.send(:attr_writer, name)
+          end
+          @attribute_names << name
+          self.send("#{name}=", value)
+        end
+      end
+
+      def attribute(name)
+        if instance_variable_defined?("@#{name}")
+          instance_variable_get("@#{name}")
+        else
+          raise Errors::UnknownAttributeError if attribute_lock
+          refresh_data
+          attribute(name)
+        end
+      end
+
+      def attach_client(client)
+        self.api_client = client
+        self.attribute_names.each do |name|
+          if send(name).respond_to?("api_client=")
+            send(name).attach_client(client)
+          end
+        end
+      end
+
+      def unlock_attributes
+        @attribute_lock = false
+      end
+    end
+  end
+end

data/lib/arbor/model/factory.rb

@@ -0,0 +1,18 @@
+require 'arbor/model/abstract'
+
+module Arbor
+  module Model
+    class Factory
+      def self.create(type = :unknown)
+        class_name = type.to_s.classify
+
+        unless Arbor::Model.const_defined?(class_name)
+          type_class = Class.new(Arbor::Model::Abstract)
+          Arbor::Model.const_set(class_name, type_class)
+        end
+
+        Arbor::Model.const_get(class_name)
+      end
+    end
+  end
+end

data/lib/arbor/model/no_op_serialiser.rb

@@ -0,0 +1,9 @@
+module Arbor
+  module Model
+    class NoOpSerialiser
+      def self.deserialise(data)
+        data
+      end
+    end
+  end
+end

data/lib/arbor/model/serialiser.rb

@@ -0,0 +1,41 @@
+require 'arbor/model/factory'
+
+module Arbor
+  module Model
+    class Serialiser
+      class << self
+        def deserialise(data)
+          attributes = parse_attributes(data)
+
+          resource = data["entityType"].underscore.to_sym
+          Factory.create(resource).new(attributes)
+        end
+
+        def parse_attributes(attributes)
+          attr_array = attributes.map do |key, value|
+            value = case value
+              when Hash
+                parse_resource(value)
+              when Array
+                value.map { |nr| parse_resource(nr) }
+              else
+                value
+              end
+            [key, value]
+          end
+
+          transform_keys(Hash[attr_array])
+        end
+
+        def parse_resource(r)
+          nested_type = r["entityType"]
+          nested_type ? Arbor.serialisers[nested_type].deserialise(r) : r
+        end
+
+        def transform_keys(hash)
+          Hash[hash.map { |k, v| [k.underscore, v] }]
+        end
+      end
+    end
+  end
+end

data/lib/arbor/query.rb

@@ -0,0 +1,24 @@
+require 'uri'
+require 'arbor/utils'
+require 'arbor/filter'
+
+module Arbor
+  class Query
+    include Arbor::Utils
+
+    attr_accessor :filters, :resource
+
+    def initialize(type, filters = [])
+      @resource = parse_resource(type)
+      @filters = filters
+    end
+
+    def build_query_string
+      URI.escape(filters.map(&:to_s).join("&"))
+    end
+
+    def add_filter(*args)
+      @filters << Arbor::Filter.new(*args)
+    end
+  end
+end

data/lib/arbor/serialiser_registry.rb

@@ -0,0 +1,25 @@
+require 'arbor/model/serialiser'
+
+module Arbor
+  class SerialiserRegistry
+    attr_accessor :registry, :default_serialiser
+
+    def initialize
+      @registry = {}
+      @default_serialiser = Model::Serialiser
+    end
+
+    def register(resource, serialiser)
+      registry[resource] = serialiser
+    end
+
+    def unregister(resource)
+      registry[resource] = nil
+    end
+
+    def get_serialiser(resource)
+      registry[resource] || default_serialiser
+    end
+    alias_method :[], :get_serialiser
+  end
+end

data/lib/arbor/utils.rb

@@ -0,0 +1,29 @@
+require 'active_support/core_ext/string'
+
+module Arbor
+  module Utils
+    def parse_resource(type)
+      validate(get_resource(type), Arbor::RESOURCES)
+    end
+
+    def get_resource(type)
+      case type
+      when Class
+        type.name.pluralize.underscore.to_sym
+      else
+        type.to_s.pluralize.to_sym
+      end
+    end
+
+    def validate(choice, options)
+      unless options.include?(choice)
+        raise ArgumentError, "#{choice} is not a valid option: #{options}"
+      end
+      choice
+    end
+
+    def left_pad(array, num)
+      num.times { array.unshift(nil) }
+    end
+  end
+end

data/lib/arbor/version.rb

@@ -0,0 +1,3 @@
+module Arbor
+  VERSION = "0.0.2"
+end

data/lib/arbor.rb

@@ -0,0 +1,149 @@
+require 'arbor/client'
+require 'arbor/query'
+require 'arbor/serialiser_registry'
+require 'active_support/inflector'
+require 'arbor/errors'
+
+module Arbor
+  class << self
+    def serialisers
+      @serialisers ||= SerialiserRegistry.new
+    end
+  end
+
+  RESOURCES = [:academic_calendar_dates, :academic_holidays, :academic_levels,
+    :academic_level_memberships, :academic_level_registration_form_mappings,
+    :academic_level_tutors, :academic_programmes, :academic_programme_instances,
+    :academic_teaching_hours, :academic_units,
+    :academic_unit_automatic_enrolments, :academic_unit_cohorts,
+    :academic_unit_cohort_memberships, :academic_unit_curriculums,
+    :academic_unit_enrolments, :academic_unit_leads, :academic_unit_tags,
+    :academic_working_days, :academic_years, :achievement_levels,
+    :achievement_level_sets, :additional_payment_reasons, :alerts, :allowances,
+    :allowance_amounts, :applications, :application_settings,
+    :application_withdrawal_reasons, :aspects, :aspect_sets, :assessments,
+    :assessment_batches, :assessment_batch_targets, :assessment_derivations,
+    :assessment_derivation_dependants, :assessment_templates,
+    :assessment_template_assessments, :attendance_follow_ups, :attendance_marks,
+    :attendance_patterns, :attendance_pattern_periods, :attendance_records,
+    :attendance_register_types, :attendance_register_type_marks,
+    :awarding_bodies, :awarding_body_staffs, :bank_details, :behaviours,
+    :behavioural_contracts, :behavioural_contract_goals,
+    :behavioural_contract_parties, :behavioural_contract_periods,
+    :behavioural_incidents, :behavioural_incident_actions,
+    :behavioural_incident_behaviours, :behavioural_incident_staff_involvements,
+    :behavioural_incident_student_involvements, :behavioural_notes,
+    :boarding_patterns, :boarding_statuses, :bookable_resource_periods,
+    :business_roles, :business_role_assignments,
+    :business_role_default_user_roles, :calendars, :calendar_entries,
+    :calendar_entry_dates, :calendar_entry_mappings, :calendar_types, :cases,
+    :center_numbers, :check_clearance_levels, :check_types,
+    :child_protection_statuses, :child_protection_status_assignments,
+    :collections, :communication_actions, :communication_tags, :companies,
+    :company_staffs, :consents, :consent_types, :contents, :content_tags,
+    :countries, :court_orders, :court_order_parties, :cover_arrangements,
+    :cover_requirements, :curriculums, :curriculum_evidences, :curriculum_goals,
+    :curriculum_grades, :curriculum_judgements, :curriculum_sections,
+    :curriculum_stages, :curriculum_tiers, :custom_groups,
+    :custom_group_memberships, :dashboards, :dashboard_kpis,
+    :dashboard_sections, :data_check_errors, :data_check_error_related_entities,
+    :data_export_errors, :data_export_error_tags, :data_item_subscriptions,
+    :data_set_subscriptions, :detentions, :detention_sessions,
+    :dietary_requirements, :dietary_requirement_types, :document_html_templates,
+    :document_image_templates, :document_layouts, :education_plans,
+    :education_plan_contributors, :eligibilities, :eligibility_records, :emails,
+    :email_accounts, :email_account_access_permissions, :email_addresses,
+    :email_drafts, :email_mailboxes, :email_parts, :email_recipients,
+    :email_references, :email_senders, :email_statuses, :enrolment_modes,
+    :ethnicities, :event_participants, :event_participant_invitations,
+    :exceptions, :exclusion_reasons, :faculties, :faculty_members, :files,
+    :genders, :grades, :grade_point_scales, :grade_point_scale_level_grade_sets,
+    :grade_sets, :guardians, :guardian_consultations,
+    :guardian_relationship_types, :hearing_tests, :houses, :house_memberships,
+    :house_tutors, :hydrators, :identification_document_types, :identity_cards,
+    :identity_card_readers, :immunizations, :immunization_types,
+    :impairment_categories, :import_records, :in_care_statuses,
+    :in_care_status_assignments, :intake_seasons,
+    :intake_season_applicant_buckets, :intake_season_groups, :item_units, :kpis,
+    :kpi_ranges, :kpi_targets, :kpi_values, :languages, :language_abilities,
+    :layout_object_types, :letters, :letter_drafts, :meals, :meal_patterns,
+    :meal_prices, :meal_provisions, :meal_sessions,
+    :meal_session_register_records, :meal_sittings,
+    :meal_sitting_automatic_attendee_targets, :medical_conditions,
+    :medical_condition_medications, :medical_condition_types, :medical_events,
+    :medical_event_types, :medical_institutions, :medical_institution_staffs,
+    :medical_plans, :medical_relationship_types, :medications, :meetings,
+    :meeting_notes, :meeting_topics, :message_draft_recipients, :model_bases,
+    :motor_vehicles, :motor_vehicle_makes, :nationality_statuses,
+    :next_of_kin_relationships, :notes, :notices, :operations, :pastoral_notes,
+    :pay_scales, :pay_scale_grades, :pay_scale_grade_spinal_points,
+    :pay_scale_spinal_points, :pay_scale_spinal_point_values,
+    :permanent_exclusions, :people, :person_checks, :person_former_names,
+    :person_identification_documents, :person_impairments,
+    :person_nationalities, :person_next_of_kins,
+    :person_professional_qualifications, :person_training_courses,
+    :person_transportation_methods, :point_awards, :point_award_categories,
+    :point_award_scales, :point_award_totals, :positions,
+    :position_business_roles, :postal_addresses, :postal_address_occupancies,
+    :professional_qualification_classes, :professional_qualification_subjects,
+    :professional_qualification_types, :progress_assessment_batches,
+    :progress_assessment_batch_measurement_periods,
+    :progress_assessment_batch_targets, :progress_measurement_periods,
+    :qualification_aspects, :qualification_assessables,
+    :qualification_assessable_instances, :qualification_awards,
+    :qualification_award_level_types, :qualification_award_types,
+    :qualification_centre_assessed_marks,
+    :qualification_element_disallowed_combinations,
+    :qualification_element_relationships, :qualification_element_series_links,
+    :qualification_grades, :qualification_grade_sets,
+    :qualification_incoming_messages, :qualification_learning_units,
+    :qualification_predictions, :qualification_registrations,
+    :qualification_registration_requests, :qualification_request_batches,
+    :qualification_results, :qualification_schemes, :qualification_series,
+    :qualification_special_arrangements,
+    :qualification_special_arrangement_types, :qualification_timetable_sessions,
+    :qualification_timetable_session_types, :qualification_time_windows,
+    :qualification_time_window_collections, :registration_forms,
+    :registration_form_memberships, :registration_form_tutors, :religions,
+    :report_card_batches, :report_card_batch_targets,
+    :report_card_batch_template_variables, :report_card_templates,
+    :report_card_template_sections, :report_subscriptions, :rooms, :room_assets,
+    :room_features, :room_room_assets, :room_room_features, :schools,
+    :school_enrolments, :school_events, :school_event_types, :school_staffs,
+    :school_trips, :schoolworks, :schoolwork_curriculum_goals,
+    :schoolwork_types, :sending_profiles, :sen_events, :sen_event_outcomes,
+    :sen_event_outcome_types, :sen_event_types, :sen_needs, :sen_need_types,
+    :sen_notes, :sen_provisions, :sen_provision_linked_relationships,
+    :sen_provision_types, :sen_statements, :sen_statuses,
+    :sen_status_assignments, :sessions, :session_curriculum_goals,
+    :session_room_asset_requirements, :session_room_feature_requirements,
+    :session_streams, :session_stream_automatic_enrolments,
+    :session_stream_enrolments, :session_stream_leads, :sites,
+    :site_operating_periods, :site_operating_period_exceptions,
+    :site_travel_times, :sms_messages, :sms_message_drafts, :sms_message_parts,
+    :sms_message_statuses, :snippets, :snippet_availabilities, :staffs,
+    :staff_absences, :staff_absence_categories, :staff_attendance_marks,
+    :staff_attendance_records, :staff_contracts, :staff_contract_posts,
+    :staff_contract_post_additional_payments, :staff_contract_post_allowances,
+    :staff_contract_post_end_reasons, :staff_contract_post_rates,
+    :staff_contract_post_salaries, :staff_contract_post_start_reasons,
+    :staff_destinations, :staff_employment_types, :staff_origins,
+    :staff_room_feature_requirements, :staff_working_periods, :students,
+    :student_absence_notes, :student_assessments, :student_assessment_marks,
+    :student_attendance_patterns, :student_guardian_relationships,
+    :student_linked_relationships, :student_linked_relationship_types,
+    :student_medical_relationships, :student_other_school_attendance_records,
+    :student_progress_assessments, :student_progress_assessment_marks,
+    :student_progress_baselines, :student_progress_goals, :student_report_cards,
+    :student_report_card_marks, :student_report_card_sections,
+    :student_room_feature_requirements, :student_schools, :student_schoolworks,
+    :student_schoolwork_marks, :subjects, :superannuation_schemes,
+    :superannuation_scheme_values, :tags, :taggings,
+    :teaching_assistant_allocations, :telephone_calls, :telephone_numbers,
+    :temporary_exclusions, :terms, :timetable_slots, :timetable_slot_staffs,
+    :titles, :training_courses, :training_events, :transportation_methods,
+    :triggers, :unenrolment_reasons, :universities, :university_staffs,
+    :usage_log_entries, :users, :user_defined_fields, :user_defined_records,
+    :user_notifications, :user_roles, :user_role_assignments, :vision_tests,
+    :widgets, :widget_types, :workitems, :workitem_assignments]
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: arbor
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Mike Campbell
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: httpi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.5
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Interface for the Arbor Education REST API.
+email:
+- mike.campbell@meritec.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- MIT-LICENSE
+- README.md
+- Rakefile
+- arbor.gemspec
+- doctor.rb
+- lib/arbor.rb
+- lib/arbor/api.rb
+- lib/arbor/client.rb
+- lib/arbor/errors.rb
+- lib/arbor/filter.rb
+- lib/arbor/model/abstract.rb
+- lib/arbor/model/factory.rb
+- lib/arbor/model/no_op_serialiser.rb
+- lib/arbor/model/serialiser.rb
+- lib/arbor/query.rb
+- lib/arbor/serialiser_registry.rb
+- lib/arbor/utils.rb
+- lib/arbor/version.rb
+homepage: http://github.com/meritec/arbor-rb
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.3.0
+signing_key: 
+specification_version: 4
+summary: Interface for the Arbor Education REST API.
+test_files: []
+has_rdoc: