view 1.0.0.alpha.3 → 1.0.0.alpha.4

data/lib/view/formatters/image.rb

@@ -1,35 +1,76 @@
 module View
 
+  # Makes an image tag. It also works with paperclip objects.
+  #
+  # With paperclip, it also checks if the file was really uploaded.
+  #
+  # This is actually longer than the regular Rails way. But the added benefit
+  # of this formatter comes from using it inside the table and definition list
+  # formatter.
+  #
+  # @example Without paperclip
+  #
+  #   = view "foo.jpg", :as => :image
+  #
+  # @example With paperclip
+  #
+  #   = view @user.avatar, :as => :image
+  #
+  # @example With options
+  #
+  #   = view @user.avatar, :as => :image, :html => { :class => "meh" }
+  #
+  # @example Inside the definition_list formatter:
+  #
+  #   = definition_list_for @user do |dl|
+  #     = dl.view :name
+  #     = dl.view :avatar, :as => :image
+  #
+  #
   class Image < Formatter
 
-    self.reserved_options = [ :with ]
+    self.default_options = { :html => {} }
 
     def format
       template.image_tag(path, options) if file?
     end
 
+    # Returns the path of the image, based on the path_methods and
+    # path_arguments configuration.
     def path
-      value.send(path_method, *path_arguments)
+      if value.is_a?(String)
+        value
+      else
+        value.send(path_method, *path_arguments)
+      end
+    end
+
+    # The options for the image tag are in the :html option.
+    # You can use the default options to change them.
+    #
+    # @example
+    #
+    #   View::Image.default_options = { :html => { :class => "avatar" } }
+    def options
+      super[:html]
     end
 
     # TODO I'm only guessing here, I don't actually know how other upload gems
     # work, besides paperclip.
     def path_method
-      View.path_methods.find { |method| value.respond_to?(method) }
+      View.configuration.path_methods.find { |method| value.respond_to?(method) }
     end
 
-    # TODO with seems like a stupid name, but style is probably used for
-    # image_tag
     def path_arguments
-      all_options[:with] || View.path_arguments
+      all_options[:style] || View.configuration.path_arguments
     end
 
     def file?
-      value.send(file_method)
+      value.is_a?(String) || value.send(file_method)
     end
 
     def file_method
-      View.file_methods.find { |method| value.respond_to?(method) }
+      View.configuration.file_methods.find { |method| value.respond_to?(method) }
     end
 
   end

data/lib/view/formatters/link.rb

@@ -1,11 +1,36 @@
 module View
 
+  # Makes a link of it.
+  #
+  # The text will be determined by a new formatter.
+  #
+  # You can specify a url with the `:to` option.
+  # You can specify part of the polymorphic_path with `:path`.
+  #
+  # @example
+  #
+  #   = view @post, :as => :link
+  #   -# equal to
+  #   = link_to @post.title, @post
+  #
+  # @example
+  #
+  #   = view @post, :as => :link, :path => :edit
+  #
+  # @example
+  #
+  #   = view @post, :as => :link, :to => "http://example.com"
+  #
+  # @example
+  #
+  #   = view @post, :as => :link, :text => "go to the post"
+  #
   class Link < Formatter
 
     self.reserved_options = [ :to, :path, :text ]
 
     def format
-      template.link_to(format, to, options)
+      template.link_to(text, to, options)
     end
 
     def to
@@ -13,11 +38,11 @@ module View
     end
 
     def automatic_link
-      (all_options[:path] || []) + [ value ]
+      ::Array.wrap(all_options[:path]) + [ value ]
     end
 
-    def as
-      all_options[:text] || :auto
+    def text
+      all_options[:text] || View.format(value, {:as => :auto}, template)
     end
 
   end

data/lib/view/formatters/percentage.rb

@@ -1,8 +1,10 @@
 module View
 
+  # Uses the number_to_percentage helper
   class Percentage < Formatter
 
-    self.allowed_options = [ :precision, :separator, :delimiter ]
+    self.allowed_options = [ :precision, :separator, :delimiter, :locale,
+      :signigicant, :strip_insignificant_zeros ]
 
     def format
       template.number_to_percentage(value, options)

data/lib/view/formatters/phone.rb

@@ -1,5 +1,6 @@
 module View
 
+  # Formats with the number_to_phone helper
   class Phone < Formatter
 
     self.allowed_options = [ :area_code, :delimiter, :extension, :country_code ]

data/lib/view/formatters/precision.rb

@@ -1,8 +1,10 @@
 module View
 
