buttons 0.1.0

data/.gitignore

@@ -0,0 +1,2 @@
+pkg
+*.gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Clinton R. Nixon
+
+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.rdoc

@@ -0,0 +1,74 @@
+= Buttons
+
+<b>NOTE: This is a very early version of Buttons. Expect it to change rapidly.</b>
+
+Buttons is a Rack framework for working with JavaScript-heavy applications. It
+automatically creates Ajax endpoints for Ruby methods, and creates a set of
+JavaScript functions to access those endpoints.
+
+== Example
+
+Here's an example. The Ruby class below will automatically generate the
+JavaScript found beneath it. For now, we only generate code that relies on
+jQuery, but that's planned to change.
+
+Ruby code:
+
+    class ProfileButton < Buttons::Button
+      get :show
+      post :login
+    
+      def login(username, password)
+        # The variable's set just to show that it's being returned.      
+        token = generate_login_token(username, password)
+        token
+      end
+      
+      def show(profile_id)
+        Profile.find(profile_id)
+      end
+    end
+    
+JavaScript code (found at /profile.js):
+
+    (function () {
+      this.Profile = {};
+
+      Profile.login = function (username, password, _ajaxOptions) {
+        var data = { 'username': username, 'password': password };
+        if (_ajaxOptions === undefined || typeof(_ajaxOptions) != "object") {
+          _ajaxOptions = {};
+        }
+        _ajaxOptions['type'] = "POST";
+        _ajaxOptions['url'] = "/profile/login";
+        _ajaxOptions['data'] = data;
+
+        if (_ajaxOptions['dataType'] === 'undefined') {
+          _ajaxOptions['dataType'] = 'json';
+        }
+
+        return jQuery.ajax(_ajaxOptions);
+      };
+
+      Profile.show = function (profileId, _ajaxOptions) {
+        var data = { 'profile_id': profileId };
+        if (_ajaxOptions === undefined || typeof(_ajaxOptions) != "object") {
+          _ajaxOptions = {};
+        }
+        _ajaxOptions['type'] = "GET";
+        _ajaxOptions['url'] = "/profile/show";
+        _ajaxOptions['data'] = data;
+
+        if (_ajaxOptions['dataType'] === 'undefined') {
+          _ajaxOptions['dataType'] = 'json';
+        }
+
+        return jQuery.ajax(_ajaxOptions);
+      };
+    })();
+    
+== How to use this
+
+Run <tt>buttons <directory></tt> to create a new Buttons application in that
+directory. There's not any helpers or generators yet, but you can look at the
+generated application to figure it out for now.

data/Rakefile

@@ -0,0 +1,34 @@
+task :default => :test
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "buttons"
+    gemspec.summary = "Buttons is a Rack framework for working with JavaScript-heavy applications."
+    gemspec.description = "Buttons is a Rack framework for working with JavaScript-heavy applications. It
+automatically creates Ajax endpoints for Ruby methods, and creates a set of
+JavaScript functions to access those endpoints."
+    gemspec.email = "crnixon@gmail.com"
+    gemspec.homepage = "http://github.com/crnixon/buttons"
+    gemspec.authors = ["Clinton R. Nixon"]
+
+    gemspec.add_dependency('get_args', '>= 1.1.1')
+    gemspec.add_dependency('facets')
+    gemspec.add_dependency('json')
+    gemspec.add_dependency('rack', '>= 1.0.1')
+    gemspec.add_dependency('bundler')
+    gemspec.add_dependency('rubigen')
+    gemspec.add_development_dependency('riot')
+
+#    if RUBY_PLATFORM != 'java' && RUBY_VERSION < "1.9"
+#      gemspec.add_dependency('ParseTree')
+#      gemspec.add_dependency('ruby2ruby')
+#    end
+  end
+  
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"
+end
+
+Dir[File.join(File.dirname(__FILE__), 'tasks', '*.rake')].each { |file| load file }

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/buttons

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'rubigen'
+require 'rubigen/scripts/generate'
+
+RubiGen::Base.sources << RubiGen::PathSource.new(:buttons, File.join(File.dirname(__FILE__), %w[.. generators]))
+RubiGen::Scripts::Generate.new.run(ARGV, :generator => 'buttons_app')

