cru_lib 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5c8f38e8b4e257661870015c17629990db58161d
+  data.tar.gz: 9998e4d8a67bb11c536e7b4cbc7c2ac6282c6fc9
+SHA512:
+  metadata.gz: af8bb684ad41e2666550aef5042653c4fec652146d47d9a40eff77187c7f2123fc6a0ef8e5917e56f44342ed16c878c2a92848c9e7f764917ef4f7c33d529745
+  data.tar.gz: 75a86c8d69ed9fb4dbb0453f425ceffc13b5d943bebdc4d1dd00dc4d0bbd79b1d13f6e4dbe378f9c7ce64526a4a9da0dd91a19f9e0176b29bb42f479b733212f

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in cru_lib.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Josh Starcher
+
+MIT License
+
+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,30 @@
+# CruLib
+
+This gem hold a useful collection of functions, methods and classes used
+in various Cru apps.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'cru_lib'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cru_lib
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/cru_lib/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/cru_lib.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cru_lib/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "cru_lib"
+  spec.version       = CruLib::VERSION
+  spec.authors       = ["Josh Starcher"]
+  spec.email         = ["josh.starcher@gmail.com"]
+  spec.summary       = %q{Misc libraries for Cru}
+  spec.description   = %q{Collection of common ruby logic used by a number of Cru apps}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+end

data/lib/cru_lib/async.rb

@@ -0,0 +1,23 @@
+module CruLib
+  module Async
+
+    # This will be called by a worker when a job needs to be processed
+    def perform(id, method, *args)
+      if id
+        begin
+          self.class.find(id).send(method, *args)
+        rescue ActiveRecord::RecordNotFound
+          # If the record was deleted after the job was created, swallow it
+        end
+      else
+        self.class.send(method, *args)
+      end
+    end
+
+    def async(method, *args)
+      Sidekiq::Client.enqueue(self.class, id, method, *args)
+    end
+
+  end
+end
+

data/lib/cru_lib/global_registry_methods.rb

@@ -0,0 +1,131 @@
+require 'cru_lib'
+require 'cru_lib/async'
+
+module CruLib
+  module GlobalRegistryMethods
+    extend ActiveSupport::Concern
+    include CruLib::Async
+
+
+    included do
+      after_commit :push_to_global_registry
+      after_destroy :delete_from_global_registry
+    end
+
+    def delete_from_global_registry
+      if global_registry_id
+        Sidekiq::Client.enqueue(self.class, nil, :async_delete_from_global_registry, global_registry_id)
+      end
+    end
+
+    # Define default push method
+    def push_to_global_registry
+      async(:async_push_to_global_registry)
+    end
+
+    def async_push_to_global_registry(parent_id = nil, parent_type = nil)
+      self.class.push_structure_to_global_registry
+
+      if global_registry_id
+        begin
+          update_in_global_registry(parent_id, parent_type)
+        rescue RestClient::ResourceNotFound
+          create_in_global_registry(parent_id, parent_type)
+        end
+      else
+        create_in_global_registry(parent_id, parent_type)
+      end
+    end
+
+    def attributes_to_push(*args)
+      unless @attributes_to_push
+        @attributes_to_push = {}
+        attributes_to_push['client_integration_id'] = id unless self.class.skip_fields_for_gr.include?('client_integration_id')
+        attributes_to_push['client_updated_at'] = updated_at if respond_to?(:updated_at)
+        attributes.collect {|k, v| @attributes_to_push[k.underscore] = v}
+        @attributes_to_push.select! {|k, v| v.present? && !self.class.skip_fields_for_gr.include?(k)}
+      end
+      @attributes_to_push
+    end
+
+    def update_in_global_registry(parent_id = nil, parent_type = nil)
+      if parent_type
+        create_in_global_registry(parent_id, parent_type)
+      else
+        GlobalRegistry::Entity.put(global_registry_id, {entity: attributes_to_push})
+      end
+    end
+
+    def create_in_global_registry(parent_id = nil, parent_type = nil)
+      entity_attributes = { self.class.global_registry_entity_type_name => attributes_to_push }
+      if parent_type.present?
+        entity_attributes = {parent_type => entity_attributes}
+        GlobalRegistry::Entity.put(parent_id, {entity: entity_attributes})
+      else
+        entity = GlobalRegistry::Entity.post(entity: entity_attributes)
+        global_registry_id = entity['entity'][self.class.global_registry_entity_type_name]['id']
+        update_column(:global_registry_id, global_registry_id)
+      end
+    end
+
+    module ClassMethods
+      def push_structure_to_global_registry(parent_id = nil)
+        # Make sure all columns exist
+        entity_type = Rails.cache.fetch(global_registry_entity_type_name, expires_in: 1.hour) do
+          GlobalRegistry::EntityType.get(
+            {'filters[name]' => global_registry_entity_type_name, 'filters[parent_id]' => parent_id}
+          )['entity_types'].first
+        end
+        if entity_type
+          existing_fields = entity_type['fields'].collect {|f| f['name']}
+        else
+          entity_type = GlobalRegistry::EntityType.post(entity_type: {name: global_registry_entity_type_name, parent_id: parent_id, field_type: 'entity'})['entity_type']
+          existing_fields = []
+        end
+
+        columns_to_push.each do |column|
+          unless existing_fields.include?(column[:name])
+            GlobalRegistry::EntityType.post(entity_type: {name: column[:name], parent_id: entity_type['id'], field_type: column[:type]})
+          end
+        end
+      end
+
+      def columns_to_push
+        @columns_to_push ||= columns.select { |c|
+          !skip_fields_for_gr.include?(c.name.underscore)
+        }.collect {|c|
+          { name: c.name.underscore, type: normalize_column_type(c.type, c.name.underscore) }
+        }
+      end
+
+      def normalize_column_type(column_type, name)
+        case
+        when column_type.to_s == 'text'
+          'string'
+        when name.ends_with?('_id')
+          'uuid'
+        else
+          column_type
+        end
+      end
+
+      def async_delete_from_global_registry(registry_id)
+        begin
+          GlobalRegistry::Entity.delete(registry_id)
+        rescue RestClient::ResourceNotFound
+          # If the record doesn't exist, we don't care
+        end
+      end
+
+      def global_registry_entity_type_name
+        to_s.underscore
+      end
+
+      def skip_fields_for_gr
+        %w(id global_registry_id created_at updated_at)
+      end
+
+    end
+  end
+end
+

