representations 0.0.2 → 0.0.3

data/README.markdown

@@ -1,10 +1,10 @@
-# Resouce Representations
+# Representations
 
 Rails helpers, including form builders are great to allow rapid development of applications and views.
 
 They are procedural in nature and have hard time to adapt to complex models. They also live in a single namespace making it difficult to find which helpers apply to which models.
 
-Resource representations change syntax to object oriented and model specific.
+Representations change syntax to object oriented and model specific.
 
 ## Example usage
 
@@ -27,7 +27,7 @@ Rails helpers:
             = f.label(:eye_color_blue, "Blue")
       = f.submit("Submit")
 
-Resource Representations
+Representations:
 
     - r(user).form do
       login:
@@ -42,10 +42,24 @@ Resource Representations
         = p.last_name.text_field
         = p.eye_color.radio_button('blue')
         = p.eye_color.radio_button_label('blue', 'Blue')
-###Extensions
+##Extensions
 Representations can be altered. For example to add new method DefaultRepresentation create file app/representations/default_representation.rb with the content:
-module DefaultRepresentation
-  def new_method
-    some code
-  end
-end
+    module DefaultRepresentation
+        def new_method
+            some code
+        end
+    end
+##Nested attributes
+    - user.children.each do |child|
+        = child.name.label
+        = child.name.text_field
+        = child.delete_checkbox
+        = child.delete_checkbox_label
+Or even:
+    - user.children.build do |child|
+        = child.name.label
+        = child.name.text_field
+## Automatic wrapping
+Create file config/initializers/representations.rb
+    Representations.enable_automatic_wrapping = true
+if you want Representations to automatically wrap variables from the controller

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.3

data/init.rb

@@ -2,3 +2,4 @@ require 'view_helpers'
 require 'representations'
 ActionView::Base.send :include, Representations::ViewHelpers
 ActiveSupport::Dependencies.load_paths << "#{RAILS_ROOT}/app/representations/"
+

data/lib/representations.rb

@@ -1,33 +1,48 @@
 module Representations
+  #Enables automatic wrapping
+  #TODO should be disabled until module unloading will be fixed
+  def self.enable_automatic_wrapping=(value)
+    if value
+      ActionView::Base.class_eval do 
+       def instance_variable_set_with_r(symbol, obj)
+         load ActiveSupport::Dependencies.search_for_file('representations.rb')
+         obj = Representations.representation_for(obj, self, symbol.to_s[1..-1]) if obj.is_a?(ActiveRecord::Base)
+         instance_variable_set_without_r(symbol, obj) #call to the original method
+       end
+       self.alias_method_chain :instance_variable_set, :r
+     end
+    end
+  end
   #Creates Representation for object passed as a paremeter, type of the representation
   #depends on the type of the object
   def representation_for(object, template, name=nil, parent=nil)
-    representation_class = if object.is_a?(ActiveRecord::Base)
-      ActiveRecordRepresentation
-    else
-      "Representations::#{object.class.to_s.demodulize}Representation".constantize rescue DefaultRepresentation
-    end
+    representation_class =
+      begin
+        if object.is_a?(ActiveRecord::Base)
+          ActiveRecordRepresentation
+        else
+          "Representations::#{object.class.to_s.demodulize}Representation".constantize 
+        end
+      rescue 
+        AssociationsRepresentation if object.ancestors.include?(ActiveRecord::Associations) rescue DefaultRepresentation
+      end
     representation_class.new(object, template, name, parent)
   end
 
   module_function :representation_for
-
   class Representation 
 
     #value - object for which the representation is created 
-    #template - template view
+    #template - template view (needed because some ActionView::Base methods are private)
     #name - the actuall name of the method that was called on the object's parent that is being initialize
+    #parent - Representation object which contains the object that is being initialize
     def initialize(value, template, name=nil, parent=nil)
       @value = value
       @name = name
       @template = template
       @parent = parent
-      begin #extend class if user provided file for customisation
-        self.send(:extend, "::#{self.class.to_s.demodulize}".constantize) 
-      rescue
-        puts "::#{self.class.to_s.demodulize} not defined"
-        #procced then (user did not provide file for customisation of the class)
-      end
+      #extend class if user provided appropriate file (look at the files app/representations/*_representation.rb)
+      self.send(:extend, "::#{self.class.to_s.demodulize}".constantize) rescue Rails.logger.info "No extension defined for ::#{self.class.to_s}"
      end
 
     def id
@@ -40,7 +55,7 @@ module Representations
     #returns html label tag for the representation
     def label(value = nil, html_options = {})
       tree = get_parents_tree
