artirix_data_models 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f6a90c9b7956cc31c38374094fd416d8d4e9dd09
+  data.tar.gz: 3cf3edcbf15f24b14b7beb57943b9f93bb12dbaa
+SHA512:
+  metadata.gz: 568c1f293797134592df3bd5bca0ba3daacf0ede0aff7770004b5a3aae4821f9ae8eb2df8a668607bff2bfcb4f31bc6ea1a8c334b213084c19763ddebe578714
+  data.tar.gz: 5e27b33a022ccb060b174fb4466fb62bea449cc8c6ff8a5b3b405482b20f0f7c14eba73eeeddd4f62b31d447b0f2999d0afa8cf2485f095eda3ff3d425dea8bc

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.idea

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,17 @@
+language: ruby
+rvm:
+  - 2.1.2
+before_install: gem install bundler -v 1.10.3
+
+addons:
+  code_climate:
+    repo_token: 84e47c3e41ba9fbc2d639c167be45aa3f6c077374015309dac005ab51f713d83
+
+script: 'bundle exec rake spec'
+
+notifications:
+  email:
+    recipients:
+      - eturino@eturino.com
+    on_failure: change
+    on_success: never

data/Gemfile

@@ -0,0 +1,18 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in artirix_data_models.gemspec
+gemspec
+
+group :development, :test do
+  gem 'pry'
+  gem 'pry-nav'
+  gem 'pry-stack_explorer'
+  gem 'pry-doc'
+  gem 'pry-rescue'
+end
+
+group :test do
+  gem 'fakeredis', require: "fakeredis/rspec"
+end
+
+gem 'codeclimate-test-reporter', :group => :test, :require => nil

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Eduardo Turiño
+
+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,230 @@
+# ArtirixDataModels
+
+
+[![Gem Version](https://badge.fury.io/rb/artirix_data_models.svg)](http://badge.fury.io/rb/artirix_data_models)
+[![Build Status](https://travis-ci.org/artirix/artirix_data_models.svg?branch=master)](https://travis-ci.org/artirix/artirix_data_models)
+[![Code Climate](https://codeclimate.com/github/artirix/artirix_data_models.png)](https://codeclimate.com/github/artirix/artirix_data_models)
+[![Code Climate Coverage](https://codeclimate.com/github/artirix/artirix_data_models/coverage.png)](https://codeclimate.com/github/artirix/artirix_data_models)
+
+
+This gem provides the tools for building Data Models (ActiveModel compliant objects that only receive attributes on initialisation), 
+with their DAOs (Data Access Objects, the ones responsible for loading them up), the EsCollection objects (collection of 
+objects, paginatable and with extra features), and tools that allow them to work.
+
+Its goal is to provide a set of Read Only model objects that receive their data from some sort of Data API.
+ 
+It's designed to work assuming JSON APIs and ElasticSearch responses.
+
+# TODO:
+- usage doc
+- change Cache to use [artirix_cache_service](https://github.com/artirix/artirix_cache_service)
+
+
+## Usage
+
+### Model
+
+TODO:
+
+### DAO
+
+TODO:
+
+### EsCollection
+
+TODO:
+
+#### Pagination
+
+TODO:
+
+### The Registry
+
+Your app should extend the `ArtirixDataModels::DAORegistry`. We can override the `setup_config` method to add extra loaders. 
+
+**important: do not forget to call `super` on `setup_config`.**
+
+Also, the Registry class that you want to use in your app should have in its definition a call to `self.mark_as_main_registry`. This call must be **after the override of `setup_config`.**
+
+```ruby
+class DAORegistry < ArtirixDataModels::DAORegistry
+  def setup_config
+    super
+
+    set_loader(:aggregations_factory) { AggregationsFactory.new }
+
+    set_loader(:yacht) { YachtDAO.new gateway: get(:gateway) }
+    set_loader(:article) { ArticleDAO.new gateway: get(:gateway) }
+    set_loader(:broker) { BrokerDAO.new gateway: get(:gateway) }
+
+    set_loader(:artirix_hub_api_gateway) { ArtirixDataModels::DataGateway.new connection: ArtirixHubApiService::ConnectionLoader.connection }
+    set_loader(:lead) { LeadDAO.new gateway: get(:artirix_hub_api_gateway) }
+  end
+
+
+  # AFTER defining setup_config
+  self.mark_as_main_registry
+
+end
+```
+
+### initializer
+
+An initializer should be added for extra configuration. 
+
+We can enable pagination with either `will_paginate` or `kaminari`.
+
+We can also disable cache at a lib level.
+
+```ruby
+require 'artirix_data_models'
+
+# pagination
+ArtirixDataModels::EsCollection.work_with_kaminari
+# or ArtirixDataModels::EsCollection.work_with_will_paginate
+
+#cache
+ArtirixDataModels.disable_cache unless Rails.configuration.dao_cache_enabled
+```
+
+
+### Cache
+
+By default all `get`, `get_full` and `get_some` calls to on a normal DAO will be cached. The response body and status of the Gateway is cached (if it is successful or a 404 error).
+
+The cache key and the options will be determined by the cache adaptor, set by the DAO. The options are loaded from SimpleConfig, merging `default_options` with the first most specific option hash.
+
+For example, a DAO `get` call will try to load the first options hash defined from the following list:
+- "dao_#{dao_name}_get_options"
+- "dao_#{dao_name}_options"
+- 'dao_get_options'
+
+
+example of config options (using SimpleConfig)
+
+```
+SimpleConfig.for(:site) do
+  set :cache_app_prefix, 'ui'
+
+  group :cache_options do
+    group :default_options do
+      set :expires_in, 15.minutes
+    end
+
+    group :dao_get_full_options do
+      set :expires_in, 1.hour
+    end
+
+    group :dao_get_full_no_time_options do
+      set :expires_in, 5.minutes
+    end
+
+    group :dao_yacht_get_full_options do
+      set :expires_in, 15.minutes
+    end
+  end
+end
+```
+
+Cache can be disabled at lib level with `ArtirixDataModels.disable_cache`
+
+### Rails integration
+
+if Rails is defined when the lib is first used, then the `logger` will be assigned to `Rails.logger` by default, and
+`cache` will be `Rails.cache` by default.
+
+### Fake Mode
+
+TODO:
+
+fake mode will be enabled if:
+
+```ruby
+SimpleConfig.for(:site) do
+  group :data_fake_mode do
+    set :article, false # NO FAKE MODE
+    set :broker, false # WITH FAKE MODE
+  end
+end
+```
+
+### Use with RSpec
+
+#### Custom DAO Registry
+
+For the use of a custom DAO Registry, it is recomended to actually require it on the test helper:
+ 
+ 
+in spec/rails_helper.rb:
+
+```ruby
+# This file is copied to spec/ when you run 'rails generate rspec:install'
+ENV["RAILS_ENV"] ||= 'test'
+require 'rspec/given'
+require 'spec_helper'
+require File.expand_path("../../config/environment", __FILE__)
+require 'rspec/rails'
+# Add additional requires below this line. Rails is not loaded until this point!
+
+# force the use of the custom DAORegistry
+require 'dao_registry'
+```
+
+#### Spec Support
+
+add the spec support in your support files or rails_helper file:
+
+
+```ruby
+require 'artirix_data_models/spec_support'
+```
+
+This depends on SimpleConfig!
+
+```ruby
+SimpleConfig.for(:site) do
+  group :data_gateway do
+    set :url, c
+  end
+end
+```
+
+### FactoryGirl
+
+In order to use FactoryGirl with these Models, we need to specify:
+
+1. the objects cannot be saved, so we need to specify `skip_create` to avoid it.
+2. the setting of the data is only to be done on the model's initialisation, not with public setters. 
+For that, we need to specify: `initialize_with { new(attributes) }`
+
+```ruby
+
+FactoryGirl.define do
+  factory :article do
+    # no save call
+    skip_create
+    
+    # in our models we have private setters -> we need the attributes to be
+    # passed on object initialisation
+    initialize_with { new(attributes) }
+    
+    sequence(:id)
+    title { Faker::Lorem.sentence }
+  end
+end
+```
+
+## TODO
+
+1. Documentation
+2. clean `basic_dao` (probably not backwards compatible, so we'll do it in a new major release)
+3. use [artirix_cache_service](https://github.com/artirix/artirix_cache_service) instead of this implementation (might be not backwards compatible. If so: new major release)
+
+
+
+## Changes
+
+### v.0.5.0
+
+- opening gem as is to the public.
+- still a lot of TODOs in the documentation

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/artirix_data_models.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'artirix_data_models/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'artirix_data_models'
+  spec.version       = ArtirixDataModels::VERSION
+  spec.authors       = ['Eduardo Turiño']
+  spec.email         = ['eturino@artirix.com']
+  spec.summary       = 'Data Models (read only model) and Data Layer connection lib'
+  spec.description   = %q{used in Boat International UI and Admin 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_dependency 'activesupport'
+  spec.add_dependency 'simpleconfig'
+  spec.add_dependency 'oj'
+  spec.add_dependency 'faraday'
+  spec.add_dependency 'keyword_init', '~> 1.3'
+  spec.add_dependency 'naught'
+
+  spec.add_development_dependency 'kaminari', '~> 0.16'
+  spec.add_development_dependency 'will_paginate', '~> 3.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.10'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rspec-given'
+  spec.add_development_dependency 'faker'
+end

data/lib/artirix_data_models/aggregation.rb

@@ -0,0 +1,58 @@
+module ArtirixDataModels
+  class Aggregation < Struct.new(:name, :buckets)
+
+    include Enumerable
+
+    delegate :each, :empty?, to: :buckets
+
+    def self.from_json(definition, value_class = Value)
+      buckets = definition[:buckets].map do |bucket|
+        value_class.new definition[:name].to_sym, bucket[:name], bucket[:count]
+      end
+
+      new definition[:name].to_sym, buckets
+    end
+
+    def pretty_name
+      I18n.t("aggregations.#{name.to_s.gsub('.', '_')}.name", default: default_pretty_name)
+    end
+
+    def default_pretty_name
+      name
+    end
+
+    def non_empty_buckets
+      buckets.reject { |x| x.empty? }
+    end
+
+    def data_hash
+      {
+        name:    name,
+        buckets: buckets.map(&:data_hash)
+      }
+    end
+
+    class Value < Struct.new(:aggregation_name, :name, :count)
+
+      def pretty_name
+        tranlsation_key = "aggregations.#{aggregation_name.to_s.gsub('.', '_')}.buckets.#{name.to_s.gsub('.', '_')}"
+        I18n.t(tranlsation_key, default: default_pretty_name)
+      end
+
+      def default_pretty_name
+        name
+      end
+
+      def empty?
+        count == 0
+      end
+
+      def data_hash
+        {
+          name:  name,
+          count: count
+        }
+      end
+    end
+  end
+end

data/lib/artirix_data_models/aggregations_factory.rb

@@ -0,0 +1,45 @@
+module ArtirixDataModels
+  class AggregationsFactory
+    DEFAULT_FACTORY               = ->(aggregation) { Aggregation.from_json aggregation }
+    DEFAULT_COLLECTION_CLASS_NAME = ''.freeze
+
+    # singleton instance
+    def initialize
+      @_loaders = Hash.new { |h, k| h[k] = {} }
+      setup_config
+    end
+
+    def setup_config
+      # To be Extended
+    end
+
+    def build_from_json(aggregation, collection_class = nil)
+      get_loader(aggregation[:name], collection_class).call aggregation
+    end
+
+    def get_loader(aggregation_name, collection_class)
+      @_loaders[collection_class.to_s][aggregation_name.to_s] ||
+        @_loaders[DEFAULT_COLLECTION_CLASS_NAME][aggregation_name.to_s] ||
+        DEFAULT_FACTORY
+    end
+
+    def set_loader(aggregation_name, collection_class = nil, loader = nil, &block)
+      if block
+        @_loaders[collection_class.to_s][aggregation_name.to_s] = block
+      elsif loader.respond_to? :call
+        @_loaders[collection_class.to_s][aggregation_name.to_s] = loader
+      else
+        raise ArgumentError, "no block and no loader given for key #{key}"
+      end
+    end
+
+    # static methods
+    def self.set_loader(aggregation_name, collection_class, loader = nil, &block)
+      instance.set_loader aggregation_name, collection_class, loader, &block
+    end
+
+    def self.build_from_json(aggregation_name, collection_class)
+      instance.build_from_json aggregation_name, collection_class
+    end
+  end
+end

data/lib/artirix_data_models/cache_service.rb

@@ -0,0 +1,168 @@
+module ArtirixDataModels::CacheService
+
+  def self.digest_element(element)
+    Digest::SHA1.hexdigest element.to_s
+  end
+
+  def self.first_options(*options, return_if_none: :default)
+    key = options.detect { |x| OptionsStore.has? x }
+    return OptionsStore.get(key) if key.present?
+
+    case return_if_none
+    when NilClass
+      nil
+    when :default
+      OptionsStore.default.dup
+    else
+      {}
+    end
+  end
+
+  def self.method_missing(m, *args, &block)
+    method = m.to_s
+
+    if KeyCleaner.valid_method method
+      KeyCleaner.final_key(m, *args)
+
+    elsif OptionsStore.valid_method method
+      OptionsStore.send m, *args, &block
+
+    elsif Expirer.valid_method method
+      Expirer.send m, *args, &block
+
+    else
+      super
+    end
+  end
+
+  def self.respond_to_missing?(m, include_all = false)
+    method = m.to_s
+
+    if KeyCleaner.valid_method method
+      true
+
+    elsif OptionsStore.valid_method method
+      OptionsStore.respond_to? m, include_all
+
+    elsif Expirer.valid_method method
+      Expirer.respond_to? m, include_all
+
+    else
+      super
+    end
+  end
+
+  private
+
+  module KeyCleaner
+    def self.valid_method(method_name)
+      method_name.end_with? '_key'
+    end
+
+    def self.final_key(m, *args)
+      cleaned = clean_key_section(m, *args)
+      CacheStoreHelper.final_key cleaned
+    end
+
+    private
+    def self.clean_key_section(key, *args)
+      key_name = clean_key_name key
+      a        = clean_key_args args
+      suffix   = a.present? ? "/#{a}" : ''
+      "#{key_name}#{suffix}"
+    end
+
+    def self.clean_key_name(key)
+      key.to_s.gsub(/_key$/, '').to_sym
+    end
+
+    def self.clean_key_args(args)
+      args.map { |x| x.try(:cache_key) || x.to_s }.join '/'
+    end
+  end
+
+  module OptionsStore
+    def self.valid_method(method_name)
+      method_name.end_with? '_options'
+    end
+
+    def self.method_missing(m, *args, &block)
+      if has?(m)
+        get(m)
+      else
+        super
+      end
+    end
+
+    def self.respond_to_missing?(m, include_all = false)
+      has?(m) || super
+    end
+
+    private
+    def self.has?(name)
+      option_store.respond_to?(name)
+    end
+
+    def self.get(name)
+      default.merge(get_particular(name))
+    end
+
+    def self.get_particular(name)
+      Hash(option_store.send(name))
+    end
+
+    def self.default
+      @default ||= Hash(option_store.default_options)
+    end
+
+    def self.option_store
+      @option_store ||= SimpleConfig.for(:site).try(:cache_options) || disabled_options_store
+    end
+
+    def self.disabled_options_store
+      DisabledOptionsStore.new
+    end
+
+    class DisabledOptionsStore
+      def method_missing(m, *args, &block)
+        {}
+      end
+
+      def respond_to_missing?(m, include_all = false)
+        true
+      end
+    end
+  end
+
+  module Expirer
+    def self.valid_method(method_name)
+      method_name.start_with? 'expire_'
+    end
+
+    def self.expire_cache(pattern = nil)
+      CacheStoreHelper.delete_matched(pattern)
+    end
+  end
+
+  # we use `delete_matched` method -> it will work fine with Redis but it seems that it won't with Memcached
+  module CacheStoreHelper
+    def self.final_key(key_value)
+      "#{prefix}__#{key_value}"
+    end
+
+    def self.final_pattern(pattern)
+      suf = pattern.present? ? "#{pattern}*" : ''
+      "*#{prefix}*#{suf}"
+    end
+
+    def self.delete_matched(pattern = nil)
+      return false unless ArtirixDataModels.cache.present?
+      ArtirixDataModels.cache.delete_matched final_pattern(pattern)
+    end
+
+    def self.prefix
+      SimpleConfig.for(:site).try(:cache_app_prefix)
+    end
+  end
+
+end

data/lib/artirix_data_models/cached_action_adaptor/get.rb

@@ -0,0 +1,22 @@
+class ArtirixDataModels::CachedActionAdaptor::Get < ArtirixDataModels::CachedActionAdaptor
+
+  attr_reader :dao_name, :model_pk
+
+  def initialize(dao_name:, model_pk:, **extra_options)
+    @dao_name = dao_name
+    @model_pk = model_pk
+
+    super(**extra_options)
+  end
+
+  def load_cache_key
+    ArtirixDataModels::CacheService.dao_get_key(dao_name, model_pk)
+  end
+
+  def load_cache_options
+    ArtirixDataModels::CacheService.first_options "dao_#{dao_name}_get_options",
+                                                  "dao_#{dao_name}_options",
+                                                  'dao_get_options',
+                                                  return_if_none: :default
+  end
+end