growthforecast 0.0.1

data/.gitignore

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

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2013- TAGOMORI Satoshi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,194 @@
+# GrowthForecast
+
+Client library to operate GrowthForecast.
+
+* http://kazeburo.github.com/GrowthForecast/ (Japanese)
+* https://github.com/kazeburo/growthforecast
+
+Update graph value, or create/edit/delete basic graphs and complex graphs.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'growthforecast'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install growthforecast
+
+## Usage
+
+Update graph's value:
+
+```ruby
+require 'growthforecast'
+gf = GrowthForecast.new('your.gf.host.name', 5125)
+
+gf.post('servicename', 'sectionname', 'graphname', 50)
+#### or post with graph mode and color
+# gf.post('servicename', 'sectionname', 'graphname', 50, 'gauge', '#ff00ff')
+```
+
+Get graph list and full descripted object:
+
+```ruby
+glist = gf.graphs() #=> [] or array of GrowthForecast::Path
+
+glist[0].id
+glist[0].service_name
+glist[0].section_name
+glist[0].graph_name
+glist[0].complex? #=> false
+
+graph = gf.graph(glist[0].id) #=> instance of GrowthForecast::Graph
+
+graph.id
+graph.description
+graph.color
+graph.type
+graph.number
+graph.created_at #=> instance of Time
+
+### complex
+clist = gf.complexes() #=> [] or array of GrowthForecast::Path
+
+clist[0].id
+clist[0].service_name
+clist[0].section_name
+clist[0].graph_name
+clist[0].complex? #=> true
+
+complex = gf.complex(clist[0].id) #=> instance of GrowthForecast::Complex
+
+complex.id
+complex.description
+complex.data        #=> array of GrowthForecast::Complex::Item
+
+complex.data[1].graph_id #=> id of GrowthForecast::Graph
+complex.data[1].stack    #=> boolean
+complex.data[1].gmode    #=> 'gauge' or 'subtract'
+complex.data[1].type     #=> 'AREA', 'LINE1' or 'LINE2'
+
+### get data of elements of complex graph
+
+complex.data.each do |e|
+  graph = gf.graph(e.graph_id) #=> GrowthForecast::Graph
+  # ...
+end
+
+### get full list of both of graph and complex
+
+list = gf.all() #=> array of GrowthForecast::Graph and GrowthForecast::Complex
+
+tree = gf.tree()
+tree['service']['section']['name']
+   #=> instance of GrowthForecast::Graph or GrowthForecast::Complex
+
+### Or more simply, get one by path name
+### (heavy operation: consider to cache result of gf.all() or gf.tree() to call multiple times)
+one = gf.by_name('service', 'section', 'name')
+   #=> instance of GrowthForecast::Graph or GrowthForecast::Complex
+```
+
+To edit:
+
+```ruby
+target = gf.graph(glist.first.id)
+
+target.description = 'OK, we are now testing...'
+target.color = '#000000'
+target.type = 'LINE2'
+
+result = gf.edit(target) #=> boolean: success or not
+
+raise "Something goes wrong..." unless result
+
+### invert complex graph element order
+complex = gf.complex(clist.last.id)
+
+complex.data.reverse!
+
+gf.edit(complex)
+
+### add graph into complex graph's data
+
+item = GrowthForecast::Complex::Item.new({graph_id: g.id, stack: true, gmode: 'gauge', type: 'AREA'})
+complex.data.push(item)
+
+gf.edit(complex)
+
+### delete graph
+gf.delete(graph)   #=> if false, not deleted correctly...
+gf.delete(complex)
+```
+
+To add graph, `add_graph()` and `add()` are available:
+
+```ruby
+# add_graph(service, section, graph_name, initial_value=0, color=nil, mode=nil)
+## color default: nil(random)
+## mode  default: nil('gauge')
+gf.add_graph('example', 'test', 'graph1')
+
+# add(spec)
+## spec: instance of GrowthForecast::Graph
+spec = GrowthForecast::Graph({service_name: 'example', section_name: 'test', graph_name: 'graph1', color: '#0000ff'})
+gf.add(spec)
+```
+
+As same as graph, to add complex, `add_complex()` and `add()` are available:
+
+```ruby
+# add_complex(service, section, graph_name, description, sumup, sort, type, gmode, stack, data_graph_ids)
+## sumup: true or false
+## sort: 0-19
+## type,gmode,stack: specify all options of members of data, with same value
+## type: 'AREA', 'LINE1', 'LINE2'
+## gmode: 'gauge', 'subtract'
+## stack: true or false
+gf.add_complex('example', 'test', 'summary1', 'testing...', true, 0, 'AREA', 'gauge', true, [graph1.id, graph2.id])
+
+# add(spec)
+## spec: instance of GrowthForecast::Complex
+spec = GrowthForecast::Complex({
+  service_name: 'example', section_name: 'test', graph_name: 'summary1',
+  description: 'testing...', sumup: true,
+  data: graph_id_list.map{|id| GrowthForecast::Complex::Item.new({graph_id: id, type: 'AREA', gmode: 'gauge', stack: true}) }
+})
+# hmm, i want not to stack last of data, and want to show by bold line.
+spec.data.last.stack = false
+spec.data.last.type = 'LINE2'
+
+gf.add(spec)
+```
+
+`add()` accepts graph/complex instance already exists as template:
+
+```ruby
+# copy template complex graph
+complex_spec = gf.complex(template.id)
+
+complex_spec.graph_name = 'copy_of_template_1' # you MUST change one of service/section/graph at least
+complex_spec.description = '....'
+
+gf.add(complex_spec) # add() ignores 'id' attribute
+```
+
+## TODO
+
+* validations of specs
+* diff of 2 graph objects
+* bin/gfclient
+* tests
+
+## Copyright
+
+* Copyright (c) 2013- TAGOMORI Satoshi (tagomoris)
+* License
+  * Apache License, Version 2.0
+  * see 'LICENSE'

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/example/test1.rb