+  # Format it with the number_with_precision helper
   class Precision < Formatter
 
-    self.allowed_options = [ :precision, :separator, :delimiter ]
+    self.allowed_options = [ :precision, :separator, :delimiter,
+      :locale, :significant, :strip_insignificant_zeros ]
 
     def format
       template.number_with_precision(value, options)

data/lib/view/formatters/size.rb

@@ -1,5 +1,12 @@
 module View
 
+  # Formats with number_to_human_size
+  #
+  # @example
+  #
+  #   = view 1999, :as => :size # => "1.95 KB"
+  #
+  # @see http://rubydoc.info/docs/rails/3.0.0/ActionView/Helpers/NumberHelper:number_to_human_size
   class Size < Formatter
 
     self.allowed_options = [ :precision, :separator, :delimiter ]

data/lib/view/formatters/table.rb

@@ -0,0 +1,208 @@
+module View
+
+  # Renders a table.
+  #
+  # It uses a partial, which you can find in the gem under
+  # app/views/shared/_table.html.erb (and haml).
+  #
+  # To change the table layout, you can copy the partial to your own
+  # application.
+  #
+  # You can use a block to format attributes, or you can specify them with the
+  # fields option and trust them to be properly formatted automatically.
+  #
+  # If you don't provide a block or fields, it will try to detect your fields
+  # automatically.
+  #
+  # Use the partial option to render a different table partial.
+  #
+  # When you use :as => :link, it will link to the record, or you specify the
+  # path option. Please see the documentation of View::Link for more information.
+  #
+  # You will need to specify the class option to get a proper table headers
+  # when the collection is empty.
+  #
+  # @example Without a block:
+  #
+  #   = view @posts, :as => :table, :fields => [ :title, :author ]
+  #
+  # @example With a block:
+  #
+  #   = view @posts, :as => :table do |tb|
+  #
+  #     = tb.view :title, :path => :edit
+  #
+  #     = tb.view :author do |formatter|
+  #       = link_to formatter.to_s, user_path(formatter.value)
+  #
+  #     = tb.view :published_at
+  #
+  # @example With a different partial:
+  #
+  #   = view @posts, :as => :table, :partial => "shared/fancy_table"
+  #
+  # @example Change the partial globally:
+  #
+  #   View::Table.partial = "shared/fancy_table"
+  #
+  # @example Linking a column, without passing a block:
+  #
+  #   = view @posts, :as => :table,
+  #     :link => :title, :link_options => { :path => :edit }
+  #
+  class Table < Formatter
+
+    class_inheritable_accessor :partial
+    self.partial = 'shared/table'
+
+    # This will add the th and td tags.
+    #
+    # @param [Symbol] attribute The name of the attribute to be called on +value+
+    # @param [Hash] options These will be delegated to the formatting of the
+    #   attribute's value.
+    # @yield [formatter] The block will be used for formatting the attribute's
+    #   value
+    def view(attribute, options = {}, &block)
+      columns << Column.new(attribute, options, block, self)
+      nil
+    end
+
+    # The columns defined
+    # @return [Array]
+    def columns
+      @columns ||= []
+    end
+
+    # Iterates over the collection and yields rows.
+    # @yield [Row]
+    def each
+      value.each_with_index do |resource, index|
+        yield Row.new(resource, self, index)
+      end
+    end
+
+    def resource_class
+      all_options[:class] || value.first.class
+    end
+
+    protected
+
+    # FIXME duplication with definition_list formatter
+    def format
+      unless block
+        fields.inject("".html_safe) do |html, field|
+          html << view(field)
+        end
+      end
+    end
+
+    def fields
+      all_options[:fields] || all_fields
+    end
+
+    def partial
+      all_options[:partial] || self.class.partial
+    end
+
+    private
+
+    def all_fields
+      resource_class.respond_to?(:column_names) ? resource_class.column_names : []
+    end
+
+    def format!
+      super
+      template.render(partial, :table => self)
+    end
+
+    class Column < Struct.new(:attribute, :options, :block, :table)
+
+      delegate :resource_class, :to => :table
+
+      # Returns the name of the column.
+      # If the record extends ActiveModel::Translations, it will use
+      # human_attribute_name, which gets the translations from I18n. Otherwise
+      # it will just titleize the name of the attribute.
+      def name
+        if resource_class.respond_to?(:human_attribute_name)
+          resource_class.human_attribute_name(attribute)
+        else
+          attribute.to_s.titleize
+        end
+      end
+
+      # Html options to add to your td and th tags.
+      # @return [Hash]
+      def html_options
+        { :class => attribute }
+      end
+
+    end
+
+    class Row < Struct.new(:resource, :table, :index)
+
+      # Loops through all columns and yields cells.
+      #
+      # @yield [Cell]
+      def each
+        table.columns.each do |column|
+          yield Cell.new(self, column)
+        end
+      end
+
+    end
+
+    class Cell < Struct.new(:row, :column)
+
+      delegate :resource, :table, :to => :row
+      delegate :template, :to => :table
+      delegate :attribute, :block, :options, :html_options, :to => :column
+
+      # Returns the formatted value for the cell
+      def value
+        View.format(value_or_resource, options, template, &block)
+      end
+
+      private
+
+      def value_or_resource
+        link? ? resource : original_value
+      end
+
+      def original_value
+        resource.send(attribute)
+      end
+
+      def all_options
+        column.options
+      end
+
+      def options
+        link_options.merge(all_options)
+      end
+
+      def link?
+        has_link_options? || global_link_column?
+      end
+
+      def global_link_column?
+        table.all_options[:link].to_s == attribute.to_s
+      end
+
+      def has_link_options?
+        all_options[:as] == :link || (!all_options[:as] && all_options[:path])
+      end
+
+      def link_options
+        link? ? table_link_options.merge(:text => original_value, :as => :link) : {}
+      end
+
+      def table_link_options
+        table.all_options[:link_options] || {}
+      end
+
+    end
+
+  end
+
+end