data/generators/buttons_app/buttons_app_generator.rb

@@ -0,0 +1,24 @@
+class ButtonsAppGenerator < RubiGen::Base
+  BASEDIRS = ['app', 'app/buttons', 'public']
+
+  def initialize(args, opts = {})
+    super
+    usage if args.empty?
+    @destination_root = args.shift
+    @app_name = File.basename(File.expand_path(@destination_root))
+    @module_name = @app_name.camelize
+  end
+
+  def manifest
+    record do |m|
+      m.directory ''
+      BASEDIRS.each { |dir| m.directory dir }
+
+      m.file_copy_each [ 'config.ru',
+                         'start.rb',
+                         'Rakefile',
+                         'public/index.html',
+                         'app/buttons/example_button.rb' ]
+    end
+  end
+end

data/generators/buttons_app/templates/app/buttons/example_button.rb

@@ -0,0 +1,11 @@
+class ExampleButton < Buttons::Button
+  get :add, :multiply
+
+  def add(operand1, operand2)
+    operand1.to_i + operand2.to_i
+  end
+  
+  def multiply(operand1, operand2)
+    operand1.to_i * operand2.to_i
+  end
+end

data/generators/buttons_app/templates/config.ru

@@ -0,0 +1,8 @@
+require File.join(File.dirname(__FILE__), 'start')
+
+files = Dir.chdir('public') { Dir['**/*'].map { |file| "/#{file}" } }
+app = Buttons.app do
+  use Rack::Static, :root => 'public', :urls => files
+end
+
+run app

data/generators/buttons_app/templates/public/index.html

@@ -0,0 +1,9 @@
+<html>
+  <head>
+    <title>Buttons Example</title>
+    <link rel="stylesheet" href="/example.js" />
+  </head>
+  <body>
+    <h1>Buttons Example</h1>
+  </body>
+</html>

data/generators/buttons_app/templates/start.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'buttons'
+
+Buttons.configure do |config|  
+  config.app_root = File.dirname(__FILE__)
+end
+
+Buttons.app.start

data/lib/buttons.rb

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'facets'
+
+module Buttons
+  def self.lib_root(*paths)
+    File.expand_path(File.join(File.dirname(__FILE__), 'buttons', *paths))
+  end
+
+  def self.app(&block)
+    @app ||= Buttons::Application.new
+    @app.instance_eval(&block) unless block.nil?
+    @app
+  end
+
+  def self.configure
+    yield app if block_given?
+  end
+end
+
+require Buttons.lib_root('core_ext/string')
+require Buttons.lib_root('application')
+require Buttons.lib_root('javascript')
+require Buttons.lib_root('button')

data/lib/buttons/application.rb

@@ -0,0 +1,68 @@
+require Buttons.lib_root('router')
+require Buttons.lib_root('config')
+
+module Buttons
+  class Application
+    include Buttons::Config
+
+    def initialize(&block)
+      @router ||= Buttons::Router.new
+      @middlewares ||= []
+    end
+
+    def use(middleware, options = nil)
+      @middlewares << [middleware, options]
+    end
+
+    def start
+      unless app_root.nil?
+        Dir[app_root('app', '**', '*.rb')].each do |ruby_file|
+          require ruby_file
+        end
+      end
+    end
+    
+    def add_route(http_method, path, params)
+      @router.add_route(http_method, path, params)
+    end
+    
+    def call(environment)
+      rack_app = lambda { |env|
+        request = ::Rack::Request.new(env)
+        response = ::Rack::Response.new
+        route = @router.recognize(request)
+
+        if route
+          render(request, response, route)
+        else
+          [404, {"Content-Type" => 'text/plain'}, "not found: #{request.path}\n\n" +
+              "All routes: \n#{@router.print_routes}"
+          ]
+        end
+      }
+
+      @middlewares.each do |middleware, options|
+        rack_app = if options
+          middleware.new(rack_app, options)
+        else
+          middleware.new(rack_app)
+        end
+      end
+
+      rack_app.call environment
+    end
+
+    def render(request, response, params)
+      button_klass, method_name = params[:button], params[:method]
+
+      response['Content-Type'] = 'text/javascript'
+      content = button_klass.new(request).call_method(method_name)
+      if conversion = params.delete(:convert)
+        content = content.send(conversion)
+      end
+      response.write(content)
+
+      response.finish
+    end
+  end
+end

