focuslight 0.1.1

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'rubygems'
+require 'rspec'
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')

data/spec/syntax_spec.rb

@@ -0,0 +1,9 @@
+require_relative './spec_helper'
+
+describe Focuslight do
+  it 'has modules that passes syntax check' do
+    Dir.glob(__dir__ + '/../lib/**/*.rb').each do |file|
+      require file
+    end
+  end
+end

data/spec/validator_predefined_rules_spec.rb

@@ -0,0 +1,177 @@
+require_relative './spec_helper'
+
+require 'focuslight/validator'
+
+describe Focuslight::Validator do
+  describe '.rule' do
+    it 'returns not_blank predefined rule' do
+      r = Focuslight::Validator.rule(:not_blank)
+      expect(r.check(nil)).to be_false
+      expect(r.check("")).to be_false
+      expect(r.check(" ")).to be_false
+      expect(r.check("a")).to be_true
+
+      expect(r.format("a")).to eql("a")
+      expect(r.format(" a ")).to eql("a")
+
+      expect(r.message).to eql("missing or blank")
+    end
+
+    it 'returns choice predefined rule' do
+      r1 = Focuslight::Validator.rule(:choice, "x", "y", "z")
+      expect(r1.check("a")).to be_false
+      expect(r1.check("x")).to be_true
+      expect(r1.check("z")).to be_true
+
+      expect(r1.format("x")).to eql("x")
+
+      expect(r1.message).to eql("invalid value")
+
+      r2 = Focuslight::Validator.rule(:choice, ["x", "y", "z"])
+      expect(r2.check("a")).to be_false
+      expect(r2.check("x")).to be_true
+      expect(r2.check("z")).to be_true
+
+      expect(r2.format("x")).to eql("x")
+    end
+
+    it 'returns int predefined rule' do
+      r = Focuslight::Validator.rule(:int)
+      expect(r.check("0")).to be_true
+      expect(r.check("100")).to be_true
+      expect(r.check("-21")).to be_true
+      expect(r.check("1.0")).to be_false
+      expect(r.check("-3e10")).to be_false
+      expect(r.check("xyz")).to be_false
+
+      expect(r.format("0")).to eql(0)
+      expect(r.format("100")).to eql(100)
+      expect(r.format("-21")).to eql(-21)
+
+      expect(r.message).to eql("invalid integer")
+    end
+
+    it 'returns uint predefined rule' do
+      r = Focuslight::Validator.rule(:uint)
+      expect(r.check("0")).to be_true
+      expect(r.check("100")).to be_true
+      expect(r.check("-21")).to be_false
+      expect(r.check("1.0")).to be_false
+      expect(r.check("-3e10")).to be_false
+      expect(r.check("xyz")).to be_false
+
+      expect(r.format("0")).to eql(0)
+      expect(r.format("100")).to eql(100)
+
+      expect(r.message).to eql("invalid integer (>= 0)")
+    end
+
+    it 'returns natural predefined rule' do
+      r = Focuslight::Validator.rule(:natural)
+      expect(r.check("0")).to be_false
+      expect(r.check("100")).to be_true
+      expect(r.check("-21")).to be_false
+      expect(r.check("1.0")).to be_false
+      expect(r.check("-3e10")).to be_false
+      expect(r.check("xyz")).to be_false
+
+      expect(r.format("0")).to eql(0)
+      expect(r.format("100")).to eql(100)
+
+      expect(r.message).to eql("invalid integer (>= 1)")
+    end
+
+    it 'returns float/double/real predefined rule' do
+      r1 = Focuslight::Validator.rule(:float)
+      r2 = Focuslight::Validator.rule(:double)
+      r3 = Focuslight::Validator.rule(:real)
+      [r1, r2, r3].each do |r|
+        expect(r.check("0")).to be_true
+        expect(r.check("0.0")).to be_true
+        expect(r.check("1.0")).to be_true
+        expect(r.check("1e+10")).to be_true
+        expect(r.check("2e-10")).to be_true
+        expect(r.check("-2e-10")).to be_true
+        expect(r.check("e")).to be_false
+        expect(r.check("xyz")).to be_false
+        expect(r.check("")).to be_false
+
+        expect(r.format("0")).to eql(0.0)
+        expect(r.format("0.0")).to eql(0.0)
+        expect(r.format("1.0")).to eql(1.0)
+        expect(r.format("1e+10")).to eql(1e+10)
+        expect(r.format("2e-10")).to eql(2e-10)
+        expect(r.format("-2e-10")).to eql(-2e-10)
+
+        expect(r.message).to eql("invalid floating point num")
+      end
+    end
+
+    it 'returns int_range predefined rule' do
+      r1 = Focuslight::Validator.rule(:int_range, 0..3)
+      expect(r1.check("0")).to be_true
+      expect(r1.check("1")).to be_true
+      expect(r1.check("3")).to be_true
+      expect(r1.check("-1")).to be_false
+
+      expect(r1.format("0")).to eql(0)
+
+      expect(r1.message).to eql("invalid number in range 0..3")
+
+      r2 = Focuslight::Validator.rule(:int_range, 1..3)
+      expect(r2.check("0")).to be_false
+      expect(r2.check("1")).to be_true
+      expect(r2.check("3")).to be_true
+      expect(r2.check("-1")).to be_false
+
+      expect(r2.format("1")).to eql(1)
+
+      expect(r2.message).to eql("invalid number in range 1..3")
+    end
+
+    it 'returns bool predefined rule, which parse numeric 1/0 as true/false' do
+      r = Focuslight::Validator.rule(:bool)
+      expect(r.check("0")).to be_true
+      expect(r.check("1")).to be_true
+      expect(r.check("true")).to be_true
+      expect(r.check("True")).to be_true
+      expect(r.check("false")).to be_true
+      expect(r.check("nil")).to be_false
+      expect(r.check("maru")).to be_false
+      expect(r.check("")).to be_false
+
+      expect(r.format("0")).to equal(false)
+      expect(r.format("1")).to equal(true)
+      expect(r.format("true")).to equal(true)
+      expect(r.format("True")).to equal(true)
+      expect(r.format("false")).to equal(false)
+
+      expect(r.message).to eql("invalid bool value")
+    end
+
+    it 'return regexp predefined rule' do
+      r = Focuslight::Validator.rule(:regexp, /^[0-9a-f]{4}$/i)
+      expect(r.check("000")).to be_false
+      expect(r.check("0000")).to be_true
+      expect(r.check("00000")).to be_false
+      expect(r.check("a0a0")).to be_true
+      expect(r.check("FFFF")).to be_true
+
+      str = "FfFf"
+      expect(r.format(str)).to equal(str)
+
+      expect(r.message).to eql("invalid input for pattern ^[0-9a-f]{4}$")
+    end
+
+    it 'returns rule instance whatever we want with "lambda" rule name' do
+      r = Focuslight::Validator.rule(:lambda, ->(v){ v == 'kazeburo' }, "kazeburo only permitted", :to_sym)
+      expect(r.check("kazeburo")).to be_true
+      expect(r.check(" ")).to be_false
+      expect(r.check("tagomoris")).to be_false
+
+      expect(r.format("kazeburo")).to eql(:kazeburo)
+
+      expect(r.message).to eql("kazeburo only permitted")
+    end
+  end
+end

