@voxgig/sdkgen 0.35.2 → 0.37.0

package/project/.sdk/tm/rb/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+gem "json"
+gem "minitest"

package/project/.sdk/tm/rb/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) $$const.year$$ $$const.Name$$
+
+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.
+

package/project/.sdk/tm/rb/Makefile

@@ -0,0 +1,10 @@
+.PHONY: test build clean
+
+test:
+	ruby -Ilib test/exists_test.rb
+
+build:
+	@echo "No build step for Ruby"
+
+clean:
+	@echo "No clean step for Ruby"

package/project/.sdk/tm/rb/core/context.rb

@@ -0,0 +1,105 @@
+# ProjectName SDK context
+
+require_relative '../utility/struct/voxgig_struct'
+require_relative 'control'
+require_relative 'operation'
+require_relative 'spec'
+require_relative 'result'
+require_relative 'response'
+require_relative 'error'
+require_relative 'helpers'
+
+class ProjectNameContext
+  attr_accessor :id, :out, :client, :utility, :ctrl, :meta, :config,
+                :entopts, :options, :entity, :shared, :opmap,
+                :data, :reqdata, :match, :reqmatch, :point,
+                :spec, :result, :response, :op
+
+  def initialize(ctxmap = {}, basectx = nil)
+    ctxmap ||= {}
+    @id = "C#{rand(10000000..99999999)}"
+    @out = {}
+
+    @client = ProjectNameHelpers.get_ctx_prop(ctxmap, "client") || basectx&.client
+    @utility = ProjectNameHelpers.get_ctx_prop(ctxmap, "utility") || basectx&.utility
+
+    @ctrl = ProjectNameControl.new
+    ctrl_raw = ProjectNameHelpers.get_ctx_prop(ctxmap, "ctrl")
+    if ctrl_raw.is_a?(Hash)
+      @ctrl.throw_err = ctrl_raw["throw"] if ctrl_raw.key?("throw")
+      @ctrl.explain = ctrl_raw["explain"] if ctrl_raw["explain"].is_a?(Hash)
+    elsif basectx&.ctrl
+      @ctrl = basectx.ctrl
+    end
+
+    m = ProjectNameHelpers.get_ctx_prop(ctxmap, "meta")
+    @meta = m.is_a?(Hash) ? m : (basectx&.meta || {})
+
+    cfg = ProjectNameHelpers.get_ctx_prop(ctxmap, "config")
+    @config = cfg.is_a?(Hash) ? cfg : basectx&.config
+
+    eo = ProjectNameHelpers.get_ctx_prop(ctxmap, "entopts")
+    @entopts = eo.is_a?(Hash) ? eo : basectx&.entopts
+
+    o = ProjectNameHelpers.get_ctx_prop(ctxmap, "options")
+    @options = o.is_a?(Hash) ? o : basectx&.options
+
+    e = ProjectNameHelpers.get_ctx_prop(ctxmap, "entity")
+    @entity = e || basectx&.entity
+
+    s = ProjectNameHelpers.get_ctx_prop(ctxmap, "shared")
+    @shared = s.is_a?(Hash) ? s : basectx&.shared
+
+    om = ProjectNameHelpers.get_ctx_prop(ctxmap, "opmap")
+    @opmap = om.is_a?(Hash) ? om : (basectx&.opmap || {})
+
+    @data = ProjectNameHelpers.to_map(ProjectNameHelpers.get_ctx_prop(ctxmap, "data")) || {}
+    @reqdata = ProjectNameHelpers.to_map(ProjectNameHelpers.get_ctx_prop(ctxmap, "reqdata")) || {}
+    @match = ProjectNameHelpers.to_map(ProjectNameHelpers.get_ctx_prop(ctxmap, "match")) || {}
+    @reqmatch = ProjectNameHelpers.to_map(ProjectNameHelpers.get_ctx_prop(ctxmap, "reqmatch")) || {}
+
+    pt = ProjectNameHelpers.get_ctx_prop(ctxmap, "point")
+    @point = pt.is_a?(Hash) ? pt : basectx&.point
+
+    sp = ProjectNameHelpers.get_ctx_prop(ctxmap, "spec")
+    @spec = sp.is_a?(ProjectNameSpec) ? sp : basectx&.spec
+
+    r = ProjectNameHelpers.get_ctx_prop(ctxmap, "result")
+    @result = r.is_a?(ProjectNameResult) ? r : basectx&.result
+
+    rp = ProjectNameHelpers.get_ctx_prop(ctxmap, "response")
+    @response = rp.is_a?(ProjectNameResponse) ? rp : basectx&.response
+
+    opname = ProjectNameHelpers.get_ctx_prop(ctxmap, "opname") || ""
+    @op = resolve_op(opname)
+  end
+
+  def resolve_op(opname)
+    return @opmap[opname] if @opmap[opname]
+    return ProjectNameOperation.new({}) if opname.empty?
+
+    entname = @entity&.respond_to?(:get_name) ? @entity.get_name : "_"
+    opcfg = VoxgigStruct.getpath(@config, "entity.#{entname}.op.#{opname}")
+
+    input = (opname == "update" || opname == "create") ? "data" : "match"
+
+    points = []
+    if opcfg.is_a?(Hash)
+      t = VoxgigStruct.getprop(opcfg, "points")
+      points = t if t.is_a?(Array)
+    end
+
+    op = ProjectNameOperation.new({
+      "entity" => entname,
+      "name" => opname,
+      "input" => input,
+      "points" => points,
+    })
+    @opmap[opname] = op
+    op
+  end
+
+  def make_error(code, msg)
+    ProjectNameError.new(code, msg, self)
+  end
+end