data/lib/buttons/button.rb

@@ -0,0 +1,119 @@
+require 'get_args'
+
+module Buttons
+  class Button
+    attr_reader :request
+
+    def initialize(request)
+      @request = request
+    end
+
+    def to_js
+      self.class.to_js
+    end
+
+    def call_method(method_name)      
+      send(method_name, *create_method_args(method_name))
+    end
+    
+    class << self
+      def inherited(base)        
+        Buttons.app.add_route(:get, "/#{base.namespace}.js",
+          :button => base, :method => :to_js)
+      end
+
+      def method_added(name)
+        routes.each do |http_method, methods|
+          if methods.include?(name)
+            setup_route(http_method, instance_method(name))
+          end
+        end
+      end
+
+      def namespace
+        self.to_s.debuttonize
+      end
+
+      def js_functions
+        @js_functions ||= []
+      end
+
+      def argument_list
+        @argument_list ||= {}
+      end
+
+      def routes
+        @routes ||= { }
+      end
+
+      def get(*names)
+        names.each do |name|
+          add_route(:get, name)
+        end
+      end
+
+      def post(*names)
+        names.each do |name|
+          add_route(:post, name)
+        end
+      end     
+  
+      def to_js
+        Buttons::Javascript::JsGenerator.new(self).to_js
+      end
+
+      private
+
+      def add_route(http_method, name)
+        routes[http_method] ||= []
+        routes[http_method] << name
+
+        method = instance_method(name) rescue nil
+        if method          
+          setup_route(http_method, method)
+        end
+      end
+
+      def setup_route(http_method, method)
+        name = method.name
+        route_path = "/#{namespace}/#{name}"
+        argument_list[name] = method.get_argument_list
+        js_functions << Buttons::Javascript::JsFunction.new(
+          name, http_method, route_path, method.get_argument_list)
+        Buttons.app.add_route(http_method, route_path, 
+          :button => self, :method => name, :convert => 'to_json')
+      end
+    end
+
+    private
+
+    def params
+      request.params
+    end
+    
+    def create_method_args(method_name)
+      args = []
+      argument_list = self.class.argument_list[method_name]
+
+      unless argument_list.nil?
+        argument_list.each do |argument|
+          param_name = argument.name.to_s
+          param_name = param_name.slice(1, param_name.length) if argument.multiple?
+          value = params[param_name]
+        
+          if value.nil? and argument.optional?
+            value = argument.default
+          end
+          if argument.multiple?
+            args += value
+          else
+            args << value
+          end
+        end
+      end
+
+      p args.inspect
+      args
+    end
+  end
+end

data/lib/buttons/config.rb

@@ -0,0 +1,13 @@
+module Buttons
+  module Config
+    def app_root=(path)
+      @app_root = path
+    end
+
+    def app_root(*paths)
+      if @app_root
+        File.expand_path(File.join(@app_root, *paths))
+      end
+    end
+  end
+end

data/lib/buttons/core_ext/string.rb

@@ -0,0 +1,9 @@
+class String
+  def strip_whitespace
+    self.strip.gsub(/[\n\s]+/, ' ')
+  end
+  
+  def debuttonize
+    self.underscore.gsub(/_button$/, '')
+  end
+end