-      for_attr_value = tree.join('_')
+      for_attr_value = tree.collect{ |x| x[0] }.join('_')
       tags = get_tags(html_options, {:for => for_attr_value})
       value = ERB::Util::h(@name.humanize) if value.nil?
       %Q{<label #{tags}>#{value}</label>}
@@ -51,31 +66,40 @@ module Representations
     def with_block(&block)
       yield self if block_given?
     end
-    #Returns array of Represantation objects which are linked together by @parent field
+    #Returns two dimensional array based on the tree of the Represantation objects which are linked together by the @parent field
+    #First element of the array consists of Representation's @name and the second of Representation's class
     def get_parents_tree
-      children_names = Array.new
+      tree = Array.new
+      tree[0] = []
+      tree[0][0] = @name
+      tree[0][1] = self.class
       parent = @parent
-      children_names.push(@name)
-      while parent.nil? == false do #iterate parent tree
-        children_names.push(parent.instance_variable_get(:@name))
+      while parent do #iterate parent tree
+        array = []
+        array[0] = parent.instance_variable_get(:@name)
+        array[1] = parent.class
+        tree.unshift(array)
         parent = parent.instance_variable_get(:@parent)
-      end #children_names now looks something like that [name, profile, user]
-      children_names.reverse!
+      end
+      tree #tree now looks something like this [['user', ActiverRecordRepresentation], ['nick', DefaultRepresentation]]
     end
-    #Creates value of the html name attribute according to passed tree of objects
+    #Creates value of the html name attribute according to the passed tree 
     def get_html_name_attribute_value(tree)
-      root_name = tree.delete_at(0)
-      name = Array.new
-      tree.each_index do |idx| 
-        name[idx] =  if idx < tree.length - 1
-             "[" + tree[idx] + "_attributes]"
-                     else
-             "[" + tree[idx] + "]"
-                     end
+      first = tree.delete_at(0)
+      root_name = first[0]
+      name = []
+      prev = nil
+      tree.each do |elem| 
+        if elem[1] == DefaultRepresentation || elem[1] == TimeWithZoneRepresentation || prev == AssociationsRepresentation
+          name.push "[" + elem[0] + "]"
+        else
+          name.push "[" + elem[0] + "_attributes]"
+        end
+        prev = elem[1]
       end
       name.unshift(root_name)
     end
-    #Returns string created by merging two hashes of html options passed as an argument
+    #Returns string created by merging two hashes of html options passed as the arguments
     def get_tags(user_options, base_options)
       options = base_options.merge(user_options)
       options.stringify_keys!
@@ -85,14 +109,11 @@ module Representations
   end
 
   class DefaultRepresentation < Representation
-    #require_dependency "#{RAILS_ROOT}/app/representations/default_representation"
-    #require "#{RAILS_ROOT}/app/representations/default_representation"
-    #include DefaultRepresentationExt
     #not tested in the view
     #Returns string with html check box tag
     def check_box(checked_value = "1", unchecked_value = "0", html_options = {})
       tree = get_parents_tree
-      id_attr_value = tree.join('_') 
+      id_attr_value = tree.collect{ |x| x[0] }.join('_') 
       name_attr_value = get_html_name_attribute_value(tree)
       tags = get_tags(html_options, {:value => checked_value, :id => id_attr_value, :name=>name_attr_value})
       %Q{<input type="checkbox" #{tags}/>\n<input type="hidden" value="#{unchecked_value}" id="#{id_attr_value}" name="#{name_attr_value}"/>}
@@ -101,7 +122,7 @@ module Representations
     #Returns string with html file field tag
     def file_field(html_options = {})
       tree = get_parents_tree
-      id_attr_value = tree.join('_') 
+      id_attr_value = tree.collect{ |x| x[0] }.join('_') 
       tags = get_tags(html_options, {:value => to_s, :id => id_attr_value, :name=>get_html_name_attribute_value(tree)})
       %Q{<input type="file" #{tags}/>}
     end
@@ -109,36 +130,35 @@ module Representations
     #Returns string with html hidden input tag
     def hidden_field(html_options = {})
       tree = get_parents_tree
-      id_attr_value = tree.join('_') 
+      id_attr_value = tree.collect{ |x| x[0] }.join('_') 
       tags = get_tags(html_options, {:value => to_s, :id => id_attr_value, :name=>get_html_name_attribute_value(tree)})
       %Q{<input type="hidden" #{tags}/>}
     end
     #Returns string with html text input tag
     def text_field(html_options = {})
-      puts "#{RAILS_ROOT}/app/representations/default_representation"
       tree = get_parents_tree
-      id_attr_value = tree.join('_') 
+      id_attr_value = tree.collect{ |x| x[0] }.join('_') 
       tags = get_tags(html_options, {:value => to_s, :id => id_attr_value, :name=>get_html_name_attribute_value(tree)})
       %Q{<input type="text" #{tags}/>}
     end
     #Returns string with html text area tag
     def text_area(html_options = {})
       tree = get_parents_tree
-      id_attr_value = tree.join('_') 
+      id_attr_value = tree.collect{ |x| x[0] }.join('_') 
       tags = get_tags(html_options, {:id => id_attr_value, :name => get_html_name_attribute_value(tree)})
       %Q{<textarea #{tags}>\n#{to_s}\n</textarea>}
     end
     #Returns string with html password tag
     def password_field(html_options = {})
       tree = get_parents_tree
-      id_attr_value = tree.join('_') 
+      id_attr_value = tree.collect{ |x| x[0] }.join('_') 
       tags = get_tags(html_options, {:value => to_s, :id => id_attr_value, :name=>get_html_name_attribute_value(tree)})
       %Q{<input type="password" #{tags}/>}
     end
     #Returns string with html radio button tag
     def radio_button(value, html_options = {})
       tree = get_parents_tree
-      id_attr_value = tree.join('_') + "_#{value}"
+      id_attr_value = tree.collect{ |x| x[0] }.join('_') + "_#{value}"
       name_attr_value = get_html_name_attribute_value(tree)
       tags = get_tags(html_options, {:name => name_attr_value, :value=>value, :id=>id_attr_value, :checked=>"#{@value.capitalize==value.capitalize}"})
       %Q{<input type="radio" #{tags}/>}
@@ -146,68 +166,115 @@ module Representations
     #Returns string with html label tag with for attribute set to the radio button of this object
     def radio_button_label(radio_button_value, value = nil, html_options = {})
       tree = get_parents_tree
-      for_attr_value = tree.join('_') + "_#{radio_button_value}"
+      for_attr_value = tree.collect{ |x| x[0] }.join('_') + "_#{radio_button_value}"
       value = radio_button_value.capitalize if value.nil?
       tags = get_tags(html_options, {:for => for_attr_value})
       %Q{<label #{tags}>#{ERB::Util::h(value)}</label>}
       end
+  end
+  #Representation for objects which are nil
+  class NilClassRepresentation < Representation
+    #Returns self so the calls:
+    #nil_object.not_defined_method.another_not_defined_method
+    #want raise an error
+    def method_missing(method_name, *args)
+      return self
     end
-    #Representation for objects which are nil
-    class NilClassRepresentation < Representation
-      #Returns self so the calls:
-      #nil_object.not_defined_method.another_not_defined_method
-      #want raise an error
-      def method_missing(method_name, *args)
-        return self
-      end
-      #Passed block shouldn't be called
-      def with_block(&block)
-      end
-      #Returns blank string
-      def to_s
-        return ''
-      end
+    #Passed block shouldn't be called
+    def with_block(&block)
     end
-    #Representation for ActiveRecord::Base object's
-    class ActiveRecordRepresentation < Representation
-      #Form builder
-      def form(&block)
-        raise "You need to provide block to form representation" unless block_given?
-        content = @template.capture(self, &block)
-        @template.concat(@template.form_tag(@value))
-        @template.concat(content)
-        @template.concat("</form>")
-        self
-      end
-      #Forwards ActiveRecord invocation and wraps result in apropriate Representation
-      #Suppose that User extends ActiveRecord::Base :
-      #ar_user = User.new
-      #ar_user.nick = 'foo'
-      #user = r(ar_user) #user is now ActiveRecordRepresentation
-      #user.nick.text_field #method_missing will be called on user with method_name = 'nick' in which new method for user will be created and will be called. The newly created method will create a new DefaultRepresentation with @value set to the string 'foo'. Next the text_field will be called on the newly created DefauleRepresentation
-      #
-      def method_missing(method_name, *args, &block)
-        method = <<-EOF
+    #Returns blank string
+    def to_s
+      return ''
+    end
+  end
+  #Representation for ActiveRecord::Base object's
+  class ActiveRecordRepresentation < Representation
+    #Form builder
+    def form(&block)
+      raise "You need to provide block to form representation" unless block_given?
+      content = @template.capture(self, &block)
+      @template.concat(@template.form_tag(@value))
+      @template.concat(content)
+      @template.concat("</form>")
+      self
+    end
+    #Forwards ActiveRecord invocation and wraps result in appropriate Representation
+    #Suppose that User extends ActiveRecord::Base :
+    #ar_user = User.new
+    #ar_user.nick = 'foo'
+    #user = r(ar_user) #user is now ActiveRecordRepresentation
+    #user.nick.text_field #method_missing will be called on user with method_name = 'nick' in which new method for user will be created and will be called. The newly created method will create a new DefaultRepresentation with @value set to the string 'foo'. Next the text_field will be called on the newly created DefaultRepresentation
+    def method_missing(method_name, *args, &block)
+      method = <<-EOF
             def #{method_name}(*args, &block)
               @__#{method_name} ||= Representations.representation_for(@value.#{method_name}, @template, "#{method_name}", self)
               @__#{method_name}.with_block(&block)
               @__#{method_name} if block.nil?
             end
-         EOF
-        ::Representations::ActiveRecordRepresentation.class_eval(method, __FILE__, __LINE__)
-
-        self.__send__(method_name, &block)
+      EOF
+      ::Representations::ActiveRecordRepresentation.class_eval(method, __FILE__, __LINE__)
+      self.__send__(method_name, &block)
+    end
+  end
+  #Representation for TimeWithZone object 
+  class TimeWithZoneRepresentation < Representation
+    def select(passed_options = {}, html_options = {})
+      options = {:defaults => {:day => @value.day, :month => @value.month, :year => @value.year}}
+      options.merge!(passed_options)
+      tree = get_parents_tree
+      name = get_html_name_attribute_value(tree)
+      @template.date_select(name, @name, options, html_options)
+    end
+  end
+  #Representation for Collections
+  class AssociationsRepresentation < Representation
+    #initilize @num variable
+    def initialize(object, template, name, parent)
+      super
+      @num = 0
+    end
+    #Creates Representation for every object in the Array and invokes passed block with this Representation as the argument
+    def each
+      @value.each do |object|
+        representation_object = Representations.representation_for(object, @template, object.id.to_s, self)
+        yield representation_object
       end
     end
-    #Representation for TimeWithZone object 
-    class TimeWithZoneRepresentation < Representation
-      def select(passed_options = {}, html_options = {})
-        options = {:defaults => {:day => @value.day, :month => @value.month, :year => @value.year}}
-        options.merge!(passed_options)
-        tree = get_parents_tree
-        tree.pop
-        name = get_html_name_attribute_value(tree)
-        @template.date_select(name, @name, options, html_options)
+    #Creates new object in the collection and input fields for it defined in the passed block 
+    def build
+      new_object = @value.build 
+      representation_object = AssociationsRepresentation::NewRecordRepresentation.new(new_object, @template, 'new_' + num.to_s, self)
+      yield representation_object
+    end
+    private 
+    attr_reader :num
+    #Used for generating unique @name for ArrayRepresentation::NewRecordRepresentation
+    def num
+       @num += 1 
+    end
+    #Representation that wraps newly created ActiveRecord::Base that will be added to some collection
+    class NewRecordRepresentation < Representation
+      #Creates new method which wraps call for ActionRecord
+      #New method returns Representation which represents datatype in the appropriate column
+      def method_missing(method_name_symbol, *args, &block)
+        method_name = method_name_symbol.to_s
+        representation_class = case @value.class.columns_hash[method_name].type
+        when :string
+          "DefaultRepresentation"
+        when :date
+          "TimeWithZoneRepresentation"
+        end
+        method = <<-EOF
+          def #{method_name}(*args, &block)
+             @__#{method_name} ||= #{representation_class}.new(@value.#{method_name}, @template, "#{method_name}", self)
+             @__#{method_name}.with_block(&block)
+             @__#{method_name} if block.nil?
+          end
+        EOF
+        ::Representations::AssociationsRepresentation::NewRecordRepresentation.class_eval(method, __FILE__, __LINE__)
+        self.__send__(method_name_symbol, &block)
       end
     end
   end
+end

data/lib/view_helpers.rb

@@ -1,9 +1,15 @@
 module Representations
     module ViewHelpers
         def r(model)
-            r = Representations.representation_for(model, self, model.class.to_s.downcase)
+            r = Representations.representation_for(model, self, find_variables_name(model))
             yield r if block_given?
             r
         end
+        private
+        def find_variables_name(object)
+            self.instance_variables.each do |name|
+                return name[1..-1] if instance_variable_get(name) == object
+            end
+        end
     end
 end

data/representations.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{representations}
-  s.version = "0.0.2"
+  s.version = "0.0.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["\305\201ukasz Piestrzeniewicz", "Adam Sokolnicki"]
-  s.date = %q{2009-10-20}
+  s.date = %q{2009-10-24}
   s.description = %q{Rails helpers, including form builders are great to allow rapid development of applications and views.  
 They are procedural in nature and have hard time to adapt to complex models. They also live in a single namespace making it difficult to find which helpers apply to which models.  
 Resource representations change syntax to object oriented and model specific.}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: representations
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - "\xC5\x81ukasz Piestrzeniewicz"
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-20 00:00:00 +02:00
+date: 2009-10-24 00:00:00 +02:00
 default_executable: 
 dependencies: []