package/project/.sdk/tm/rb/core/control.rb

@@ -0,0 +1,11 @@
+# ProjectName SDK control
+
+class ProjectNameControl
+  attr_accessor :throw_err, :err, :explain
+
+  def initialize(opts = {})
+    @throw_err = opts[:throw_err]
+    @err = nil
+    @explain = opts[:explain]
+  end
+end

package/project/.sdk/tm/rb/core/error.rb

@@ -0,0 +1,24 @@
+# ProjectName SDK error
+
+class ProjectNameError < StandardError
+  attr_accessor :is_sdk_error, :sdk, :code, :msg, :ctx, :result, :spec
+
+  def initialize(code = "", msg = "", ctx = nil)
+    super(msg)
+    @is_sdk_error = true
+    @sdk = "ProjectName"
+    @code = code
+    @msg = msg
+    @ctx = ctx
+    @result = nil
+    @spec = nil
+  end
+
+  def error
+    @msg
+  end
+
+  def to_s
+    @msg
+  end
+end

package/project/.sdk/tm/rb/core/helpers.rb

@@ -0,0 +1,16 @@
+# ProjectName SDK helpers
+
+module ProjectNameHelpers
+  def self.to_map(v)
+    v.is_a?(Hash) ? v : nil
+  end
+
+  def self.to_int(v)
+    v.is_a?(Numeric) ? v.to_i : -1
+  end
+
+  def self.get_ctx_prop(m, key)
+    return nil if m.nil?
+    m[key]
+  end
+end

package/project/.sdk/tm/rb/core/operation.rb

@@ -0,0 +1,26 @@
+# ProjectName SDK operation
+
+require_relative '../utility/struct/voxgig_struct'
+
+class ProjectNameOperation
+  attr_accessor :entity, :name, :input, :points, :alias_map
+
+  def initialize(opmap = {})
+    opmap ||= {}
+    e = VoxgigStruct.getprop(opmap, "entity")
+    @entity = (e.is_a?(String) && !e.empty?) ? e : "_"
+    n = VoxgigStruct.getprop(opmap, "name")
+    @name = (n.is_a?(String) && !n.empty?) ? n : "_"
+    i = VoxgigStruct.getprop(opmap, "input")
+    @input = (i.is_a?(String) && !i.empty?) ? i : "_"
+
+    @points = []
+    raw_points = VoxgigStruct.getprop(opmap, "points")
+    if raw_points.is_a?(Array)
+      raw_points.each { |t| @points << t if t.is_a?(Hash) }
+    end
+
+    raw_alias = VoxgigStruct.getprop(opmap, "alias")
+    @alias_map = raw_alias.is_a?(Hash) ? raw_alias : nil
+  end
+end

package/project/.sdk/tm/rb/core/response.rb

