leenookx-json-mangler 0.1.0

data/features/mocks/extraction.json

@@ -0,0 +1 @@
+{"doc": {"title": "A test document", "author": "My Name", "published": "1999", "keywords": ["rubbish", "nonsense"]}  }

data/features/mocks/extraction2.json

@@ -0,0 +1 @@
+{ "doc": { "info": {"author": "My Name", "title": "Document name"}, "bibtex": {"published": "1999", "ISBN": "1234567890"} }, "background": {"submitted": "2001"} }

data/features/mocks/grouped.json

@@ -0,0 +1,9 @@
+{
+    "doc": {
+        "title": "My example document",
+        "author": "leenookx",
+        "author": "Ghost author",
+        "keyword": "example",
+        "keyword": "keyword2"
+    }
+}

data/features/mocks/non_grouped.json

@@ -0,0 +1,8 @@
+{
+    "doc": {
+        "title": "My example document",
+        "author": "leenookx",
+        "keyword": "example"
+    }
+}
+

data/features/mocks/valid.json

@@ -0,0 +1,23 @@
+{
+"glossary": {
+        "title": "example glossary",
+		"GlossDiv": {
+            "title": "S",
+			"GlossList": {
+                "GlossEntry": {
+                    "ID": "SGML",
+					"SortAs": "SGML",
+					"GlossTerm": "Standard Generalized Markup Language",
+					"Acronym": "SGML",
+					"Abbrev": "ISO 8879:1986",
+					"GlossDef": {
+                        "para": "A meta-markup language, used to create markup languages such as DocBook.",
+						"GlossSeeAlso": ["GML", "XML"]
+                    },
+					"GlossSee": "markup"
+                }
+            }
+        }
+    }
+}
+

data/features/prune.feature

@@ -0,0 +1,11 @@
+Feature: Creation
+  In order to test that the JSON stream can be pruned
+  As a developer
+  I want to prune some mangling objects
+
+  Scenario: Prune branch from JSON stream Object
+    Given I already have a valid JSON mock stream
+    When I try and create a mangler object
+      And prune the 'glossary' branch
+    Then the 'glossary' branch is removed
+

data/features/step_definitions/creation_steps.rb

@@ -0,0 +1,24 @@
+Given /^I already have a valid JSON mock stream$/ do
+  @response = File.open('features/mocks/valid.json','r') {|f| f.readlines.to_s}
+end
+
+When /^I try and create a mangler object$/ do
+  @json_mangler = JSONMangler.new( @response )
+end
+
+Then /^the resultant object is valid$/ do
+  assert_equal(@json_mangler.valid, true)
+end
+
+Then /^I should get an invalid JSON mangler object$/ do
+  assert_equal(@json_mangler.valid, false)
+end
+
+Given /^I already have an empty JSON mock stream$/ do
+  @response = File.open('features/mocks/empty.json','r') {|f| f.readlines.to_s}
+end
+
+Then /^the output equals the input JSON mock stream$/ do
+  assert_not_equal("nil", @json_mangler.to_json)
+end
+

data/features/step_definitions/extaction_steps.rb

