lhs 0.3.0

data/lib/lhs/errors.rb

@@ -0,0 +1,86 @@
+# Like ActiveModel::Errors
+class LHS::Errors
+  include Enumerable
+
+  attr_reader :messages, :message
+
+  def initialize(response)
+    @messages = messages_from_response(response)
+    @message = message_from_response(response)
+    rescue JSON::ParserError
+  end
+
+  def include?(attribute)
+    messages[attribute].present?
+  end
+  alias :has_key? :include?
+  alias :key? :include?
+
+  def get(key)
+    messages[key]
+  end
+
+  def set(key, value)
+    messages[key] = value
+  end
+
+  def delete(key)
+    messages.delete(key)
+  end
+
+  def [](attribute)
+    get(attribute.to_sym) || set(attribute.to_sym, [])
+  end
+
+  def []=(attribute, error)
+    self[attribute] << error
+  end
+
+  def each
+    messages.each_key do |attribute|
+      self[attribute].each { |error| yield attribute, error }
+    end
+  end
+
+  def size
+    values.flatten.size
+  end
+
+  def values
+    messages.values
+  end
+
+  def keys
+    messages.keys
+  end
+
+  def count
+    to_a.size
+  end
+
+  def empty?
+    all? { |k, v| v && v.empty? && !v.is_a?(String) }
+  end
+
+  private
+
+  def messages_from_response(response)
+    messages = {}
+    return messages if !response.body.is_a?(String) || response.body.length.zero?
+    json = JSON.parse(response.body)
+    return messages unless json['fields']
+    json['fields'].each do |field|
+      name = field['name'].to_sym
+      messages[name] ||= []
+      field['details'].each do |detail|
+        messages[name].push(detail['code'])
+      end
+    end
+    messages
+  end
+
+  def message_from_response(response)
+    json = JSON.parse(response.body)
+    json['message']
+  end
+end

data/lib/lhs/item.rb

@@ -0,0 +1,83 @@
+require File.join(__dir__, 'proxy.rb')
+Dir[File.dirname(__FILE__) + '/concerns/item/*.rb'].each {|file| require file }
+
+# An item is a concrete record.
+# It can be part of another proxy like collection.
+class LHS::Item < LHS::Proxy
+  include Destroy
+  include Save
+  include Update
+
+  # prevent clashing with attributes of underlying data
+  attr_accessor :errors
+
+  def _raw
+    _data._raw
+  end
+
+  protected
+
+  def method_missing(name, *args, &block)
+    return set(name, args.try(&:first)) if name.to_s[/=$/]
+    name = args.first if name == :[]
+    value = _data._raw[name.to_s]
+    value = _data._raw[name.to_sym] if value.nil?
+    if value.is_a?(Hash)
+      handle_hash(value)
+    elsif value.is_a?(Array)
+      data = LHS::Data.new(value, _data)
+      collection = LHS::Collection.new(data)
+      LHS::Data.new(collection, _data)
+    else
+      convert(value)
+    end
+  end
+
+  def respond_to_missing?(name, include_all = false)
+    # We accept every message that does not belong to set of keywords
+    BLACKLISTED_KEYWORDS.exclude?(name.to_s)
+  end
+
+  private
+
+  # FIXME: Extend the set of keywords
+  BLACKLISTED_KEYWORDS = %w( new proxy_association )
+
+  def convert(value)
+    return value unless value.is_a?(String)
+    if date_time?(value)
+      DateTime.parse(value)
+    elsif date?(value)
+      Date.parse(value)
+    else
+      value
+    end
+  end
+
+  def handle_hash(value)
+    LHS::Data.new(value, _data)
+  end
+
+  def set(name, value)
+    key = name.to_s.gsub(/=$/, '')
+    _data._raw[key] = value
+  end
+
+  private
+
+  def date?(value)
+    value[date_time_regex, :date].presence
+  end
+
+  def time?(value)
+    value[date_time_regex, :time].presence
+  end
+
+  def date_time?(value)
+    date?(value) && time?(value)
+  end
+
+  def date_time_regex
+    /(?<date>\d{4}-\d{2}-\d{2})?(?<time>T\d{2}:\d{2}:\d{2}\.\d*.\d{2}:\d{2})?/
+  end
+end