@@ -0,0 +1,20 @@
+# ProjectName SDK response
+
+require_relative '../utility/struct/voxgig_struct'
+
+class ProjectNameResponse
+  attr_accessor :status, :status_text, :headers, :json_func, :body, :err
+
+  def initialize(resmap = {})
+    resmap ||= {}
+    s = VoxgigStruct.getprop(resmap, "status")
+    @status = s.is_a?(Numeric) ? s.to_i : -1
+    st = VoxgigStruct.getprop(resmap, "statusText")
+    @status_text = st.is_a?(String) ? st : ""
+    @headers = VoxgigStruct.getprop(resmap, "headers")
+    jf = VoxgigStruct.getprop(resmap, "json")
+    @json_func = jf.is_a?(Proc) ? jf : nil
+    @body = VoxgigStruct.getprop(resmap, "body")
+    @err = VoxgigStruct.getprop(resmap, "err")
+  end
+end

package/project/.sdk/tm/rb/core/result.rb

@@ -0,0 +1,23 @@
+# ProjectName SDK result
+
+require_relative '../utility/struct/voxgig_struct'
+
+class ProjectNameResult
+  attr_accessor :ok, :status, :status_text, :headers, :body, :err, :resdata, :resmatch
+
+  def initialize(resmap = {})
+    resmap ||= {}
+    @ok = VoxgigStruct.getprop(resmap, "ok") == true
+    s = VoxgigStruct.getprop(resmap, "status")
+    @status = s.is_a?(Numeric) ? s.to_i : -1
+    st = VoxgigStruct.getprop(resmap, "statusText")
+    @status_text = st.is_a?(String) ? st : ""
+    h = VoxgigStruct.getprop(resmap, "headers")
+    @headers = h.is_a?(Hash) ? h : {}
+    @body = VoxgigStruct.getprop(resmap, "body")
+    @err = VoxgigStruct.getprop(resmap, "err")
+    @resdata = VoxgigStruct.getprop(resmap, "resdata")
+    rm = VoxgigStruct.getprop(resmap, "resmatch")
+    @resmatch = rm.is_a?(Hash) ? rm : nil
+  end
+end

package/project/.sdk/tm/rb/core/spec.rb

@@ -0,0 +1,23 @@
+# ProjectName SDK spec
+
+class ProjectNameSpec
+  attr_accessor :parts, :headers, :alias_map, :base, :prefix, :suffix,
+                :params, :query, :step, :method, :body, :url, :path
+
+  def initialize(specmap = {})
+    specmap ||= {}
+    @parts = specmap["parts"] || specmap[:parts] || []
+    @headers = specmap["headers"] || specmap[:headers] || {}
+    @alias_map = specmap["alias"] || specmap[:alias] || {}
+    @base = specmap["base"] || specmap[:base] || ""
+    @prefix = specmap["prefix"] || specmap[:prefix] || ""
+    @suffix = specmap["suffix"] || specmap[:suffix] || ""
+    @params = specmap["params"] || specmap[:params] || {}
+    @query = specmap["query"] || specmap[:query] || {}
+    @step = specmap["step"] || specmap[:step] || ""
+    @method = specmap["method"] || specmap[:method] || "GET"
+    @body = specmap["body"] || specmap[:body]
+    @url = specmap["url"] || specmap[:url] || ""
+    @path = specmap["path"] || specmap[:path] || ""
+  end
+end

package/project/.sdk/tm/rb/core/utility_type.rb

@@ -0,0 +1,32 @@
+# ProjectName SDK utility type
+
+class ProjectNameUtility
+  attr_accessor :clean, :done, :make_error, :feature_add, :feature_hook,
+                :feature_init, :fetcher, :make_fetch_def, :make_context,
+                :make_options, :make_request, :make_response, :make_result,
+                :make_point, :make_spec, :make_url, :param, :prepare_auth,
+                :prepare_body, :prepare_headers, :prepare_method,
+                :prepare_params, :prepare_path, :prepare_query,
+                :result_basic, :result_body, :result_headers,
+                :transform_request, :transform_response, :custom
+
+  @@registrar = nil
+
+  def self.registrar=(r)
+    @@registrar = r
+  end
+
+  def initialize
+    @custom = {}
+    @@registrar&.call(self)
+  end
+
+  def self.copy(src)
+    u = ProjectNameUtility.new
+    src.instance_variables.each do |var|
+      u.instance_variable_set(var, src.instance_variable_get(var))
+    end
+    u.instance_variable_set(:@custom, src.custom.dup)
+    u
+  end
+end

package/project/.sdk/tm/rb/feature/base_feature.rb