data/spec/validator_result_spec.rb

@@ -0,0 +1,27 @@
+require_relative './spec_helper'
+
+require 'focuslight/validator'
+
+describe Focuslight::Validator::Result do
+  it 'indicate that it has errors or not' do
+    r = Focuslight::Validator::Result.new
+    expect(r.has_error?).to be_false
+    r.error(:key, "error 1")
+    expect(r.has_error?).to be_true
+    expect(r.errors).to eql({key: "key: error 1"})
+    r.error(:key2, "error 2")
+    expect(r.has_error?).to be_true
+    expect(r.errors).to eql({key:"key: error 1", key2:"key2: error 2"})
+  end
+
+  it 'can contain values like Hash, but keys are symbolized' do
+    r = Focuslight::Validator::Result.new
+    expect(r[:something]).to be_nil
+    r['something'] = 'somevalue'
+    expect(r[:something]).to eql("somevalue")
+    r[:key1] = "value1"
+    expect(r[:key1]).to eql("value1")
+    r[:key2] = ["value2", "value2alt"]
+    expect(r[:key2]).to eql(["value2", "value2alt"])
+  end
+end

data/spec/validator_rule_spec.rb

@@ -0,0 +1,68 @@
+require_relative './spec_helper'
+
+require 'focuslight/validator'
+
+describe Focuslight::Validator::Rule do
+  it 'can be initialized with 2 or 3 arguments' do
+    expect{ Focuslight::Validator::Rule.new() }.to raise_error(ArgumentError)
+    r1 = Focuslight::Validator::Rule.new(->(v){ v.nil? }, "message")
+    r2 = Focuslight::Validator::Rule.new(->(v){ v.nil? }, "message", ->(v){ nil })
+    expect{ Focuslight::Validator::Rule.new(->(v){ v.nil? }, "message", ->(v){ nil }, "something") }.to raise_error(ArgumentError)
+  end
+
+  describe '#check' do
+    it 'can validate value with first argument lambda' do
+      r1 = Focuslight::Validator::Rule.new(->(v){ v.nil? }, "only nil")
+      expect(r1.check(nil)).to be_true
+      expect(r1.check("str")).to be_false
+
+      r2 = Focuslight::Validator::Rule.new(->(v){ v.to_i == 1 }, "one")
+      expect(r2.check("0")).to be_false
+      expect(r2.check("1.00")).to be_true
+      expect(r2.check("1")).to be_true
+      expect(r2.check("2")).to be_false
+    end
+
+    it 'can receive 2 or more values for lambda arguments if specified' do
+      r1 = Focuslight::Validator::Rule.new(->(v1,v2,v3){ v1.to_i > v2.to_i && v2.to_i > v3.to_i }, "order by desc")
+      expect(r1.check("1","2","3")).to be_false
+      expect(r1.check("3","2","1")).to be_true
+      expect{ r1.check("3") }.to raise_error(ArgumentError)
+
+      r2 = Focuslight::Validator::Rule.new(->(v1){ v1.to_i > 0 }, "greater than zero")
+      expect{ r2.check("1", "2") }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#format' do
+    context 'when formatter not specified' do
+      it 'returns value itself' do
+        r = Focuslight::Validator::Rule.new(->(v){ v.size == 3 }, "3chars")
+        str = "abc"
+        expect(r.format(str)).to equal(str)
+      end
+    end
+    context 'when formatter lambda specified' do
+      it 'returns lambda return value' do
+        r = Focuslight::Validator::Rule.new(->(v){ v == '0' }, 'zero', ->(v){ 0 })
+        expect(r.format("0")).to eql(0)
+      end
+    end
+    context 'when formatter symbol specified' do
+      it 'returns value from Symbol.to_proc' do
+        r = Focuslight::Validator::Rule.new(->(v){ v == '1' || v == '2' }, 'one or two', :to_i)
+        expect(r.format("1")).to eql(1)
+        expect(r.format("2")).to eql(2)
+      end
+    end
+  end
+
+  describe '#message' do
+    it 'returns predefined message' do
+      r = Focuslight::Validator::Rule.new(->(v){ v.nil? }, "nil only allowed")
+      expect(r.message).to eql("nil only allowed")
+      expect(r.message).to eql("nil only allowed")
+      expect(r.message).to eql("nil only allowed")
+    end
+  end
+end

