json_select 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in json_select.gemspec
+gemspec
+
+gem 'rspec'
+gem 'yajl-ruby'

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Simon Menke
+
+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.

data/README.md

@@ -0,0 +1,67 @@
+# JSONSelect
+
+**CSS-like selectors for JSON.**
+
+[More info about the JSON:select format](http://jsonselect.org/)
+
+## Installation
+
+From your terminal:
+
+```bash
+gem install json_select
+```
+
+In your `Gemfile`:
+
+```ruby
+gem 'json_select'
+```
+
+## Usage
+
+```ruby
+require 'json_select'
+
+json = { # This would normally be loaded with something like yajl-ruby
+  "name" => {
+    "first" => "Lloyd",
+    "last" => "Hilaiel"
+  },
+  "favoriteColor" => "yellow",
+  "languagesSpoken" => [
+    {
+      "language" => "Bulgarian",
+      "level" => "advanced"
+    },
+    {
+      "language" => "English",
+      "level" => "native"
+    },
+    {
+      "language" => "Spanish",
+      "level" => "beginner"
+    }
+  ],
+  "seatingPreference" => [ "window", "aisle" ],
+  "drinkPreference" => [ "beer", "whiskey", "wine" ],
+  "weight" => 172
+}
+
+JSONSelect('string:first-child').match(json) # => ["Lloyd", "Bulgarian", "English", "Spanish", "window", "beer"]
+```
+
+## Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a future version
+  unintentionally.
+* Commit, do not mess with `Rakefile` or version. (if you want to have your
+  own version, that is fine but bump version in a commit by itself I can
+  ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+## Copyright
+
+Copyright (c) 2011 Simon Menke. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,18 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new do |t|
+  t.pattern   = "./spec/**/*_spec.rb"
+  t.rspec_opts = [
+    '--color',
+    '-r', File.expand_path("../spec/spec_helper.rb", __FILE__)]
+end
+
+task :build_parser do
+  sh "bundle exec tt lib/json_select/selector_parser.tt -o lib/json_select/selector_parser.rb"
+end
+
+task :spec    => :build_parser
+task :build   => :build_parser
+task :default => :spec

data/json_select.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "json_select/version"
+
+Gem::Specification.new do |s|
+  s.name        = "json_select"
+  s.version     = JSONSelect::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Simon Menke"]
+  s.email       = ["simon.menke@gmail.com"]
+  s.homepage    = "http://github.com/fd/json_select"
+  s.summary     = %q{JSONSelect implementation for Ruby}
+  s.description = %q{JSONSelect implementation for Ruby}
+
+  s.rubyforge_project = "json_select"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.add_runtime_dependency 'treetop'
+end

data/lib/json_select.rb

@@ -0,0 +1,35 @@
+module JSONSelect
+  
+  require 'treetop'
+  
+  require 'json_select/version'
+  require 'json_select/selector_parser'
+  require 'json_select/selector'
+  require 'json_select/parser'
+  
+  module Ast
+    require 'json_select/ast/combination_selector'
+    require 'json_select/ast/simple_selector'
+    require 'json_select/ast/selector_group'
+    require 'json_select/ast/type_selector'
+    require 'json_select/ast/hash_selector'
+    require 'json_select/ast/pseudo_selector'
+    require 'json_select/ast/universal_selector'
+    
+    require 'json_select/ast/odd_expr'
+    require 'json_select/ast/even_expr'
+    require 'json_select/ast/simple_expr'
+    require 'json_select/ast/complex_expr'
+  end
+  
+  ParseError = Class.new(RuntimeError)
+  
+  def self.parse(selector)
+    JSONSelect::Parser.new(selector).parse
+  end
+  
+end
+
+def JSONSelect(selector)
+  JSONSelect.parse(selector)
+end

data/lib/json_select/ast/combination_selector.rb

@@ -0,0 +1,14 @@
+module JSONSelect::Ast::CombinationSelector
+  
+  def to_ast
+    ast = [a.to_ast]
+    
+    b.elements.each do |comb|
+      ast.push('>') if comb.c.text_value.strip == '>'
+      ast.push(comb.d.to_ast)
+    end
+    
+    ast
+  end
+  
+end

data/lib/json_select/ast/complex_expr.rb

@@ -0,0 +1,27 @@
+module JSONSelect::Ast::ComplexExpr
+  
+  def to_ast
+    _a = ""
+    
+    if a.text_value.size > 0
+      _a += a.text_value
+    else
+      _a += '+'
+    end
+    
+    if b.text_value.size > 0
+      _a += b.text_value
+    else
+      _a += '1'
+    end
+    
+    if c.text_value.size > 0
+      _b = c.text_value.to_i
+    else
+      _b = 0
+    end
+    
+    { 'a' => _a.to_i, 'b' => _b }
+  end
+  
+end

data/lib/json_select/ast/even_expr.rb

@@ -0,0 +1,7 @@
+module JSONSelect::Ast::EvenExpr
+  
+  def to_ast
+    { 'a' => 2, 'b' => 0 }
+  end
+  
+end

data/lib/json_select/ast/hash_selector.rb

@@ -0,0 +1,12 @@
+module JSONSelect::Ast::HashSelector
+
+  def to_ast
+    tv = self.text_value[1..-1]
+    if tv[0,1] == '"'
+      { "class" => eval(tv) }
+    else
+      { "class" => tv }
+    end
+  end
+  
+end

data/lib/json_select/ast/odd_expr.rb

@@ -0,0 +1,7 @@
+module JSONSelect::Ast::OddExpr
+  
+  def to_ast
+    { 'a' => 2, 'b' => 1 }
+  end
+  
+end

data/lib/json_select/ast/pseudo_selector.rb

@@ -0,0 +1,24 @@
+module JSONSelect::Ast::PseudoSelector
+
+  def to_ast
+    if respond_to?(:e)
+      ast = { "pseudo_function" => a.text_value, 'a' => 0 , 'b' => 0 }
+      ast.merge!(e.to_ast)
+      ast
+    else
+      case a.text_value
+        
+      when 'first-child'
+        { "pseudo_function" => 'nth-child', 'a' => 0, 'b' => 1 }
+        
+      when 'last-child'
+        { "pseudo_function" => 'nth-last-child', 'a' => 0, 'b' => 1 }
+        
+      else
+        { "pseudo_class" => a.text_value }
+        
+      end
+    end
+  end
+  
+end

data/lib/json_select/ast/selector_group.rb

@@ -0,0 +1,17 @@
+module JSONSelect::Ast::SelectorGroup
+  
+  def to_ast
+    if b.elements.empty?
+      return a.to_ast
+    end
+    
+    ast = [',', a.to_ast]
+    
+    b.elements.each do |group|
+      ast.push group.c.to_ast
+    end
+    
+    ast
+  end
+  
+end

data/lib/json_select/ast/simple_expr.rb

@@ -0,0 +1,7 @@
+module JSONSelect::Ast::SimpleExpr
+  
+  def to_ast
+    { 'a' => 0, 'b' => text_value.to_i }
+  end
+  
+end

data/lib/json_select/ast/simple_selector.rb

@@ -0,0 +1,23 @@
+module JSONSelect::Ast::SimpleSelector
+  
+  def to_ast
+    ast = {}
+    
+    if respond_to?(:a) and respond_to?(:b)
+      ast.merge! a.to_ast
+      
+      b.elements.each do |s|
+        ast.merge!(s.to_ast)
+      end
+      
+    else
+      self.elements.each do |s|
+        ast.merge!(s.to_ast)
+      end
+      
+    end
+    
+    ast
+  end
+  
+end

data/lib/json_select/ast/type_selector.rb

@@ -0,0 +1,8 @@
+module JSONSelect::Ast::TypeSelector
+  
+  # `object` | `array` | `number` | `string` | `boolean` | `null`
+  def to_ast
+    { "type" => self.text_value }
+  end
+  
+end

data/lib/json_select/ast/universal_selector.rb

@@ -0,0 +1,7 @@
+module JSONSelect::Ast::UniversalSelector
+  
+  def to_ast
+    {}
+  end
+  
+end

data/lib/json_select/parser.rb

@@ -0,0 +1,19 @@
+class JSONSelect::Parser
+  
+  def initialize(source)
+    @parser = JSONSelect::SelectorParserParser.new
+    @source = source
+  end
+  
+  def parse
+    tree = @parser.parse(@source)
+    if tree
+      JSONSelect::Selector.new(tree.to_ast)
+    else
+      raise JSONSelect::ParseError, @parser.failure_reason
+      # puts parser.failure_line
+      # puts parser.failure_column
+    end
+  end
+  
+end

data/lib/json_select/selector.rb

@@ -0,0 +1,176 @@
+class JSONSelect::Selector
+  
+  attr_reader :ast
+  
+  def initialize(ast)
+    @ast = ast
+  end
+  
+  def match(object)
+    matches = []
+    
+    _each(@ast, object, nil, nil, nil) do |object|
+      matches << object
+    end
+    
+    matches
+  end
+  
+  alias_method :evaluate, :match
+  alias_method :=~,       :match
+  alias_method :===,      :match
+  
+private
+  
+  # function forEach(sel, obj, fun, id, num, tot) {
+  #   var a = (sel[0] === ',') ? sel.slice(1) : [sel];
+  #   var a0 = [];
+  #   var call = false;
+  #   for (var i = 0; i < a.length; i++) {
+  #     var x = mn(obj, a[i], id, num, tot);
+  #     if (x[0]) call = true;
+  #     for (var j = 0; j < x[1].length; j++) a0.push(x[1][j]);
+  #   }
+  #   if (a0.length && typeof obj === 'object') {
+  #     if (a0.length >= 1) a0.unshift(",");
+  #     if (isArray(obj)) {
+  #       for (var i = 0; i < obj.length; i++) forEach(a0, obj[i], fun, undefined, i, obj.length);
+  #     } else {
+  #       // it's a shame to do this for :last-child and other
+  #       // properties which count from the end when we don't
+  #       // even know if they're present.  Also, the stream
+  #       // parser is going to be pissed.
+  #       var l = 0;
+  #       for (var k in obj) if (obj.hasOwnProperty(k)) l++;
+  #       var i = 0;
+  #       for (var k in obj) if (obj.hasOwnProperty(k)) forEach(a0, obj[k], fun, k, i++, l);
+  #     }
+  #   }
+  #   if (call && fun) fun(obj);
+  # };
+  def _each(selector, object, id, number, total, &block)
+    a0 = (selector[0] == ',' ? selector[1..-1] : [selector])
+    a1 = []
+    
+    call = false
+    
+    a0.each do |selector|
+      ok, extra = _match(object, selector, id, number, total)
+      
+      call = true if ok
+      a1.concat extra
+    end
+    
+    if (Array === object or Hash === object) and a1.any?
+      a1.unshift(',')
+      size = object.size
+      
+      if Array === object
+        object.each_with_index do |child, idx|
+          _each(a1, child, nil, idx, size, &block)
+        end
+      end
+      
+      if Hash === object
+        object.each_with_index do |(key, child), idx|
+          _each(a1, child, key, idx, size, &block)
+        end
+      end
+      
+    end
+    
+    if call and block
+      block.call(object)
+    end
+  end
+  
+  
+  # function mn(node, sel, id, num, tot) {
+  #   var sels = [];
+  #   var cs = (sel[0] === '>') ? sel[1] : sel[0];
+  #   var m = true;
+  #   if (cs.type) m = m && (cs.type === mytypeof(node));
+  #   if (cs.id)   m = m && (cs.id === id);
+  #   if (m && cs.pf) {
+  #     if (cs.pf === ":nth-last-child") num = tot - num;
+  #     else num++;
+  #     if (cs.a === 0) {
+  #       m = cs.b === num;
+  #     } else {
+  #       m = (!((num - cs.b) % cs.a) && ((num*cs.a + cs.b) >= 0));
+  #     }
+  #   }
+  #   
+  #   // should we repeat this selector for descendants?
+  #   if (sel[0] !== '>' && sel[0].pc !== ":root") sels.push(sel);
+  #   
+  #   if (m) {
+  #     // is there a fragment that we should pass down?
+  #     if (sel[0] === '>') { if (sel.length > 2) { m = false; sels.push(sel.slice(2)); } }
+  #     else if (sel.length > 1) { m = false; sels.push(sel.slice(1)); }
+  #   }
+  #   
+  #   return [m, sels];
+  # }
+  def _match(object, selector, id, number, total)
+    selectors = []
+    current_selector = (selector[0] == '>' ? selector[1] : selector[0])
+    match = true
+    
+    if current_selector.key?('type')
+      match = (match and current_selector['type'] == _type_of(object))
+    end
+    
+    if current_selector.key?('class')
+      match = (match and current_selector['class'] == id)
+    end
+    
+    if match and current_selector.key?('pseudo_function')
+      pseudo_function = current_selector['pseudo_function']
+      
+      if pseudo_function == 'nth-last-child'
+        number = total - number
+      else
+        number += 1
+      end
+      
+      if current_selector['a'] == 0
+        match = current_selector['b'] == number
+      else
+        # WTF!
+        match = ((((number - current_selector['b']) % current_selector['a']) == 0) && ((number * current_selector['a'] + current_selector['b']) >= 0))
+      end
+    end
+    
+    if selector[0] != '>' and selector[0]['pseudo_class'] != 'root'
+      selectors.push selector
+    end
+    
+    if match
+      if selector[0] == '>'
+        if selector.length > 2
+          m = false
+          selectors.push selector[2..-1]
+        end
+      elsif selector.length > 1
+        m = false
+        selectors.push selector[1..-1]
+      end
+    end
+    
+    return [match, selectors]
+  end
+  
+  def _type_of(object)
+    case object
+    when Hash       then 'object'
+    when Array      then 'array'
+    when String     then 'string'
+    when Numeric    then 'number'
+    when TrueClass  then 'boolean'
+    when FalseClass then 'boolean'
+    when NilClass   then 'null'
+    end
+  end
+  
+end