@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+
+require 'minitest/unit'
+include MiniTest::Assertions
+
+require 'growthforecast'
+
+gf = GrowthForecast.new
+
+start_graphs = gf.all().size
+
+# value update
+r = gf.post('example', 'test', 'graph2', Process.pid)
+g1a = gf.graph(r.id)
+g1b = gf.post('example', 'test', 'graph2', 0, 'count')
+assert (g1a.number == g1b.number), "if number changed, something goes wrong..."
+
+# get graph
+r = gf.graph(99999) # maybe non-existing graph id
+assert r.nil?, "may be nil"
+
+# list check
+glist = gf.graphs()
+assert (glist.is_a?(Array) and glist.size >= 0), "lists must be not nil"
+
+# add graph and edit it
+r = gf.add_graph('example', 'test', 'graphrb' + Process.pid.to_s + 'a', 0, '#ff0000')
+g2 = gf.by_name('example', 'test', 'graphrb' + Process.pid.to_s + 'a')
+
+assert (g2.color == '#ff0000'), "added graph color must be #ffff00"
+assert (g2.type == 'AREA'), "initial type of graph may be AREA"
+
+g2.type = 'LINE2'
+
+r = gf.edit(g2)
+
+g3 = gf.graph(g2.id)
+assert (g3.type == 'LINE2'), "type not changed correctly #{g3.type}"
+
+glist2 = gf.graphs()
+assert (glist.size + 1 == glist2.size), "graphs not added one: #{glist.size} -> #{glist2.size}"
+
+# add graph by spec
+spec = GrowthForecast::Graph.new({
+    'service_name' => 'example', 'section_name' => 'test', 'graph_name' => 'graphrb' + Process.pid.to_s + 'b',
+    'color' => '#00FF00', 'mode' => 'derive',
+  })
+r = gf.add(spec)
+
+assert r, "add failed with return value #{r}"
+
+g4 = gf.by_name('example', 'test', 'graphrb' + Process.pid.to_s + 'b')
+assert (g4.mode == 'derive'), "mode should be derive, but #{g4.mode}"
+
+# complex
+r = gf.complex(99999) # may be non-existing id
+assert r.nil?, "may be nil"
+
+clist = gf.complexes()
+assert (clist.is_a?(Array) and clist.size >= 0), "lists must be not nil"
+
+r = gf.add_complex('example', 'test', 'graphrb' + Process.pid.to_s + 'c', 'testing now', true, 19, 'LINE1', 'gauge', true, [g1b.id, g2.id, g4.id])
+
+assert r, "add_complex failed with return value #{r}"
+c1 = gf.by_name('example', 'test', 'graphrb' + Process.pid.to_s + 'c')
+assert c1.complex?, "c1 is not complex, why?"
+
+c2spec = gf.complex(c1) #copy of c1 instance
+c2spec.graph_name = 'graphrb' + Process.pid.to_s + 'd'
+c2spec.data = [
+  GrowthForecast::Complex::Item.new(graph_id: g2.id),
+  GrowthForecast::Complex::Item.new(graph_id: g4.id),
+]
+
+r = gf.add(c2spec)
+
+assert r, "add failed with return value #{r}"
+
+c2 = gf.by_name('example', 'test', 'graphrb' + Process.pid.to_s + 'd')
+c2.sort = 0
+
+r = gf.edit(c2)
+
+c2 = gf.complex(c2)
+assert (c2.sort == 0), "sort value not updated correctly"
+
+# delete graphs
+unless gf.delete(c2) && gf.delete(c1) && gf.delete(g4) && gf.delete(g2) && gf.delete(g1b)
+  raise "failed to delete graphs ..."
+end
+
+end_graphs = gf.all().size
+assert (start_graphs == end_graphs), "start graph nums and end graph nums mismatch: #{start_graphs} -> #{end_graphs}"
+

