grom 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: '05864c0145ac584f326c708cd0b7c0331856a111'
-  data.tar.gz: 3f3eeb74ad8b02887fc8365e3650ceba0a6134bd
+  metadata.gz: 34878dcc73dda4ed7d3145cc1bee503d8843d471
+  data.tar.gz: 91303eb86ec021e9ef6d4ab62edb271c1d8a4b89
 SHA512:
-  metadata.gz: 5b8bc8f5cf98c9668df249284774ec47ee0ce06a4b75d87135eba191fa2f900504e728fd86d4ebecaf70058801d1cd8d193b278cb4a3ff1dedc71f73ca7dc0fc
-  data.tar.gz: ea8afc191d34039ab45e1f3f51807f65b2125e70edd83ef20e2f928acec57e58bfe23d5d4d41bb25982439d06b96268221948cc9f5ccefc1fa76c4123368302b
+  metadata.gz: 362e2f954adc564f22875118b2ee2901a968183a72ba900da4d7469153b1198c2f2793efa22c88f0a88bd7b25aa22f91ef58f983124dd5ad6298429114e620b9
+  data.tar.gz: 74f6dd9f20628e1e3e766ca1874c487ea4368aabbf99c33bbe647f1ed488a379216368c75e364d995d4a7b13d4732ba701925ec3f5add0af94534367a977ef29

data/README.md

@@ -1,15 +1,18 @@
 # Graph Object Mapper (Grom)