data/spec/validator_spec.rb

@@ -0,0 +1,121 @@
+require_relative './spec_helper'
+
+require 'focuslight/validator'
+
+describe Focuslight::Validator do
+  describe '.validate_single' do
+    it 'returns default value as valid value for params without specified key' do
+      result = Focuslight::Validator::Result.new
+      params = {key1: "1", key2: "2"}
+      spec = {default: "0", rule: Focuslight::Validator.rule(:not_blank)}
+      Focuslight::Validator.validate_single(result, params, :key3, spec)
+
+      expect(result[:key3]).to eql("0")
+    end
+
+    it 'checks and formats about specified single key, that should have single value in params' do
+      params = {key1: "1", key2: "2", keyx: "x"}
+
+      result1 = Focuslight::Validator::Result.new
+      spec1 = {rule: Focuslight::Validator.rule(:not_blank)}
+      Focuslight::Validator.validate_single(result1, params, :key1, spec1)
+      Focuslight::Validator.validate_single(result1, params, :key2, spec1)
+      Focuslight::Validator.validate_single(result1, params, :keyx, spec1)
+      expect(result1.has_error?).to be_false
+      expect(result1[:key1]).to eql("1")
+      expect(result1[:key2]).to eql("2")
+      expect(result1[:keyx]).to eql("x")
+
+      result2 = Focuslight::Validator::Result.new
+      spec2 = {rule: [ Focuslight::Validator.rule(:not_blank), Focuslight::Validator.rule(:uint) ]}
+      Focuslight::Validator.validate_single(result2, params, :key1, spec2)
+      Focuslight::Validator.validate_single(result2, params, :key2, spec2)
+      Focuslight::Validator.validate_single(result2, params, :keyx, spec2)
+      expect(result2.has_error?).to be_true
+      expect(result2[:key1]).to eql(1)
+      expect(result2[:key2]).to eql(2)
+      expect(result2[:keyx]).to be_nil
+      expect(result2.errors).to eql({keyx: "keyx: invalid integer (>= 0)"})
+    end
+  end
+
+  describe '.validate_array' do
+    it 'cannot accept default spec' do
+      params = {key1: ["0", "1", "2"], key2: [], key3: ["kazeburo"]}
+
+      result1 = Focuslight::Validator::Result.new
+      spec1 = {array: true, default: 1, rule: Focuslight::Validator.rule(:not_blank)}
+      expect{ Focuslight::Validator.validate_array(result1, params, :key1, spec1) }.to raise_error(ArgumentError)
+    end
+
+    it 'checks array size' do
+      params = {key1: ["0", "1", "2"], key2: [], key3: ["kazeburo"]}
+
+      result1 = Focuslight::Validator::Result.new
+      spec1 = {array: true, size: 0..3, rule: Focuslight::Validator.rule(:not_blank)}
+      Focuslight::Validator.validate_array(result1, params, :key1, spec1)
+      Focuslight::Validator.validate_array(result1, params, :key2, spec1)
+      Focuslight::Validator.validate_array(result1, params, :key3, spec1)
+      expect(result1.has_error?).to be_false
+      expect(result1[:key1]).to eql(["0", "1", "2"])
+      expect(result1[:key2]).to eql([])
+      expect(result1[:key3]).to eql(["kazeburo"])
+
+      result2 = Focuslight::Validator::Result.new
+      spec2 = {array: true, size: 1...3, rule: Focuslight::Validator.rule(:not_blank)}
+      Focuslight::Validator.validate_array(result2, params, :key1, spec2)
+      Focuslight::Validator.validate_array(result2, params, :key2, spec2)
+      Focuslight::Validator.validate_array(result2, params, :key3, spec2)
+      expect(result2.has_error?).to be_true
+      expect(result2[:key1]).to be_nil
+      expect(result2[:key2]).to be_nil
+      expect(result2[:key3]).to eql(["kazeburo"])
+    end
+
+    it 'formats all elements of valid field' do
+      params = {key1: ["0", "1", "2"], key2: [], key3: ["kazeburo"]}
+
+      result1 = Focuslight::Validator::Result.new
+      spec1 = {array: true, size: 0..3, rule: Focuslight::Validator.rule(:not_blank)}
+      Focuslight::Validator.validate_array(result1, params, :key1, spec1)
+      Focuslight::Validator.validate_array(result1, params, :key2, spec1)
+      Focuslight::Validator.validate_array(result1, params, :key3, spec1)
+      expect(result1.has_error?).to be_false
+      expect(result1[:key1]).to eql(["0", "1", "2"])
+      expect(result1[:key2]).to eql([])
+      expect(result1[:key3]).to eql(["kazeburo"])
+
+      result2 = Focuslight::Validator::Result.new
+      spec2 = {array: true, size: 0..3, rule: [Focuslight::Validator.rule(:not_blank), Focuslight::Validator.rule(:uint)]}
+      Focuslight::Validator.validate_array(result2, params, :key1, spec2)
+      Focuslight::Validator.validate_array(result2, params, :key2, spec2)
+      Focuslight::Validator.validate_array(result2, params, :key3, spec2)
+      expect(result2.has_error?).to be_true
+      expect(result2[:key1]).to eql([0, 1, 2])
+      expect(result2[:key2]).to eql([])
+      expect(result2[:key3]).to be_nil
+    end
+  end
+  describe '.validate_multi_key' do
+    it 'does not accept default keyword' do
+      params = {key1: "10", key2: "1", key3: "0", key4: "5", key5: "3"}
+      result = Focuslight::Validator::Result.new
+      spec = { default: 1, rule: Focuslight::Validator::Rule.new(->(x,y,z){ x.to_i + y.to_i + z.to_i < 15 }, "too large") }
+      expect{ Focuslight::Validator.validate_multi_key(result, params, [:key1, :key2, :key3], spec) }.to raise_error(ArgumentError)
+    end
+
+    it 'checks complex expression with array key (multi field validation)' do
+      params = {key1: "10", key2: "1", key3: "0", key4: "5", key5: "3"}
+      spec = { rule: Focuslight::Validator::Rule.new(->(x,y,z){ x.to_i + y.to_i + z.to_i < 15 }, "too large") }
+
+      r1 = Focuslight::Validator::Result.new
+      Focuslight::Validator.validate_multi_key(r1, params, [:key1, :key2, :key3], spec)
+      expect(r1.has_error?).to be_false
+
+      r2 = Focuslight::Validator::Result.new
+      Focuslight::Validator.validate_multi_key(r2, params, [:key1, :key2, :key4], spec)
+      expect(r2.has_error?).to be_true
+      expect(r2.errors).to eql({:'key1,key2,key4' => "key1,key2,key4: too large"})
+    end
+  end
+end

