databox 0.1.2 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2a6922c503db36ec8c5a0402a96c7a098d6c2e18
-  data.tar.gz: 5824a170a896105170b2d17318af8ca22878ffd5
+  metadata.gz: a6e85fe8361df5f8a6e5e222fded72b065e72a06
+  data.tar.gz: 831e85f19a7a8162c5c1bc77d95601f45f8f9807
 SHA512:
-  metadata.gz: 23cd2a8298ba629d762508a141fb10ab9d9f38de59a766f9899db1a41d9f08f3710089dbed5b3cc27d5f9669955c0a3187e90732c1e71e33810c7b1b960500bd
-  data.tar.gz: 4e5d98b5a643cb4e79364fda6f329a32d5d4fd85d0440c4fc2e5c270ac53d5b2d767978bd1a0bf951bf784c3650081da13339c3aac87d4ce6128ab60eadc25ef
+  metadata.gz: a175fdc88f0efdd14afed93bb1d3db17edc7714633702a7731f5ce1f390f1db1edbc5f836f654167fc75ef12d8cf4263594fa725b38385ef9d32d58e9359713b
+  data.tar.gz: 32e2097b929ea498c8b5205eef0ad9c7ec62b58789fd11dc49fde733caa1a05389a026c70b5a3afcd5beb5ff7c5bfa776410845771b8bd709d0e89f4ee304966

data/.gitignore

@@ -1,3 +1,4 @@
+.idea/
 *.sh
 !*test_*sh
 *.gem

data/.pryrc

@@ -0,0 +1,7 @@
+require 'databox'
+
+Databox.configure do |c|
+  c.push_token = ENV["DATABOX_PUSH_TOKEN"]
+end
+
+client = Databox::Client.new

data/.ruby-version

@@ -1 +1 @@
-ruby-2.0.0
+ruby-2.2.2

data/.travis.yml

@@ -1,7 +1,4 @@
-script: "bundle exec rspec"
-
-install: "travis_retry bundle install"
-
-rvm:
-  - 1.9.3
-  - 2.0.0
+install:
+  - "travis_retry bundle install"
+script:
+  - "bundle exec rspec --format doc --color"

data/README.md

@@ -1,11 +1,9 @@
-# Databox
+# Databox bindings for Ruby
 