@@ -0,0 +1,63 @@
+Given /^I already have a JSON stream$/ do
+    @extraction_input = File.open('features/mocks/extraction.json', 'r') {|f| f.readlines.to_s}
+end
+
+When /^I try and extract a tag '(.*)' which doesn't exist$/ do |tag|
+    je = JSONExtractor.new
+    @extraction_results = je.extract(@extraction_input, "object", tag) 
+end
+
+Then /^the resultant JSON is empty$/ do
+   extraction_comparison = File.open('features/test_comparisons/empty_extraction.json', 'r') {|f| f.readlines.to_s}
+
+   assert_equal(extraction_comparison, @extraction_results)
+end
+
+When /^I try and extract the authors name$/ do
+    je = JSONExtractor.new
+    @extraction_results = je.extract(@extraction_input, "object", "author")
+end
+
+Then /^the resultant JSON contains the author details$/ do
+   extraction_comparison = File.open('features/test_comparisons/author_extraction.json', 'r') {|f| f.readlines.to_s}
+
+   assert_equal(extraction_comparison, @extraction_results)
+end
+
+When /^I try and extract any tags where the publishing date was 1999$/ do
+    je = JSONExtractor.new
+    @extraction_results = je.extract(@extraction_input, "data", "1999")
+end
+
+Then /^the resultant JSON contains the publishing date$/ do
+   extraction_comparison = File.open('features/test_comparisons/published_extraction.json', 'r') {|f| f.readlines.to_s}
+
+   assert_equal(extraction_comparison, @extraction_results)
+end
+
+Given /^I already have a complicated JSON stream$/ do
+    @extraction_input = File.open('features/mocks/extraction2.json', 'r') {|f| f.readlines.to_s}
+end
+
+When /^I try and extract data from the keyword array$/ do
+    je = JSONExtractor.new
+    @extraction_results = je.extract(@extraction_input, "data", "nonsense") 
+end
+
+Then /^the resultant JSON data contains the array$/ do
+   extraction_comparison = File.open('features/test_comparisons/array_extraction.json', 'r') {|f| f.readlines.to_s}
+
+   assert_equal(extraction_comparison, @extraction_results)
+end
+
+When /^I try and extract data from the keyword array with a depth of 2$/ do
+    je = JSONExtractor.new
+    @extraction_results = je.extract(@extraction_input, "data", "1999", 2) 
+end
+
+Then /^the result JSON data contains the array and its parent$/ do
+   extraction_comparison = File.open('features/test_comparisons/2level_extraction.json', 'r') {|f| f.readlines.to_s}
+
+   assert_equal(extraction_comparison, @extraction_results)
+end
+

data/features/step_definitions/groups_steps.rb

@@ -0,0 +1,24 @@
+Given /^I already have a valid JSON mock stream containing groups$/ do
+  @response = File.open('features/mocks/grouped.json', 'r') {|f| f.readlines.to_s}
+end
+
+When /^I group the contents of the mangling object$/ do
+  @json_mangler.group
+end
+
+Then /^the JSON mangler remains valid$/ do
+  assert_equal(@json_mangler, true)
+end
+
+Then /^the JSON stream is grouped correctly$/ do
+  pending
+end
+
+Given /^I already have a valid JSON mock stream containing no groups$/ do
+  @response = File.open('features/mocks/non_grouped.json', 'r') {|f| f.readlines.to_s}
+end
+
+Then /^the JSON stream remains the same as at the start$/ do
+  pending
+end
+

data/features/step_definitions/prune_steps.rb

@@ -0,0 +1,10 @@
+When /^prune the '(.*)' branch$/ do |branch|
+  @json_mangler.prune( branch )
+end
+
+Then /^the '(.*)' branch is removed$/ do |branch|
+  response = JSON.parse( @json_mangler.to_json )
+
+  assert_equal(response[branch], nil)
+end
+

data/features/support/env.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'spec/expectations'
+require "test/unit"
+
+# We'll have some unicode support please.
+require 'cucumber/formatter/unicode'
+
+mangler_file = File.join(File.dirname(__FILE__), *%w[.. .. lib json_mangler.rb])
+require mangler_file
+extractor_file = File.join(File.dirname(__FILE__), *%w[.. .. lib json_extractor.rb])
+require extractor_file
+
+ 
+World do
+  include Test::Unit::Assertions
+end
+

data/features/test_comparisons/2level_extraction.json

@@ -0,0 +1 @@
+{ "results": {"title": "A test document", "author": "My Name", "published": "1999", "keywords": ["rubbish", "nonsense"]} }

data/features/test_comparisons/array_extraction.json

@@ -0,0 +1 @@
+{ "results": {"keywords": ["rubbish", "nonsense"]} }

data/features/test_comparisons/author_extraction.json

@@ -0,0 +1 @@
+{ "results": {"author": "My Name"} }

data/features/test_comparisons/empty_extraction.json

@@ -0,0 +1 @@
+{ "results": {} }

data/features/test_comparisons/published_extraction.json

@@ -0,0 +1 @@
+{ "results": {"published": "1999"} }

data/json-mangler.gemspec