data/lib/lhs/proxy.rb

@@ -0,0 +1,26 @@
+# Proxy makes different kind of data accessible
+# If href is present it also alows loading/reloading
+class LHS::Proxy
+
+  # prevent clashing with attributes of underlying data
+  attr_accessor :_data, :_loaded
+
+  def initialize(data)
+    self._data = data
+    self._loaded = false
+  end
+
+  def load!
+    return self if _loaded
+    reload!
+  end
+
+  def reload!
+    fail 'No href found' unless _data.href
+    service = _data._root._service
+    data = service.instance.request(url: _data.href, method: :get)
+    merge!(data)
+    self._loaded = true
+    self
+  end
+end

data/lib/lhs/service.rb

@@ -0,0 +1,20 @@
+require 'singleton'
+Dir[File.dirname(__FILE__) + '/concerns/service/*.rb'].each {|file| require file }
+
+# A Service makes data available using multiple endpoints.
+class LHS::Service
+  include All
+  include Batch
+  include Build
+  include Create
+  include Endpoints
+  include Find
+  include FindBy
+  include First
+  include Mapping
+  include Model
+  include Includes
+  include Request
+  include Singleton
+  include Where
+end

data/lib/lhs/version.rb

@@ -0,0 +1,3 @@
+module LHS
+  VERSION = "0.3.0"
+end

data/script/ci/build.sh

@@ -0,0 +1,19 @@
+#!/bin/bash -e
+
+# custom vars
+# RUBY = ruby-1.9.3-p125
+# GEMSET = location-app-${GitHub pull request id|branch name}
+# standard vars
+# https://jenkins.intra.local.ch/env-vars.html/
+
+if [ -z "$SKIP_RVM" ]; then
+  [[ -s "/usr/local/rvm/scripts/rvm" ]] && . "/usr/local/rvm/scripts/rvm"
+  RUBY=${RUBY:-ruby-2.1.2}
+  GEMSET=${GEMSET:-LHS}
+  rvm use ${RUBY}@${GEMSET} --create
+  gem install bundler --no-rdoc --no-ri
+fi
+
+bundle install --local || bundle install
+RAILS_ENV=test bundle exec rspec
+rvm --force gemset delete ${RUBY}@${GEMSET}

data/spec/collection/meta_data_spec.rb

@@ -0,0 +1,54 @@
+require 'rails_helper'
+
+describe LHS::Collection do
+
+  let(:total) { 0 }
+
+  let(:limit) { 50 }
+
+  let(:offset) { 0 }
+
+  let(:collection) do
+    {
+      href: "#{datastore}/feedbacks",
+      items: [],
+      total: total,
+      limit: limit,
+      offset: offset
+    }
+  end
+
+  let(:item) do
+    {
+      href: "#{datastore}/users/1",
+      feedbacks: collection
+    }
+  end
+
+  let(:datastore) { 'http://datastore-stg.lb-service.sunrise.intra.local.ch/v2' }
+
+  before(:each) do
+    LHC.config.placeholder('datastore', datastore)
+    class Feedback < LHS::Service
+      endpoint ':datastore/feedbacks'
+    end
+    class User < LHS::Service
+      endpoint ':datastore/users'
+    end
+  end
+
+  it 'provides meta data for collections' do
+    stub_request(:get, "#{datastore}/feedbacks").to_return(status: 200, body: collection.to_json)
+    feedbacks = Feedback.where
+    expect(feedbacks.total).to eq total
+    expect(feedbacks.limit).to eq limit
+    expect(feedbacks.offset).to eq offset
+    expect(feedbacks.href).to eq "#{datastore}/feedbacks"
+  end
+
+  it 'provides meta data also when navigating' do
+    stub_request(:get, "#{datastore}/users/1").to_return(status: 200, body: item.to_json)
+    user = User.find(1)
+    expect(user.feedbacks.href).to eq "#{datastore}/feedbacks"
+  end
+end

data/spec/collection/respond_to_spec.rb

@@ -0,0 +1,19 @@
+require 'rails_helper'
+
+describe LHS::Collection do
+
+  let(:data) {
+    ['ROLE_USER', 'ROLE_LOCALCH_ACCOUNT']
+  }
+
+  let(:collection){
+    described_class.new(LHS::Data.new(data))
+  }
+
+  context '#respond_to?' do
+    # In this case raw collection is an Array implementing first
+    it 'forwards calls to raw collection' do
+      expect(collection.respond_to?(:first)).to be(true)
+    end
+  end
+end