data/growthforecast.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/growthforecast/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["TAGOMORI Satoshi"]
+  gem.email         = ["tagomoris@gmail.com"]
+  gem.description   = %q{Client library and tool to update values, create/edit/delete graphs of GrowthForecast}
+  gem.summary       = %q{A client library for GrowthForecast}
+  gem.homepage      = "https://github.com/tagomoris/rb-growthforecast"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "growthforecast"
+  gem.require_paths = ["lib"]
+  gem.version       = GrowthForecast::VERSION
+end

data/lib/growthforecast/complex.rb

@@ -0,0 +1,75 @@
+require 'json'
+require 'time'
+
+class GrowthForecast::Complex
+  attr_accessor :id, :service_name, :section_name, :graph_name
+  attr_accessor :description, :sort, :sumup
+  attr_accessor :data
+  attr_accessor :number, :data, :created_at, :updated_at
+
+  # TODO strict validations
+  
+  def initialize(obj)
+    if obj.is_a?(String)
+      obj = JSON.parse(obj)
+    end
+    obj.keys.each do |k|
+      obj[k.to_sym] = obj.delete(k)
+    end
+
+    if not obj[:complex]
+      raise ArgumentError, "non-complex graph is for GrowthForecast::Complex"
+    end
+
+    @id = obj[:id] ? obj[:id].to_i : nil
+    @service_name = obj[:service_name]
+    @section_name = obj[:section_name]
+    @graph_name = obj[:graph_name]
+    @description = obj[:description]
+    @sort = (obj[:sort] || 19).to_i
+    @sumup = obj[:sumup] ? true : false
+    @data = (obj[:data] || []).map{|d| Item.new(d)}
+    @number = (obj[:number] || 0).to_i
+    @created_at = obj[:created_at] ? Time.strptime(obj[:created_at], GrowthForecast::TIME_FORMAT) : nil
+    @updated_at = obj[:updated_at] ? Time.strptime(obj[:updated_at], GrowthForecast::TIME_FORMAT) : nil
+  end
+
+  def complex?
+    true
+  end
+
+  def to_json
+    {
+      'complex' => true,
+      'id' => @id,
+      'service_name' => @service_name, 'section_name' => @section_name, 'graph_name' => @graph_name,
+      'description' => @description, 'sort' => @sort, 'sumup' => @sumup,
+      'data' => @data.map(&:to_hash),
+      'number' => @number,
+      'created_at' => (@created_at ? @created_at.strftime(GrowthForecast::TIME_FORMAT) : nil),
+      'updated_at' => (@updated_at ? @updated_at.strftime(GrowthForecast::TIME_FORMAT) : nil),
+    }.to_json
+  end
+
+  class Item
+    attr_accessor :graph_id, :gmode, :stack, :type
+
+    def initialize(obj)
+      if obj.is_a?(String)
+        obj = JSON.parse(obj)
+      end
+      obj.keys.each do |k|
+        obj[k.to_sym] = obj.delete(k)
+      end
+
+      @graph_id = obj[:graph_id]
+      @gmode = obj[:gmode] || 'gauge'
+      @stack = (obj[:stack] || obj[:stack].nil?) ? true : false
+      @type = obj[:type] || 'AREA'
+    end
+
+    def to_hash
+      {'graph_id' => @graph_id, 'gmode' => @gmode, 'stack' => @stack, 'type' => @type}
+    end
+  end
+end

data/lib/growthforecast/graph.rb