data/lib/view/helper.rb

@@ -2,10 +2,37 @@ module View
 
   module Helper
 
+    # Use the formatter straight from the view
     def view(value, options = {}, &block)
       ::View.format(value, options, self, &block)
     end
 
+    # Shortcut for rendering tables
+    def table_for(value, options = {}, &block)
+      view(value, options.merge(:as => :table), &block)
+    end
+
+    # If you're using something like InheritedResource, this will automatically
+    # set the table for the current collection, so you'll only need to do:
+    #
+    #   = table
+    def table(options = {}, &block)
+      table_for(collection, options.merge(:class => resource_class), &block)
+    end
+
+    # Shortcut for definition_lists
+    def definition_list_for(value, options = {}, &block)
+      view(value, options.merge(:as => :definition_list), &block)
+    end
+
+    # If you're using something like InheritedResource, this will automatically
+    # set the definition_list for the current resource, so you'll only need to do:
+    #
+    #   = definition_list
+    def definition_list(options = {}, &block)
+      definition_list_for(resource, options, &block)
+    end
+
   end
 
 end

data/lib/view/railtie.rb

@@ -1,6 +1,6 @@
 module View
 
-  class Railtie < ::Rails::Railtie
+  class Railtie < ::Rails::Engine
 
     ActiveSupport.on_load(:after_initialize) do
       ActiveSupport.on_load(:action_view) do

data/lib/view/version.rb

@@ -1,3 +1,3 @@
 module View
-  VERSION = '1.0.0.alpha.3'
+  VERSION = '1.0.0.alpha.4'
 end

data/lib/view.rb

@@ -1,61 +1,9 @@
 module View
 
-  autoload :Formatter, 'view/formatter'
-  autoload :Helper,    'view/helper'
-  autoload :VERSION,   'view/version'
-
-  class << self
-    # Used by the guess filter, these are the methods used to format an object.
-    # It will use the first method that the object responds to.
-    attr_accessor :guessing_methods
-
-    # To determine if something is an uploaded image, it checks
-    # to see whether it responds to one of these methods.
-    attr_accessor :file_methods
-
-    # To show an image, it will use one of these methods to get the src
-    # attribute.
-    attr_accessor :path_methods
-
-    # You can set a default argument for rendering images, like the style or size
-    # of the image. It will be passed to one of the path_methods.
-    attr_accessor :path_arguments
-
-    # Which formatter will be used by default. The default is auto, which does
-    # all sorts of interesting stuff to see what to do.
-    attr_accessor :default_formatter
-
-    # The auto formatter will choose this formatter by default when your value is
-    # an array (or really, something that responds to +each+).
-    attr_accessor :default_list_formatter
-
-    # Holds a list of formatters. It will be filled automatically by inheriting
-    # from View::Formatter.
-    attr_accessor :formatters
-
-    # Shorthand for configuring this gem.
-    #
-    # @example In +config/initializers/view.rb+
-    #
-    #   View.configure do |config|
-    #     config.default_formatter = :self
-    #   end
-    #
-    # @yield [config] The View module
-    def configure
-      yield self
-    end
-
-  end
-
-  self.guessing_methods       = %w|to_label display_name full_name name title
-                                   username login value to_s|
-  self.file_methods           = %w|mounted_as file? public_filename|
-  self.path_methods           = %w|mounted_as url public_filename|
-  self.path_arguments         = []
-  self.default_formatter      = :auto
-  self.default_list_formatter = :sentence
-
+  autoload :Formatter,     'view/formatter'
+  autoload :Helper,        'view/helper'
+  autoload :Configuration, 'view/configuration'
+  autoload :VERSION,       'view/version'
 
   # This is the main method to use this gem. Any formatting from outside this
   # gem should be done through this method (notwithstanding custom formatters).