data/spec/collection/without_object_items_spec.rb

@@ -0,0 +1,26 @@
+require 'rails_helper'
+
+describe LHS::Collection do
+
+  let(:datastore) { 'http://datastore-stg.lb-service.sunrise.intra.local.ch/v2' }
+
+  before(:each) do
+    LHC.config.placeholder('datastore', datastore)
+    class Account < LHS::Service
+      endpoint ':datastore/accounts'
+    end
+  end
+
+  let(:data) {
+    {
+      'authorities' => ['ROLE_USER', 'ROLE_LOCALCH_ACCOUNT']
+    }
+  }
+
+  it 'lets you access items of an array if they are not objects' do
+    stub_request(:get, "#{datastore}/accounts/1").to_return(status: 200, body: data.to_json)
+    feedback = Account.find(1)
+    expect(feedback.authorities.first).to eq 'ROLE_USER'
+    expect(feedback.authorities[1]).to eq 'ROLE_LOCALCH_ACCOUNT'
+  end
+end

data/spec/data/collection_spec.rb

@@ -0,0 +1,36 @@
+require 'rails_helper'
+
+describe LHS::Data do
+
+  let(:json) do
+    load_json(:feedbacks)
+  end
+
+  let(:data) do
+    LHS::Data.new(json)
+  end
+
+  context 'collections' do
+
+    it 'forwards calls to the collection' do
+      expect(data.count).to be_kind_of Fixnum
+      expect(data[0]).to be_kind_of LHS::Data
+      expect(data.sample).to be_kind_of LHS::Data
+    end
+
+    it 'provides a total method to get the number of total records' do
+      expect(data.total).to be_kind_of Fixnum
+    end
+  end
+
+  context 'collections from arrays' do
+
+    let(:data) do
+      LHS::Data.new([1,2,3,4])
+    end
+
+    it 'uses collection as proxy for arrays' do
+      expect(data._proxy).to be_kind_of LHS::Collection
+    end
+  end
+end

data/spec/data/item_spec.rb

@@ -0,0 +1,44 @@
+require 'rails_helper'
+
+describe LHS::Data do
+
+  before(:each) do
+    class SomeService < LHS::Service
+      endpoint ':datastore/v2/:campaign_id/feedbacks'
+      endpoint ':datastore/v2/feedbacks'
+    end
+  end
+
+  let(:json) do
+    load_json(:feedbacks)
+  end
+
+  let(:data) do
+    LHS::Data.new(json, nil, SomeService)
+  end
+
+  let(:item) do
+    data[0]
+  end
+
+  context 'item' do
+
+    it 'makes data accessible' do
+      expect(item.href).to be_kind_of String
+      expect(item.recommended).to be_kind_of TrueClass
+      expect(item.average_rating).to be_kind_of Float
+    end
+
+    it 'returns nil if no data is present' do
+      expect(item.something).to eq nil
+    end
+
+    it 'returns datetime if string can be parsed as date_time' do
+      expect(item.created_date).to be_kind_of DateTime
+    end
+
+    it 'returns date if string can be parsed as date' do
+      expect(item.valid_from).to be_kind_of Date
+    end
+  end
+end

data/spec/data/merge_spec.rb

@@ -0,0 +1,32 @@
+require 'rails_helper'
+
+describe LHS::Data do
+
+  before(:each) do
+    class SomeService < LHS::Service
+      endpoint ':datastore/v2/:campaign_id/feedbacks'
+      endpoint ':datastore/v2/feedbacks'
+    end
+  end
+
+  let(:data) do
+    LHS::Data.new({
+      href: 'http://www.local.ch/v2/stuff'
+    }, nil, SomeService)
+  end
+
+  let(:loaded_data) do
+    LHS::Data.new({
+      href: 'http://www.local.ch/v2/stuff',
+      id: '123123123'
+    }, nil, SomeService)
+  end
+
+  context 'merging' do
+
+    it 'merges data' do
+      data.merge!(loaded_data)
+      expect(data.id).to eq loaded_data.id
+    end
+  end
+end