@@ -0,0 +1,30 @@
+# ProjectName SDK base feature
+
+class ProjectNameBaseFeature
+  attr_accessor :version, :name, :active
+
+  def initialize
+    @version = "0.0.1"
+    @name = "base"
+    @active = true
+  end
+
+  def get_version; @version; end
+  def get_name; @name; end
+  def get_active; @active; end
+
+  def init(ctx, options); end
+  def PostConstruct(ctx); end
+  def PostConstructEntity(ctx); end
+  def SetData(ctx); end
+  def GetData(ctx); end
+  def GetMatch(ctx); end
+  def SetMatch(ctx); end
+  def PrePoint(ctx); end
+  def PreSpec(ctx); end
+  def PreRequest(ctx); end
+  def PreResponse(ctx); end
+  def PreResult(ctx); end
+  def PreDone(ctx); end
+  def PreUnexpected(ctx); end
+end

package/project/.sdk/tm/rb/feature/log_feature.rb

@@ -0,0 +1,50 @@
+# ProjectName SDK log feature
+
+require_relative 'base_feature'
+
+class ProjectNameLogFeature < ProjectNameBaseFeature
+  def initialize
+    super
+    @version = "0.0.1"
+    @name = "log"
+    @active = true
+    @client = nil
+    @options = nil
+    @logger = nil
+  end
+
+  def init(ctx, options)
+    @client = ctx.client
+    @options = options
+    @active = options["active"] == true
+
+    if @active
+      if options["logger"]
+        @logger = options["logger"]
+      else
+        @logger = $stderr
+      end
+    end
+  end
+
+  def _loghook(hook, ctx, level = "info")
+    return unless @logger
+    opname = ctx.op ? ctx.op.name : ""
+    msg = "hook=#{hook} op=#{opname}"
+    if @logger.respond_to?(:puts)
+      @logger.puts("[#{level.upcase}] #{msg}")
+    end
+  end
+
+  def PostConstruct(ctx); _loghook("PostConstruct", ctx); end
+  def PostConstructEntity(ctx); _loghook("PostConstructEntity", ctx); end
+  def SetData(ctx); _loghook("SetData", ctx); end
+  def GetData(ctx); _loghook("GetData", ctx); end
+  def SetMatch(ctx); _loghook("SetMatch", ctx); end
+  def GetMatch(ctx); _loghook("GetMatch", ctx); end
+  def PrePoint(ctx); _loghook("PrePoint", ctx); end
+  def PreSpec(ctx); _loghook("PreSpec", ctx); end
+  def PreRequest(ctx); _loghook("PreRequest", ctx); end
+  def PreResponse(ctx); _loghook("PreResponse", ctx); end
+  def PreResult(ctx); _loghook("PreResult", ctx); end
+end

package/project/.sdk/tm/rb/feature/test_feature.rb