@@ -0,0 +1,70 @@
+require 'json'
+require 'time'
+
+class GrowthForecast::Graph
+  attr_accessor :id, :service_name, :section_name, :graph_name
+  attr_accessor :description, :mode, :sort, :color, :gmode
+  attr_accessor :type, :ulimit, :llimit, :stype, :sulimit, :sllimit
+  attr_accessor :adjust, :adjustval, :unit
+  attr_accessor :number, :data, :created_at, :updated_at
+
+  # TODO strict validations
+  
+  def initialize(obj)
+    if obj.is_a?(String)
+      obj = JSON.parse(obj)
+    end
+
+    obj.keys.each do |k|
+      obj[k.to_sym] = obj.delete(k)
+    end
+
+    if obj[:complex]
+      raise ArgumentError, "complex graph is for GrowthForecast::Complex"
+    end
+
+    @id = obj[:id] ? obj[:id].to_i : nil
+    @service_name = obj[:service_name]
+    @section_name = obj[:section_name]
+    @graph_name = obj[:graph_name]
+    @description = obj[:description]
+    @mode = obj[:mode] || 'gauge'
+    @sort = (obj[:sort] || 19).to_i
+    @color = obj[:color]
+    @gmode = obj[:gmode] || 'gauge'
+    @type = obj[:type] || 'AREA'
+    @ulimit = obj[:ulimit] || 1000000000
+    @llimit = obj[:llimit] || -1000000000
+    @stype = obj[:stype] || 'AREA'
+    @sulimit = obj[:sulimit] || 100000
+    @sllimit = obj[:sllimit] || -100000
+    @adjust = obj[:adjust] || '*'
+    @adjustval = (obj[:adjustval] || 1).to_i
+    @unit = obj[:unit] || ''
+    @number = (obj[:number] || 0).to_i
+    @data = obj[:data] || []
+    @created_at = obj[:created_at] ? Time.strptime(obj[:created_at], GrowthForecast::TIME_FORMAT) : nil
+    @updated_at = obj[:updated_at] ? Time.strptime(obj[:updated_at], GrowthForecast::TIME_FORMAT) : nil
+  end
+
+  def complex?
+    false
+  end
+
+  def to_json
+    if @color.nil?
+      raise RuntimeError, "cannot stringify as json without 'color' parameter"
+    end
+
+    {
+      'complex' => false,
+      'id' => @id,
+      'service_name' => @service_name, 'section_name' => @section_name, 'graph_name' => @graph_name,
+      'description' => @description, 'mode' => @mode, 'sort' => @sort, 'color' => @color, 'gmode' => @gmode,
+      'type' => @type, 'ulimit' => @ulimit, 'llimit' => @llimit, 'stype' => @stype, 'sulimit' => @sulimit, 'sllimit' => @sllimit,
+      'adjust' => @adjust, 'adjustval' => @adjustval, 'unit' => @unit,
+      'number' => @number, 'data' => @data,
+      'created_at' => @created_at.strftime(GrowthForecast::TIME_FORMAT), 'updated_at' => @updated_at.strftime(GrowthForecast::TIME_FORMAT)
+    }.to_json
+  end
+end

data/lib/growthforecast/path.rb

@@ -0,0 +1,58 @@
+require 'json'
+require_relative './graph'
+require_relative './complex'
+
+class GrowthForecast::Path
+  attr_accessor :id, :service_name, :section_name, :graph_name
+  attr_accessor :complex
+
+  PATH_KEYS = [:id,:service_name,:section_name,:graph_name,:complex]
+  def self.path?(obj)
+    if obj.is_a?(String)
+      obj = JSON.parse(obj)
+    end
+    keys = obj.keys.size
+    if keys >= 4 && keys <= 5 && obj.keys.map(&:to_sym).reduce(true){|r,k| r && PATH_KEYS.include?(k)}
+      return true
+    end
+    false
+  end
+
+  def initialize(obj)
+    if obj.is_a?(String)
+      obj = JSON.parse(obj)
+    end
+    obj.keys.each do |k|
+      obj[k.to_sym] = obj.delete(k)
+    end
+
+    @id = obj[:id].to_i
+    @service_name = obj[:service_name]
+    @section_name = obj[:section_name]
+    @graph_name = obj[:graph_name]
+    @complex = obj[:complex] ? true : false
+  end
+
+  def complex?
+    @complex
+  end
+
+  def to_json
+    {
+      'id' => @id, 'complex' => @complex,
+      'service_name' => @service_name, 'section_name' => @section_name, 'graph_name' => @graph_name,
+    }.to_json
+  end
+
+  def to_graph
+    if @complex
+      GrowthForecast::Complex.new({
+          complex: true, id: @id, service_name: @service_name, section_name: @section_name, graph_name: @graph_name
+        })
+    else
+      GrowthForecast::Graph.new({
+          complex: false, id: @id, service_name: @service_name, section_name: @section_name, graph_name: @graph_name
+        })
+    end
+  end
+end