data/lib/buttons/javascript.rb

@@ -0,0 +1,7 @@
+require 'json'
+
+require Buttons.lib_root('javascript', 'js_var')
+require Buttons.lib_root('javascript', 'js_arg')
+require Buttons.lib_root('javascript', 'js_function')
+require Buttons.lib_root('javascript', 'js_generator')
+

data/lib/buttons/javascript/js_arg.rb

@@ -0,0 +1,30 @@
+module Buttons
+  module Javascript
+    class JsArg < JsVar
+      attr_reader :name
+
+      def initialize(var)
+        @var = var
+        super(@var.name)        
+      end
+
+      def method_missing(*args, &block)
+        @var.send(*args, &block)
+      end
+      
+      def default
+        @var.default.to_json
+      end
+      
+      def to_default(index)
+        if optional?
+          %Q[
+            if (#{name} === undefined) {
+              #{name} = #{default};
+            }
+          ]
+        end        
+      end
+    end 
+  end
+end

data/lib/buttons/javascript/js_function.rb

@@ -0,0 +1,62 @@
+module Buttons
+  module Javascript
+    class JsFunction < JsVar
+      attr_reader :name, :args
+
+      def initialize(name, http_method, url, args)
+        super(name)
+
+        @http_method = http_method
+        @url = url
+        @args = args.map { |arg| JsArg.new(arg) }
+      end
+      
+      def to_js(namespace = 'this')
+        %Q[
+          #{namespace}.#{name} = function (#{args_to_param_list}, _ajaxOptions) {
+            #{args_to_defaults}
+            #{assign_args_to_js_object}
+            #{ajax_call}
+          };
+        ].strip_whitespace        
+      end
+      
+      private
+
+      def ajax_call
+        %Q[
+          if (_ajaxOptions === undefined || typeof(_ajaxOptions) != "object") {
+            _ajaxOptions = {};
+          }
+          _ajaxOptions['type'] = #{@http_method.to_s.upcase.to_json};
+          _ajaxOptions['url'] = #{@url.to_json};
+          _ajaxOptions['data'] = data;
+
+          if (_ajaxOptions['dataType'] === 'undefined') {
+            _ajaxOptions['dataType'] = 'json';
+          }
+
+          return jQuery.ajax(_ajaxOptions);
+        ]
+      end
+      
+      def args_to_param_list
+        args.map { |arg| arg.name }.compact.join(", ")
+      end
+      
+      def args_to_defaults
+        args.map_with_index { |arg, i| 
+          arg.to_default(i)
+        }.compact.join("\n")
+      end
+      
+      def assign_args_to_js_object
+        arg_assignments = args.map { |arg|
+          "'#{arg.ruby_name}#{'[]' if arg.multiple?}': #{arg.name}"
+        }.join(", ")
+        
+        %Q[var data = { #{arg_assignments} };]
+      end
+    end 
+  end
+end

data/lib/buttons/javascript/js_generator.rb

@@ -0,0 +1,27 @@
+require "yui/compressor"
+
+module Buttons
+  module Javascript
+    class JsGenerator
+      def initialize(button)
+        @button = button
+        # @compressor = YUI::JavaScriptCompressor.new
+      end
+
+      def to_js
+        js = %Q[
+          (function () {
+            this.#{@button.namespace.capitalize} = {};
+
+            #{@button.js_functions.map { |function| 
+              function.to_js(@button.namespace.capitalize)
+            }.join("\n")}
+          })();
+        ]
+        
+        # @compressor.compress(js)
+        js.strip_whitespace
+      end
+    end
+  end
+end

data/lib/buttons/javascript/js_var.rb