data/view/add_complex.erb

@@ -0,0 +1,143 @@
+<form id="complex-form" class="hxrpost form-horizontal" method="post" action="<%= url_for '/add_complex' %>" role="form">
+
+<fieldset>
+
+<div class="form-group">
+  <label for="" class="control-label col-sm-3">Path</label>
+  <div class="col-sm-8">
+    <div class="input-group">
+      <span class="input-group-addon">/</span>
+      <input type="text" class="form-control" name="service_name" value="<%= params[:service_name] %>" />
+      <span class="input-group-addon">/</span>
+      <input type="text" class="form-control" name="section_name" value="<%= params[:section_name] %>" />
+      <span class="input-group-addon">/</span>
+      <input type="text" class="form-control" name="graph_name" value="<%= params[:graph_name] %>" />
+    </div>
+    <p class="help-block">Graph's URI(service name/section name/graph name)</p>
+  </div>
+</div>
+
+<div class="form-group">
+  <label for="" class="col-sm-3 control-label">Description</label>
+  <div class="col-sm-9">
+    <input type="text" class="form-control" name="description" value="<%= params[:description] %>" />
+  </div>
+</div>
+
+<div class="form-group">
+  <label for="" class="control-label col-sm-3">Display sum up value</label>
+  <div class="col-sm-4">
+    <select name="sumup" class="form-control">
+    <option value="0" <%= selected?(params[:sumup], 0) %>>disable</option>
+    <option value="1" <%= selected?(params[:sumup], 1) %>>enable</option>
+    </select>
+  </div>
+</div>
+
+<div class="form-group">
+  <label for="" class="control-label col-sm-3">Display order</label>
+  <div class="col-sm-4">
+    <select name="sort" class="form-control">
+    <% (0..19).map(&:to_i).reverse.each do |i| %>
+      <option value="<%= i %>" <%= selected?(params[:sort], i) %>><%= i %></option>
+    <% end %>
+    </select>
+    <p class="help-block">19 is top</p>
+  </div>
+</div>
+
+</fieldset>
+
+<fieldset>
+<legend>Data</legend>
+
+<div class="form-group">
+<label for="" class="control-label col-sm-2">Series-1</label>
+<div class="col-sm-10">
+
+<table class="table table-bordered table-striped">
+<tr>
+<th style="width: 6%;">&nbsp;</th>
+<th style="width: 18%;">Type</th>
+<th style="width: 62%;">Path</th>
+<th style="width: 13%; text-align: center">Mode</th>
+</tr>
+<tr>
+<td>&nbsp;</td>
+<td><select name="type-1" class="form-control">
+<option value="AREA"  <%= selected?(params[:'type-1'], 'AREA') %>>AREA</option>
+<option value="LINE1" <%= selected?(params[:'type-1'], 'LINE1') %>>LINE</option>
+<option value="LINE2" <%= selected?(params[:'type-1'], 'LINE2') %>>LINE(Bold)</option>
+</select></td>
+<td><select name="path-1" class="form-control">
+<% graphs.each do |row| %>
+<option value="<%= row[:id] %>">/<%= row[:service_name] %>/<%= row[:section_name] %>/<%= row[:graph_name] %></option>
+<% end %>
+</select></td>
+</tr>
+</table>
+</div>
+</div>
+
+<div class="form-group">
+<label for="" class="control-label col-sm-2">Series-2 and more</label>
+<div class="col-sm-10">
+
+<table class="table table-bordered table-striped" id="add-data-tbl">
+<tr>
+<th style="width: 6%;">&nbsp;</th>
+<th style="width: 18%;">Type</th>
+<th style="width: 39%;">Path</th>
+<th style="width: 12%; text-align: center;">Mode</th>
+<th style="width: 12%; text-align: center;">Stack</th>
+<th style="width: 12%; text-align: center;">&nbsp;</th>
+</tr>
+
+<tr>
+<td>&nbsp;</td>
+<td><select name="type-add" id="type-add" class="form-control">
+<option value="AREA">AREA</option>
+<option value="LINE1">LINE</option>
+<option value="LINE2">LINE(Bold)</option>
+</select></t>
+<td><select name="path-add" id="path-add" class="form-control">
+<% graphs.each do |row| %>
+<option value="<%= row[:id] %>">/<%= row[:service_name] %>/<%= row[:section_name] %>/<%= row[:graph_name] %></option>
+<% end %>
+</select></td>
+<td style="text-align:center;"><select name="stack-add" id="stack-add" class="form-control">
+<option value="1">enable</option>
+<option value="0">disable</option>
+</select>
+</td>
+<td style="text-align:center;"><button id="add-new-row" class="btn btn-default" style="padding: 3px 14px 4px;">Add</button></td>
+</tr>
+</table>
+</div>
+</div>
+
+</fieldset>
+
+<fieldset>
+<legend>Preview</legend>
+
+<div class="form-group">
+  <div class="col-sm-offset-2 col-sm-10">
+    <div id="preview-graph"></div>
+  </div>
+</div>
+
+</fieldset>
+
+<hr />
+
+<div class="form-group">
+  <div class="col-sm-offset-3 col-sm-9">
+    <input type="submit" class="btn btn-primary" value="Add" />
+  </div>
+</div>
+
+</form>
+<br />
+<br />
+