data/lib/cru_lib/global_registry_relationship_methods.rb

@@ -0,0 +1,106 @@
+module CruLib
+  module GlobalRegistryRelationshipMethods
+    extend ActiveSupport::Concern
+    include CruLib::GlobalRegistryMethods
+
+    def async_push_to_global_registry
+      super
+    end
+
+    # TODO - deleting a relationship is different.
+    def delete_from_global_registry
+      if global_registry_id
+        Sidekiq::Client.enqueue(self.class, nil, :async_delete_from_global_registry, global_registry_id)
+      end
+    end
+
+    # @param [String] relationship_name
+    # @param [String] related_name
+    # @param [Object] related_object
+    def attributes_to_push(relationship_name = nil, related_name = nil, related_object = nil)
+      if global_registry_id
+        attributes_to_push = super
+        attributes_to_push
+      else
+        {
+          "#{relationship_name}:relationship" => {
+            client_integration_id: id,
+            related_name => related_object.global_registry_id
+          }
+        }
+      end
+    end
+
+    # @param [Object] base_object
+    # @param [String] relationship_name
+    def create_in_global_registry(base_object, relationship_name)
+      entity = GlobalRegistry::Entity.put(
+        base_object.global_registry_id,
+        entity: {base_object.class.global_registry_entity_type_name => attributes_to_push}
+      )
+
+      base_object_id = entity['entity'][base_object.class.global_registry_entity_type_name]['id']
+
+      entity = GlobalRegistry::Entity.find(base_object_id)['entity']
+
+      global_registry_id = Array.wrap(
+        entity[base_object.class.global_registry_entity_type_name]["#{relationship_name}:relationship"]
+      ).detect { |hash| hash['client_integration_id'] == id.to_s }['relationship_entity_id']
+
+      update_column(:global_registry_id, global_registry_id)
+
+      update_in_global_registry
+    end
+
+    module ClassMethods
+      # @param [Class] base_type
+      # @param [Class] related_type
+      # @param [String] relationship1_name
+      # @param [String] relationship2_name
+      def push_structure_to_global_registry(base_type, related_type, relationship1_name, relationship2_name)
+        # A summer project application is a join table between people and projects
+        base_type_cache_key = "#{base_type.global_registry_entity_type_name}_entity_type"
+        base_entity_type = Rails.cache.fetch(base_type_cache_key, expires_in: 1.hour) do
+          GlobalRegistry::EntityType.get({'filters[name]' => base_type.global_registry_entity_type_name})['entity_types'].first
+        end
+
+        related_type_cache_key = "#{related_type.global_registry_entity_type_name}_entity_type"
+        related_entity_type = Rails.cache.fetch(related_type_cache_key, expires_in: 1.hour) do
+          GlobalRegistry::EntityType.get({'filters[name]' => related_type.global_registry_entity_type_name})['entity_types'].first
+        end
+
+        relationship_type_cache_key = "#{base_type}_#{related_type}_#{relationship1_name}"
+        relationship_type = Rails.cache.fetch(relationship_type_cache_key, expires_in: 1.hour) do
+          GlobalRegistry::RelationshipType.get(
+            {'filters[between]' => "#{base_entity_type['id']},#{related_entity_type['id']}"}
+          )['relationship_types'].detect { |r| r['relationship1']['relationship_name'] == relationship1_name }
+        end
+
+        unless relationship_type
+          relationship_type = GlobalRegistry::RelationshipType.post(relationship_type: {
+            entity_type1_id: base_entity_type['id'],
+            entity_type2_id: related_entity_type['id'],
+            relationship1: relationship1_name,
+            relationship2: relationship2_name
+          })['relationship_type']
+        end
+
+        existing_fields = relationship_type['fields'].collect {|f| f['name']}
+
+        (columns_to_push).each do |field|
+          next if existing_fields.include?(field[:name])
+
+          GlobalRegistry::RelationshipType.put(relationship_type['id'], relationship_type: {
+            fields: [field]
+          })
+        end
+      end
+
+      def columns_to_push
+        super
+      end
+    end
+  end
+
+end
+

data/lib/cru_lib/version.rb

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

data/lib/cru_lib.rb

@@ -0,0 +1,7 @@
+require "cru_lib/version"
+require 'cru_lib/async'
+require 'cru_lib/global_registry_methods'
+require 'cru_lib/global_registry_relationship_methods'
+
+module CruLib
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: cru_lib
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Josh Starcher
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !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: Collection of common ruby logic used by a number of Cru apps
+email:
+- josh.starcher@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- cru_lib.gemspec
+- lib/cru_lib.rb
+- lib/cru_lib/async.rb
+- lib/cru_lib/global_registry_methods.rb
+- lib/cru_lib/global_registry_relationship_methods.rb
+- lib/cru_lib/version.rb
+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.2.1
+signing_key: 
+specification_version: 4
+summary: Misc libraries for Cru
+test_files: []