@@ -0,0 +1,16 @@
+module Buttons
+  module Javascript
+    class JsVar
+      attr_reader :name, :ruby_name
+
+      def initialize(name)
+        @ruby_name = name = name.to_s.gsub(/^\*/, '')
+        @name = name.camelcase
+      end
+
+      def to_s
+        @name
+      end
+    end
+  end
+end

data/lib/buttons/router.rb

@@ -0,0 +1,28 @@
+module Buttons
+  class Router
+    def initialize
+      @routes = {}
+    end
+
+    def add_route(http_method, path, params)
+      http_method = http_method.to_s.downcase
+
+      @routes[http_method] ||= {}
+      @routes[http_method][path] = params
+    end
+
+    def recognize(request)
+      request_method = request.request_method.to_s.downcase
+
+      @routes[request_method] && @routes[request_method][request.path]
+    end
+
+    def print_routes
+      @routes.map do |http_method, routes|
+        routes.map do |route, params|
+          "%8s %s %s" % [http_method.upcase, route, params.inspect]
+        end.join("\n")
+      end.join("\n")
+    end
+  end
+end

data/public/index.txt

@@ -0,0 +1 @@
+hi there

data/tasks/test.rake

@@ -0,0 +1,6 @@
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.test_files = FileList['tests/**/*_tests.rb']
+  t.libs << 'test'
+end

data/tests/button_tests.rb

@@ -0,0 +1,58 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+class ProfileButton < Buttons::Button
+  get :show
+  post :login
+
+  def login(username, password)
+    # The variable's set just to show that it's being returned.
+    token = generate_login_token(username, password)
+    token
+  end
+
+  def show(profile_id)
+    Profile.find(profile_id)
+  end
+end
+
+context "ProfileButton" do
+  should("generate JS") {
+    ProfileButton.to_js
+  }.equals(%Q[
+    (function () {
+      this.Profile = {};
+
+      Profile.login = function (username, password, _ajaxOptions) {
+        var data = { 'username': username, 'password': password };
+        if (_ajaxOptions === undefined || typeof(_ajaxOptions) != "object") {
+          _ajaxOptions = {};
+        }
+        _ajaxOptions['type'] = "POST";
+        _ajaxOptions['url'] = "/profile/login";
+        _ajaxOptions['data'] = data;
+
+        if (_ajaxOptions['dataType'] === 'undefined') {
+          _ajaxOptions['dataType'] = 'json';
+        }
+
+        return jQuery.ajax(_ajaxOptions);
+      };
+
+      Profile.show = function (profileId, _ajaxOptions) {
+        var data = { 'profile_id': profileId };
+        if (_ajaxOptions === undefined || typeof(_ajaxOptions) != "object") {
+          _ajaxOptions = {};
+        }
+        _ajaxOptions['type'] = "GET";
+        _ajaxOptions['url'] = "/profile/show";
+        _ajaxOptions['data'] = data;
+
+        if (_ajaxOptions['dataType'] === 'undefined') {
+          _ajaxOptions['dataType'] = 'json';
+        }
+
+        return jQuery.ajax(_ajaxOptions);
+      };
+    })();
+  ].strip_whitespace)
+end

data/tests/helper.rb

