json-yaml-embedded-expressions 0.0.1

data/README.md

@@ -0,0 +1,110 @@
+JSON/YAML/etc. with embedded expressions
+========================================
+
+A library for resolving embedded expressions in YAML, JSON and other. Empower your data with calculations!
+
+Install
+-------
+
+    $ gem install json-yaml-embedded-expressions
+    
+Usage
+-----
+
+`example.yaml`:
+    
+    packages:
+      "Office":
+        subpath: utils/office
+        modules:
+        - basename: writer
+          path: ="#{top.install_path}/#{parent.parent.subpath}/#{basename}"
+        - basename: spreadsheet
+          path: ="#{top.install_path}/#{parent.parent.subpath}/#{basename}"
+        modules_count: =modules.size
+    install_path: /home/alice
+    all_paths: =packages["Office"].modules.map(&:path)
+    
+Command line:
+    
+    $ yaml-embedded-expressions example.yaml
+    ---
+    packages:
+      Office:
+        subpath: utils/office
+        modules:
+        - basename: writer
+          path: /home/alice/utils/office/writer
+        - basename: spreadsheet
+          path: /home/alice/utils/office/spreadsheet
+        modules_count: 2
+    install_path: /home/alice
+    all_paths:
+    - /home/alice/utils/office/writer
+    - /home/alice/utils/office/spreadsheet
+
+Command line (JSON):
+
+    $ json-embedded-expressions example.json | json_pp
+    {
+      "packages" : {
+          "Office" : {
+            "subpath" : "utils/office",
+            "modules" : [
+                {
+                  "path" : "/home/alice/utils/office/writer",
+                  "basename" : "writer"
+                },
+                {
+                  "basename" : "spreadsheet",
+                  "path" : "/home/alice/utils/office/spreadsheet"
+                }
+            ],
+            "modules_count" : 2
+          }
+      },
+      "install_path" : "/home/alice",
+      "all_paths" : [
+          "/home/alice/utils/office/writer",
+          "/home/alice/utils/office/spreadsheet"
+      ]
+    }
+
+In Ruby:
+
+    require 'yaml/embedded_expressions'
+    require 'easy_hash'
+    
+    d = (YAML.load(File.read('example.yaml'))
+    YAML::EmbeddedExpressions.resolve!(d)
+    puts d
+      # {
+      #   "packages" => {
+      #     "Office" => {
+      #       "subpath" => "utils/office",
+      #       "modules" => [
+      #         {
+      #           "basename" => "writer", 
+      #           "path" => "/home/alice/utils/office/writer"
+      #         },
+      #         {
+      #           "basename" => "spreadsheet",
+      #           "path" => "/home/alice/utils/office/spreadsheet"
+      #         }
+      #       ],
+      #       "modules_count" => 2
+      #     }
+      #   },
+      #   "install_path" => "/home/alice",
+      #   "all_paths" => [
+      #     "/home/alice/utils/office/writer",
+      #     "/home/alice/utils/office/spreadsheet"
+      #   ]
+      # }
+
+### Details ###
+
+Embedded expression is a string of the form `=expr` (and not `==expr`) where
+`expr` is a Ruby expression. The expression is evaluated in context of the map/array it is contained in. Inside `expr` you may use `self`, `parent` and `top`. Map entries may be accessed/assigned via `map['key']`. If using command-line utilities or required `easy_hash` then `map.key` also works.
+
+Embedded expressions in map's keys are ignored, e. g., the following is not evaluated: `{"=2+2": "foobar"}`.

data/bin/json-embedded-expressions

@@ -0,0 +1,30 @@
+#!/usr/bin/ruby
+require 'json'
+require 'json/embedded_expressions'
+
+def usage
+  puts <<-USAGE
+
+Usage: #{File.basename __FILE__} [-h|--help] [file]
+
+Resolves embedded expressions in JSON. The JSON is read from file or from
+standard input.
+
+  USAGE
+end
+
+if ["-h", "--help"].include? ARGV.first then
+  usage
+  exit
+end
+
+input =
+  if ARGV.empty? then STDIN
+  elsif ARGV.size == 1 then File.open(ARGV.shift)
+  else usage; abort
+  end
+begin
+  puts(JSON::EmbeddedExpressions.resolve!(JSON.parse(input.read)).to_json)
+ensure
+  input.close
+end

data/bin/yaml-embedded-expressions

@@ -0,0 +1,30 @@
+#!/usr/bin/ruby
+require 'yaml'
+require 'yaml/embedded_expressions'
+
+def usage
+  puts <<-USAGE
+
+Usage: #{File.basename __FILE__} [-h|--help] [file]
+
+Resolves embedded expressions in YAML. The YAML is read from file or from
+standard input.
+
+  USAGE
+end
+
+if ["-h", "--help"].include? ARGV.first then
+  usage
+  exit
+end
+
+input =
+  if ARGV.empty? then STDIN
+  elsif ARGV.size == 1 then File.open(ARGV.shift)
+  else usage; abort
+  end
+begin
+  puts(YAML::EmbeddedExpressions.resolve!(YAML.load(input.read)).to_yaml)
+ensure
+  input.close
+end

data/lib/easy_hash.rb

@@ -0,0 +1,24 @@
+# encoding: UTF-8
+
+# 
+# Refines {Hash} so it behaves like following:
+# - <code>hash.xxx</code> is the same as <code>hash["xxx"]</code>
+# - <code>hash.xxx = y</code> is the same as <code>hash["xxx"] = y</code>
+# 
+module EasyHash
+  
+  class ::Hash
+    
+    def method_missing(method_id, *args, &block)
+      if method_id.to_s.end_with? '=' and args.size == 1 and block.nil? then
+        self[method_id.to_s.chop] = args.first
+      elsif args.size == 0 and block.nil? then
+        self[method_id.to_s]
+      else
+        super
+      end
+    end
+    
+  end
+  
+end

data/lib/embedded_expressions.rb

@@ -0,0 +1,160 @@
+
+module EmbeddedExpressions
+  
+  # Resolves embedded expressions in +data+.
+  # 
+  # +data+ is a tree, its nodes are {Array}s and {Hash}es, its leaves are
+  # arbitrary {Object}s. Subnodes and leaves are stored as {Array}s' items or
+  # as {Hash}es' values.
+  # 
+  # This function does the following:
+  # 1. For each node in +data+ it sets up {BackReferences}: sets
+  #    {BackReferences#parent} to the containing node ({Hash} or {Array}) and
+  #    {BackReferences#top} to +data.
+  # 2. Then for each leaf which is a {String} of the form +"=expr"+ and not of
+  #    the form "==expr" it evaluates +expr+ in context of the containing node
+  #    and replaces the leaf with the +expr+'s value. +expr+ which is required
+  #    by another +expr+ is evaluated first.
+  # 
+  # @return +data+ with embedded expressions resolved as described above.
+  # 
+  # @example
+  #   
+  #   d = {
+  #     "a" => [
+  #       "= parent['b'] + self.size",
+  #       "== ignored"
+  #     ],
+  #     "b" => "= self['c'] * 2",
+  #     "c" => 20
+  #   }
+  #   EmbeddedExpressions.resolve!(d)
+  #   puts d.inspect
+  #     #=>
+  #       {
+  #         "a" => [
+  #           42,
+  #           "== ignored"
+  #         ],
+  #         "b" => 40,
+  #         "c" => 20
+  #       }
+  # 
+  def resolve!(data)
+    # Replace all "=expr" strings with {EmbeddedExpression}s.
+    y = lambda do |data|
+      case data
+      when Array
+        for i in 0...data.size
+          data[i] = y.(data[i])
+        end
+        data
+      when Hash
+        for key in data.keys
+          data[key] = y.(data[key])
+        end
+        data
+      when /^\=\=/
+        data
+      when /^\=/
+        EmbeddedExpression.new(&eval("proc do \n #{data[1..-1]} \n end"))
+      else
+        data
+      end
+    end
+    y.(data)
+    # Populate {BackReferences} and {EmbeddedExpression#__context__}.
+    y = lambda do |data, parent, top|
+      case data
+      when Array
+        data.parent = parent
+        data.top = top
+        data.each { |item| y.(item, data, top) }
+      when Hash
+        data.parent = parent
+        data.top = top
+        data.values.each { |value| y.(value, data, top) }
+      when EmbeddedExpression
+        data.__context__ = parent
+      end
+    end
+    y.(data, nil, data)
+    # Replace all {EmbeddedExpression}s with their values.
+    y = lambda do |data|
+      case data
+      when Array
+        for i in 0...data.size
+          data[i] = y.(data[i])
+        end
+        data
+      when Hash
+        for key in data.keys
+          data[key] = y.(data[key])
+        end
+        data
+      when EmbeddedExpression
+        data.__value__
+      else
+        data
+      end
+    end
+    y.(data)
+    #
+    return data
+  end
+  
+  module_function :resolve!
+  
+  module BackReferences
+    
+    attr_accessor :parent
+    
+    attr_accessor :top
+    
+  end
+  
+  class ::Hash
+    
+    include BackReferences
+    
+  end
+  
+  class ::Array
+    
+    include BackReferences
+    
+  end
+  
+  private
+  
+  # @!visibility private
+  class EmbeddedExpression < BasicObject
+    
+    def initialize(&computation)
+      @context = nil
+      @expr = computation
+      @expr_resolved = false
+    end
+    
+    def __context__=(value)
+      @context = value
+    end
+    
+    def __value__
+      if @expr_resolved then
+        return @expr
+      else
+        @expr = @context.instance_eval(&@expr)
+        @expr_resolved = true
+        @context = nil
+        return @expr
+      end
+    end
+    
+    def method_missing(method_id, *args, &block)
+      __value__.__send__(method_id, *args, &block)
+    end
+    
+  end
+  
+end

data/lib/json/embedded_expressions.rb

@@ -0,0 +1,14 @@
+require 'json'
+require 'embedded_expressions'
+
+module JSON
+  
+  # @!parse
+  #   module EmbeddedExpressions
+  #     include ::EmbeddedExpressions
+  #   end
+  
+  # @!visibility private
+  EmbeddedExpressions = ::EmbeddedExpressions
+    
+end

data/lib/yaml/embedded_expressions.rb

@@ -0,0 +1,14 @@
+require 'yaml'
+require 'embedded_expressions'
+
+module YAML
+  
+  # @!parse
+  #   module EmbeddedExpressions
+  #     include ::EmbeddedExpressions
+  #   end
+  
+  # @!visibility private
+  EmbeddedExpressions = ::EmbeddedExpressions
+  
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: json-yaml-embedded-expressions
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Lavir the Whiolet
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-05-19 00:00:00.000000000 Z
+dependencies: []
+description: ! 'A library for resolving embedded expressions in YAML, JSON and other.
+  Empower your data with calculations!
+
+'
+email: Lavir.th.Whiolet@gmail.com
+executables:
+- json-embedded-expressions
+- yaml-embedded-expressions
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/easy_hash.rb
+- lib/json/embedded_expressions.rb
+- lib/yaml/embedded_expressions.rb
+- lib/embedded_expressions.rb
+- README.md
+- bin/json-embedded-expressions
+- bin/yaml-embedded-expressions
+homepage: 
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - '='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Embedded expressions in YAML/JSON/etc.
+test_files: []
+has_rdoc: