grom 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: '05864c0145ac584f326c708cd0b7c0331856a111'
+  data.tar.gz: 3f3eeb74ad8b02887fc8365e3650ceba0a6134bd
+SHA512:
+  metadata.gz: 5b8bc8f5cf98c9668df249284774ec47ee0ce06a4b75d87135eba191fa2f900504e728fd86d4ebecaf70058801d1cd8d193b278cb4a3ff1dedc71f73ca7dc0fc
+  data.tar.gz: ea8afc191d34039ab45e1f3f51807f65b2125e70edd83ef20e2f928acec57e58bfe23d5d4d41bb25982439d06b96268221948cc9f5ccefc1fa76c4123368302b

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 Rebecca Appleyard
+
+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,77 @@
+# 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. 
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'grom', git: "https://github.com/ukpds/grom"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+## Usage
+
+#### Set up
+You will need to set three constants in order for the package to work. 
+
+```
+API_ENDPOINT = 'http://example.com'
+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.
+
+
+#### 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.
+
+Here is an example of a Person class.
+
+```
+class Person < Grom::Base
+
+  def self.property_translator
+    {
+        id: 'id',
+        forename: 'forename',
+        surname: 'surname',
+        middleName: 'middle_name',
+        dateOfBirth: 'date_of_birth'
+    }
+  end
+end
+```
+
+#### 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.
+
+The name of the association must match the name of the class but it needs to be underscored and pluralized just like in ActiveRecord.
+
+```
+class Person < Grom::Base
+  has_many :contact_points
+```
+
+
+##### #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.
+
+```
+class Person < Grom::Base
+  has_many_through :parties, via: :party_memberships
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,34 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Grom'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+
+
+require 'bundler/gem_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/lib/grom/base.rb

@@ -0,0 +1,108 @@
+require 'grom'
+require 'uri'
+require_relative '../../lib/grom/helpers'
+
+module Grom
+  class Base
+    extend Grom::GraphMapper
+    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?)
+          instance_variable_set("@#{translated_key}", v)
+          self.class.send(:attr_reader, translated_key)
+        end
+      end
+    end
+
+    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)
+    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)
+    end
+
+    def self.has_many(association)
+      self.class_eval("def #{association}(optional=nil); #{create_class_name(association)}.has_many_query(self, optional); 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")
+    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)
+    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)
+    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
+    end
+
+    def self.through_getter_setter(through_property_plural)
+      self.class_eval("def #{through_property_plural}=(array); @#{through_property_plural} = array; end")
+      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)
+      end
+    end
+
+    def self.object_single_maker(graph_data)
+      self.object_array_maker(graph_data).first
+    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)
+        end
+      end
+      hash
+    end
+  end
+end

data/lib/grom/graph_mapper.rb

@@ -0,0 +1,79 @@
+require 'grom'
+
+module Grom
+  module GraphMapper
+
+    def get_graph_data(uri)
+      ttl_data = Net::HTTP.get(URI(uri))
+      create_graph_from_ttl(ttl_data)
+    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
+    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|
+        reader.each_statement do |statement|
+          graph << statement
+        end
+      end
+      graph
+    end
+
+    def get_id(uri)
+      uri == RDF.type.to_s ? 'type' : uri.to_s.split("/").last
+    end
+
+    def get_object_and_predicate(statement)
+      predicate = get_id(statement.predicate)
+      { 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
+        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
+
+  end
+end

data/lib/grom/helpers.rb

@@ -0,0 +1,60 @@
+require 'grom'
+
+module Grom
+  module Helpers
+
+    def associations_url_builder(owner_object, associated_class_name, options={})
+      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"
+    end
+
+    def find_base_url_builder(class_name, id)
+      "#{API_ENDPOINT}/#{create_plural_property_name(class_name)}/#{id}"
+    end
+
+    def all_base_url_builder(class_name, *options)
+      endpoint = "#{API_ENDPOINT}/#{create_plural_property_name(class_name)}"
+        options.each do |option|
+          endpoint += "/#{option}" unless option.nil?
+        end
+      endpoint
+    end
+
+    def create_class_name(plural_name)
+      ActiveSupport::Inflector.camelize(ActiveSupport::Inflector.singularize(plural_name.to_s).capitalize)
+    end
+
+    def create_plural_property_name(class_name)
+      ActiveSupport::Inflector.pluralize(create_property_name(class_name))
+    end
+
+    def create_property_name(class_name)
+      ActiveSupport::Inflector.underscore(class_name).downcase
+    end
+
+    def collective_graph(objects)
+      collective_graph = RDF::Graph.new
+      objects.each do |o|
+        collective_graph << o.graph
+      end
+      collective_graph
+    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
+    end
+  end
+end

data/lib/grom.rb

@@ -0,0 +1,12 @@
+require_relative '../lib/grom/graph_mapper'
+require_relative '../lib/grom/base'
+require_relative '../lib/grom/helpers'
+require 'active_support/core_ext/string/inflections'
+
+module Grom
+  VERSION = '0.1.0'
+
+    def self.root
+      File.dirname __dir__
+    end
+end

data/lib/tasks/grom_tasks.rake

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

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: grom
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Rebecca Appleyard
+- Giuseppe De Santis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0.1
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  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'
+- !ruby/object:Gem::Dependency
+  name: rdf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: webmock
+  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'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: Grom is a Graph Object Mapper designed for UK Parliament
+email:
+- rklappleyard@gmail.com
+- giusdesan@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/grom.rb
+- lib/grom/base.rb
+- lib/grom/graph_mapper.rb
+- lib/grom/helpers.rb
+- lib/tasks/grom_tasks.rake
+homepage: ''
+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.6.7
+signing_key: 
+specification_version: 4
+summary: ''
+test_files: []