-[![Gem Version][fury-badge]][fury] [![Build Status][travis-badge]][travis] [![Coverage Status](https://coveralls.io/repos/otobrglez/databox/badge.png?branch=master)](https://coveralls.io/r/otobrglez/databox?branch=master)
+[![Build Status][travis-badge]][travis]
 
 Ruby Gem for [Databox](http://databox.com/) - Mobile Executive Dashboard.
 
-- By [Oto Brglez](https://github.com/otobrglez)
-
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -20,175 +18,68 @@ Or install it yourself as:
 
     $ gem install databox
 
-## Usage
-
-Before using Databox gem you have to initialize it with key and token. There are 3 ways how you can do initialization.
-
-- Within simple initializer
-
-  ```ruby
-  Databox.configure do |c|
-    c.token   = "YOUR_TOKEN"
-    c.key     = "YOUR_KEY"
-  end
-  ```
-
-- By setting system ```ENV``` variables ```DATABOX_KEY``` and ```DATABOX_TOKEN```
-
-- If your are using custom integration with different key please use ```id```.
-
-  ```ruby
-  chart = Databox::LineChart.new "my_line", id: "OTHER_KEY"
-  ```
-
-Databox gem support following widgets
-
-| Widget          | Implemented   | Example                        | Databox Documentation
-| --------------- | :-----------: | ------------------------------ | ----------------------
-| Big Number      | Yes           | [Example](#big-number)         | [Basic Widgets / Big Number](https://developers.databox.com/push/v1/widgets/main/#big-number)
-| Compare         | Yes           | [Example](#compare)            | [Basic Widgets / Compare](https://developers.databox.com/push/v1/widgets/main/#compare)
-| Internal        | Yes           | [Example](#interval)    | [Basic Widgets / Interval Values](https://developers.databox.com/push/v1/widgets/main/#interval-values)
-| Line Chart      | Yes           | [Example](#line-chart)         | [Basic Widgets / Line Chart](https://developers.databox.com/push/v1/widgets/main/#line-chart-and-bar-chart)
-| Bar Chart       | Yes           | [Example](#bar-chart)          | [Basic Widgets / Bar Chart](https://developers.databox.com/push/v1/widgets/main/#line-chart-and-bar-chart)
-| Pipeline        | Yes           | [Example](#pipeline)           | [Pipeline](https://developers.databox.com/push/v1/widgets/pipeline/)
-| Funnel          | Yes           | [Example](#funnel)             | [Funnel](https://developers.databox.com/push/v1/widgets/funnel/)
-| Pie             | Yes           | [Example](#pie)                | [Pie](https://developers.databox.com/push/v1/widgets/pie/)
-| Progress        | Yes           | [Example](#progress)           | [Progress](https://developers.databox.com/push/v1/widgets/progress/)
-| Table           | No            |                                |
-| Messages        | Yes           | [Example](#messages)           | [Messages](https://developers.databox.com/push/v1/widgets/messages/)
+## Initialisation
 
+Before pushing data to Databox you have to initialize it with token.
 
-### Big Number
 ```ruby
-number = Databox::BigNumber.new "just_number"
-number.set 5000
-number.save
-
-# You can set date on initialize
-number_dated = Databox::BigNumber.new "just_number", date: "2014-02-03"
-# Or when setting number
-number_dated.set 10_000, "2014-02-03"
-number_dated.save
-
+Databox.configure do |c|
+  c.push_token   = "YOUR_TOKEN"
+end
 ```
 
-### Line Chart
-```ruby
-chart = Databox::LineChart.new "my_line"
-chart.add 40,   "2014-01-29"
-chart.add 100,  "2014-02-01"
-chart.add 500,  "2014-02-02"
-chart.add 20,   "2014-02-03"
-chart.save
+## Usage
 
-```
+Pushing data directly to Databox with help of `push` method:
 
-### Bar Chart
 ```ruby
-chart = Databox::BarChart.new "my_bar"
-chart.add 40,   "2014-01-29"
-chart.add 100,  "2014-02-01"
-chart.add 500,  "2014-02-02"
-chart.add 20,   "2014-02-03"
-chart.save
-```
+client = Databox::Client.new
 
-### Compare
-```ruby
-compare = Databox::BarChart.new "my_compare"
-compare.add 40,   "2014-01-29"
-compare.add 100,  "2014-02-01"
-compare.add 500,  "2014-02-02"
-compare.add 20,   "2014-02-03"
-compare.save
-```
+client.push(key: 'sales.total', value: 3000)
+client.push(key: 'temp.boston', value: 52.0)
+client.push(key: 'temp.boston', value: 52.0, date: '2015-01-01 17:00:00')
+client.push(key: 'temp.boston', value: 52.0, attributes: {
+    location: 'boston-south'
+})
 
-### Interval
-```ruby
-interval = Databox::BarChart.new "my_interval"
-interval.add 40,   "2014-01-29"
-interval.add 100,  "2014-02-01"
-interval.add 500,  "2014-02-02"
-interval.add 20,   "2014-02-03"
-interval.save
 ```
 
-### Pipeline
-```ruby
-pipeline = Databox::Pipeline.new "pipe_visits"
-pipeline.add "Negotiation", 1_121_603
-pipeline.add "Proposal",    3_245_927
-pipeline.add "Solution",    10_726_397
-pipeline.save
-```
-
-### Funnel
-```ruby
-funnel = Databox::Funnel.new "funnel_simple"
-funnel.add "Requests sent",   33_342
-funnel.add "New Accounts",    25_350
-funnel.add "Viewed results",  8_930
-funnel.add "Return Visits",   3_580
-funnel.save
-```
+Inserting multiple matrices with one `insert_all`:
 
-### Pie
 ```ruby
-pie = Databox::Pie.new "my_pie"
-pie.add "A", 3_014
-pie.add "B", 29_496
-pie.add "C", 9_121
-pie.add "D", 20_390
-pie.add "E", 7_423
-pie.save
-```
-
-### Progress
-```ruby
-progress = Databox::Progress.new "my_progress"
-progress.set "33% done", 100, 33
-pie.save
-```
+client = Databox::Client.new
 
-### Messages
-
-```ruby
-messages = Databox::Messages.new "just_messages"
-messages.add "I was here"
-messages.add "Second message"
-messages.save
+client.insert_all [
+    {key: 'temp.boston', value: 52},
+    {key: 'temp.boston', value: 50, date: '2015-01-01 17:00:00'},
+    {key: 'temp.ny', value: 49}
+]
 ```
 
-## Using client directly
-
-You can also use Databox::Client directly to insert raw KPIs. This is done by invoking Databox::Client and pushing Hash or Array of Hashes to it.
+Retrieving information from last push with `last_push`:
 
 ```ruby
-client = Databox.client
-
-client.push([{
-  key: "name",
-  date: "2014-01-22T12:00:00",
-  value: 1
-}])
-
-puts client.logs
+client.last_push
+
+# =>
+#[{
+#  "push"=>"{\"data\":[{\"$sales.total\":2000}]}",
+#  "err"=>"[]",
+#  "no_err"=>0,
+#  "datetime"=>"2015-06-05T10:21:23.861Z",
+#  "keys"=>"[\"132|sales.total\"]"
+#}]
 ```
 
-## Versions
-
-[Databox](https://github.com/otobrglez/databox) is tested on following Ruby versions
-
-- MRI 1.9.3
-- MRI 2.0.0
-
 ## Resources
 
 - [Databox Web App](https://app.databox.com/)
 - [Databox Developers Portal](https://developers.databox.com/)
 
+## Author & License
+
+- [Oto Brglez](https://github.com/otobrglez)
+- Comes with `MIT` license and terms
 
-[fury-badge]: https://badge.fury.io/rb/databox.png
-[fury]: http://badge.fury.io/rb/databox
-[travis-badge]: https://secure.travis-ci.org/otobrglez/databox.png?branch=master
-[travis]: http://travis-ci.org/otobrglez/databox
+[travis-badge]: https://secure.travis-ci.org/databox/databox-ruby.png?branch=v2
+[travis]: http://travis-ci.org/databox/databox-ruby

data/databox.gemspec

@@ -4,35 +4,25 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'databox/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "databox"
+  spec.name          = 'databox'
   spec.version       = Databox::VERSION
-  spec.authors       = ["Oto Brglez"]
-  spec.email         = ["otobrglez@gmail.com"]
+  spec.authors       = ['Oto Brglez']
+  spec.email         = ['otobrglez@gmail.com']
   spec.description   = %q{Ruby Gem for Databox - Mobile Executive Dashboard.}
   spec.summary       = %q{API wrapper for Databox}
-  spec.homepage      = "https://github.com/otobrglez/databox"
-  spec.license       = "MIT"
+  spec.homepage      = 'https://github.com/databox/databox-ruby'
+  spec.license       = 'MIT'
 
   spec.files         = `git ls-files`.split($/)
   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.require_paths = ['lib']
 
-
-  spec.add_dependency "httparty"
-
-  #TODO: Use multi_json spec.add_dependency "multi_json"
+  spec.add_dependency 'httparty'
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "shoulda-matchers"
-  spec.add_development_dependency "webmock"
-  spec.add_development_dependency "dotenv"
-  spec.add_development_dependency "guard"
-  spec.add_development_dependency "guard-rspec"
   spec.add_development_dependency "pry"
-  spec.add_development_dependency "simplecov"
-  spec.add_development_dependency "coveralls"
-
 end

data/example.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+require 'pp'
+require 'bundler/setup'
+require 'databox'
+
+Databox.configure do |c|
+  c.push_token   = ENV["DATABOX_PUSH_TOKEN"]
+end
+
+client = Databox::Client.new()
+
+3.times do |t|
+	client.push("example.ruby", t*100, (DateTime.now - t).strftime('%Y-%m-%d'))
+end
+
+pp client.last_push(3)
+

data/lib/databox.rb

@@ -1,34 +1,21 @@
-require "httparty"
-
 module Databox
-  autoload :VERSION,        "databox/version"
-  autoload :Client,         "databox/client"
-  autoload :Configuration,  "databox/configuration"
-  autoload :Integration,    "databox/integration"
-
-  autoload :BigNumber,      "databox/integration"
-  autoload :LineChart,      "databox/integration"
-  autoload :BarChart,       "databox/integration"
-  autoload :Compare,        "databox/integration"
-  autoload :Interval,       "databox/integration"
-
-  autoload :Pipeline,       "databox/integration"
-  autoload :Funnel,         "databox/integration"
-  autoload :Pie,            "databox/integration"
-  autoload :Progress,       "databox/integration"
-  autoload :Messages,       "databox/integration"
-
+  autoload :VERSION,        'databox/version'
+  autoload :Client,         'databox/client'
+  autoload :Configuration,  'databox/configuration'
 
   class << self
     attr_accessor :configuration
 
     def configured?
       return false if configuration.nil?
-      [configuration.token, configuration.key, configuration.url].compact.size == 3
+      [
+          configuration.push_host,
+          configuration.push_token
+      ].compact.size == 2
     end
 
     def client
-      @client ||= Databox::Client.new
+      @client ||= ::Client.new
     end
   end
 
@@ -36,5 +23,4 @@ module Databox
     self.configuration ||= Configuration.new
     yield configuration if block_given?
   end
-
 end

data/lib/databox/client.rb

@@ -1,90 +1,71 @@
+require 'httparty'
+require 'json'
+
 class Databox::Client
   include HTTParty
   format :json
-
-  headers "User-Agent" => "Databox/#{Databox::VERSION} (Ruby)"
-
-  debug_output if ENV["HTTPARTY_DEBUG"] == "1"
-
+  headers 'User-Agent' => "Databox/#{Databox::VERSION} (Ruby)"
+  debug_output if [1, "1"].include?(ENV["HTTPARTY_DEBUG"])
   default_timeout 1 if ENV["DATABOX_MODE"] == "test"
 
-  attr_accessor :token
-  def token
-    @token || Databox.configuration.token
-  end
-
-  def key; Databox.configuration.key end
-  def url; Databox.configuration.url end
+  attr_accessor :last_push_content
 
   def initialize
     Databox.configure unless Databox.configured?
 
-    self.class.base_uri url
-    self.class.basic_auth key, "password"
+    self.class.base_uri push_host
+    self.class.basic_auth push_token, ''
+    self.class.headers 'Content-Type' => 'application/json'
+    self
   end
 
-  def push data={}
-    if validate data
-      data = [data] unless data.is_a?(Array)
-      handle self.class.post("/push/custom/#{self.token}", body: { data: data }.to_json)
-    end
+  def push_host
+    Databox.configuration.push_host
   end
 
-  def logs
-    handle self.class.get("/push/custom/#{self.token}/logs")
+  def push_token
+    Databox.configuration.push_token
   end
 
-  def handle response
-    if response.code > 201
-      raise Databox::ClientError.new(
-        response.code.to_s+" - "+
-        response.parsed_response["error"]["type"]+" - "+
-        response.parsed_response["error"]["message"]
-      )
-    end
-
-    output = response.parsed_response
+  # Sends data to actual end-point.
+  def raw_push(path='/', data=nil)
+    handle self.class.post(path, data.nil? ? {} : {body: JSON.dump({data: data})})
+  end
 
-    if output.is_a?(Hash) and output.keys.include?("response")
-      Databox::Response.new(output["response"])
-    elsif output.is_a?(Array)
-      output.map { |item| Databox::Response.new(item) }
-    else
-      output
-    end
+  def handle(response)
+    response.parsed_response
   end
 
-  def validate data
-    return data.map do |dp|
-      validate(dp)
-    end if data.is_a?(Array)
+  def process_kpi(options={})
+    options.delete_if { |k, _| [:date, 'date'].include?(k) }
 
-    errors = []
-    errors.push("Data is missing") if data.nil? or data == {}
-    errors.push("Key is required") if data[:key].nil?
-    # errors.push("Value is required") if data[:value].nil?
+    %i{key value}.each do |k|
+      raise("Missing '#{k}'") if (options[k] || options[k.to_s]).nil?
+    end
 
-    errors.push("Date format is invalid") if not(data[:date].nil?) and (Date.iso8601(data[:date]) rescue false) == false
-    errors.push("Key format is invalid") unless data[:key] =~/^[a-zA-Z0-9_\.\@]*$/
+    options["$#{(options['key'] || options[:key])}"] = options['value'] || options[:value]
+    options.delete_if { |k, _| [:key, 'key', :value, 'value'].include?(k) }
 
-    unless errors.empty?
-      invalid_record = Databox::InvalidRecord.new "Payload is invalid"
-      invalid_record.errors = errors
-      raise invalid_record
+    attributes = options[:attributes] || options['attributes']
+    unless attributes.nil?
+      [:attributes, 'attributes'].each {|k| options.delete(k) }
+      attributes.each { |k,v| options[k] = v }
     end
 
-    true
+    options
   end
-end
 
-class Databox::InvalidRecord < StandardError
-  attr_accessor :errors
-end
+  def push(kpi={})
+    self.last_push_content = raw_push('/', [process_kpi(kpi)])
+    self.last_push_content['status'] == 'ok'
+  end
 
-class Databox::ClientError < StandardError; end
+  def insert_all(rows=[])
+    self.last_push_content = raw_push('/', rows.map {|r| process_kpi(r) })
+    self.last_push_content['status'] == 'ok'
+  end
 
-class Databox::Response < OpenStruct
-  def success?
-    self.type == "success"
+  def last_push(n=1)
+    raw_push "/lastpushes/#{n}"
   end
 end