data/lib/growthforecast/version.rb

@@ -0,0 +1,3 @@
+class GrowthForecast
+  VERSION = "0.0.1"
+end

data/lib/growthforecast.rb

@@ -0,0 +1,235 @@
+require "growthforecast/version"
+
+class GrowthForecast
+  TIME_FORMAT = '%Y/%m/%d %H:%M:%S'
+end
+
+require "growthforecast/graph"
+require "growthforecast/complex"
+require "growthforecast/path"
+
+require 'net/http'
+require 'uri'
+require 'json'
+
+class GrowthForecast
+  attr_accessor :host, :port, :prefix, :timeout, :debug
+
+  def initialize(host='localhost', port=5125, prefix=nil, timeout=30, debug=false)
+    @host = host
+    @port = port.to_i
+    @prefix = if prefix && (prefix =~ /^\//) then prefix
+              elsif prefix then '/' + prefix
+              else '/'
+              end
+    @prefix.chop! if @prefix =~ /\/$/
+    @timeout = timeout.to_i
+    @debug = debug ? true : false
+  end
+
+  def debug(mode=nil)
+    if mode.nil?
+      return GrowthForecast.new(@host,@port,@prefix,@timeout,true)
+    end
+    @mode = mode ? true : false
+    self
+  end
+
+  def post(service, section, name, value, mode=nil, color=nil)
+    form = {'number' => value}
+    form.update({'mode' => mode}) if mode
+    form.update({'color' => color}) if color
+    content = URI.encode_www_form(form)
+
+    request('POST', "/api/#{service}/#{section}/#{name}", {}, content)
+  end
+
+  def by_name(service, section, name)
+    ((self.tree()[service] || {})[section] || {})[name]
+  end
+
+  def graph(id)
+    if id.respond_to?(:complex?) && (not id.complex?) # accept graph object itself to reload
+      id = id.id
+    end
+    request('GET', "/json/graph/#{id}")
+  end
+
+  def complex(id)
+    if id.respond_to?(:complex?) && id.complex? # accept complex object itself to reload
+      id = id.id
+    end
+    request('GET', "/json/complex/#{id}")
+  end
+
+  def graphs
+    request('GET', "/json/list/graph", {}, '', true)
+  end
+
+  def complexes
+    list = request('GET', "/json/list/complex", {}, '', true)
+    list.each do |path|
+      path.complex = true
+    end
+    list
+  end
+
+  def all
+    request('GET', "/json/list/all", {}, '', true)
+  end
+
+  def tree
+    root = {}
+    self.all().each do |i|
+      root[i.service_name] ||= {}
+      root[i.service_name][i.section_name] ||= {}
+      root[i.service_name][i.section_name][i.graph_name] = i
+    end
+    root
+  end
+
+  def edit(spec)
+    if spec.id.nil?
+      raise ArgumentError, "cannot edit graph without id (get graph data from GrowthForecast at first)"
+    end
+    path = if spec.complex?
+             "/json/edit/complex/#{spec.id}"
+           else
+             "/json/edit/graph/#{spec.id}"
+           end
+    request('POST', path, {}, spec.to_json)
+  end
+
+  def delete(spec)
+    if spec.id.nil?
+      raise ArgumentError, "cannot delete graph without id (get graph data from GrowthForecast at first)"
+    end
+    path = if spec.complex?
+             "/delete_complex/#{spec.id}"
+           else
+             "/delete/#{spec.service_name}/#{spec.section_name}/#{spec.graph_name}"
+           end
+    request('POST', path)
+  end
+
+  ADDITIONAL_PARAMS = ['description' 'sort' 'gmode' 'ulimit' 'llimit' 'sulimit' 'sllimit' 'type' 'stype' 'adjust' 'adjustval' 'unit']
+  def add(spec)
+    unless spec.respond_to?(:complex?)
+      raise ArgumentError, "parameter of add() must be instance of GrowthForecast::Graph or GrowthForecast::Complex (or use add_graph/add_complex)"
+    end
+    if spec.complex?
+      add_complex_spec(spec)
+    else
+      add_graph(spec.service_name, spec.section_name, spec.graph_name, spec.number, spec.color, spec.mode)
+    end
+  end
+
+  def add_graph(service, section, graph_name, initial_value=0, color=nil, mode=nil)
+    if service.empty? || section.empty? || graph_name.empty?
+      raise ArgumentError, "service, section and graph_name must be specified"
+    end
+    if (not color.nil?)
+      unless color =~ /^#[0-9a-fA-F]{6}/
+        raise ArgumentError, "color must be specified like #FFFFFF"
+      end
+    end
+    post(service, section, graph_name, initial_value, mode, color) and true # 'add' and 'add_graph' returns boolean not graph object
+  end
+
+  def add_complex(service, section, graph_name, description, sumup, sort, type, gmode, stack, data_graph_ids)
+    unless data_graph_ids.is_a?(Array) && data_graph_ids.size > 0
+      raise ArgumentError, "To create complex graph, specify 1 or more sub graph ids"
+    end
+    unless sort >= 0 and sort <= 19
+      raise ArgumentError, "sort must be 0..19"
+    end
+    unless type == 'AREA' || type == 'LINE1' || type == 'LINE2'
+      raise ArgumentError, "type must be one of AREA/LINE1/LINE2"
+    end
+    unless gmode == 'gauge' || gmode == 'subtract'
+      raise ArgumentError, "gmode must be one of gauge/subtract"
+    end
+    spec = GrowthForecast::Complex.new({
+        complex: true,
+        service_name: service, section_name: section, graph_name: graph_name,
+        description: description, sumup: sumup, sort: sort,
+        data: data_graph_ids.map{|id| {'graph_id' => id, 'type' => type, 'gmode' => gmode, 'stack' => stack} }
+      })
+    add_complex_spec(spec)
+  end
+
+  private
+
+  def add_complex_spec(spec)
+    request('POST', "/json/create/complex", {}, spec.to_json)
+  end
+
+  def concrete(obj)
+    case
+    when obj.nil?
+      nil
+    when obj.is_a?(TrueClass) || obj.is_a?(FalseClass)
+      obj
+    when obj.is_a?(Array)
+      obj.map{|e| concrete(e)}
+    when GrowthForecast::Path.path?(obj)
+      GrowthForecast::Path.new(obj)
+    when obj['complex']
+      Complex.new(obj)
+    else
+      Graph.new(obj)
+    end
+  end
+
+  def request(method, path, header={}, content='', getlist=false)
+    concrete(http_request(method, path, header, content, getlist))
+  end
+
+  def http_request(method, path, header={}, content='', getlist=false)
+    conn = Net::HTTP.new(@host, @port)
+    conn.open_timeout = conn.read_timeout = @timeout
+    request_path = @prefix + path
+    res = conn.send_request(method, request_path, content, header)
+
+    unless res.is_a?(Net::HTTPSuccess)
+      return [] if getlist and res.code == '404'
+
+      # GrowthForecast returns 200 for validation and other errors. hmm...
+      if @debug
+        warn "GrowthForecast returns response code #{res.code}"
+        warn " request (#{method}) http://#{host}:#{port}#{request_path}"
+        warn " with content #{content}"
+      end
+      return nil
+    end
+    # code 200
+    return true if res.body.length < 1
+
+    obj = begin
+            JSON.parse(res.body)
+          rescue JSON::ParserError => e
+            warn "failed to parse response content as json, with error: #{e.message}"
+            nil
+          end
+    return nil unless obj
+
+    if obj.is_a?(Array) # get valid list
+      return obj
+    end
+
+    # hash obj
+    if obj.has_key?('error') && obj['error'] != 0
+      warn "request ended with error:"
+      (obj['messages'] || {}).each do |key,msg|
+        warn "  #{key}: #{msg}"
+      end
+      warn "  request (#{method}) http://#{host}:#{port}#{request_path}"
+      warn "  with content #{res.body}"
+      nil
+    elsif obj.has_key?('error') && obj.has_key?('data') # valid response, without any errors
+      obj['data']
+    else  # bare growthforecast object
+      obj
+    end
+  end
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: growthforecast
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- TAGOMORI Satoshi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-03 00:00:00.000000000 Z
+dependencies: []
+description: Client library and tool to update values, create/edit/delete graphs of
+  GrowthForecast
+email:
+- tagomoris@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- example/test1.rb
+- growthforecast.gemspec
+- lib/growthforecast.rb
+- lib/growthforecast/complex.rb
+- lib/growthforecast/graph.rb
+- lib/growthforecast/path.rb
+- lib/growthforecast/version.rb
+homepage: https://github.com/tagomoris/rb-growthforecast
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: A client library for GrowthForecast
+test_files: []