[{"authors":"Ryan Davis","built_at":"2012-05-01T00:00:00.000Z","created_at":"2012-05-01T23:39:27.004Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse\ntree for an entire class or a specific method and returns it as a\ns-expression (aka sexp) using ruby's arrays, strings, symbols, and\nintegers.\n\nAs an example:\n\n  def conditional1(arg1)\n    if arg1 == 0 then\n      return 1\n    end\n    return 0\n  end\n\nbecomes:\n\n  [:defn,\n    :conditional1,\n    [:scope,\n     [:block,\n      [:args, :arg1],\n      [:if,\n       [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]],\n       [:return, [:lit, 1]],\n       nil],\n      [:return, [:lit, 0]]]]]","downloads_count":92582,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"3.0.9","summary":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers","platform":"ruby","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"ab9abdce14b77632abac47d066a2263de6e34cb280267afec33013af7c9e4b35","spec_sha":"882195d9f21170df605dd6d8bb4ab95b42ecc993667e9aa959af142a42ad82fd"},{"authors":"Ryan Davis","built_at":"2011-09-27T00:00:00.000Z","created_at":"2011-09-27T20:37:15.515Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse\ntree for an entire class or a specific method and returns it as a\ns-expression (aka sexp) using ruby's arrays, strings, symbols, and\nintegers.\n\nAs an example:\n\n  def conditional1(arg1)\n    if arg1 == 0 then\n      return 1\n    end\n    return 0\n  end\n\nbecomes:\n\n  [:defn,\n    :conditional1,\n    [:scope,\n     [:block,\n      [:args, :arg1],\n      [:if,\n       [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]],\n       [:return, [:lit, 1]],\n       nil],\n      [:return, [:lit, 0]]]]]","downloads_count":193142,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"3.0.8","summary":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers","platform":"ruby","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"0172ea4b94a93ab5b475c023f1ce6b564600fe493640e886cd1ca12da9039399","spec_sha":"ff5125c7c5925991bf2a04fe177828a850f7e1ba90430259d900667f1618766d"},{"authors":"Ryan Davis","built_at":"2011-02-18T08:00:00.000Z","created_at":"2011-02-18T23:57:00.313Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse\ntree for an entire class or a specific method and returns it as a\ns-expression (aka sexp) using ruby's arrays, strings, symbols, and\nintegers.\n\nAs an example:\n\n  def conditional1(arg1)\n    if arg1 == 0 then\n      return 1\n    end\n    return 0\n  end\n\nbecomes:\n\n  [:defn,\n    :conditional1,\n    [:scope,\n     [:block,\n      [:args, :arg1],\n      [:if,\n       [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]],\n       [:return, [:lit, 1]],\n       nil],\n      [:return, [:lit, 0]]]]]","downloads_count":27031,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"3.0.7","summary":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers","platform":"ruby","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"e2c6dbc6b6b2187290af9ca2506875672450e3fbf1ddd7ec3a5a8db20f79ee0a","spec_sha":"5f086f8626543357d829269d45fe2c9371ae2608cb67b1219a961883b273c5df"},{"authors":"Ryan Davis","built_at":"2010-09-01T07:00:00.000Z","created_at":"2010-09-01T23:00:12.460Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse\ntree for an entire class or a specific method and returns it as a\ns-expression (aka sexp) using ruby's arrays, strings, symbols, and\nintegers.\n\nAs an example:\n\n  def conditional1(arg1)\n    if arg1 == 0 then\n      return 1\n    end\n    return 0\n  end\n\nbecomes:\n\n  [:defn,\n    :conditional1,\n    [:scope,\n     [:block,\n      [:args, :arg1],\n      [:if,\n       [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]],\n       [:return, [:lit, 1]],\n       nil],\n      [:return, [:lit, 0]]]]]","downloads_count":24732,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"3.0.6","summary":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers","platform":"ruby","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"59ba3eb6eddca64f267a87ef8667063291cb895f969b115a6ca675ab220cdc2a","spec_sha":"9de41dbc95c959f7867ce61957a0b7ddd8787a6d6195981455c44167213ef758"},{"authors":"Ryan Davis","built_at":"2010-03-27T07:00:00.000Z","created_at":"2010-03-28T05:21:19.062Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse\ntree for an entire class or a specific method and returns it as a\ns-expression (aka sexp) using ruby's arrays, strings, symbols, and\nintegers.\n\nAs an example:\n\n  def conditional1(arg1)\n    if arg1 == 0 then\n      return 1\n    end\n    return 0\n  end\n\nbecomes:\n\n  [:defn,\n    :conditional1,\n    [:scope,\n     [:block,\n      [:args, :arg1],\n      [:if,\n       [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]],\n       [:return, [:lit, 1]],\n       nil],\n      [:return, [:lit, 0]]]]]","downloads_count":22741,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"3.0.5","summary":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers","platform":"ruby","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"084b6784980cebb89cb408a9e1b3cddd676695cb5f8ae627856e85cb1adaa7d0","spec_sha":"e81dbc0fe22e4191f55f221edb9a523893dae07499a0e4e5c0c828c0283507cd"},{"authors":"Ryan Davis","built_at":"2009-06-23T07:00:00.000Z","created_at":"2009-08-05T13:15:25.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse\ntree for an entire class or a specific method and returns it as a\ns-expression (aka sexp) using ruby's arrays, strings, symbols, and\nintegers.\n\nAs an example:\n\n  def conditional1(arg1)\n    if arg1 == 0 then\n      return 1\n    end\n    return 0\n  end\n\nbecomes:\n\n  [:defn,\n    :conditional1,\n    [:scope,\n     [:block,\n      [:args, :arg1],\n      [:if,\n       [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]],\n       [:return, [:lit, 1]],\n       nil],\n      [:return, [:lit, 0]]]]]","downloads_count":21025,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"3.0.4","summary":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers","platform":"ruby","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"855855525978055a6747ab85de3d2631a517d6e760226293cf3d16d8b982f4d6","spec_sha":"bbe6b624a5aea8901ddc2c51f8294ace499b2f37400d496c3829f9ad047abc50"},{"authors":"Ryan Davis","built_at":"2009-01-20T08:00:00.000Z","created_at":"2009-07-25T18:37:03.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.  As an example:  def conditional1(arg1) if arg1 == 0 then return 1 end return 0 end  becomes:  [:defn, :conditional1, [:scope, [:block, [:args, :arg1], [:if, [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]], [:return, [:lit, 1]], nil], [:return, [:lit, 0]]]]]","downloads_count":7316,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"3.0.3","summary":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers","platform":"ruby","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"1b93866d041c2cc6bd5df5f97db865680456815e57a8b13fa6eb2955cf8db5f9","spec_sha":"796803f177849859fa1df6ff6b8cf65fd238381486ec5b7668342e93f87e2b8c"},{"authors":"Ryan Davis","built_at":"2009-01-20T02:00:00.000Z","created_at":"2009-07-25T18:37:03.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.  As an example:  def conditional1(arg1) if arg1 == 0 then return 1 end return 0 end  becomes:  [:defn, :conditional1, [:scope, [:block, [:args, :arg1], [:if, [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]], [:return, [:lit, 1]], nil], [:return, [:lit, 0]]]]]","downloads_count":4688,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"3.0.3","summary":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers","platform":"x86-mswin32-60","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"92ac6e13d9979be1b521c2c9aa542473c3fff9f93b4f3d014caa7b059149ffbc","spec_sha":"907a00ee9a5054e1c9ffda88715b9d016585b74c3f5abc99d7c410498ad962a0"},{"authors":"Ryan Davis","built_at":"2009-01-20T02:00:00.000Z","created_at":"2009-07-25T18:37:03.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.  As an example:  def conditional1(arg1) if arg1 == 0 then return 1 end return 0 end  becomes:  [:defn, :conditional1, [:scope, [:block, [:args, :arg1], [:if, [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]], [:return, [:lit, 1]], nil], [:return, [:lit, 0]]]]]","downloads_count":4677,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"3.0.3","summary":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers","platform":"x86-mingw32","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"68993bc24acfc28b971065ab0b93c5756469ceffd3416b2ef110d1de45872093","spec_sha":"d93ae26dde3df7f94ef0e8e351842c8787a1c5731e897da30ec0adeaba54bc66"},{"authors":"Ryan Davis","built_at":"2008-11-04T08:00:00.000Z","created_at":"2009-07-25T18:37:03.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.  As an example:  def conditional1(arg1) if arg1 == 0 then return 1 end return 0 end  becomes:  [:defn, :conditional1, [:scope, [:block, [:args, :arg1], [:if, [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]], [:return, [:lit, 1]], nil], [:return, [:lit, 0]]]]]","downloads_count":5068,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"3.0.2","summary":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers","platform":"ruby","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"b5bb6abf58ef4096f1ba5db185b6c7a66e1082e3812659c12602b7144a59634c","spec_sha":"1b2da441e9ac67739855de0b2f6a9080e390d434de27926c04d9f6aacac83165"},{"authors":"Ryan Davis","built_at":"2008-11-05T03:00:00.000Z","created_at":"2009-07-25T18:37:03.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.  As an example:  def conditional1(arg1) if arg1 == 0 then return 1 end return 0 end  becomes:  [:defn, :conditional1, [:scope, [:block, [:args, :arg1], [:if, [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]], [:return, [:lit, 1]], nil], [:return, [:lit, 0]]]]]","downloads_count":3733,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"3.0.2","summary":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers","platform":"x86-mswin32-60","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"e7ccd6399da53eeb124e2a9527263abc6cf7dc50b78cfdfbd4b6c0ae605309ea","spec_sha":"118b3bb8ca3c16ccb21a8cf4540cfeddd7ffca8cfccbf88f5b34efb410a1110f"},{"authors":"Ryan Davis","built_at":"2008-11-05T03:00:00.000Z","created_at":"2009-07-25T18:37:03.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.  As an example:  def conditional1(arg1) if arg1 == 0 then return 1 end return 0 end  becomes:  [:defn, :conditional1, [:scope, [:block, [:args, :arg1], [:if, [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]], [:return, [:lit, 1]], nil], [:return, [:lit, 0]]]]]","downloads_count":3668,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"3.0.2","summary":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers","platform":"x86-mingw32","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"5c7f4398ae28cc90fc3ed7d92bd17870b32f660a4bf7fc8d76001e2dac4f3ee9","spec_sha":"e302959f6316b87c5a0b6a0ed2ad4812b463a668f1101fcaed1b36086d2af90d"},{"authors":"Ryan Davis","built_at":"2008-10-24T03:00:00.000Z","created_at":"2009-07-25T18:37:04.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.  As an example:  def conditional1(arg1) if arg1 == 0 then return 1 end return 0 end  becomes:  [:defn, :conditional1, [:scope, [:block, [:args, :arg1], [:if, [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]], [:return, [:lit, 1]], nil], [:return, [:lit, 0]]]]]","downloads_count":4024,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"3.0.1","summary":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers","platform":"x86-mingw32","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"d8c18c6a2042ee6d2144aeea50a4a255d4028782a081e66b6eabcc62c48a8fbc","spec_sha":"54d1cdacb7640989292c439aff60a11a7bedc9e11351f9c025491689b1a0d7b7"},{"authors":"Ryan Davis","built_at":"2008-10-23T05:00:00.000Z","created_at":"2009-07-25T18:37:03.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.  As an example:  def conditional1(arg1) if arg1 == 0 then return 1 end return 0 end  becomes:  [:defn, :conditional1, [:scope, [:block, [:args, :arg1], [:if, [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]], [:return, [:lit, 1]], nil], [:return, [:lit, 0]]]]]","downloads_count":4551,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"3.0.1","summary":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers","platform":"ruby","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"44ad7b0013554346d42100fb07da561bc83074676ea3faad4d76af96df5ed20c","spec_sha":"bbbbf8c60af2c1393568679dfea3de3db9a69adf6a2d57ec89a710503b1ed00f"},{"authors":"Ryan Davis","built_at":"2008-10-24T03:00:00.000Z","created_at":"2009-07-25T18:37:03.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.  As an example:  def conditional1(arg1) if arg1 == 0 then return 1 end return 0 end  becomes:  [:defn, :conditional1, [:scope, [:block, [:args, :arg1], [:if, [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]], [:return, [:lit, 1]], nil], [:return, [:lit, 0]]]]]","downloads_count":3722,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"3.0.1","summary":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers","platform":"x86-mswin32-60","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"a740b0ae4f32ebb421d0f3cbe072e7f31f84a7b6f2e1eca68d4294c22313fd31","spec_sha":"1671dac4b96798bb9f946dc57041426f62c96f77b45627adf0c60f1d56328f66"},{"authors":"Ryan Davis","built_at":"2008-10-22T05:00:00.000Z","created_at":"2009-07-25T18:37:04.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.  As an example:  def conditional1(arg1) if arg1 == 0 then return 1 end return 0 end  becomes:  [:defn, :conditional1, [:scope, [:block, [:args, :arg1], [:if, [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]], [:return, [:lit, 1]], nil], [:return, [:lit, 0]]]]]","downloads_count":4522,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"3.0.0","summary":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers","platform":"ruby","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"a7f6f7fa6314606675fb8a8fc8a78be66b5ff4d3998f0d5cb61257c5bbea25f3","spec_sha":"a3fc3f57b0f36b05d9ecd39c0d97d4c4d4060116f16d44e16d4fa727e00e8ca0"},{"authors":"Ryan Davis","built_at":"2008-06-09T07:00:00.000Z","created_at":"2009-07-25T18:37:04.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.  As an example:  def conditional1(arg1) if arg1 == 0 then return 1 end return 0 end  becomes:  [:defn, :conditional1, [:scope, [:block, [:args, :arg1], [:if, [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]], [:return, [:lit, 1]], nil], [:return, [:lit, 0]]]]]","downloads_count":8391,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"2.2.0","summary":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers","platform":"ruby","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"c10960c14eb1cfea88d43ec5fb138237289cf86c9948e35d6ed2d360b690c69f","spec_sha":"5682b6258d5f94c09af032b2c4776f2b80aa5cede5be6b7d3b9cc614c9c317aa"},{"authors":"Ryan Davis","built_at":"2007-12-22T08:00:00.000Z","created_at":"2009-07-25T18:37:05.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.  As an example:  def conditional1(arg1) if arg1 == 0 then return 1 end return 0 end  becomes:  [:defn, :conditional1, [:scope, [:block, [:args, :arg1], [:if, [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]], [:return, [:lit, 1]], nil], [:return, [:lit, 0]]]]]  * Uses RubyInline, so it just drops in. * Includes SexpProcessor and CompositeSexpProcessor. * Allows you to write very clean filters. * Includes UnifiedRuby, allowing you to automatically rewrite ruby quirks. * ParseTree#parse_tree_for_string lets you parse arbitrary strings of ruby. * Includes parse_tree_show, which lets you quickly snoop code. * echo "1+1" | parse_tree_show -f for quick snippet output. * Includes parse_tree_abc, which lets you get abc metrics on code. * abc metrics = numbers of assignments, branches, and calls. * whitespace independent metric for method complexity. * Includes parse_tree_deps, which shows you basic class level dependencies. * Does not work on the core classes, as they are not ruby (yet).","downloads_count":8748,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"2.1.1","summary":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.","platform":"ruby","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"32c2b2bc7843a3c459d3800a362dd87602774ae4c98bde7f8b9a95265ee398a7","spec_sha":"719c4e04e5c10f60582a2f186c7ea3ade6679182b0ac04f84a8b1fa6560fe17e"},{"authors":"Ryan Davis","built_at":"2007-12-22T08:00:00.000Z","created_at":"2009-07-25T18:37:05.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.  As an example:  def conditional1(arg1) if arg1 == 0 then return 1 end return 0 end  becomes:  [:defn, :conditional1, [:scope, [:block, [:args, :arg1], [:if, [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]], [:return, [:lit, 1]], nil], [:return, [:lit, 0]]]]]  * Uses RubyInline, so it just drops in. * Includes SexpProcessor and CompositeSexpProcessor. * Allows you to write very clean filters. * Includes UnifiedRuby, allowing you to automatically rewrite ruby quirks. * ParseTree#parse_tree_for_string lets you parse arbitrary strings of ruby. * Includes parse_tree_show, which lets you quickly snoop code. * echo "1+1" | parse_tree_show -f for quick snippet output. * Includes parse_tree_abc, which lets you get abc metrics on code. * abc metrics = numbers of assignments, branches, and calls. * whitespace independent metric for method complexity. * Includes parse_tree_deps, which shows you basic class level dependencies. * Does not work on the core classes, as they are not ruby (yet).","downloads_count":4521,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"2.1.0","summary":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.","platform":"ruby","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"a636238af2c557df2ee450bf68baeda5960a3f9329aeb9dc96f0c8b5e96ab109","spec_sha":"828e30a0c08368b7194fe225f672068a87a1ed7b19de32d4b6c7665bac6f9200"},{"authors":"Ryan Davis","built_at":"2007-09-20T07:00:00.000Z","created_at":"2009-07-25T18:37:05.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.  As an example:  def conditional1(arg1) if arg1 == 0 then return 1 end return 0 end  becomes:  [:defn, :conditional1, [:scope, [:block, [:args, :arg1], [:if, [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]], [:return, [:lit, 1]], nil], [:return, [:lit, 0]]]]]  * Uses RubyInline, so it just drops in. * Includes SexpProcessor and CompositeSexpProcessor. * Allows you to write very clean filters. * Includes UnifiedRuby, allowing you to automatically rewrite ruby quirks. * ParseTree#parse_tree_for_string lets you parse arbitrary strings of ruby. * Includes parse_tree_show, which lets you quickly snoop code. * echo "1+1" | parse_tree_show -f for quick snippet output. * Includes parse_tree_abc, which lets you get abc metrics on code. * abc metrics = numbers of assignments, branches, and calls. * whitespace independent metric for method complexity. * Includes parse_tree_deps, which shows you basic class level dependencies. * Does not work on the core classes, as they are not ruby (yet).","downloads_count":4298,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"2.0.2","summary":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.","platform":"ruby","rubygems_version":">= 0","ruby_version":"> 0.0.0","prerelease":false,"licenses":null,"requirements":null,"sha":"cbdcc3ac6ed2d9713f46ab81b13cdc704885d7f1a5329cc64cd944954712789c","spec_sha":"71bff765be2c30e9c6b52947bb81eebe618a821abd1e9222e61cc683597769a4"},{"authors":"Ryan Davis","built_at":"2007-08-21T07:00:00.000Z","created_at":"2009-07-25T18:37:05.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.  As an example:  def conditional1(arg1) if arg1 == 0 then return 1 end return 0 end  becomes:  [:defn, :conditional1, [:scope, [:block, [:args, :arg1], [:if, [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]], [:return, [:lit, 1]], nil], [:return, [:lit, 0]]]]]  * Uses RubyInline, so it just drops in. * Includes SexpProcessor and CompositeSexpProcessor. * Allows you to write very clean filters. * Includes UnifiedRuby, allowing you to automatically rewrite ruby quirks. * ParseTree#parse_tree_for_string lets you parse arbitrary strings of ruby. * Includes parse_tree_show, which lets you quickly snoop code. * echo "1+1" | parse_tree_show -f for quick snippet output. * Includes parse_tree_abc, which lets you get abc metrics on code. * abc metrics = numbers of assignments, branches, and calls. * whitespace independent metric for method complexity. * Includes parse_tree_deps, which shows you basic class level dependencies. * Does not work on the core classes, as they are not ruby (yet).","downloads_count":4403,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"2.0.1","summary":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.","platform":"ruby","rubygems_version":">= 0","ruby_version":"> 0.0.0","prerelease":false,"licenses":null,"requirements":null,"sha":"b81d57705e2fcebcccb4b4171ede53cc27cdd1c6a6dd5042c3956070838e18c7","spec_sha":"9d0f68f085f7df445e1b4c711c78f8951cd6b4b0a1fdb5ec09f9e1b1ae4aadbe"},{"authors":"Ryan Davis","built_at":"2007-08-01T07:00:00.000Z","created_at":"2009-07-25T18:37:05.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.  As an example:  def conditional1(arg1) if arg1 == 0 then return 1 end return 0 end  becomes:  [:defn, :conditional1, [:scope, [:block, [:args, :arg1], [:if, [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]], [:return, [:lit, 1]], nil], [:return, [:lit, 0]]]]]  * Uses RubyInline, so it just drops in. * Includes SexpProcessor and CompositeSexpProcessor. * Allows you to write very clean filters. * Includes UnifiedRuby, allowing you to automatically rewrite ruby quirks. * ParseTree#parse_tree_for_string lets you parse arbitrary strings of ruby. * Includes parse_tree_show, which lets you quickly snoop code. * echo "1+1" | parse_tree_show -f for quick snippet output. * Includes parse_tree_abc, which lets you get abc metrics on code. * abc metrics = numbers of assignments, branches, and calls. * whitespace independent metric for method complexity. * Includes parse_tree_deps, which shows you basic class level dependencies. * Does not work on the core classes, as they are not ruby (yet).","downloads_count":4574,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"2.0.0","summary":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.","platform":"ruby","rubygems_version":">= 0","ruby_version":"> 0.0.0","prerelease":false,"licenses":null,"requirements":null,"sha":"190b12160d0d6c6e9a6b2a6d215d11ac1b2d4ccf89380c0d96fbc4a584f74c3d","spec_sha":"d1e85f61879eb201dc28da84f4bc4667b8d323dcd65e6c36de1f8939f6830b2a"},{"authors":"Ryan Davis","built_at":"2007-06-05T07:00:00.000Z","created_at":"2009-07-25T18:37:05.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.","downloads_count":4647,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"1.7.1","summary":"Extract and enumerate ruby parse trees.","platform":"ruby","rubygems_version":">= 0","ruby_version":"> 0.0.0","prerelease":false,"licenses":null,"requirements":null,"sha":"ca10735fffedf94a552e2aa7635f940f4d12b916d99fa31995e3e8f59a355521","spec_sha":"13ce5ca4dc82166245a72e7898e6c7c0fe8171ed6d7708b6c2d4ca5b4df4c27b"},{"authors":"Ryan Davis","built_at":"2007-02-13T08:00:00.000Z","created_at":"2009-07-25T18:37:06.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.","downloads_count":4357,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"1.7.0","summary":"Extract and enumerate ruby parse trees.","platform":"ruby","rubygems_version":">= 0","ruby_version":"> 0.0.0","prerelease":false,"licenses":null,"requirements":null,"sha":"25dd61a38a444c07a0644b75006baeb0eb0c62d9f71129ae1ab5df3fd563207c","spec_sha":"a70ddfafbbd77f1df47ecce327935f53f2beb18314bce9df65bdc9eca8500cf4"},{"authors":"Ryan Davis","built_at":"2007-01-15T08:00:00.000Z","created_at":"2009-07-25T18:37:06.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.","downloads_count":4458,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"1.6.4","summary":"Extract and enumerate ruby parse trees.","platform":"ruby","rubygems_version":">= 0","ruby_version":"> 0.0.0","prerelease":false,"licenses":null,"requirements":null,"sha":"0980e760ca3cb05f7726ee75357ce8e5c89fdbfe4e67bec843d31b6db71944bb","spec_sha":"680ccc550cd8a53be4fe45a6d93b8ae53ca0da72c4308841c3f1f817d2c0d540"},{"authors":"Ryan Davis","built_at":"2006-12-20T08:00:00.000Z","created_at":"2009-07-25T18:37:06.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.","downloads_count":4288,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"1.6.3","summary":"Extract and enumerate ruby parse trees.","platform":"ruby","rubygems_version":">= 0","ruby_version":"> 0.0.0","prerelease":false,"licenses":null,"requirements":null,"sha":"b8a38e1dfecf09d2662a51af032d20f49d1178509fc5f19f12514f1e09235c1a","spec_sha":"c375da2773d9e065c48527f97e2b6db5bbed8aceb85e350140e016be52fcdf63"},{"authors":"Ryan Davis","built_at":"2006-12-19T08:00:00.000Z","created_at":"2009-07-25T18:37:06.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.","downloads_count":4365,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"1.6.2","summary":"Extract and enumerate ruby parse trees.","platform":"ruby","rubygems_version":">= 0","ruby_version":"> 0.0.0","prerelease":false,"licenses":null,"requirements":null,"sha":"970d3c9ade7256e8475917363adfd134d9887bdc00c42dc5002ed83114a5b0af","spec_sha":"60f4f6c19deabe2777a53bc71af84014d1c3ab916d746571172e33f832bb18d2"},{"authors":"Ryan Davis","built_at":"2006-11-13T05:00:00.000Z","created_at":"2009-07-25T18:37:06.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.","downloads_count":4285,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"1.6.1","summary":"Extract and enumerate ruby parse trees.","platform":"ruby","rubygems_version":">= 0","ruby_version":"> 0.0.0","prerelease":false,"licenses":null,"requirements":null,"sha":"790861ebb7cd05752f23c1b36da093d8eb1afcc56a9506c46d1ef452511b28fb","spec_sha":"5dae16ba0d40222cc7c9e83f8e6380e2c7b5cbe4131bda0d7c4ea451eece87fd"},{"authors":"Ryan Davis","built_at":"2006-10-11T07:00:00.000Z","created_at":"2009-07-25T18:37:06.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.","downloads_count":4239,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"1.6.0","summary":"Extract and enumerate ruby parse trees.","platform":"ruby","rubygems_version":">= 0","ruby_version":"> 0.0.0","prerelease":false,"licenses":null,"requirements":null,"sha":"76705c02931576bb886d9bd7160c2ba58489ccad0dd6c1c101558a18d1c60a6b","spec_sha":"524733de4305420f093da001e02ccbf48627cca7e4dc44749bee9b4bd4ee4c6e"},{"authors":"Ryan Davis","built_at":"2006-09-24T07:00:00.000Z","created_at":"2009-07-25T18:37:06.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.","downloads_count":4380,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"1.5.0","summary":"Extract and enumerate ruby parse trees.","platform":"ruby","rubygems_version":">= 0","ruby_version":"> 0.0.0","prerelease":false,"licenses":null,"requirements":null,"sha":"ab9a27e7d7bd630a041d6952191c3c18fafcc808c661475edd453527962826e6","spec_sha":"5eee9d91d956e353f4e20e42b1f1c7b529d0890948ba394a178b9196349e4fa1"},{"authors":"Ryan Davis","built_at":"2006-04-10T07:00:00.000Z","created_at":"2009-07-25T18:37:06.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.","downloads_count":4219,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"1.4.1","summary":"Extract and enumerate ruby parse trees.","platform":"ruby","rubygems_version":">= 0","ruby_version":"> 0.0.0","prerelease":false,"licenses":null,"requirements":null,"sha":"b00f6b7df831a17e89e1f518c79e16bf00c330b4aa489c13bd07e7091928a632","spec_sha":"8661e8836ae71cd52142a7e7168b810a086b4434a725bcf7b5e1f2afdba822c2"},{"authors":"Ryan Davis","built_at":"2005-10-17T07:00:00.000Z","created_at":"2009-07-25T18:37:06.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.","downloads_count":4140,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"1.4.0","summary":"Extract and enumerate ruby parse trees.","platform":"ruby","rubygems_version":">= 0","ruby_version":"> 0.0.0","prerelease":false,"licenses":null,"requirements":null,"sha":"8338d6ab0c21c6dbc2e6509a23c7e0a1310b9285cfe79c6849936cbf5e4aa947","spec_sha":"0b3d07300cc71e9933c0e1eb7a1ed0463dd68bdff2c0023c047f75e0d65f0ca1"},{"authors":"Ryan Davis","built_at":"2005-07-13T04:00:00.000Z","created_at":"2009-07-25T18:37:06.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.","downloads_count":4292,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"1.3.7","summary":"Extract and enumerate ruby parse trees.","platform":"ruby","rubygems_version":">= 0","ruby_version":"> 0.0.0","prerelease":false,"licenses":null,"requirements":null,"sha":"8b8fcbaeb199bc6899531c9cdc7ec66dd0fd71c680c389d6f9ea09c52960d2a9","spec_sha":"e728340fc4fc34599a4bf6005c7f9eb90b85ca91f8c641d63caac8520f1033fd"},{"authors":"Ryan Davis","built_at":"2005-05-19T04:00:00.000Z","created_at":"2009-07-25T18:37:07.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.","downloads_count":4286,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"1.3.6","summary":"Extract and enumerate ruby parse trees.","platform":"ruby","rubygems_version":">= 0","ruby_version":"> 0.0.0","prerelease":false,"licenses":null,"requirements":null,"sha":"40023c2cfaf5e87ea337ad267c2da13cc2e329373472b52ea7028c2f69c618e6","spec_sha":"e129cf2f3ab231959c5b9468065b500f13b3413b8588870950f87a197df64ae8"},{"authors":"Ryan Davis","built_at":"2005-04-19T04:00:00.000Z","created_at":"2009-07-25T18:37:07.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.","downloads_count":4171,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"1.3.5","summary":"Extract and enumerate ruby parse trees.","platform":"ruby","rubygems_version":">= 0","ruby_version":"> 0.0.0","prerelease":false,"licenses":null,"requirements":null,"sha":"18a4a4f7022c867a9be4805642d272ffd15634f2981f9942bae999739a20f790","spec_sha":"ff20fb93c9dcbf2505e9409c3a8af1ab09bb94fe123f401b36aacae43bd5096c"},{"authors":"Ryan Davis","built_at":"2005-02-09T05:00:00.000Z","created_at":"2009-07-25T18:37:07.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.","downloads_count":4305,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"1.3.4","summary":"Extract and enumerate ruby parse trees.","platform":"ruby","rubygems_version":">= 0","ruby_version":"> 0.0.0","prerelease":false,"licenses":null,"requirements":null,"sha":"050314de2f30deb0e7a8b8e534fb431325b0e030bb8cac8c7c7e4d6c9fc2c8b6","spec_sha":"308822820bf3fc883e117745dcd408eac42f3610054a2adcb6a5d51f541b88dd"},{"authors":"Ryan Davis","built_at":"2005-02-01T05:00:00.000Z","created_at":"2009-07-25T18:37:07.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.","downloads_count":4092,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"1.3.3","summary":"Extract and enumerate ruby parse trees.","platform":"ruby","rubygems_version":">= 0","ruby_version":"> 0.0.0","prerelease":false,"licenses":null,"requirements":null,"sha":"7849ad1531a1b507b4714ae2697553797bf959dc8870b20cf9645fad7c84f5fc","spec_sha":"2813ac41a1c523c330070ee3404c85004cfe8f82d4785e1d88278e03bc4e4504"},{"authors":"","built_at":"2005-01-04T05:00:00.000Z","created_at":"2009-07-25T18:37:07.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.","downloads_count":4329,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"1.3.2","summary":"Extract and enumerate ruby parse trees.","platform":"ruby","rubygems_version":">= 0","ruby_version":"> 0.0.0","prerelease":false,"licenses":null,"requirements":null,"sha":"6742861aa1e94cb6be5b9bf3b1a7d2a44f6340fdbab5d90979a576c7a032eb30","spec_sha":"e337835255f0d15ee3ca2eef23dec29db2d68b1a833999136ecc1530435d3ffd"},{"authors":"","built_at":"2004-12-07T05:00:00.000Z","created_at":"2009-07-25T18:37:07.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.","downloads_count":4201,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"1.3.0","summary":"Extract and enumerate ruby parse trees.","platform":"ruby","rubygems_version":">= 0","ruby_version":"> 0.0.0","prerelease":false,"licenses":null,"requirements":null,"sha":"e18652cf82bbbdc237fbe024c62a3e617bbc0c2fc0e6d1e2566b0808c1ac7f44","spec_sha":"ae4c09c4d062e125fde85fae7be8b89300c024b910979ea8bcc7f3d4c4b102af"},{"authors":"","built_at":"2004-11-29T05:00:00.000Z","created_at":"2009-07-25T18:37:07.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.","downloads_count":4185,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"1.2.0","summary":"Extract and enumerate ruby parse trees.","platform":"ruby","rubygems_version":">= 0","ruby_version":"> 0.0.0","prerelease":false,"licenses":null,"requirements":null,"sha":"24c0b68017086138afab719c26b05724e0d09325bde77c617102fa922aa650a7","spec_sha":"283616921fa5157ef85c12b5750424b70a728d18e5654abf2936100074556fd6"},{"authors":"","built_at":"2004-11-20T05:00:00.000Z","created_at":"2009-07-25T18:37:07.000Z","description":"def conditional1(arg1) if arg1 == 0 then return 1 end return 0 end","downloads_count":4331,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"1.1.1","summary":"Extract and enumerate ruby parse trees.","platform":"ruby","rubygems_version":">= 0","ruby_version":"> 0.0.0","prerelease":false,"licenses":null,"requirements":null,"sha":"3db0bd6151faeba4d1fbe4f6e25a94767b485a8fda372313118bc4a0ba718286","spec_sha":"cd4628b6666b0eaff8cc7a97d5d142be23278243a6fd90abcdd324e69d4a145a"},{"authors":"","built_at":"2004-11-20T05:00:00.000Z","created_at":"2009-07-25T18:37:07.000Z","description":"ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.","downloads_count":4176,"metadata":{"homepage_uri":"https://github.com/seattlerb/parsetree"},"number":"1.1.0","summary":"Extract and enumerate ruby parse trees.","platform":"ruby","rubygems_version":">= 0","ruby_version":"> 0.0.0","prerelease":false,"licenses":null,"requirements":null,"sha":"55ec8e6d42af272b2e6fef9891c5621ffb9362ce03c018a674a4e7ef4cfd6998","spec_sha":"ff721f5e423426bdf95715161f9b920c1e2fc2d9ea600081eef430970cff92a4"}]