experimentation/experiments/inheritable_accessor.rb spec/public/core_ext/class_spec.rb @@ -2,29 +2,100 @@ require "rubygems" require "erubis" module Erubis + module Basic::Converter + def add_tailchar(src, tailchar) + end + + def convert_input(src, input) + pat = @pattern + regexp = pat.nil? || pat == '<% %>' ? DEFAULT_REGEXP : pattern_regexp(pat) + pos = 0 + is_bol = true # is beginning of line + input.scan(regexp) do |indicator, code, tailch, rspace| + match = Regexp.last_match() + len = match.begin(0) - pos + text = input[pos, len] + pos = match.end(0) + ch = indicator ? indicator[0] : nil + lspace = ch == ?= ? nil : detect_spaces_at_bol(text, is_bol) + is_bol = rspace ? true : false + add_text(src, text) if text && !text.empty? + ## * when '<%= %>', do nothing + ## * when '<% %>' or '<%# %>', delete spaces iff only spaces are around '<% %>' + if ch == ?= # <%= %> + rspace = nil if tailch && !tailch.empty? + add_text(src, lspace) if lspace + add_expr(src, code, indicator) + add_text(src, rspace) if rspace + elsif ch == ?\# # <%# %> + n = code.count("\n") + (rspace ? 1 : 0) + if @trim && lspace && rspace + add_stmt(src, "\n" * n) + else + add_text(src, lspace) if lspace + add_stmt(src, "\n" * n) + add_text(src, rspace) if rspace + end + elsif ch == ?% # <%% %> + s = "#{lspace}#{@prefix||='<%'}#{code}#{tailch}#{@postfix||='%>'}#{rspace}" + add_text(src, s) + else # <% %> + if @trim && lspace && rspace + if respond_to?(:add_stmt2) + add_stmt2(src, "#{lspace}#{code}#{rspace}", tailch) + else + add_stmt(src, "#{lspace}#{code}#{rspace}") + end + else + add_text(src, lspace) if lspace + if respond_to?(:add_stmt2) + add_stmt2(src, code, tailch) + else + add_stmt(src, code) + end + add_text(src, rspace) if rspace + end + end + end + #rest = $' || input # ruby1.8 + rest = pos == 0 ? input : input[pos..-1] # ruby1.9 + add_text(src, rest) + end + + end + module BlockAwareEnhancer def add_preamble(src) src << "_old_buf, @_erb_buf = @_erb_buf, ''; " + src << "@_engine = 'erb'; " end - + def add_postamble(src) src << "\n" unless src[-1] == ?\n - src << "_ret = @_erb_buf; @_erb_buf = _old_buf; _ret.to_s\n" + src << "_ret = @_erb_buf; @_erb_buf = _old_buf; _ret.to_s;\n" end - + def add_text(src, text) - src << " @_erb_buf << '" << text << "'; " + p escape_text(text) + src << " @_erb_buf.concat('" << escape_text(text) << "'); " end - + def add_expr_escaped(src, code) - src << ' @_erb_buf << ' << escaped_expr(code) << ';' + src << ' @_erb_buf.concat(' << escaped_expr(code) << ');' + end + + def add_stmt2(src, code, tailch) + #src << code << ';' + src << code + src << " ).to_s; " if tailch == "=" + src << ';' unless code[-1] == ?\n end def add_expr_literal(src, code) - unless code =~ /(do|\{)(\s*|[^|]*|)?\s*$/ - src << ' @_erb_buf << (' << code << ').to_s;' + if code =~ /(do|\{)(\s*\|[^|]*\|)?\s*\Z/ + src << ' @_erb_buf.concat( ' << code << "; " else - src << ' @_erb_buf << ' << code << "; " + src << ' @_erb_buf.concat((' << code << ').to_s);' end end end @@ -46,11 +117,67 @@ class Context def hello "Hello" end + + def hello2 + "Hello" + end def helper(&blk) "<tag>#{capture(&blk)}</tag>" end end -puts Erubis::BlockAwareEruby.new("Begin: <%= helper do %>Hello<% end %><% 3.times do %>X<% end %><%= hello %>").src -p Erubis::BlockAwareEruby.new.process("Begin: <%= helper do %>Hello<% end %><% 3.times do %>X<% end %><%= hello %>", Context.new) \ No newline at end of file +# puts Erubis::BlockAwareEruby.new("Begin: <%= helper do %>Hello<% 3.times do %>X<% end %><% end %><%= hello %>").src +# p Erubis::BlockAwareEruby.new.process("Begin: <%= helper do %>Hello<%= 3.times do %>X<% end %><% end %><%= hello %>", Context.new) + +def form_for(bar) + bar.to_s +end + +class Foo +end + +# _old_verbose, $VERBOSE = $VERBOSE, nil +# Erubis::BlockAwareEruby.new("<%= form_for :foo do %>Hello<% end %>").def_method(Foo, :stuffs) +# $VERBOSE = _old_verbose +# require "parse_tree" +require "ruby_parser" +require "ruby2ruby" + +text = <<-END +Pre. <p><%= form_for :field do %> + Capturing +<% end =%> + +<% if true %>Hello<% end %> +<% if false %>Goodbye<% end %> +END + +p Erubis::BlockAwareEruby.new(text).src +p Erubis::BlockAwareEruby.new.process(text) + +__END__ +puts Erubis::BlockAwareEruby.new(<<-TEMPLATE).src +<ul id="nav"> + <% @nav_items = [] %> + <% @nav_items << nav_item('Home', url(:root)) %> + <% @nav_items << nav_item('Messaging', url(:new_message)) if current_user.has_permission?('message.send') %> + <% if current_user.has_permission?('schedule.power_user') %> + <% @nav_items << "<li>\#{link_to('Schedule', 'https://belpark.net/schedule/pwrusr/', :popup => true)}</li>" %> + <% elsif current_user.has_permission?('schedule.view') %> + <% @nav_items << nav_item('Schedule', 'https://belpark.net/schedule/user/calendar.php') %> + <% end %> + <% if current_user.emails.exists?(["emails.address LIKE ?", '%@belpark.net']) %> + <% @nav_items << "<li>\#{link_to('Email', 'https://belpark.net/dwmail/', :popup => true)}</li>" %> + <% end %> + <% @nav_items << nav_item('Directory', url(:users)) if current_user.has_permission?('user.view') %> + <%= @nav_items.join('<li class="divider">|</li>') %> +</ul> +<ul id="nav2"> + <% @nav_items = [] %> + <% @nav_items << "<li>\#{current_user.full_name}</li>" %> + <% @nav_items << "<li>\#{link_to('Settings', url(:edit_user, current_user.id))}</li>" if current_user.has_permission?('user.modify_self') %> + <% @nav_items << "<li>\#{link_to 'Log Out', url(:logout), :id => 'logout'}</li>" %> + <%= @nav_items.join('<li class="divider">|</li>') %> +</ul> +TEMPLATE \ No newline at end of file experimentation/experiments/erubis.rb @@ -81,8 +81,8 @@ class Merb::AbstractController include Merb::RenderMixin include Merb::InlineTemplates - class_inheritable_accessor :_layout, :_template_root - class_inheritable_array :_before_filters, :_after_filters + class_inheritable_accessor :_layout, :_template_root, :template_roots + class_inheritable_accessor :_before_filters, :_after_filters FILTER_OPTIONS = [:only, :exclude, :if, :unless, :with] @@ -144,13 +144,21 @@ class Merb::AbstractController template end + def self._template_root=(root) + @_template_root = root + _reset_template_roots + end + + def self._reset_template_roots + self.template_roots = [[self._template_root, :_template_location]] + end + # ==== Returns # roots<Array[Array]>:: # Template roots as pairs of template root path and template location # method. def self._template_roots - read_inheritable_attribute(:template_roots) || - write_inheritable_attribute(:template_roots, [[self._template_root, :_template_location]]) + self.template_roots || _reset_template_roots end # ==== Parameters @@ -158,7 +166,7 @@ class Merb::AbstractController # Template roots as pairs of template root path and template location # method. def self._template_roots=(roots) - write_inheritable_attribute(:template_roots, roots) + self.template_roots = roots end cattr_accessor :_abstract_subclasses, :_template_path_cache lib/merb-core/controller/abstract_controller.rb @@ -1,6 +1,9 @@ class Merb::Controller < Merb::AbstractController class_inheritable_accessor :_hidden_actions, :_shown_actions + self._hidden_actions ||= [] + self._shown_actions ||= [] + cattr_accessor :_subclasses, :_session_id_key, :_session_secret_key, :_session_expiry, :_session_cookie_domain self._subclasses = Set.new @@ -75,26 +78,6 @@ class Merb::Controller < Merb::AbstractController self._shown_actions = self._shown_actions | names.map {|n| n.to_s} end - # This list of actions that should not be callable. - # - # ==== Returns - # Array[String]:: An array of actions that should not be dispatchable. - def _hidden_actions - actions = read_inheritable_attribute(:_hidden_actions) - actions ? actions : write_inheritable_attribute(:_hidden_actions, []) - end - - # This list of actions that should be callable. - # - # ==== Returns - # Array[String]:: - # An array of actions that should be dispatched to even if they would not - # otherwise be. - def _shown_actions - actions = read_inheritable_attribute(:_shown_actions) - actions ? actions : write_inheritable_attribute(:_shown_actions, []) - end - # The list of actions that are callable, after taking defaults, # _hidden_actions and _shown_actions into consideration. It is calculated # once, the first time an action is dispatched for this controller. lib/merb-core/controller/merb_controller.rb @@ -105,7 +105,7 @@ module Merb::RenderMixin template_method, template_location = _template_for(thing, content_type, controller_name, opts[:template]) - + # Raise an error if there's no template unless template_method && self.respond_to?(template_method) template_files = Merb::Template.template_extensions.map { |ext| "#{template_location}.#{ext}" } lib/merb-core/controller/mixins/render.rb @@ -134,9 +134,7 @@ module Merb #--- # @public def provides(*formats) - formats.each do |fmt| - self.class_provided_formats << fmt unless class_provided_formats.include?(fmt) - end + self.class_provided_formats |= formats end # This class should only provide the formats listed here, despite any @@ -214,7 +212,6 @@ module Merb if @_content_type raise ContentTypeAlreadySet, "Cannot modify provided_formats because content_type has already been set" end - @_provided_formats = [] provides(*formats) end alias :_provided_formats= :_set_provided_formats @@ -240,9 +237,8 @@ module Merb if @_content_type raise ContentTypeAlreadySet, "Cannot modify provided_formats because content_type has already been set" end - formats.each do |fmt| - _provided_formats << fmt unless _provided_formats.include?(fmt) - end + @_provided_formats ||= [] + @_provided_formats |= formats end # Sets list of provided formats for this particular request. Usually used lib/merb-core/controller/mixins/responder.rb @@ -19,7 +19,6 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - # Allows attributes to be shared within an inheritance hierarchy, but where # each descendant gets a copy of their parents' attributes, instead of just a # pointer to the same. This means that the child can add elements to, for @@ -39,7 +38,7 @@ class Class def cattr_reader(*syms) syms.flatten.each do |sym| next if sym.is_a?(Hash) - class_eval(<<-EOS, __FILE__, __LINE__) + class_eval(<<-RUBY, __FILE__, __LINE__ + 1) unless defined? @@#{sym} @@#{sym} = nil end @@ -51,7 +50,7 @@ class Class def #{sym} @@#{sym} end - EOS + RUBY end end @@ -65,7 +64,7 @@ class Class def cattr_writer(*syms) options = syms.last.is_a?(Hash) ? syms.pop : {} syms.flatten.each do |sym| - class_eval(<<-RUBY, __FILE__, __LINE__) + class_eval(<<-RUBY, __FILE__, __LINE__ + 1) unless defined? @@#{sym} @@#{sym} = nil end @@ -76,7 +75,7 @@ class Class RUBY unless options[:instance_writer] == false - class_eval(<<-RUBY, __FILE__, __LINE__) + class_eval(<<-RUBY, __FILE__, __LINE__ + 1) def #{sym}=(obj) @@#{sym} = obj end @@ -110,22 +109,28 @@ class Class # (error out or do the same as other methods above) instead of silently # moving on). In particular, this makes the return value of this function # less useful. - def class_inheritable_reader(*syms) - syms.each do |sym| - next if sym.is_a?(Hash) - class_eval <<-EOS, __FILE__, __LINE__ - - def self.#{sym} - read_inheritable_attribute(:#{sym}) - end - - def #{sym} - self.class.#{sym} + def class_inheritable_reader(*ivars) + instance_reader = ivars.pop[:reader] if ivars.last.is_a?(Hash) + + ivars.each do |ivar| + self.class_eval <<-RUBY, __FILE__, __LINE__ + 1 + def self.#{ivar} + return @#{ivar} if self == #{self} || defined?(@#{ivar}) + ivar = superclass.#{ivar} + return nil if ivar.nil? && !#{self}.instance_variable_defined?("@#{ivar}") + @#{ivar} = ivar ? ivar.dup : ivar end - EOS + RUBY + unless instance_reader == false + self.class_eval <<-RUBY, __FILE__, __LINE__ + 1 + def #{ivar} + self.class.#{ivar} + end + RUBY + end end end - + # Defines class-level inheritable attribute writer. Attributes are available to subclasses, # each subclass has a copy of parent's attribute. # @@ -138,83 +143,22 @@ class Class # # @todo We need a style for class_eval <<-HEREDOC. I'd like to make it # class_eval(<<-RUBY, __FILE__, __LINE__), but we should codify it somewhere. - def class_inheritable_writer(*syms) - options = syms.last.is_a?(Hash) ? syms.pop : {} - syms.each do |sym| - class_eval(<<-RUBY, __FILE__, __LINE__) - def self.#{sym}=(obj) - write_inheritable_attribute(:#{sym}, obj) - end - RUBY - unless options[:instance_writer] == false - class_eval <<-RUBY, __FILE__, __LINE__ - def #{sym}=(obj) - self.class.#{sym} = obj - end - RUBY - end - end - end - - # Defines class-level inheritable array writer. Arrays are available to subclasses, - # each subclass has a copy of parent's array. Difference between other inheritable - # attributes is that array is recreated every time it is written. - # - # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of array attribute - # names to define inheritable writer for. - # @option syms :instance_writer<Boolean> if true, instance-level inheritable array - # attribute writer is defined. - # @return <Array[#to_s]> An array of the attributes that were made into inheritable - # array writers. - # - # @api public - def class_inheritable_array_writer(*syms) - options = syms.last.is_a?(Hash) ? syms.pop : {} - syms.each do |sym| - class_eval(<<-RUBY, __FILE__, __LINE__) - def self.#{sym}=(obj) - write_inheritable_array(:#{sym}, obj) + def class_inheritable_writer(*ivars) + instance_writer = ivars.pop[:instance_writer] if ivars.last.is_a?(Hash) + ivars.each do |ivar| + self.class_eval <<-RUBY, __FILE__, __LINE__ + 1 + def self.#{ivar}=(obj) + @#{ivar} = obj end RUBY - unless options[:instance_writer] == false - class_eval(<<-RUBY, __FILE__, __LINE__) - def #{sym}=(obj) - self.class.#{sym} = obj - end - RUBY - end - end - end - - # Defines class-level inheritable hash writer. Hashs are available to subclasses, - # each subclass has a copy of parent's hash. Difference between other inheritable - # attributes is that hash is recreated every time it is written. - # - # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]>:: Array of hash - # attribute names to define inheritable writer for. - # @option syms :instance_writer<Boolean>:: if true, instance-level inheritable hash - # attribute writer is defined. - # @return <Array[#to_s]> An Array of attributes turned into hash_writers. - # - # @api public - def class_inheritable_hash_writer(*syms) - options = syms.last.is_a?(Hash) ? syms.pop : {} - syms.each do |sym| - class_eval(<<-RUBY, __FILE__, __LINE__) - def self.#{sym}=(obj) - write_inheritable_hash(:#{sym}, obj) - end - RUBY - unless options[:instance_writer] == false - class_eval(<<-RUBY, __FILE__, __LINE__) - def #{sym}=(obj) - self.class.#{sym} = obj - end + unless instance_writer == false + self.class_eval <<-RUBY, __FILE__, __LINE__ + 1 + def #{ivar}=(obj) self.class.#{ivar} = obj end RUBY end end end - + # Defines class-level inheritable attribute accessor. Attributes are available to subclasses, # each subclass has a copy of parent's attribute. # @@ -228,136 +172,4 @@ class Class class_inheritable_reader(*syms) class_inheritable_writer(*syms) end - - # Defines class-level inheritable array accessor. Arrays are available to subclasses, - # each subclass has a copy of parent's array. Difference between other inheritable - # attributes is that array is recreated every time it is written. - # - # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of array attribute - # names to define inheritable accessor for. - # @option syms :instance_writer<Boolean> if true, instance-level inheritable array - # attribute writer is defined. - # @return <Array[#to_s]> An Array of attributes turned into inheritable arrays. - # - # @api public - def class_inheritable_array(*syms) - class_inheritable_reader(*syms) - class_inheritable_array_writer(*syms) - end - - # Defines class-level inheritable hash accessor. Hashs are available to subclasses, - # each subclass has a copy of parent's hash. Difference between other inheritable - # attributes is that hash is recreated every time it is written. - # - # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of hash attribute - # names to define inheritable accessor for. - # @option syms :instance_writer<Boolean> if true, instance-level inheritable hash - # attribute writer is defined. - # @return <Array[#to_s]> An Array of attributes turned into inheritable hashes. - def class_inheritable_hash(*syms) - class_inheritable_reader(*syms) - class_inheritable_hash_writer(*syms) - end - - # @return <Hash> inheritable attributes hash or it's default value, new frozen Hash. - # - # @api private - def inheritable_attributes - @inheritable_attributes ||= EMPTY_INHERITABLE_ATTRIBUTES - end - - # Sets the attribute which copy is available to subclasses. - # - # @param key<#to_s> inheritable attribute name - # @param value<not(Array, Hash)> value of inheritable attribute - # @return <not(Array, Hash)> the value that was set - # - # @api private - # - # @note - # If inheritable attributes storage has it's default value, - # a new frozen hash, it is set to new Hash that is not frozen. - def write_inheritable_attribute(key, value) - if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES) - @inheritable_attributes = {} - end - inheritable_attributes[key] = value - end - - # Sets the array attribute which copy is available to subclasses. - # - # @param key<#to_s> inheritable attribute name - # @param elements<Array> value of inheritable attribute - # @return <Array> the Array that was set - # - # @api private - # - # @note - # Inheritable array is re-created on each write. - def write_inheritable_array(key, elements) - write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil? - write_inheritable_attribute(key, read_inheritable_attribute(key) + elements) - end - - # Sets the hash attribute which copy is available to subclasses. - # - # @param key<#to_s> inheritable attribute name - # @param value<Hash> value of inheritable attribute - # @return <Hash> the new hash that resulted from merging the new values - # with the inherited values. - # - # @api private - # - # @note - # Inheritable hash is re-created on each write. - def write_inheritable_hash(key, hash) - write_inheritable_attribute(key, {}) if read_inheritable_attribute(key).nil? - write_inheritable_attribute(key, read_inheritable_attribute(key).merge(hash)) - end - - # Reads value of inheritable attributes. - # - # @param key<#to_s> the key of the attribute to read - # @return <Object> - # Inheritable attribute value. Subclasses store copies of values. - # - # @api private - def read_inheritable_attribute(key) - inheritable_attributes[key] - end - - # Resets inheritable attributes. - # - # @return <Object> the empty inheritable attributes. By default, this - # is a frozen, empty Hash. You can override this for a class by defining - # EMPTY_INHERITABLE_ATTRIBUTES - # - # @api private - # - # @todo do we need this? - def reset_inheritable_attributes - @inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES - end - - private - # Prevent this constant from being created multiple times - EMPTY_INHERITABLE_ATTRIBUTES = {}.freeze unless const_defined?(:EMPTY_INHERITABLE_ATTRIBUTES) - - # @todo document this - def inherited_with_inheritable_attributes(child) - inherited_without_inheritable_attributes(child) if respond_to?(:inherited_without_inheritable_attributes) - - if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES) - new_inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES - else - new_inheritable_attributes = inheritable_attributes.inject({}) do |memo, (key, value)| - memo.update(key => ((value.is_a?(Module) ? value : value.dup) rescue value)) - end - end - - child.instance_variable_set('@inheritable_attributes', new_inheritable_attributes) - end - - alias inherited_without_inheritable_attributes inherited - alias inherited inherited_with_inheritable_attributes end lib/merb-core/core_ext/class.rb spec/private/core_ext/class_spec.rb 8a2e4d1daf96a3beaed151d643d497e8a52cae1f Yehuda Katz wycats@gmail.com http://github.com/wycats/merb-core/commit/b5e42a1d7e1000516b7799bbc35efe442bbea6c9 b5e42a1d7e1000516b7799bbc35efe442bbea6c9 2008-06-27T21:36:13-07:00 2008-06-27T21:36:13-07:00 Redo Merb's inheritable_accessors so that they have correct semantics, then redo everything that uses inheritable_accessors so they don't have to hack around the bad semantics. b23327b14d1f1e72fc1b368ecae8f2670f8aa6c1 Yehuda Katz wycats@gmail.com