-Grom is a custom ORM that takes graph data and deserializes it into objects. It uses the ruby-rdf library. We created it in the context
-of UK Parliament new website. 
+Grom is a custom ORM that takes graph data and deserializes it into objects. It uses the [RDF.rb](https://github.com/ruby-rdf/rdf) library. It was created in the context
+of UK Parliament's new website. 
 
 ## Installation
+```apple js
+gem install grom
+```
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'grom', git: "https://github.com/ukpds/grom"
+gem 'grom'
 ```
 
-And then execute:
+Then execute:
 ```bash
 $ bundle
 ```
@@ -17,7 +20,7 @@ $ bundle
 ## Usage
 
 #### Set up
-You will need to set three constants in order for the package to work. 
+You will need to set three constants in order for the gem to work. 
 
 ```
 API_ENDPOINT = 'http://example.com'
@@ -25,14 +28,14 @@ API_ENDPOINT_HOST = 'example.com'
 DATA_URI_PREFIX = 'http://id.example.com'
 ```
 
-Your Api Endpoint will be where you are making the calls to get your graph data. <br>
-Your Data URI prefix is just the prefix that you use to define the entities in your triple store.
+The API Endpoint will be the endpoint where you are making the calls to get graph data. <br>
+The Data URI prefix is the prefix that you use to define the entities in your triple store.
 
 
 #### Models
-In order for the deserialization to work, your models will need to inherit from `Grom::Base` and you will need to define a `self.property_translator` hash where the key should be the predicate (without the prefix) and the value should be whatever you want to call the property of the object.
+Models inherit from `Grom::Base` and need a `self.property_translator` hash defined.   The keys are predicates (without the prefix) and the values are the translated object properties.
 
-Here is an example of a Person class.
+An example of a Person class.
 
 ```
 class Person < Grom::Base
@@ -49,10 +52,31 @@ class Person < Grom::Base
 end
 ```
 
+#### Retrieving Objects
+
+##### #all
+To return a collection of objects use the class method `all`.
+```apple js
+people = Person.all #=> returns an array of People objects
+```
+
+This method can take unlimited parameters.  Including a parameter appends it to the endpoint url creating a new url.  For example,
+
+```apple js
+people = Person.all('current') #=> returns an array of current People
+```
+This generates the endpoint url `http://#{API_ENDPOINT}/people/current.ttl` and returns a list of current people from there.
+
+##### #find
+To return a single object use the class method `find` with an id.
+```apple js
+person = Person.find('1') #=> returns a Person object
+```
+
 #### Associations
 
 ##### #has_many
-For a simple `has_many` association, you need to declare the association at the top of the model. For example, if `Person` has many `contact_points`, you need to have a `ContactPoint` class and you would declare the association at the top of the `Person` class.
+For a simple `has_many` association, declare the association at the top of the model. For example, if `Person` has many `contact_points`, create a `ContactPoint` class and declare the association at the top of the `Person` class.
 
 The name of the association must match the name of the class but it needs to be underscored and pluralized just like in ActiveRecord.
 
@@ -61,17 +85,28 @@ class Person < Grom::Base
   has_many :contact_points
 ```
 
+It is then possible to retrieve the contact_points for a person in the following way:
+
+```apple js
+person = Person.find('1')
+person.contact_points #=> returns an array of contact_points related to person
+```
 
 ##### #has_many_through
-For a `has_many_through` association, you need to declare the association at the top of the model. For example, if `Person` has many `parties` through `party_memberships`, you need to have a `Party` class and a `PartyMembership` and you would declare the association at the top of the `Person` class.
+For a `has_many_through` association, declare the association at the top of the model. For example, if `Person` has many `parties` through `party_memberships`, create a `Party` class and a `PartyMembership` class, then declare the association at the top of the `Person` class.
 
 ```
 class Person < Grom::Base
   has_many_through :parties, via: :party_memberships
 ```
 
-## Contributing
-Contribution directions go here.
+It is then possible to retrieve the parties for a person in the following way:
+
+```apple js
+person = Person.find('1')
+person.parties #=> returns an array of parties with the party_memberships stored as a hash
+```
+
 
 ## License
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/lib/grom/base.rb

@@ -8,14 +8,10 @@ module Grom
     extend Grom::Helpers
 
     def initialize(attributes)
-      unless attributes == {}
-        ttl_graph = self.class.convert_to_ttl(attributes[:graph]).gsub("'", "\\\\'")
-        self.instance_eval("def graph;  self.class.create_graph_from_ttl('#{ttl_graph}') ; end")
-      end
       attributes.each do |k, v|
         translated_key = self.class.property_translator[k]
         v = self.class.create_property_name(self.class.get_id(v)) if (v =~ URI::regexp) == 0
-        unless (v.nil? || translated_key.nil?)
+        unless v.nil? || translated_key.nil?
           instance_variable_set("@#{translated_key}", v)
           self.class.send(:attr_reader, translated_key)
         end
@@ -24,54 +20,40 @@ module Grom
 
     def self.find(id)
       endpoint_url = "#{find_base_url_builder(self.name, id)}.ttl"
-      graph_data = get_graph_data(endpoint_url)
-      self.object_single_maker(graph_data)
+      ttl_data = get_ttl_data(endpoint_url)
+      self.object_single_maker(ttl_data)
     end
 
     def self.all(*options)
       endpoint_url = "#{all_base_url_builder(self.name, *options)}.ttl"
-      graph_data = get_graph_data(endpoint_url)
-      self.object_array_maker(graph_data)
+      ttl_data = get_ttl_data(endpoint_url)
+
+      self.object_array_maker(ttl_data)
     end
 
     def self.has_many(association)
-      self.class_eval("def #{association}(optional=nil); #{create_class_name(association)}.has_many_query(self, optional); end")
+      self.class_eval("def #{association}(*options); #{create_class_name(association)}.has_many_query(self, *options); end")
     end
 
     def self.has_many_through(association, through_association)
       self.has_many(through_association[:via])
-      self.class_eval("def #{association}(optional=nil); #{create_class_name(association)}.has_many_through_query(self, #{create_class_name(through_association[:via])}.new({}).class.name, optional); end")
+      self.class_eval("def #{association}(*options); #{create_class_name(association)}.has_many_through_query(self, #{create_class_name(through_association[:via])}.new({}).class.name, *options); end")
     end
 
     def self.has_one(association)
-      self.class_eval("def #{association}(optional=nil); #{create_class_name(association)}.has_one_query(self, optional); end")
-    end
-
-    def self.has_many_query(owner_object, optional=nil)
-      endpoint_url = associations_url_builder(owner_object, self.name, {optional: optional })
-      graph_data = get_graph_data(endpoint_url)
-      self.object_array_maker(graph_data)
+      self.class_eval("def #{association}(*options); #{create_class_name(association)}.has_one_query(self, *options); end")
     end
 
-    def self.has_one_query(owner_object, optional=nil)
-      endpoint_url = associations_url_builder(owner_object, self.name, {optional: optional, single: true })
-      graph_data = get_graph_data(endpoint_url)
-      self.object_single_maker(graph_data)
+    def self.has_many_query(owner_object, *options)
+      endpoint_url = associations_url_builder(owner_object, self.name, {optional: options })
+      ttl_data = get_ttl_data(endpoint_url)
+      self.object_array_maker(ttl_data)
     end
 
-    def self.has_many_through_query(owner_object, through_class, optional=nil)
-      endpoint_url = associations_url_builder(owner_object, self.name, {optional: optional })
-      graph_data = get_graph_data(endpoint_url)
-      separated_graphs = split_by_subject(graph_data, self.name)
-      associated_objects_array = self.object_array_maker(separated_graphs[:associated_class_graph])
-      through_property_plural = create_plural_property_name(through_class)
-      self.through_getter_setter(through_property_plural)
-      associated_objects_array.each do |associated_object|
-        through_class_array = get_through_graphs(separated_graphs[:through_graph], associated_object.id).map do |graph|
-          ActiveSupport::Inflector.constantize(through_class).object_single_maker(graph)
-        end
-        associated_object.send((through_property_plural + '=').to_sym, through_class_array)
-      end
+    def self.has_one_query(owner_object, *options)
+      endpoint_url = associations_url_builder(owner_object, self.name, {optional: options, single: true })
+      ttl_data = get_ttl_data(endpoint_url)
+      self.object_single_maker(ttl_data)
     end
 
     def self.through_getter_setter(through_property_plural)
@@ -79,30 +61,34 @@ module Grom
       self.class_eval("def #{through_property_plural}; @#{through_property_plural}; end")
     end
 
-    def self.object_array_maker(graph_data)
-      self.statements_mapper_by_subject(graph_data).map do |data|
-        self.new(data)
+    def self.object_array_maker(ttl_data)
+      create_hash_from_ttl(ttl_data).map do |hash|
+        self.new(hash)
       end
     end
 
-    def self.object_single_maker(graph_data)
-      self.object_array_maker(graph_data).first
+    def self.object_single_maker(ttl_data)
+      self.object_array_maker(ttl_data).first
+    end
+
+    def self.has_many_through_query(owner_object, through_class, *options)
+      through_property_plural = create_plural_property_name(through_class)
+      endpoint_url = associations_url_builder(owner_object, self.name, {optional: options })
+      self.through_getter_setter(through_property_plural)
+      ttl_data = get_ttl_data(endpoint_url)
+      self.map_hashes_to_objects(through_split_graph(ttl_data), through_property_plural)
     end
 
-    def serialize_associated_objects(*associations)
-      object_name = self.class.create_property_name(self.class.name).to_sym
-      hash = {
-          object_name => self
-      }
-      associations.each do |association|
-        if association.is_a?(Hash)
-          association_name = association.keys.first
-          hash[association_name] = self.send(association_name, association.values.first)
-        else
-          hash[association] = self.send(association)
+    def self.map_hashes_to_objects(hashes, through_property_plural)
+      through_array = hashes[:through_class_hash].values
+      hashes[:associated_class_hash].values.map do |hash|
+        associated_object = self.new(hash)
+        through_obj_array, through_array = through_array.partition do |t_hash|
+          t_hash[:associated_object_id] == associated_object.id
         end
+        associated_object.send((through_property_plural + '=').to_sym, through_obj_array)
+        associated_object
       end
-      hash
     end
   end
 end

data/lib/grom/graph_mapper.rb

@@ -1,79 +1,56 @@
 require 'grom'
+require 'rdf/turtle'
 
 module Grom
   module GraphMapper
 
-    def get_graph_data(uri)
-      ttl_data = Net::HTTP.get(URI(uri))
-      create_graph_from_ttl(ttl_data)
+    def get_ttl_data(uri)
+      Net::HTTP.get(URI(uri))
     end
 
-    def convert_to_ttl(data)
-      # p "called convert_to_ttl"
-      result = ""
-      data.each_statement do |statement|
-        result << RDF::NTriples::Writer.serialize(statement)
-      end
-      result
+    def get_id(uri)
+      uri == RDF.type.to_s ? 'type' : uri.to_s.split("/").last
     end
 
-    def create_graph_from_ttl(ttl_data)
-      # p "called create_graph_from_ttl"
-      # p ttl_data
-      ttl_data
-      graph = RDF::Graph.new
-      RDF::NTriples::Reader.new(ttl_data) do |reader|
+    def create_hash_from_ttl(ttl_data)
+      hash = {}
+      RDF::Turtle::Reader.new(ttl_data) do |reader|
         reader.each_statement do |statement|
-          graph << statement
+          statement_mapper(statement, hash)
         end
       end
-      graph
-    end
-
-    def get_id(uri)
-      uri == RDF.type.to_s ? 'type' : uri.to_s.split("/").last
+      hash.values
     end
 
-    def get_object_and_predicate(statement)
-      predicate = get_id(statement.predicate)
-      { predicate.to_sym => statement.object.to_s }
+    def statement_mapper(statement, hash)
+      subject = get_id(statement.subject)
+      hash[subject] ||= { :id => subject }
+      hash[subject][get_id(statement.predicate).to_sym] = statement.object.to_s
     end
 
-    def statements_mapper_by_subject(graph)
-      graph.subjects.map do |subject|
-        individual_graph = RDF::Graph.new
-        pattern = RDF::Query::Pattern.new(subject, :predicate, :object)
-        attributes = graph.query(pattern).map do |statement|
-          individual_graph << statement
-          get_object_and_predicate(statement)
-        end.reduce({}, :merge)
-
-        attributes.merge({id: get_id(subject), graph: individual_graph })
-      end
-    end
-
-    def split_by_subject(graph, associated_class_name)
-      associated_class_type_pattern = RDF::Query::Pattern.new(:subject, RDF.type, RDF::URI.new("#{DATA_URI_PREFIX}/schema/#{associated_class_name}"))
-      associated_graph = RDF::Graph.new
-      through_graph = RDF::Graph.new
-      graph.query(associated_class_type_pattern).subjects.map do |subject|
-        subject_pattern = RDF::Query::Pattern.new(subject, :predicate, :object)
-        graph.query(subject_pattern).each do |statement|
-          associated_graph << statement
+    def through_split_graph(ttl_data)
+      associated_hash, through_hash = {}, {}
+      RDF::Turtle::Reader.new(ttl_data) do |reader|
+        reader.each_statement do |s|
+          if (s.subject.to_s =~ URI::regexp) == 0
+            subject = get_id(s.subject)
+            associated_hash[subject] ||= { :id => subject }
+            associated_hash[subject][get_id(s.predicate).to_sym] = s.object.to_s
+          else
+            through_hash[s.subject.to_s] ||= {}
+            if get_id(s.predicate) == "connect"
+              through_hash[s.subject.to_s][:associated_object_id] = get_id(s.object)
+            elsif get_id(s.predicate) == "objectId"
+              through_hash[s.subject.to_s][:id] = get_id(s.object)
+            else
+              through_hash[s.subject.to_s][get_id(s.predicate).to_sym] = s.object.to_s
+            end
+          end
         end
-        through_graph << graph
-        through_graph.delete(associated_graph)
       end
-      { through_graph: through_graph, associated_class_graph: associated_graph }
-    end
 
-    def get_through_graphs(graph, id)
-      connection_pattern = RDF::Query::Pattern.new(:subject, :predicate, RDF::URI.new("#{DATA_URI_PREFIX}/#{id}"))
-      graph.query(connection_pattern).subjects.map do |subject|
-        subject_pattern = RDF::Query::Pattern.new(subject, :predicate, :object)
-        graph.query(subject_pattern)
-      end
-     end
+      { associated_class_hash: associated_hash, through_class_hash: through_hash }
+    end
 
   end
 end

data/lib/grom/helpers.rb

@@ -7,7 +7,15 @@ module Grom
       id = owner_object.id
       associated_class_name = options[:single].nil? ? create_plural_property_name(associated_class_name) : create_property_name(associated_class_name)
       endpoint = "#{find_base_url_builder(owner_object.class.name, id)}/#{associated_class_name}"
-      endpoint += options[:optional].nil? ? '.ttl' : "/#{options[:optional]}.ttl"
+      if options[:optional].nil?
+        endpoint += '.ttl'
+      else
+        options[:optional].each do |option|
+          endpoint += "/#{option}" unless option.nil?
+        end
+        endpoint += '.ttl'
+      end
+      endpoint
     end
 
     def find_base_url_builder(class_name, id)
@@ -34,27 +42,17 @@ module Grom
       ActiveSupport::Inflector.underscore(class_name).downcase
     end
 
-    def collective_graph(objects)
-      collective_graph = RDF::Graph.new
-      objects.each do |o|
-        collective_graph << o.graph
+    def order_list(arr, *parameters)
+      rejected = []
+      arr.delete_if{ |obj| rejected << obj if parameters.any?{ |param| obj.send(param).nil? } }
+      sorted_arr = arr.sort_by do |obj|
+        parameters.map{ |param| obj.send(param) }.select{ |p| not p.nil? }
       end
-      collective_graph
+      rejected.concat(sorted_arr)
     end
 
-    def collective_has_many_graph(owner, association)
-      owner.graph << collective_graph(association)
-    end
-
-    def collective_through_graph(owner, association, through_property)
-      graph = owner.graph
-      association.each do |associated_object|
-        graph << associated_object.graph
-        associated_object.send(through_property).each do |through_object|
-          graph << through_object.graph
-        end
-      end
-      graph
+    def order_list_by_through(arr, through_association, property)
+      arr.map{ |obj| obj.send(through_association) }.flatten.sort{ |a, b| a[property] <=> b[property] }
     end
   end
 end

data/lib/grom.rb

@@ -4,7 +4,7 @@ require_relative '../lib/grom/helpers'
 require 'active_support/core_ext/string/inflections'
 
 module Grom
-  VERSION = '0.1.0'
+  VERSION = '0.1.1'
 
     def self.root
       File.dirname __dir__

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: grom
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Rebecca Appleyard
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-29 00:00:00.000000000 Z
+date: 2016-12-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -46,13 +46,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec-rails
+  name: rdf-turtle
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -60,19 +60,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rdf
+  name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.1.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.1.0
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: webmock
   requirement: !ruby/object:Gem::Requirement