xjson 0.0.2

data/lib/xjson.rb

@@ -0,0 +1,270 @@
+require 'json'
+# require 'byebug'
+
+class Xjson
+
+    class XjsonIncludeError < RuntimeError; end
+    class XjsonReferenceError < RuntimeError; end
+
+    VERSION = "0.0.2"
+    def Xjson.version
+        Xjson::VERSION
+    end
+
+    def Xjson.load( filename )
+        Marshal.load( File.read( filename ) )
+    end
+
+    attr_reader :ext_data
+    attr_reader :data
+    attr_reader :dir
+
+    def initialize( xjson_file )
+        @cur_file = []
+        @cur_data = []
+        @ext_data = {}
+        @ext_data = read_json_file( xjson_file )
+        @data = expand( @ext_data )
+    end
+
+    # Read xjson file.
+    def read_json_file( xjson_file )
+        @cur_file.unshift xjson_file
+        if xjson_file[0] != "<"
+            JSON.parse( File.read( xjson_file ) )
+        else
+            JSON.parse( STDIN.read )
+        end
+    end
+
+    # Write expanded json file.
+    def write_json_file( json_file )
+        File.write( json_file, JSON.pretty_generate( @data ) + "\n" )
+    end
+
+    # Flatten by one level within array.
+    def flatten( data )
+        case data
+        when Array;
+            res = []
+            data.each do |i|
+                if i.class == Array
+                    res += i
+                else
+                    res.push i
+                end
+            end
+            res
+        else
+            data
+        end
+    end
+
+    def find_in_array_of_hash( scope, key, value )
+        index = 0
+        while index < scope.length
+            if Regexp.new( value).match( scope[ index ][ key ] )
+                return index
+            end
+            index += 1
+        end
+        nil
+    end
+
+    def reference_handle( data, ref_desc )
+        if ref_desc[0] != ":"
+            reference_handle( data, ":#{ref_desc}" )
+        else
+            # Relative reference from root.
+            path = ref_desc.split( ":" )[1..-1]
+            scope = data
+            while path[0..-2].any?
+                if path[0] == "*"
+                    # Wildcard for array.
+                    unless path[1] && path[2]
+                        raise XjsonReferenceError,
+                        "Invalid reference: \"#{ref_desc}\" in \"#{@cur_file[0]}\", missing match key and value ..."
+                    end
+                    index = find_in_array_of_hash( scope, path[1], path[2] )
+                    unless index
+                        raise XjsonReferenceError,
+                        "Invalid reference: \"#{ref_desc}\" in \"#{@cur_file[0]}\", key and value not matched ..."
+                    end
+                    scope = scope[ index ]
+                    path.shift( 2 )
+                else
+                    begin
+                        index = Integer( path[0] )
+                        scope = scope[ index ]
+                    rescue
+                        scope = scope[ path[0] ]
+                    end
+                end
+                path.shift
+                unless scope
+                    raise XjsonReferenceError,
+                    "Invalid reference: \"#{ref_desc}\" in \"#{@cur_file[0]}\"..."
+                end
+            end
+            [ scope, path[-1] ]
+        end
+    end
+
+    def reference( data, ref_desc )
+        path, label = reference_handle( data, ref_desc )
+        begin
+            index = Integer( label )
+            scope = path[ index ]
+        rescue
+            # scope = scope[ path[0] ]
+            scope = path[ label ]
+        end
+        scope
+    end
+
+    def override_desc( data, exp )
+        path, label = reference_handle( data, exp[0] )
+        { path: path, label: label, value: exp[1] }
+    end
+
+
+    def override_apply( desc, overwrite = false )
+        if desc[:label] == "*"
+            desc[:path].each do |place|
+                if not( place[ desc[:value][0] ] ) || overwrite
+                    place[ desc[:value][0] ] = desc[:value][1]
+                end
+            end
+        else
+            if not( desc[:path][desc[:label]] ) || overwrite
+                desc[:path][desc[:label]] = desc[:value]
+            end
+        end
+    end
+
+
+    def override( data, exp, overwrite = false )
+        desc = override_desc( data, exp )
+        override_apply( desc, overwrite )
+    end
+
+
+    # Expand json recursively.
+    def expand( data )
+
+        case data
+
+        when TrueClass; data
+
+        when FalseClass; data
+
+        when Float; data
+
+        when Integer; data
+
+        when String; data
+
+        when Array;
+            ret = []
+            @cur_data.unshift ret
+            data.each do |v|
+                value = expand( v )
+                ret.push( value ) if value
+            end
+            @cur_data.shift
+            ret
+
+        when Hash
+
+            if data.size == 1
+
+                # Most possible extension.
+
+                k, v = data.first
+
+                case k
+
+                when "@eval"
+                    %x"#{expand(v)}".split("\n")
+
+                when "@env"
+                    ENV[expand(v)]
+
+                when "@join"
+                    flatten( v[1..-1].map{|i| expand( i )} ).join( v[0] )
+
+                when "@flat"
+                    flatten( v[1..-1].map{|i| expand( i )} )
+
+                when "@self"
+                    reference( @ext_data, expand(v) )
+
+                when "@over";
+                    override( @cur_data[0], expand(v), true )
+                    nil
+
+                when "@base";
+                    override( @cur_data[0], expand(v), false )
+                    nil
+
+                when "@null"
+                    nil
+
+                when "@include";
+                    jsonfile = expand(v)
+                    subdata = read_json_file( jsonfile )
+                    expdata = expand( subdata )
+                    if expdata.class == Hash
+                        if @cur_data[0].class == expdata.class
+                            expdata.each do |ke,ve|
+                                @cur_data[0][ ke ] = ve
+                            end
+                        else
+                            raise XjsonIncludeError,
+                            "Included file (\"#{jsonfile}\") must contain a hash as top level"
+                        end
+                    elsif expdata.class == Array
+                        expdata.each do |ve|
+                            @cur_data[0].push ve
+                        end
+                    else
+                        raise XjsonIncludeError,
+                        "Included file (\"#{jsonfile}\") must contain a hash or a an array as top level"
+                    end
+                    @cur_file.shift
+                    nil
+
+                else
+                    # Non-extension.
+                    { k => expand( v ) }
+
+                end
+
+            else
+                ret = {}
+                @cur_data.unshift ret
+                data.each do |k,v|
+                    case k
+                    when "@null"; nil
+                    else
+                        value = expand( v )
+                        ret[ k ] = value if value
+                    end
+                end
+                @cur_data.shift
+                ret
+            end
+        end
+    end
+
+    # Return JSON data as string.
+    def to_s
+        JSON.pretty_generate( @data )
+    end
+
+    # Dump JSON data as marshal.
+    def dump( filename )
+        File.write( filename, Marshal.dump( @data ) )
+    end
+
+end