@@ -0,0 +1,154 @@
+# ProjectName SDK test feature
+
+require_relative '../utility/struct/voxgig_struct'
+require_relative 'base_feature'
+
+class ProjectNameTestFeature < ProjectNameBaseFeature
+  def initialize
+    super
+    @version = "0.0.1"
+    @name = "test"
+    @active = true
+    @client = nil
+    @options = nil
+  end
+
+  def init(ctx, options)
+    @client = ctx.client
+    @options = options
+
+    entity = VoxgigStruct.getprop(options, "entity")
+    entity = {} unless entity.is_a?(Hash)
+
+    @client.mode = "test"
+
+    # Ensure entity ids are correct.
+    VoxgigStruct.walk(entity) do |key, val, parent, path|
+      if path.length == 2 && val.is_a?(Hash) && key
+        val["id"] = key
+      end
+      val
+    end
+
+    test_self = self
+
+    test_fetcher = ->(fctx, _fullurl, _fetchdef) {
+      respond = ->(status, data, extra) {
+        out = {
+          "status" => status,
+          "statusText" => "OK",
+          "json" => -> { data },
+          "body" => "not-used",
+        }
+        extra&.each { |k, v| out[k] = v }
+        return out, nil
+      }
+
+      op = fctx.op
+      entmap = VoxgigStruct.getprop(entity, op.entity)
+      entmap = {} unless entmap.is_a?(Hash)
+
+      if op.name == "load"
+        args = test_self.build_args(fctx, op, fctx.reqmatch)
+        found = VoxgigStruct.select(entmap, args)
+        ent = VoxgigStruct.getelem(found, 0)
+        return respond.call(404, nil, { "statusText" => "Not found" }) unless ent
+        VoxgigStruct.delprop(ent, "$KEY")
+        out = VoxgigStruct.clone(ent)
+        respond.call(200, out, nil)
+
+      elsif op.name == "list"
+        args = test_self.build_args(fctx, op, fctx.reqmatch)
+        found = VoxgigStruct.select(entmap, args)
+        return respond.call(404, nil, { "statusText" => "Not found" }) unless found
+        if found.is_a?(Array)
+          found.each { |item| VoxgigStruct.delprop(item, "$KEY") }
+        end
+        out = VoxgigStruct.clone(found)
+        respond.call(200, out, nil)
+
+      elsif op.name == "update"
+        args = test_self.build_args(fctx, op, fctx.reqdata)
+        found = VoxgigStruct.select(entmap, args)
+        ent = VoxgigStruct.getelem(found, 0)
+        return respond.call(404, nil, { "statusText" => "Not found" }) unless ent
+        if ent.is_a?(Hash) && fctx.reqdata
+          fctx.reqdata.each { |k, v| ent[k] = v }
+        end
+        VoxgigStruct.delprop(ent, "$KEY")
+        out = VoxgigStruct.clone(ent)
+        respond.call(200, out, nil)
+
+      elsif op.name == "remove"
+        args = test_self.build_args(fctx, op, fctx.reqmatch)
+        found = VoxgigStruct.select(entmap, args)
+        ent = VoxgigStruct.getelem(found, 0)
+        return respond.call(404, nil, { "statusText" => "Not found" }) unless ent
+        if ent.is_a?(Hash)
+          id = VoxgigStruct.getprop(ent, "id")
+          VoxgigStruct.delprop(entmap, id)
+        end
+        respond.call(200, nil, nil)
+
+      elsif op.name == "create"
+        test_self.build_args(fctx, op, fctx.reqdata)
+        id = fctx.utility.param.call(fctx, "id")
+        id ||= "%04x%04x%04x%04x" % [rand(0x10000), rand(0x10000), rand(0x10000), rand(0x10000)]
+
+        ent = VoxgigStruct.clone(fctx.reqdata)
+        if ent.is_a?(Hash)
+          ent["id"] = id
+          entmap[id.to_s] = ent if id.is_a?(String)
+          VoxgigStruct.delprop(ent, "$KEY")
+          out = VoxgigStruct.clone(ent)
+          return respond.call(200, out, nil)
+        end
+        respond.call(200, ent, nil)
+
+      else
+        respond.call(404, nil, { "statusText" => "Unknown operation" })
+      end
+    }
+
+    ctx.utility.fetcher = test_fetcher
+  end
+
+  def build_args(ctx, op, args)
+    opname = op.name
+    points = VoxgigStruct.getpath(ctx.config, "entity.#{ctx.entity.get_name}.op.#{opname}.points")
+    point = VoxgigStruct.getelem(points, -1)
+
+    params_path = VoxgigStruct.getpath(point, "args.params")
+    reqd_params = VoxgigStruct.select(params_path, { "reqd" => true })
+    reqd = VoxgigStruct.transform(reqd_params, ["`$EACH`", "", "`$KEY.name`"])
+
+    qand = []
+    q = { "`$AND`" => qand }
+
+    if args
+      keys = VoxgigStruct.keysof(args)
+      if keys
+        keys.each do |key|
+          is_id = (key == "id")
+          selected = VoxgigStruct.select(reqd, key)
+          is_reqd = !VoxgigStruct.isempty(selected)
+
+          if is_id || is_reqd
+            v = ctx.utility.param.call(ctx, key)
+            ka = op.alias_map ? VoxgigStruct.getprop(op.alias_map, key) : nil
+
+            qor = [{ key => v }]
+            qor << { ka => v } if ka.is_a?(String)
+
+            qand << { "`$OR`" => qor }
+          end
+        end
+      end
+    end
+
+    q["`$AND`"] = qand
+    ctx.ctrl.explain["test"] = { "query" => q } if ctx.ctrl.explain
+
+    q
+  end
+end

package/project/.sdk/tm/rb/src/feature/README.md

@@ -0,0 +1,3 @@
+# Features
+
+This folder contains the feature source templates.