BrianTheCoder-ratpack 0.2.0 → 0.2.2

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "ratpack"
+    gem.summary = %Q{A collection of helpers I wanted for sinatra, thought I'd share}
+    gem.email = "wbsmith83@gmail.com"
+    gem.homepage = "http://github.com/BrianTheCoder/ratpack"
+    gem.authors = ["brianthecoder"]
+
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = false
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "Rat Pack #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :minor: 2
-:patch: 0
+:patch: 2
 :major: 0

data/lib/ratpack.rb

@@ -2,7 +2,7 @@ require 'sinatra/base'
 require 'extlib'
 
 module RatPack
-  VERSION = '0.0.1'
+  VERSION = '0.2.2'
   LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
   PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
 
@@ -22,9 +22,9 @@ module RatPack
     dir ||= ::File.basename(fname, '.*')
     search_me = ::File.expand_path(
         ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
-
     Dir.glob(search_me).sort.each {|rb| require rb}
   end
-end  # module VelvetRope
+end  # module RatPack
 
-RatPack.require_all_libs_relative_to(__FILE__)
+RatPack.require_all_libs_relative_to(__FILE__)
+require File.join(RatPack::LIBPATH,'sinatra','ratpack')

data/lib/ratpack/core_ext/hash.rb

@@ -0,0 +1,16 @@
+class Hash
+  # Returns the value of self for each argument and deletes those entries.
+  #
+  # ==== Parameters
+  # *args:: the keys whose values should be extracted and deleted.
+  #
+  # ==== Returns
+  # Array[Object]:: The values of the provided arguments in corresponding order.
+  #
+  # :api: public
+  def extract!(*args)
+    args.map do |arg|
+      self.delete(arg)
+    end
+  end
+end

data/lib/ratpack/forms.rb

@@ -1,126 +1,83 @@
 module RatPack
   module Forms
-    # def error_messages_for(obj = nil, opts = {})
-    #   current_form_context.error_messages_for(obj, opts[:error_class] || "error", 
-    #     opts[:build_li] || "<li>%s</li>", 
-    #     opts[:header] || "<h2>Form submission failed because of %s problem%s</h2>",
-    #     opts.key?(:before) ? opts[:before] : true)
-    # end
+    def error_messages_for(obj = nil, opts = {})
+      return unless obj.respond_to?(:errors)
+      html = tag(:h2, "Form submission failed be cause of #{obj.errors.size} #{pluralize("error",obj.errors.size)}")
+      obj.errors.each do |field,msg|
+        html << tag(:li,msg)
+      end
+    end
     
     %w(text password hidden file).each do |kind|
       self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
         def #{kind}_field(attrs)
-          update_unbound_controls(attrs, "#{kind}")
-          label = "#{kind}" == "hidden" ? "" : unbound_label(attrs)
-          label + self_closing_tag(:input, {:type => "#{kind}"}.merge(attrs))
+          attrs[:class] = "text" if %w(text password).include?("#{kind}")         
+          closed_form_field(:input, {:type => "#{kind}"}.merge(attrs))
         end
       RUBY
     end
-
-    def check_box(attrs)
-      update_unbound_controls(attrs, "checkbox")
-      if attrs.delete(:boolean)
-        on, off = attrs.delete(:on), attrs.delete(:off)
-        unbound_hidden_field(:name => attrs[:name], :value => off) <<
-          self_closing_tag(:input, {:type => "checkbox", :value => on}.merge(attrs)) + unbound_label(attrs)
-      else
-        self_closing_tag(:input, {:type => "checkbox"}.merge(attrs)) + unbound_label(attrs)
-      end
+    
+    def text_area(attrs = {})
+      form_field(:textarea, attrs.delete(:value) || "", attrs)
     end
-
+    
+    def button(contents, attrs = {})
+      form_field(:button, contents, attrs)
+    end
+    
     def radio_button(attrs)
-      update_unbound_controls(attrs, "radio")
-      self_closing_tag(:input, {:type => "radio"}.merge(attrs)) + unbound_label(attrs)
+      closed_form_field(:input, {:type => "radio"}.merge(attrs))
     end
     
     def radio_group(arr, attrs = {})
       arr.map do |ind_attrs|
         ind_attrs = {:value => ind_attrs} unless ind_attrs.is_a?(Hash)
         joined = attrs.merge(ind_attrs)
-        joined.merge!(:label => joined[:label] || joined[:value])
         radio_button(joined)
       end.join
     end
     
-    def text_area(contents, attrs)
-      update_unbound_controls(attrs, "text_area")
-      unbound_label(attrs) + tag(:textarea, contents, attrs)
-    end
-    
-    def label(contents, attrs = {})
-      if contents
-        if contents.is_a?(Hash)
-          label_attrs = contents
-          contents = label_attrs.delete(:title)
-        else
-          label_attrs = attrs
-        end
-        tag(:label, contents, label_attrs)
+    def check_box(attrs)
+      if attrs.delete(:boolean)
+        on, off = attrs.delete(:on), attrs.delete(:off)
+        hidden_field(:name => attrs[:name], :value => off) <<
+          closed_form_field(:input, {:type => "checkbox", :value => on}.merge(attrs))
       else
-        ""
+        closed_form_field(:input, {:type => "checkbox"}.merge(attrs))
       end
     end
     
     def select(attrs = {})
-      update_unbound_controls(attrs, "select")
       attrs[:name] << "[]" if attrs[:multiple] && !(attrs[:name] =~ /\[\]$/)
-      tag(:select, options_for(attrs), attrs)
+      form_field(:select, options_for(attrs), attrs)
     end
     
-    def button(contents, attrs)
-      update_unbound_controls(attrs, "button")
-      tag(:button, contents, attrs)
-    end
-
-    def submit(value, attrs)
+    def submit(value, attrs = {})
       attrs[:type]  ||= "submit"
       attrs[:name]  ||= "submit"
       attrs[:value] ||= value
-      update_unbound_controls(attrs, "submit")
-      self_closing_tag(:input, attrs)
+      closed_form_field(:input, attrs)
     end
     
-    # def form(attrs = {}, &blk)
-    #   captured = @origin.capture(&blk)
-    #   fake_method_tag = process_form_attrs(attrs)
-    #   tag(:form, fake_method_tag + captured, attrs)
-    # end
-    # 
-    # def fieldset(attrs, &blk)
-    #   captured = @origin.capture(&blk)
-    #   legend = (l_attr = attrs.delete(:legend)) ? tag(:legend, l_attr) : ""
-    #   tag(:fieldset, legend + captured, attrs)
-    # end
-    
     private
-
-    def process_form_attrs(attrs)
-      method = attrs[:method] || :post
-      attrs[:enctype] = "multipart/form-data" if attrs.delete(:multipart) || @multipart
-      method == :post || method == :get ? "" : fake_out_method(attrs, method)
+    
+    def form_field(type, content, attrs)
+      attrs[:id] = attrs[:name] unless attrs.has_key?(:id)
+      build_field(attrs) + tag(type, content, attrs)
     end
-
-    # This can be overridden to use another method to fake out methods
-    def fake_out_method(attrs, method)
-      self_closing_tag(:input, :type => "hidden", :name => "_method", :value => method)
+    
+    def closed_form_field(type, attrs)
+      attrs[:id] = attrs[:name] unless attrs.has_key?(:id)
+      build_field(attrs) + self_closing_tag(type, attrs)
     end
     
-    def update_unbound_controls(attrs, type)
-      case type
-      when "checkbox"
-        update_unbound_check_box(attrs)
-      when "radio"
-        update_unbound_radio_button(attrs)
-      when "file"
-        @multipart = true
-      when "text","password"
-        attrs[:class] = "text"
-      end
-
-      attrs[:disabled] ? attrs[:disabled] = "disabled" : attrs.delete(:disabled)
+    def build_field(attrs)
+      label = attrs.has_key?(:label) ? build_label(attrs) : ""
+      hint = attrs.has_key?(:hint) ? tag(:div,attrs.delete(:hint), :class => "hint") : ""
+      label + hint
     end
     
-    def unbound_label(attrs = {})
+    def build_label(attrs)
       if attrs[:id]
         label_attrs = {:for => attrs[:id]}
       elsif attrs[:name]
@@ -128,64 +85,32 @@ module RatPack
       else
         label_attrs = {}
       end
-
-      label_option = attrs.delete(:label)
-      if label_option.is_a? Hash
-        label(label_attrs.merge(label_option))
-      else
-        label(label_option, label_attrs)
-      end
-    end
-    
-    def update_unbound_check_box(attrs)
-      boolean = attrs[:boolean] || (attrs[:on] && attrs[:off]) ? true : false
-
-      case
-      when attrs.key?(:on) ^ attrs.key?(:off)
-        raise ArgumentError, ":on and :off must be specified together"
-      when (attrs[:boolean] == false) && (attrs.key?(:on))
-        raise ArgumentError, ":boolean => false cannot be used with :on and :off"
-      when boolean && attrs.key?(:value)
-        raise ArgumentError, ":value can't be used with a boolean checkbox"
-      end
-
-      if attrs[:boolean] = boolean
-        attrs[:on] ||= "1"; attrs[:off] ||= "0"
-      end
-
-      attrs[:checked] = "checked" if attrs.delete(:checked)
-    end
-
-    def update_unbound_radio_button(attrs)
-      attrs[:checked] = "checked" if attrs.delete(:checked)
+      tag(:label, attrs.delete(:label), label_attrs)
     end
     
     def options_for(attrs)
       blank, prompt = attrs.delete(:include_blank), attrs.delete(:prompt)
       b = blank || prompt ? tag(:option, prompt || "", :value => "") : ""
-
       # yank out the options attrs
-      collection, selected, text_method, value_method = 
-        attrs.extract!(:collection, :selected, :text_method, :value_method)
-
+      collection, selected, text_method, value_method = attrs.extract!(:collection, :selected, :text_method, :value_method)
       # if the collection is a Hash, optgroups are a-coming
       if collection.is_a?(Hash)
         ([b] + collection.map do |g,col|
-          tag(:optgroup, options(col, text_method, value_method, selected), :label => g)
+          tag(:optgroup, select_options(col, text_method, value_method, selected), :label => g)
         end).join
       else
-        options(collection || [], text_method, value_method, selected, b)
+        select_options(collection || [], text_method, value_method, selected, b)
       end
     end
-
-    def options(col, text_meth, value_meth, sel, b = nil)
+    
+    def select_options(col, text_meth, value_meth, sel, b = nil)
       ([b] + col.map do |item|
         text_meth = text_meth && item.respond_to?(text_meth) ? text_meth : :last
         value_meth = value_meth && item.respond_to?(value_meth) ? value_meth : :first
-
+    
         text  = item.is_a?(String) ? item : item.send(text_meth)
         value = item.is_a?(String) ? item : item.send(value_meth)
-
+    
         option_attrs = {:value => value}
         if sel.is_a?(Array)
           option_attrs.merge!(:selected => "selected") if value.in? sel

data/lib/ratpack/html_helpers.rb

@@ -1,5 +1,9 @@
 module RatPack
-  module HtmlHelpers    
+  module HtmlHelpers  
+    def pluralize(str,num)
+      num.to_i > 1 ? str.plural : str.singular
+    end
+      
     def link_to(name, url, options = {})
       defaults = {:href => url}
       tag(:a,name,defaults.merge(options))

data/lib/ratpack/routes.rb

@@ -7,6 +7,6 @@ module RatPack
                       else
                         []
                       end
-      end
+    end
   end
 end

data/lib/ratpack/tag.rb

@@ -2,7 +2,7 @@ module RatPack
   module Tag    
     def tag(name, contents = nil, attrs = {}, &block)
       attrs, contents = contents, nil if contents.is_a?(Hash)
-      contents = capture(&block) if block_given?
+      # contents = capture(&block) if block_given?
       open_tag(name, attrs) + contents.to_s + close_tag(name)
     end
 

data/lib/sinatra/ratpack.rb

@@ -1,17 +1,12 @@
 module Sinatra
-  module Ratpack
-    module Helpers
-      include RatPack::Tag
-      include RatPack::HtmlHelpers  
-      include RatPack::Forms
-      include RatPack::Routes
-    end
-    
+  module RatPack
     def self.registered(app)
-      puts 'loading ratpack'
-      app.helpers Helpers
+      app.helpers ::RatPack::Tag
+      app.helpers ::RatPack::HtmlHelpers
+      app.helpers ::RatPack::Routes
+      app.helpers ::RatPack::Forms
     end
   end
   
-  register Ratpack
+  register RatPack
 end # Sinatra

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: BrianTheCoder-ratpack
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.2.2
 platform: ruby
 authors: 
 - brianthecoder
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-07 00:00:00 -07:00
+date: 2009-04-12 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -20,27 +20,26 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-- README.rdoc
 - LICENSE
+- README.rdoc
 files: 
+- LICENSE
 - README.rdoc
+- Rakefile
 - VERSION.yml
-- lib/ratpack
+- lib/ratpack.rb
+- lib/ratpack/core_ext/hash.rb
 - lib/ratpack/forms.rb
 - lib/ratpack/html_helpers.rb
 - lib/ratpack/routes.rb
 - lib/ratpack/tag.rb
-- lib/ratpack.rb
-- lib/sinatra
 - lib/sinatra/ratpack.rb
 - test/ratpack_test.rb
 - test/test_helper.rb
-- LICENSE
 has_rdoc: true
 homepage: http://github.com/BrianTheCoder/ratpack
 post_install_message: 
 rdoc_options: 
-- --inline-source
 - --charset=UTF-8
 require_paths: 
 - lib
@@ -63,5 +62,6 @@ rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: A collection of helpers I wanted for sinatra, thought I'd share
-test_files: []
-
+test_files: 
+- test/ratpack_test.rb
+- test/test_helper.rb