@@ -0,0 +1,72 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{json-mangler}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["lee nookx"]
+  s.date = %q{2009-08-30}
+  s.description = %q{TODO}
+  s.email = %q{lnookx@googlemail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".autotest",
+     ".gitignore",
+     "History.txt",
+     "Manifest.txt",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "features/create.feature",
+     "features/extraction.feature",
+     "features/group.feature",
+     "features/mocks/calais.json",
+     "features/mocks/empty.json",
+     "features/mocks/extraction.json",
+     "features/mocks/extraction2.json",
+     "features/mocks/grouped.json",
+     "features/mocks/non_grouped.json",
+     "features/mocks/valid.json",
+     "features/prune.feature",
+     "features/step_definitions/creation_steps.rb",
+     "features/step_definitions/extaction_steps.rb",
+     "features/step_definitions/groups_steps.rb",
+     "features/step_definitions/prune_steps.rb",
+     "features/support/env.rb",
+     "features/test_comparisons/2level_extraction.json",
+     "features/test_comparisons/array_extraction.json",
+     "features/test_comparisons/author_extraction.json",
+     "features/test_comparisons/empty_extraction.json",
+     "features/test_comparisons/published_extraction.json",
+     "json-mangler.gemspec",
+     "lib/json_extractor.rb",
+     "lib/json_mangler.rb",
+     "test/test_json_mangler.rb"
+  ]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/leenookx/json-mangler}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{JSON data format mangling tools.}
+  s.test_files = [
+    "test/test_json_mangler.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/lib/json_extractor.rb

@@ -0,0 +1,173 @@
+require 'strscan'
+
+# A basic JSON extraction utility inspired by the parser example given at
+# http://rubyquiz.com/quiz155.html
+
+class JSONExtractor
+
+    def initialize
+      @output = ""
+      @force_capture = false
+    end
+
+    def extract(input, extract_mode, search, depth = 1)
+        @output = ""
+        @force_capture = false
+        @capture_depth = depth - 1
+        @current_depth = 0
+
+        @input = StringScanner.new( input )
+        @searchval = '"' + search + '"'
+
+        if extract_mode == "object"
+            @mode = 1
+        elsif extract_mode == "data"
+            @mode = 2
+        else
+           error "Unknown mode '" + extract_mode + "'. Supported [object, data]"
+        end
+
+        puts "Extracting data based on '" + extract_mode + "' values."
+
+        parse_value
+
+        results = "{ \"results\": {" + @output + "} }\n"
+    end
+
+  private
+
+    def error(message)
+        if @input.eos?
+            raise "Unexpected end of input."
+        else
+            raise "#{message}: @ char #{@input.pos} :: #{@input.peek(@input.string.length)}"
+        end
+    end
+
+    def parse_value
+        trim_space
+        parse_object or
+          parse_array or
+          parse_string or
+          parse_number or
+          parse_keyword or
+          error("Illegal JSON value")
+    ensure
+        trim_space
+    end
+
+    def parse_object
+        if @input.scan(/\{\s*/)
+            output = ""
+            more_pairs = false
+            capture = false
+            while key = parse_string
+                @input.scan(/\s*:\s*/) or error("Expecting object separator")
+
+                if @mode == 1 and key == @searchval
+                    capture = true
+                end
+
+                res = parse_value
+
+                if @mode == 2 and res == @searchval
+                    @current_depth = @capture_depth
+                    @force_capture = true
+                end
+
+                if @capture_depth > 0
+                    output << key << ": " << res
+                end
+
+                if @force_capture or (@mode == 1 and key == @searchval and capture)
+                    if @capture_depth == 0
+                        output << key << ": " << res
+                    end
+                    capture = false
+                    if @current_depth == 0
+                      @output << output
+                      @force_capture = false
+                    else
+                        @current_depth = @current_depth - 1
+                    end
+                end
+
+                more_pairs = @input.scan(/\s*,\s*/) or break
+
+                if @capture_depth > 0
+                    output << ", "
+                end
+            end
+            error("Missing object pair") if more_pairs
+            @input.scan(/\s*\}/) or error("Unclosed object")
+        else
+            false
+        end
+    end
+
+    def parse_array
+        if @input.scan(/\[\s*/)
+            array = "["
+            more_values = false
+            while contents = parse_value rescue nil
+                array << contents
+                more_values = @input.scan(/\s*,\s*/) or break
+                array << ", "
+            end
+            error("Missing value") if more_values
+            @input.scan(/\s*\]/) or error("Unclosed array")
+            array << "]"
+            array
+        else
+            false
+        end
+    end
+
+    def parse_string
+        if @input.scan(/"/)
+            string = '"'
+            while contents = parse_string_content || parse_string_escape
+                string << contents
+            end
+            @input.scan(/"/) or error("Unclosed string")
+            string = string + '"'
+            if @mode == 2 and string == @searchval
+                @force_capture = true
+            end
+            string
+        else
+            false
+        end
+    end
+
+    def parse_string_content
+        @input.scan(/[^\\"]+/) and @input.matched
+    end
+
+    def parse_string_escape
+        if @input.scan(%r{\\["\\/]})
+            @input.matched[-1]
+        elsif @input.scan(/\\[bfnrt]/)
+            eval(%Q{"#{@input.matched}"})
+        elsif @input.scan(/\\u[0-9a-fA-F]{4}/)
+            [Integer("0x#{@input.matched[2..-1]}")].pack("U")
+        else
+            false
+        end
+    end
+
+    def parse_number
+        @input.scan(/-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?\b/) and
+          eval(@input.matched)
+    end
+
+    def parse_keyword
+        @input.scan(/\b(?:true|false|null)\b/) and
+          eval(@input.matched.sub("null", "nil"))
+    end
+
+    def trim_space
+        @input.scan(/\s+/)
+    end
+end
+

data/lib/json_mangler.rb

@@ -0,0 +1,39 @@
+require 'json'
+
+class JSONMangler
+  VERSION = '0.1.0'
+
+  def initialize( json_data )
+    ingest_json( json_data )
+  end
+
+  def valid
+    !@json_obj.nil?
+  end
+
+  def prune( keys )
+    if valid
+      keys.each do |key|
+        @json_obj.delete_if{|k, v| k == key }
+      end
+    end
+  end
+
+  def to_json
+    if valid
+      JSON.pretty_generate( @json_obj )
+    else
+      ""
+    end
+  end
+
+ private
+
+  def ingest_json( json_string )
+    begin
+      @json_obj = JSON.parse( json_string )
+    rescue
+      @json_obj = nil
+    end
+  end
+end

data/test/test_json_mangler.rb

@@ -0,0 +1,8 @@
+require "test/unit"
+require "json_mangler"
+
+class TestJsonMangler < Test::Unit::TestCase
+  def test_sanity
+    flunk "write tests or I will kneecap you"
+  end
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: leenookx-json-mangler
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- lee nookx
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-30 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: TODO
+email: lnookx@googlemail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .autotest
+- .gitignore
+- History.txt
+- Manifest.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- features/create.feature
+- features/extraction.feature
+- features/group.feature
+- features/mocks/calais.json
+- features/mocks/empty.json
+- features/mocks/extraction.json
+- features/mocks/extraction2.json
+- features/mocks/grouped.json
+- features/mocks/non_grouped.json
+- features/mocks/valid.json
+- features/prune.feature
+- features/step_definitions/creation_steps.rb
+- features/step_definitions/extaction_steps.rb
+- features/step_definitions/groups_steps.rb
+- features/step_definitions/prune_steps.rb
+- features/support/env.rb
+- features/test_comparisons/2level_extraction.json
+- features/test_comparisons/array_extraction.json
+- features/test_comparisons/author_extraction.json
+- features/test_comparisons/empty_extraction.json
+- features/test_comparisons/published_extraction.json
+- json-mangler.gemspec
+- lib/json_extractor.rb
+- lib/json_mangler.rb
+- test/test_json_mangler.rb
+- LICENSE
+has_rdoc: true
+homepage: http://github.com/leenookx/json-mangler
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: JSON data format mangling tools.
+test_files: 
+- test/test_json_mangler.rb