@@ -91,6 +39,30 @@ module View
     Formatter.format(value, options, template, &block)
   end
 
+  # Access to the configuration object
+  # @return [Configuration]
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  # Configures this gem
+  #
+  # @example config/initializers/view.rb
+  #
+  #   View.configure do |config|
+  #     config.default_formatter = :self
+  #   end
+  #
+  # @yield [config] The configuration instance
+  def self.configure
+    yield configuration
+  end
+
+  # Contains a list of registered formatters
+  def self.formatters
+    @formatters ||= []
+  end
+
 end
 
 require 'view/railtie'

data/spec/spec_helper.rb

@@ -1,22 +1,63 @@
 require "rubygems"
 require "bundler/setup"
 Bundler.setup :default
+
 require 'rails'
 require 'action_view'
+
+# Needed to make the capture helper work in tests
+require 'action_view/template/handlers/erb'
+
+# We need them all
+require 'active_support/core_ext'
+
 require 'rspec'
 require 'view'
 
 module WithTranslation
+
+  # Temporarily use a clean 'test'-locale
+  #
+  # with_translation :foo => 'bar' do
+  #   I18n.t(:foo).should == 'bar'
+  # end
+  # I18n.t(:foo).should_not == 'bar'
   def with_translation(keys)
     locale = I18n.locale
-    I18n.backend.store_translations(:test, keys)
     I18n.locale = :test
+    I18n.backend.reload!
+    I18n.backend.store_translations(:test, keys)
     yield
   ensure
+    I18n.backend.reload!
     I18n.locale = locale
   end
+
 end
 
+# Make a fake Rails application, to test rendering partials
+class RailsApplication
+
+  def root
+    File.expand_path('../../', __FILE__)
+  end
+
+  def config
+    Struct.new(:root, :cache_classes, :assets_dir).new(root, false, root)
+  end
+
+  # This runs before every spec
+  def before(context)
+    Rails.stub(:application).and_return(self)
+    ActionView::Template.register_default_template_handler :erb, ActionView::Template::Handlers::ERB
+    context.helper.view_paths = view_paths
+  end
+
+  def view_paths
+    [ File.join(root, 'app', 'views') ]
+  end
+
+end
 
 module TemplateHelper
 
@@ -25,11 +66,13 @@ module TemplateHelper
     @helper ||= Template.new
   end
 
-  class Template
-
-    include ActionView::Helpers
+  # emulate a Rails view
+  class Template < ActionView::Base
     include View::Helper
 
+    def config
+      Struct.new(:asset_path, :asset_host).new('/', '/')
+    end
   end
 
 end
@@ -37,4 +80,9 @@ end
 RSpec.configure do |config|
   config.include(WithTranslation)
   config.include(TemplateHelper)
+  config.before do
+    RailsApplication.new.before(self)
+  end
+  # Uncomment to see the big backtrace
+  # config.backtrace_clean_patterns = []
 end

data/spec/view/configuration_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe View::Configuration do
+
+  it { should respond_to(:guessing_methods) }
+  it { should respond_to(:file_methods) }
+  it { should respond_to(:path_methods) }
+  it { should respond_to(:default_formatter) }
+  it { should respond_to(:default_list_formatter) }
+
+end

data/spec/view/formatters/currency_spec.rb

@@ -3,15 +3,11 @@ require 'spec_helper'
 
 describe "Currency formatter" do
 
-  before do
-    helper.stub(:number_to_currency).and_return("called")
-  end
-
   it "calls number_to_currency" do
-    helper.view(19.99, :as => :currency).should == "called"
+    helper.view(19.99, :as => :currency).should == "$19.99"
   end
 
-  it "allowes no other options" do
+  it "allows no other options" do
     helper.should_receive(:number_to_currency).with(19.99, :unit => "£")
     helper.view(19.99, :as => :currency, :unit => "£", :foo => "bar")
   end