data/markdown/README.md

@@ -0,0 +1,130 @@
+# Overview
+
+Xjson is an extension to JSON format. The Xjson library processes the
+extensions and outputs standard JSON.
+
+Xjson (as JSON format) is compatible with standard JSON, i.e. the
+syntax is the same and Xjson can be processed with JSON tools. The
+extensions are special Xjson keywords that have semantics which the
+Xjson processor manages.
+
+Xjson renders JSON databases more dynamic and easy to maintain. The
+same could be achieved with a separate pre-processor, but Xjson
+provides tighter integration to JSON. This means that JSON aware text
+editors can be utilized and the JSON file (with extensions) looks and
+feels like a "normal" JSON file.
+
+
+# Extensions
+
+The extensions provide dynamic behaviour and modularity support.
+
+* `@eval`: Evaluate "system"/"shell" command.
+
+* `@env`:  Reference an environment variable.
+
+* `@join`: Join pieces of strings with given separator.
+
+* `@flat`: Flatten the list by one level.
+
+* `@self`: Refer to existing key/value pair, i.e. support for variables.
+
+* `@over`: Overwrite existing value or create if not existing.
+
+* `@base`: Set base (default) value, if not existing.
+
+* `@null`: No operation.
+
+* `@include`: Expand another Xjson/JSON file inplace.
+
+
+Example:
+
+```
+    {
+        "opts": [
+            { "@eval": "/prj/sbin/list_opts" },
+            { "@join": [ " ",
+                         "-conf_file",
+                         { "@join": [ "/",
+                                      { "@self": "workdir" },
+                                      "unit/data.txt" ] }
+                       ]
+            }
+        ],
+        "sub-defs": { "@include": "submodule.json" }
+    }
+
+```
+
+Extensions are captured within a Hash with one key/value pair. The
+pair will be recursively processed, and hence the extensions can be
+nested.
+
+Value of "opts" is an array, and the extensions can be directly stored
+as array members.
+
+"sub-defs" gives a unique label (key) for the extension, and each key
+must be unique in JSON, or it will be silently overwritten and
+disappear.
+
+Hence depending on the context of the extension, it should be written
+either with or without the extension label.
+
+Extension arguments and results:
+
+```
+    @eval: <string>                           => <string>
+    @env:  <string>                           => <string>
+    @join: <separator>, <list-of-strings>     => <string>
+    @flat: <array-of-atoms-or-arrays>         => <array>
+    @self: <key-reference>                    => <value>
+    @over: <key-reference>, <value>           => -
+    @base: <key-reference>, <value>           => -
+    @null: false                              => -
+    @include: <filename-string>               => <hash>
+
+```
+
+# Key Reference
+
+Key Reference (KR) is used to refer the items in the database
+itself. It can be used with `@self`, `@over`, and `@base` extensions.
+
+Key Reference is a String, where ":" is used as hierarchy
+separator. The string should start with ":" to designate the root, but
+when if a pure top-entry reference is performed, then a plain key name
+is accepted (e.g. just "opts", and not ":opts").
+
+Key Reference is split into path selectors with the ":" character. The
+path selectors are used one by one. Typically the path selector is a
+key and the corresponding value is selected to be used for the next
+path selector.
+
+However, for arrays, the path selector can be an index. The index
+selects the Nth item in the array.
+
+In addition to selecting keys and indexed items, there is a wildcard
+selector. The "*" character is used as wildcard. Wildcard behaves
+differently depending on its location in the Key Reference string.
+
+If wildcard is the last part of the KR, then it must correspond to an
+array in the hierarchy. The wildcard thus means all the members in the
+array. Then array members must be Hash entries, if KR is used with
+`@over` or `@base`. The value in this case is array of two, where
+first entry is key for the Hash members and second entry is the
+assigned value.
+
+If wildcard is used in the middle of the KR, then the next two path
+selectors are used as key and value matching path, and finally the
+third path selector is key to a value. Wildcard must correspond to an
+array of Hash members, and the array member that matches the key and
+value, will be selected. In allows travelling through the array
+without knowing the array index of the desired member.
+
+Example:
+
+```
+    "base-name": { "@base": [ ":modules:*", [ "start", "starter" ] ] },
+    "over-name": { "@over": [ ":modules:*:name:main:stop", "stopper" ] },
+```

data/test/golden/test.json

@@ -0,0 +1,50 @@
+{
+  "action": "test",
+  "regressions": {
+    "all": {
+      "test": [
+        {
+          "name": "t_run_1_1",
+          "dir": "test_dir"
+        },
+        {
+          "name": "t_run_1_2",
+          "dir": "test_dir-1_2"
+        },
+        {
+          "name": "t_run_1_3",
+          "dir": "test_dir"
+        },
+        {
+          "foobar1": "test1",
+          "dir": "test_dir"
+        },
+        {
+          "foobar2": "test2",
+          "dir": "test_dir"
+        }
+      ]
+    }
+  },
+  "foobar1": "test1",
+  "foobar2": "test2",
+  "release": "210701",
+  "minor": "3",
+  "runroot": "prog-",
+  "home": "FOOBAR",
+  "dut_files": [
+    "/release/210701/src/main.c",
+    [
+      "YES: 3"
+    ],
+    {
+      "myarr": [
+        "bar",
+        1,
+        2,
+        3
+      ]
+    }
+  ],
+  "eof": true
+}