@@ -0,0 +1,3 @@
+$:.push(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'buttons'
+require 'riot'

data/tests/javascript_tests.rb

@@ -0,0 +1,86 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+include Buttons::Javascript
+
+context "a JsVar" do
+  setup { JsVar.new(:remember_me) }
+  
+  should("convert underscore syntax to JS syntax") { 
+    topic.name 
+  }.equals("rememberMe")
+    
+  should("remember Ruby name") { topic.ruby_name }.equals("remember_me")
+  
+  should("remove leading asterisk") {
+    JsVar.new("*names").name
+  }.equals("names")
+end
+
+context "a JsArg" do
+  setup {
+    arg = Struct.new(:name, :default, :optional?, :foo).new(
+      'arg_name', nil, true, :bar)
+    JsArg.new(arg)
+  }
+  
+  should("convert default to json") { topic.default }.equals(nil.to_json)
+  
+  should("forward all missing methods to arg") { topic.foo }.equals(:bar)
+end
+
+context "a JsFunction" do
+  setup {
+    JsFunction.new(:login, :post, '/login', GetArgs::ArgumentList.new(
+      [ [:username], [:password], [:remember_me, true] ]
+    ))
+  }
+  
+  should("emit JavaScript") {
+    topic.to_js
+  }.equals(
+    %Q[
+      this.login = function (username, password, rememberMe, _ajaxOptions) {
+        if (rememberMe === undefined) { rememberMe = true; }
+        var data = { 'username': username, 'password': password, 'remember_me': rememberMe };
+        if (_ajaxOptions === undefined || typeof(_ajaxOptions) != "object") {
+          _ajaxOptions = {};
+        }
+        _ajaxOptions['type'] = "POST";
+        _ajaxOptions['url'] = "/login";
+        _ajaxOptions['data'] = data; 
+        if (_ajaxOptions['dataType'] === 'undefined') {
+          _ajaxOptions['dataType'] = 'json';
+        }
+        return jQuery.ajax(_ajaxOptions);
+      };
+    ].strip_whitespace
+  )
+end
+
+context "a JsFunction with a star argument" do
+  setup {
+    JsFunction.new(:add_users, :post, '/add_users', GetArgs::ArgumentList.new(
+      [ [:admin_username], [:admin_password], ["*new_users"] ]
+    ))
+  }
+  
+  should("emit JavaScript") {
+    topic.to_js
+  }.equals(
+    %Q[
+      this.addUsers = function (adminUsername, adminPassword, newUsers, _ajaxOptions) {
+        var data = { 'admin_username': adminUsername, 'admin_password': adminPassword, 'new_users[]': newUsers };
+        if (_ajaxOptions === undefined || typeof(_ajaxOptions) != "object") {
+          _ajaxOptions = {};
+        }
+        _ajaxOptions['type'] = "POST";
+        _ajaxOptions['url'] = "/add_users";
+        _ajaxOptions['data'] = data; 
+        if (_ajaxOptions['dataType'] === 'undefined') {
+          _ajaxOptions['dataType'] = 'json';
+        }
+        return jQuery.ajax(_ajaxOptions);
+      };
+    ].strip_whitespace
+  )
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification 
+name: buttons
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Clinton R. Nixon
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-13 00:00:00 -05:00
+default_executable: buttons
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: get_args
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: facets
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rubigen
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: riot
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: |-
+  Buttons is a Rack framework for working with JavaScript-heavy applications. It
+  automatically creates Ajax endpoints for Ruby methods, and creates a set of
+  JavaScript functions to access those endpoints.
+email: crnixon@gmail.com
+executables: 
+- buttons
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- bin/buttons
+- generators/buttons_app/buttons_app_generator.rb
+- generators/buttons_app/templates/Rakefile
+- generators/buttons_app/templates/app/buttons/example_button.rb
+- generators/buttons_app/templates/config.ru
+- generators/buttons_app/templates/public/index.html
+- generators/buttons_app/templates/start.rb
+- lib/buttons.rb
+- lib/buttons/application.rb
+- lib/buttons/button.rb
+- lib/buttons/config.rb
+- lib/buttons/core_ext/string.rb
+- lib/buttons/javascript.rb
+- lib/buttons/javascript/js_arg.rb
+- lib/buttons/javascript/js_function.rb
+- lib/buttons/javascript/js_generator.rb
+- lib/buttons/javascript/js_var.rb
+- lib/buttons/router.rb
+- public/index.txt
+- tasks/test.rake
+- tests/button_tests.rb
+- tests/helper.rb
+- tests/javascript_tests.rb
+has_rdoc: true
+homepage: http://github.com/crnixon/buttons
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Buttons is a Rack framework for working with JavaScript-heavy applications.
+test_files: []
+