jazor 0.0.4 → 0.1.0

data/README.rdoc

@@ -1,36 +1,68 @@
 = Jazor
 
-Jazor is a simple command line JSON parsing tool.
+Jazor (rhymes with "razor") is a simple command line JSON parsing tool.
 
 == Installation
 
   gem install jazor
 
-=== General usage
+== Usage
 
-  jazor [options] [source] [slice]
+  jazor [options] [source] [expression ...]
 
-- The *source* option refers to a file, URL or string containing JSON data.
-  Jazor also accepts input from STDIN.
-- The *slice* option refers to the piece of JSON data you're interested in. This
-  is usually just the name of an attribute, but you can also access it like a
-  hash (e.g. json['<attribute>']), or if the JSON object is an array, like an
-  array (e.g. json[0], etc.).
+=== Options
 
-=== Examples
+See the *--help* command line option.
 
-==== Reading the entire JSON object from a URL
+=== Sources
 
-  jazor 'http://ajax.googleapis.com/ajax/services/search/web?v=1.0&q=jazor'
+The *source* argument refers to a file, URL or string containing a JSON object.
+Since attempts to implement a full-featured HTTP client within Jazor would have
+been futile, Jazor also accepts input from STDIN. This means if you ever need
+to use an advanced HTTP option that Jazor doesn't implement, you can always use
+a *real* HTTP client (e.g. {cURL}[http://curl.haxx.se/]) and simply pipe the
+output to Jazor.
 
-==== Reading a JSON "slice" from a URL
+=== Expressions
 
-  jazor 'http://ajax.googleapis.com/ajax/services/search/web?v=1.0&q=jazor' responseData.results[0].title
+Jazor accepts one or more Ruby *expressions* which are simply eval'ed within
+the context of your JSON object. After Jazor parses your JSON input into native
+Ruby data types (Hash, Array, etc.), these expressions are used to slice and
+dice the data any way you want. The results will be "pretty printed" to STDOUT.
 
-==== Testing the value of a JSON "slice"
+Note that hash keys can be accessed via standard Ruby (e.g. foo['bar'],
+foo.fetch('bar'), etc.) or Javascript (e.g. foo.bar) syntax.
 
-  jazor 'http://ajax.googleapis.com/ajax/services/search/web?v=1.0&q=jazor' -t 'responseData.results.is_a?(Array)'
+=== Expression Testing
 
-=== Help
+Expression testing (*--test*) allows you to test the "truthiness" of your
+expression results. If any expression returns a "falsy" value, Jazor will exit
+with a non-zero return code. This is useful for calling Jazor from within shell
+scripts.
 
-  jazor --help
+== Examples
+
+  $ jazor http://github.com/api/v2/json/commits/list/mconigliaro/jazor/master commits.count
+  16
+
+  $ curl --silent http://github.com/api/v2/json/commits/list/mconigliaro/jazor/master | jazor commits.last.message
+  initial commit
+
+  $ jazor '{ "foo": "abc", "bar": [1, 2, 3] }' 'foo.split(//)'
+  ["a", "b", "c"]
+
+  $ jazor '{ "foo": "abc", "bar": [1, 2, 3] }' 'bar.inject { |memo,obj| memo + obj }'
+  6
+
+  $ jazor '[1, 2, 3, 4, 5]' 'select { |obj| obj.even? }'
+  [2, 4]
+
+  $ jazor '[1, 2, 3, 4, 5]' 'select { |obj| obj.odd? }'
+  [1, 3, 5]
+
+  $ jazor '["a", "b", "c"]' self.count
+  3
+
+== Author
+
+Michael T. Conigliaro <mike [at] conigliaro [dot] org>

data/Rakefile

@@ -2,7 +2,7 @@ task :default => [:test]
 
 task :test do
   Dir[File.expand_path(File.join(File.dirname(__FILE__), 'test', 'test_*'))].each do |test|
-    system "ruby #{test}"
+    system "ruby -I #{File.expand_path(File.join(File.dirname(__FILE__), 'lib'))} #{test}"
   end
 end
 

data/bin/jazor

@@ -7,98 +7,90 @@ $:.push File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'jazor'
 
 
-module Jazor
-
-  begin
-
-    options = {
-      :tests        => [],
-      :rest_data    => {},
-      :rest_headers => {},
-      :rest_request => 'GET'
-    }
-
-    OptionParser.new do |opts|
-      opts.version = VERSION
-      opts.banner = "Usage: #{$0} [options] [source] [slice]\n" \
-      + "Example: #{$0} http://example.com/example.json a.b.c\n\n"
-
-      opts.on('-d', '--data DATA', 'Data sent with REST request (e.g. <name>=<value>)') do |opt|
-        key, value = opt.split('=')
-        options[:rest_data][key] = value
-      end
+options = {
+  :test         => false,
+  :rest_data    => {},
+  :rest_headers => {},
+  :rest_request => 'GET'
+}
+
+OptionParser.new do |opts|
+  opts.version = Jazor::VERSION
+  opts.banner = "Usage: #{$0} [options] [source] [expression ...]\n\n"
+
+  opts.on('-d', '--data NAME=VALUE', 'Data sent with REST request') do |opt|
+    key, value = opt.split('=')
+    options[:rest_data][key.strip] = value.strip
+  end
 
-      opts.on('-H', '--header HEADER', 'Header sent with REST request (e.g. <name>:<value>)') do |opt|
-        key, value = opt.split(':')
-        options[:rest_headers][key.strip] = value.strip
-      end
+  opts.on('-H', '--header NAME:VALUE', 'Header sent with REST request') do |opt|
+    key, value = opt.split(':')
+    options[:rest_headers][key.strip] = value.strip
+  end
 
-      opts.on('-t', '--test EXPRESSION', 'Test expression (e.g. "a.b.c == 123")') do |opt|
-        options[:tests] << opt
-      end
+  opts.on('-t', '--test', 'Enable expression testing') do |opt|
+    options[:test] = true
+  end
 
-      opts.on('-v', '--verbose', 'Turn on verbose logging') do |opt|
-        LOG.level = Logger::DEBUG
-      end
+  opts.on('-v', '--verbose', 'Enable verbose logging') do |opt|
+    Jazor::LOG.level = Logger::DEBUG
+  end
 
-      opts.on('-X', '--request REQUEST', 'REST request method (default: %s)' % options[:rest_request]) do |opt|
-        options[:rest_request] = opt
-      end
+  opts.on('-X', '--request REQUEST', 'REST request method (default: %s)' % options[:rest_request]) do |opt|
+    options[:rest_request] = opt
+  end
 
-      opts.on_tail('-h', '--help', 'Show this message') do
-        puts opts.help
-        exit
-      end
+  opts.on_tail('-h', '--help', 'Show this message') do
+    puts opts.help
+    exit
+  end
 
-      opts.on_tail('--version', 'Show version') do
-        puts "%s %s\n%s <%s>\n%s" % [opts.program_name, opts.version, AUTHOR, AUTHOR_EMAIL, URL]
-        exit
-      end
+  opts.on_tail('--version', 'Show version') do
+    puts "%s %s\n%s <%s>\n%s" % [opts.program_name, opts.version, Jazor::AUTHOR, Jazor::AUTHOR_EMAIL, Jazor::URL]
+    exit
+  end
 
-      if ARGV.length == 0 && STDIN.fcntl(Fcntl::F_GETFL, 0) != 0
-        puts opts.help
-        exit(1)
-      end
-    end.parse!
-
-    jazor = if STDIN.fcntl(Fcntl::F_GETFL, 0) == 0
-      json = STDIN.read
-      LOG.debug('Reading JSON from STDIN')
-      Jazor.new(json)
-    elsif !ARGV[0].nil?
-      if ARGV[0] =~ URI::regexp
-        LOG.debug('Reading JSON from URI: %s' % ARGV[0])
-        Jazor.new(RestClient.send(options[:rest_request], ARGV.shift, options[:rest_headers], options[:rest_data]).body)
-      elsif File.readable?(ARGV[0])
-        LOG.debug('Reading JSON from file: %s' % ARGV[0])
-        Jazor.new(IO.read(ARGV.shift))
-      else
-        LOG.debug('Reading JSON from ARGV: %s' % ARGV[0])
-        Jazor.new(ARGV.shift)
-      end
+  if ARGV.length == 0 && STDIN.fcntl(Fcntl::F_GETFL, 0) != 0
+    puts opts.help
+    exit(1)
+  end
+end.parse!
+
+begin
+
+  obj = if STDIN.fcntl(Fcntl::F_GETFL, 0) == 0
+    Jazor::LOG.debug('Reading JSON from STDIN')
+    Jazor::parse(STDIN.read)
+  elsif !ARGV[0].nil?
+    if ARGV[0] =~ URI::regexp
+      Jazor::LOG.debug("Reading JSON from URI: #{ARGV[0]}")
+      Jazor::parse(Jazor::RestClient.send(options[:rest_request], ARGV.shift, options[:rest_headers], options[:rest_data]).body)
+    elsif File.readable?(ARGV[0])
+      Jazor::LOG.debug("Reading JSON from file: #{ARGV[0]}")
+      Jazor::parse(IO.read(ARGV.shift))
     else
-      Jazor.new(nil)
-    end
-
-    slices = ARGV.length > 0 ? ARGV[0..ARGV.length] : [nil]
-    slices.each do |slice|
-      obj = jazor.get_slice(slice)
-      puts [Hash, Array].include?(obj.class) ? JSON.pretty_generate(obj) : obj
+      Jazor::LOG.debug("Reading JSON from ARGV: #{ARGV[0]}")
+      Jazor::parse(ARGV.shift)
     end
+  end
 
-    options[:tests].each do |test|
-      if jazor.instance_eval(test)
-        LOG.info("Test passed: %s" % test)
+  (ARGV.length > 0 ? ARGV[0..ARGV.length] : [nil]).each do |expression|
+    result = expression.nil? ? obj : obj.instance_eval(expression)
+    if options[:test]
+      if result
+        Jazor::LOG.info("Test passed: #{expression} => #{[Hash, Array].include?(result.class) ? result.to_json : result}")
       else
-        LOG.error("Test failed: %s" % test)
+        Jazor::LOG.error("Test failed: #{expression} => #{[Hash, Array].include?(result.class) ? result.to_json : result}")
         exit(1)
       end
+    else
+      puts [Hash, Array].include?(result.class) ? JSON.pretty_generate(result) : result
     end
-
-  rescue StandardError => e
-    LOG.error(e.message)
-    puts e.backtrace if LOG.level == Logger::DEBUG
-    exit(1)
   end
 
+rescue StandardError => e
+  puts e
+  puts e.backtrace
+  Jazor::LOG.error(e.message)
+  exit(1)
 end

data/lib/jazor.rb

@@ -1,63 +1,52 @@
-require 'json'
 require 'logger'
 require 'net/http'
 require 'pp'
 require 'uri'
 
+require 'rubygems'
+require 'json'
+
 
 module Jazor
 
-  NAME = 'jazor'
-  VERSION_INFO = ['0', '0', '4']
-  VERSION = VERSION_INFO.join('.')
-  AUTHOR = 'Michael T. Conigliaro'
+  NAME         = 'jazor'
+  VERSION      = '0.1.0'
+  AUTHOR       = 'Michael T. Conigliaro'
   AUTHOR_EMAIL = 'mike [at] conigliaro [dot] org'
-  URL = 'http://github.com/mconigliaro/jazor'
+  DESCRIPTION  = 'Jazor is a simple command line JSON parsing tool'
+  URL          = 'http://github.com/mconigliaro/jazor'
 
   LOG = Logger.new(STDOUT)
   LOG.level = Logger::INFO
 
-  class Jazor
-
-    attr_reader :json
-
-    def initialize(source=nil)
-      @json = source.nil? ? nil : JSON.parse(source)
-    end
-
-    def get_slice(slice=nil)
-      if slice.nil?
-        @json
-      elsif slice =~ /^json/
-        instance_eval(slice)
-      else
-        @json.instance_eval(slice)
+  def self.parse(input=nil)
+    # FIXME: https://github.com/flori/json/issues/16
+    obj = (JSON.parse(input) rescue false) || (Integer(input) rescue false) || (Float(input) rescue false) || String(input)
+    if obj.is_a?(String)
+      if obj == 'true'
+        obj = true
+      elsif obj == 'false'
+        obj = false
       end
     end
-
-    def method_missing(name)
-      get_slice(name.to_s)
-    end
-
+    obj
   end
 
   class RestClient
-
     def self.method_missing(method, uri, headers={}, data={})
       uri_parsed = URI.parse(uri)
       http = Net::HTTP.new(uri_parsed.host, port=uri_parsed.port)
-      request_uri = uri_parsed.query ? uri_parsed.path + '?' +  uri_parsed.query: uri_parsed.path
+      request_uri = uri_parsed.query ? "#{uri_parsed.path}?#{uri_parsed.query}" : uri_parsed.path
       request = Net::HTTP.const_get(method.to_s.capitalize).new(request_uri)
       headers.each { |k,v| request.add_field(k, v) }
       request.set_form_data(data)
 
-      LOG.debug('%s %s: uri=%s headers=%s data=%s' % [self, method.to_s.upcase, File.join(uri_parsed.host, request_uri), headers.to_json, data.to_json])
+      LOG.debug("#{self} #{method.to_s.upcase}: uri=#{File.join(uri_parsed.host, request_uri)} headers=#{headers.to_json} data=#{data.to_json}")
       response = http.request(request)
-      LOG.debug('%s result: code=%d body=%s' % [self, response.code, response.body.gsub("\r", ' ').gsub("\n", ' ')])
+      LOG.debug("#{self} result: code=#{response.code} body=%s" % response.body.gsub("\r", ' ').gsub("\n", ' '))
 
       response
     end
-
   end
 
 end

data/test/test_jazor.rb

@@ -1,73 +1,57 @@
 require 'test/unit'
 
-$:.push File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'jazor'
-
-
 class TestExecute < Test::Unit::TestCase
 
   def setup
+    require 'jazor'
+
     @init_json = IO.read(File.expand_path(File.join(File.dirname(__FILE__), 'test.json')))
     @init_hash = JSON.parse(@init_json)
-    @jazor = Jazor::Jazor.new(@init_json)
-  end
-
-  def test_init
-    Jazor::Jazor.new(@init_json)
   end
 
   def test_root_object
-    assert @jazor.json.is_a?(Hash)
-    assert @jazor.json == @init_hash
+    assert Jazor::parse(@init_json).is_a?(Hash)
+    assert Jazor::parse(@init_json) == @init_hash
   end
 
   def test_values
-    assert @jazor.json.value0.is_a?(String)
-    assert @jazor.json.value1.is_a?(Integer)
-    assert @jazor.json.value2.is_a?(Float)
+    assert Jazor::parse(@init_json).value0.is_a?(String)
+    assert Jazor::parse(@init_json).value1.is_a?(Integer)
+    assert Jazor::parse(@init_json).value2.is_a?(Float)
     (0..2).each do |i|
-      assert @jazor.json.send("value#{i}") == @init_hash["value#{i}"]
+      assert Jazor::parse(@init_json).send("value#{i}") == @init_hash["value#{i}"]
     end
   end
 
   def test_array_of_values
-    assert @jazor.json.array_of_values.is_a?(Array)
-    assert @jazor.json.array_of_values == @init_hash['array_of_values']
-    (0...@jazor.json.array_of_values.length).each do |i|
-      assert @jazor.json.array_of_values[i].is_a?(Integer)
-      assert @jazor.json.array_of_values[i] == @init_hash["array_of_values"][i]
+    assert Jazor::parse(@init_json).array_of_values.is_a?(Array)
+    assert Jazor::parse(@init_json).array_of_values == @init_hash['array_of_values']
+    (0...Jazor::parse(@init_json).array_of_values.length).each do |i|
+      assert Jazor::parse(@init_json).array_of_values[i].is_a?(Integer)
+      assert Jazor::parse(@init_json).array_of_values[i] == @init_hash["array_of_values"][i]
     end
   end
 
   def test_array_of_arrays
-    assert @jazor.json.array_of_arrays.is_a?(Array)
-    (0...@jazor.json.array_of_arrays.length).each do |i|
-      assert @jazor.json.array_of_arrays[i].is_a?(Array)
-      assert @jazor.json.array_of_arrays[i] == @init_hash['array_of_arrays'][i]
-      (0...@jazor.json.array_of_arrays[i].length).each do |j|
-        assert @jazor.json.array_of_arrays[i][j].is_a?(Integer)
-        assert @jazor.json.array_of_arrays[i][j] == @init_hash['array_of_arrays'][i][j]
+    assert Jazor::parse(@init_json).array_of_arrays.is_a?(Array)
+    (0...Jazor::parse(@init_json).array_of_arrays.length).each do |i|
+      assert Jazor::parse(@init_json).array_of_arrays[i].is_a?(Array)
+      assert Jazor::parse(@init_json).array_of_arrays[i] == @init_hash['array_of_arrays'][i]
+      (0...Jazor::parse(@init_json).array_of_arrays[i].length).each do |j|
+        assert Jazor::parse(@init_json).array_of_arrays[i][j].is_a?(Integer)
+        assert Jazor::parse(@init_json).array_of_arrays[i][j] == @init_hash['array_of_arrays'][i][j]
       end
     end
   end
 
   def test_array_of_objects
-    assert @jazor.json.array_of_objects.is_a?(Array)
-    (0...@jazor.json.array_of_objects.length).each do |i|
-      assert @jazor.json.array_of_objects[i].is_a?(Hash)
-      assert @jazor.json.array_of_objects[i] == @init_hash['array_of_objects'][i]
-      assert @jazor.json.array_of_objects[i].send("object#{i}").is_a?(Integer)
-      assert @jazor.json.array_of_objects[i].send("object#{i}") == @init_hash['array_of_objects'][i]["object#{i}"]
+    assert Jazor::parse(@init_json).array_of_objects.is_a?(Array)
+    (0...Jazor::parse(@init_json).array_of_objects.length).each do |i|
+      assert Jazor::parse(@init_json).array_of_objects[i].is_a?(Hash)
+      assert Jazor::parse(@init_json).array_of_objects[i] == @init_hash['array_of_objects'][i]
+      assert Jazor::parse(@init_json).array_of_objects[i].send("object#{i}").is_a?(Integer)
+      assert Jazor::parse(@init_json).array_of_objects[i].send("object#{i}") == @init_hash['array_of_objects'][i]["object#{i}"]
     end
   end
 
-  def test_get_nil_slice_returns_complete_object()
-    assert @jazor.get_slice.is_a?(Hash)
-    assert @jazor.get_slice == @init_hash
-  end
-
-  def test_get_slice()
-    assert @jazor.get_slice('nested_object') == @init_hash['nested_object']
-  end
-
 end

data/test/test_jazor_bin.rb

@@ -1,16 +1,14 @@
 require 'test/unit'
 
-$:.push File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'jazor'
-
-
 class TestExecute < Test::Unit::TestCase
 
   def setup
-    @init_url = 'http://ajax.googleapis.com/ajax/services/search/web?v=1.0&q=jazor'
-    @init_file = File.expand_path(File.join(File.dirname(__FILE__), 'test.json'))
+    require 'jazor'
+
+    @init_url    = 'http://github.com/api/v2/json/commits/list/mconigliaro/jazor/master'
+    @init_file   = File.expand_path(File.join(File.dirname(__FILE__), 'test.json'))
     @init_string = IO.read(@init_file)
-    @jazor_bin = File.expand_path(File.join(File.dirname(__FILE__), '..', 'bin', 'jazor'))
+    @jazor_bin   = File.expand_path(File.join(File.dirname(__FILE__), '..', 'bin', 'jazor'))
   end
 
   def test_without_paramaters
@@ -33,20 +31,16 @@ class TestExecute < Test::Unit::TestCase
     assert JSON.parse(`#{@jazor_bin} '#{@init_string}'`).is_a?(Hash)
   end
 
-  def test_bad_json
-    assert `#{@jazor_bin} '{"a":}'` =~ /ERROR/
-  end
-
-  def test_json_from_file_with_slice
-    assert eval(`#{@jazor_bin} #{@init_file} value1`).is_a?(Numeric)
+  def test_json_from_file_with_expression
+    assert eval(`#{@jazor_bin} #{@init_file} value1`).is_a?(Integer)
     assert JSON.parse(`#{@jazor_bin} #{@init_file} nested_object`).is_a?(Hash)
     assert JSON.parse(`#{@jazor_bin} #{@init_file} nested_object.array_of_values`).is_a?(Array)
     assert eval(`#{@jazor_bin} #{@init_file} dontexist`).nil?
   end
 
   def test_json_from_file_with_tests
-    assert `#{@jazor_bin} #{@init_file} -t 'value1==123'` =~ /passed/
-    assert `#{@jazor_bin} #{@init_file} -t 'value1==1234'` =~ /failed/
+    assert `#{@jazor_bin} -t #{@init_file} 'value1==123'` =~ /passed/
+    assert `#{@jazor_bin} -t #{@init_file} 'value1==1234'` =~ /failed/
   end
 
 end