petroglyph 0.0.1

data/.gitignore

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

data/.rspec

@@ -0,0 +1 @@
+--color --format documentation

data/.simplecov

@@ -0,0 +1,2 @@
+SimpleCov.add_filter 'spec'
+SimpleCov.start

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in petroglyph.gemspec
+gemspec

data/README.md

@@ -0,0 +1,95 @@
+# Petroglyph
+
+A simple, terse, and unsurprising ruby dsl to create json views.
+
+## Usage
+
+Add a node with a simple value:
+
+    node :beverage => current_user.favorite_drink
+    => '{"beverage":"mead"}'
+
+Add a node with nested content:
+
+    node :home do
+      merge {:location => {:city => 'Paris', :country => 'France'}}
+    end
+    => '{"home":{"location":{"city":"Paris","country":"France"}}}'
+
+Add sibling nodes within a node:
+
+    node :pet do
+      merge {:species => "turtle", :color => 'green'}
+      node :name => "Anthony"
+    end
+    => '{"pet":{"species":"turtle","color":"green","name":"Anthony"}}'
+
+It's all just ruby, unsurprisingly:
+
+    node :pet do
+      if user.child?
+        merge {:species => "turtle"}
+        node :name => "Anthony"
+      else
+        node :species => 'human'
+        node :name => 'Billy'
+      end
+    end
+    => '{"pet":{"species":"turtle","name":"Anthony"}}'
+
+Conveniently define which attributes to include. Create a new node with a different name for attributes you wish to alias.
+
+    alice = Person.create!(:name => 'Alice', :profession => 'surgeon', :created_at => 28.years.ago, :gender => 'female')
+
+    node :person => alice do
+      attributes :name, :gender
+      node :job => alice.profession
+    end
+    => '{"person":{"name":"Alice","gender":"female","job":"surgeon"}}'
+
+Iterate through collections:
+
+    wulong = Tea.new(:type => 'wulong')
+    lucha = Tea.new(:type => 'green')
+
+    collection :teas => [wulong, lucha] do
+      attributes :type
+    end
+    => '{"teas":[{"type":"wulong"},{"type":"wulong"}]}'
+
+
+You can also explicitly reference each item in the collection if you need to:
+
+    collection :teas => teas do |tea|
+      node :tea => tea do
+        attributes :type
+      end
+      node :provider => lookup_provider_for(tea)
+    end
+    => '{"teas":[{"tea":{"type":"wulong"},{"provider":"Imperial Teas"}},{"tea":{"type":"wulong"},{"provider":"House of Tea"}}]}'
+
+Partials have been implemented. This defaults to looking for a file in the same file as the template, or in a subdirectory called `partials`.
+
+This can be overridden by re-implementing the `Petroglyph.partial(name)` method.
+
+    collection :teas => teas do |tea|
+      # partial(template_name, local_variables)
+      partial :tea, :tea => tea
+    end
+
+## Caveat
+
+We've removed support for using instance variables (from the controller) in the template, as this was hacky and not optimal.
+
+## Related Projects
+
+Other json templating libraries exist, some of which also generate XML.
+
+* [Rabl](https://github.com/nesquena/rabl)
+* [Tequila](https://github.com/inem/tequila)
+* [Argonaut](https://github.com/jbr/argonaut)
+* [JSON Builder](https://github.com/dewski/json_builder)
+* [JBuilder](https://github.com/rails/jbuilder)
+* [Jsonify](https://github.com/bsiggelkow/jsonify)
+* [Representative](https://github.com/mdub/representative)
+* [Tokamak](https://github.com/abril/tokamak)

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/petroglyph/engine.rb

@@ -0,0 +1,18 @@
+module Petroglyph
+  class Engine
+
+    def initialize(data = nil)
+      @data = data
+    end
+
+    def render(context = Object.new, locals = {}, file = nil, &block)
+      scope = Scope.new(context, locals, file)
+      if @data
+        scope.instance_eval(@data)
+      else
+        scope.instance_eval(&block)
+      end
+      scope.value.to_json
+    end
+  end
+end

data/lib/petroglyph/scope.rb

@@ -0,0 +1,94 @@
+module Petroglyph
+  class Scope
+    attr_accessor :value, :object, :file
+
+    def initialize(context = nil, locals = {}, template_filename = nil, parent_scope = nil)
+      @file = template_filename
+      @context = context
+      @locals = locals
+      @parent_scope = parent_scope
+      @value = nil
+    end
+
+    def sub_scope(object = nil)
+      scope = Scope.new(@context, @locals, @file, self)
+      scope.object = object
+      scope
+    end
+
+    def node(input, &block)
+      @value ||= {}
+      scope = nil
+      name = nil
+      value = nil
+      if input.is_a?(Hash)
+        raise ArgumentError, "node can't deal with more than one key at a time" if input.keys.size > 1
+        name = input.keys.first
+        value = input.values.first
+      else
+        name = input
+      end
+
+      if block_given?
+        scope = sub_scope(value)
+        scope.instance_eval(&block)
+        @value[name] = scope.value if scope.value
+      else
+        @value[name] = value
+      end
+    end
+
+    def collection(input, &block)
+      @value ||= {}
+      name = input.keys.first
+      items = input.values.first
+      results = []
+      items.each do |item|
+        scope = sub_scope(item)
+        scope.instance_exec(item, &block)
+        results << scope.value
+      end
+      @value[name] = results
+    end
+
+    def merge(hash, &block)
+      @value ||= {}
+      if block_given?
+        scope = sub_scope(hash)
+        scope.instance_eval(&block)
+        hash = scope.value
+      end
+      @value.merge!(hash)
+    end
+
+    def attributes(*args)
+      fragment = {}
+      args.each do |method|
+        if @object.respond_to?(method)
+          fragment[method] = @object.send(method)
+        else
+          fragment[method] = @object[method]
+        end
+      end
+      merge fragment
+    end
+
+    def partial(name, locals = {})
+      data = Petroglyph.partial(name, file)
+      scope = Scope.new(@context, locals)
+      scope.instance_eval(data)
+      merge scope.value
+    end
+
+    def method_missing(method, *args, &block)
+      if @locals.has_key?(method)
+        @locals[method]
+      elsif @context.respond_to?(method)
+        @context.send(method)
+      else
+        super
+      end
+    end
+
+  end
+end

data/lib/petroglyph/version.rb

@@ -0,0 +1,3 @@
+module Petroglyph
+  VERSION = "0.0.1"
+end

data/lib/petroglyph.rb

@@ -0,0 +1,17 @@
+require 'json'
+
+require 'petroglyph/scope'
+require 'petroglyph/engine'
+
+module Petroglyph
+  class << self
+    def partial(filename, template_filename)
+      basedir = File.dirname(template_filename)
+      [basedir, "#{basedir}/partials"].each do |dir|
+        path = File.join(dir, "#{filename}.pg")
+        return File.read(path) if File.exist?(path)
+      end
+      raise Exception.new("Could not find partial #{filename}")
+    end
+  end
+end

data/lib/sinatra/petroglyph.rb

@@ -0,0 +1,9 @@
+require 'tilt/petroglyph'
+
+if defined?(Sinatra)
+  module Sinatra::Templates
+    def pg(template, options={}, locals={})
+      render :pg, template, options, locals
+    end
+  end
+end

data/lib/tilt/petroglyph.rb

@@ -0,0 +1,27 @@
+# Makes Petroglyph available through Tilt.
+# Also contains a utility function that will
+# be added to Sinatra if Sinatra is defined.
+
+require 'tilt'
+require 'petroglyph'
+
+module Tilt
+  class PetroglyphTemplate < Template
+    self.default_mime_type = "application/json"
+    def initialize_engine
+      return if defined? ::Petroglyph
+      require_template_library 'petroglyph'
+    end
+
+    def prepare; end
+
+    def precompiled_template(locals)
+      data.to_str
+    end
+
+    def evaluate(scope = Object.new, locals = {}, &block)
+      Petroglyph::Engine.new(data).render(scope, locals, file, &block)
+    end
+  end
+  register PetroglyphTemplate, 'pg'
+end

data/petroglyph.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "petroglyph/version"
+
+Gem::Specification.new do |s|
+  s.name        = "petroglyph"
+  s.version     = Petroglyph::VERSION
+  s.authors     = ["Katrina Owen"]
+  s.email       = ["katrina.owen@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{A simple, terse, and unsurprising ruby dsl to create json views.}
+  s.description = %q{A simple, terse, and unsurprising ruby dsl to create json views.}
+
+  s.rubyforge_project = "petroglyph"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {spec}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency "tilt"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "sinatra"
+  s.add_development_dependency "rack-test"
+end

data/spec/engine_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Petroglyph::Engine do
+  it "takes a template" do
+    engine = Petroglyph::Engine.new('node :whatever => "nevermind"')
+    engine.render.should eq({:whatever => "nevermind"}.to_json)
+  end
+
+  it "takes a block" do
+    Petroglyph::Engine.new.render do
+      node :whatever => "nevermind"
+    end.should eq({:whatever => "nevermind"}.to_json)
+  end
+
+  it "passes the locals" do
+    engine = Petroglyph::Engine.new('node :whatever => thing')
+    engine.render(nil, {:thing => 'stuff'}).should eq({:whatever => 'stuff'}.to_json)
+  end
+end

data/spec/fixtures/views/helper.pg

@@ -0,0 +1 @@
+node :price => price

data/spec/fixtures/views/index.pg

@@ -0,0 +1,3 @@
+collection :drinks => drinks do |drink|
+  attributes :type, :temperature
+end

data/spec/fixtures/views/partials/sub_partial.pg

@@ -0,0 +1 @@
+node :thing => thing

data/spec/fixtures/views/post.pg

@@ -0,0 +1 @@
+node :post => post

data/spec/fixtures/views/syntax.pg

@@ -0,0 +1,3 @@
+node :syntax do
+  node :it => "works"
+end

data/spec/fixtures/views/the_partial.pg

@@ -0,0 +1 @@
+node :thing => thing

data/spec/fixtures/views/with_partial.pg

@@ -0,0 +1,3 @@
+node :root do
+  partial :the_partial, :thing => 'stuff'
+end

data/spec/fixtures/views/with_sub_partial.pg

@@ -0,0 +1,3 @@
+node :root do
+  partial :sub_partial, :thing => 'stuff'
+end

data/spec/scope_spec.rb

@@ -0,0 +1,250 @@
+require 'spec_helper'
+
+describe Petroglyph::Scope do
+
+  it "takes a simple string value" do
+    scope = Petroglyph::Scope.new
+    scope.node :whatever => "nevermind"
+    scope.value.should eq(:whatever => "nevermind")
+  end
+
+  it "merges in a hash" do
+    tea = {:tea => {:temperature => 'hot', :type => 'wulong'}}
+
+    scope = Petroglyph::Scope.new
+    scope.merge tea
+    scope.value.should eq({:tea => {:temperature => "hot", :type => 'wulong'}})
+  end
+
+  it "merges within a block" do
+    scope = Petroglyph::Scope.new
+    scope.node :whatever do
+      merge(:stuff => {:no => :way})
+    end
+
+    scope.value.should eq({:whatever => {:stuff => {:no => :way}}})
+  end
+
+  it "lets you process what you merge in a block" do
+    scope = Petroglyph::Scope.new
+    scope.node :whatever do
+      merge(10) do
+        attributes :to_s
+      end
+    end
+
+    scope.value.should eq({:whatever => {:to_s => '10'}})
+  end
+
+  it "handles sibling nodes" do
+    scope = Petroglyph::Scope.new
+    scope.node :whatever => "nevermind"
+    scope.node :stuff => "awesome"
+
+    scope.value.should eq({:whatever => "nevermind", :stuff => "awesome"})
+  end
+
+  it "handles sibling nodes as blocks" do
+    scope = Petroglyph::Scope.new
+    scope.node :whatever => "nevermind"
+    scope.node :stuff do
+      merge(:too => :cool)
+    end
+
+    scope.value.should eq({:whatever => "nevermind", :stuff => {:too => :cool}})
+  end
+
+  it "nests nodes" do
+    scope = Petroglyph::Scope.new
+    scope.node :whatever do
+      node :stuff => "awesome"
+    end
+
+    scope.value.should eq({:whatever => {:stuff => 'awesome'}})
+  end
+
+  it "nests stuff arbitrarily deeply with complex values" do
+    scope = Petroglyph::Scope.new
+    scope.node :drink do
+      node :tea do
+        node :temperature do
+          merge(:really => :hot)
+        end
+      end
+    end
+
+    scope.value.should eq({:drink => {:tea => {:temperature => {:really => :hot}}}})
+  end
+
+  it "uses regular ruby" do
+    scope = Petroglyph::Scope.new
+    scope.node :drink do
+      if false
+        "cold"
+      else
+        node(:tea) do
+          merge(:temperature => "hot".upcase)
+        end
+      end
+    end
+
+    scope.value.should eq({:drink => {:tea => {:temperature => "HOT"}}})
+  end
+
+  context "with locals" do
+    it "resolves values" do
+      scope = Petroglyph::Scope.new(nil, {:thing => 'stuff'})
+
+      scope.instance_eval do
+        node :thing => thing
+      end
+
+      scope.value.should eq({:thing => 'stuff'})
+    end
+  end
+
+  describe "within a context" do
+    it "has access to methods" do
+      context = Object.new
+      def context.thing
+        'stuff'
+      end
+
+      scope = Petroglyph::Scope.new(context)
+      scope.instance_eval do
+        node :thing => thing
+      end
+      scope.value.should eq({:thing => 'stuff'})
+    end
+
+    it "lets local variables take precedence over methods" do
+      context = Object.new
+      def context.thing
+        'junk'
+      end
+
+      scope = Petroglyph::Scope.new(context, {:thing => 'stuff'})
+      scope.instance_eval do
+        node :thing => thing
+      end
+      scope.value.should eq({:thing => 'stuff'})
+    end
+  end
+
+  describe "attributes" do
+    it "evaluates on an object" do
+      hal = OpenStruct.new(:name => 'HAL 9000', :temperament => 'psychotic', :garbage => 'junk')
+
+      scope = Petroglyph::Scope.new
+      scope.node :hal => hal do
+        attributes :name, :temperament
+      end
+
+      scope.value.should eq({:hal => {:name => 'HAL 9000', :temperament => 'psychotic'}})
+    end
+
+    it "evaluates on a hash" do
+      hal = {:name => 'HAL 9000', :temperament => 'psychotic', :garbage => 'junk'}
+
+      scope = Petroglyph::Scope.new
+      scope.node :hal => hal do
+        attributes :name, :temperament
+      end
+
+      scope.value.should eq({:hal => {:name => 'HAL 9000', :temperament => 'psychotic'}})
+    end
+  end
+
+  context "with a collection" do
+    let(:tea) { OpenStruct.new(:type => 'tea', :temperature => 'hot') }
+    let(:coffee) { OpenStruct.new(:type => 'coffee', :temperature => 'lukewarm') }
+    let(:drinks) { [tea, coffee] }
+
+    it "evaluates attributes" do
+      scope = Petroglyph::Scope.new
+      scope.collection :drinks => drinks do
+        attributes :type, :temperature
+      end
+
+      scope.value.should eq({:drinks => [{:type => 'tea', :temperature => 'hot'}, {:type => 'coffee', :temperature => 'lukewarm'}]})
+    end
+
+    it "evaluates attributes on explicitly named items" do
+      scope = Petroglyph::Scope.new
+      scope.collection :drinks => drinks do |drink|
+        node :drink do
+          node :type => drink.type
+        end
+        node :prep => "Make water #{drink.temperature}."
+      end
+
+      scope.value.should eq({:drinks => [{:drink => {:type => 'tea'}, :prep => "Make water hot."}, {:drink => {:type => 'coffee'}, :prep => "Make water lukewarm."}]})
+    end
+
+    it "evaluates object attributes within a sub node" do
+      scope = Petroglyph::Scope.new
+      scope.collection :drinks => drinks do |drink|
+        node :drink => drink do
+          attributes :type
+        end
+        node :prep => "Make water #{drink.temperature}."
+      end
+
+      scope.value.should eq({:drinks => [{:drink => {:type => 'tea'}, :prep => "Make water hot."}, {:drink => {:type => 'coffee'}, :prep => "Make water lukewarm."}]})
+    end
+
+    it "evaluates an empty collection to an empty array" do
+      scope = Petroglyph::Scope.new
+      scope.collection :drinks => [] do |drink|
+        node :drink => drink
+      end
+
+      scope.value.should eq({:drinks => []})
+    end
+  end
+
+  context "with partials" do
+    it "renders a partial" do
+      Petroglyph.stub(:partial) { 'node :drink => "tea"' }
+
+      scope = Petroglyph::Scope.new
+      scope.node :partial do
+        partial :the_partial
+      end
+
+      scope.value.should eq({:partial => {:drink => 'tea'}})
+    end
+
+    it "renders a partial with local variables" do
+      Petroglyph.stub(:partial) { 'node :drink => drink' }
+
+      scope = Petroglyph::Scope.new
+      scope.node :partial do
+        partial :the_partial, :drink => 'tea'
+      end
+
+      scope.value.should eq({:partial => {:drink => 'tea'}})
+    end
+
+    it "finds the partial" do
+      scope = Petroglyph::Scope.new
+      scope.file = "spec/fixtures/views/some_template.pg"
+      scope.node :partial do
+        partial :the_partial, :thing => 'stuff'
+      end
+
+      scope.value.should eq({:partial => {:thing => 'stuff'}})
+    end
+
+    it "finds the partial in a subdirectory" do
+      scope = Petroglyph::Scope.new
+      scope.file = "spec/fixtures/views/some_template.pg"
+      scope.node :partial do
+        partial :sub_partial, :thing => 'stuff'
+      end
+
+      scope.value.should eq({:partial => {:thing => 'stuff'}})
+    end
+
+  end
+end

data/spec/sinatra_integration_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'sinatra'
+require 'sinatra/petroglyph'
+require 'rack/test'
+
+class PetroglyphApp < Sinatra::Base
+  set :root, File.dirname(__FILE__)+"/fixtures"
+  set :show_exceptions, false
+
+  get "/" do
+    tea = OpenStruct.new(:type => 'tea', :temperature => 'hot')
+    coffee = OpenStruct.new(:type => 'coffee', :temperature => 'lukewarm')
+    pg :index, :locals => {:drinks => [tea, coffee]}
+  end
+
+  post '/' do
+    pg :post, :locals => {:post => 'a post'}
+  end
+end
+
+describe "Sinatra integration" do
+  include Rack::Test::Methods
+
+  def app
+    PetroglyphApp
+  end
+
+  it "works" do
+    get "/"
+    last_response.body.should eq '{"drinks":[{"type":"tea","temperature":"hot"},{"type":"coffee","temperature":"lukewarm"}]}'
+  end
+
+  xit "doesn't freak out on the HTTP method" do
+    post '/'
+    last_response.body.should eq '{}'
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+begin
+  require 'simplecov'
+rescue LoadError => e
+  # ignore code coverage
+end
+
+require 'ostruct'
+require 'petroglyph'

data/spec/tilt_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'tilt/petroglyph'
+
+describe "Tilt integration" do
+  it "registers .pg as a petroglyph template" do
+    Tilt.mappings['pg'].should include(Tilt::PetroglyphTemplate)
+  end
+
+  it "renders from a file" do
+    template = Tilt::PetroglyphTemplate.new('spec/fixtures/views/syntax.pg')
+    template.render.should eq('{"syntax":{"it":"works"}}')
+  end
+
+  it "renders from a block" do
+    template = Tilt::PetroglyphTemplate.new { |t| 'node :hello => "world"' }
+    template.render.should eq("{\"hello\":\"world\"}")
+  end
+
+  it "can be rendered more than once" do
+    template = Tilt::PetroglyphTemplate.new { |t| 'node :hello => "world"' }
+
+    3.times do
+      template.render.should eq("{\"hello\":\"world\"}")
+    end
+  end
+
+  it "takes local variables" do
+    template = Tilt::PetroglyphTemplate.new { |t| 'node :hello => place' }
+    template.render(Object.new, :place => 'world').should eq("{\"hello\":\"world\"}")
+  end
+
+  context "with partials" do
+    it "loads the partial" do
+      template = Tilt::PetroglyphTemplate.new('spec/fixtures/views/with_partial.pg')
+      template.render.should eq('{"root":{"thing":"stuff"}}')
+    end
+
+    it "loads the partial from a subdirectory" do
+      template = Tilt::PetroglyphTemplate.new('spec/fixtures/views/with_sub_partial.pg')
+      template.render.should eq('{"root":{"thing":"stuff"}}')
+    end
+
+  end
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: petroglyph
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Katrina Owen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-20 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tilt
+  requirement: &2161013440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2161013440
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2161013020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2161013020
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: &2161012600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2161012600
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: &2161012180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2161012180
+description: A simple, terse, and unsurprising ruby dsl to create json views.
+email:
+- katrina.owen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .simplecov
+- Gemfile
+- README.md
+- Rakefile
+- lib/petroglyph.rb
+- lib/petroglyph/engine.rb
+- lib/petroglyph/scope.rb
+- lib/petroglyph/version.rb
+- lib/sinatra/petroglyph.rb
+- lib/tilt/petroglyph.rb
+- petroglyph.gemspec
+- spec/engine_spec.rb
+- spec/fixtures/views/helper.pg
+- spec/fixtures/views/index.pg
+- spec/fixtures/views/partials/sub_partial.pg
+- spec/fixtures/views/post.pg
+- spec/fixtures/views/syntax.pg
+- spec/fixtures/views/the_partial.pg
+- spec/fixtures/views/with_partial.pg
+- spec/fixtures/views/with_sub_partial.pg
+- spec/scope_spec.rb
+- spec/sinatra_integration_spec.rb
+- spec/spec_helper.rb
+- spec/tilt_spec.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: petroglyph
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A simple, terse, and unsurprising ruby dsl to create json views.
+test_files: []