smklib 1.0.6

data/lib/smklib/movable_children.rb

@@ -0,0 +1,28 @@
+
+class ActiveRecord::Base
+	def self.has_movable(association_id, options = {}, &extension)
+		define_method('last_order_index') do
+			max = -6500
+			self.send(association_id.to_s).each { |p| max = p.order_index.to_i if p.order_index.to_i > max.to_i }
+			max < -1 ? -1 : max
+		end
+
+		define_method('update_order_indexes') do |moved_page_id, above_page_id|
+			moved_page = self.send(association_id.to_s).find(moved_page_id)
+			above_page = self.send(association_id.to_s).find(above_page_id)
+			next_next_order_index = above_page.order_index.to_i + 2
+			self.send(association_id.to_s).find(:all, :conditions => ['order_index > ?', above_page.order_index]).each { |p|
+				p.order_index = next_next_order_index
+				p.save
+				next_next_order_index +=1
+			}
+			moved_page.order_index = above_page.order_index.to_i + 1
+			moved_page.save
+		end
+
+	end
+
+	def self.is_movable_within_a(association_id, options = {}, &extension)
+		before_create { |model| model.order_index = model.send(association_id.to_s).last_order_index + 1 }
+	end
+end

data/lib/smklib/object_ext.rb

@@ -0,0 +1,34 @@
+class Object
+
+  def self.run_once(unique_string, &block)
+    $run_once_guard ||= {}
+    return if $run_once_guard[unique_string]
+    raise "No block given" unless block_given?
+    yield
+    $run_once_guard[unique_string] = true
+  end
+  
+  def to_class
+    self.class.const_get self.to_s
+  end
+  
+  def in?(array)
+    array.include? self
+  end
+
+	# based on http://www.rubygarden.org/ruby?Make_A_Deep_Copy_Of_An_Object
+	def deep_clone
+		Marshal::load(Marshal.dump(self))
+	end
+
+	def ignore_exception(*exceptions, &block)
+		begin
+			yield
+		rescue Exception => e
+			skip = false
+			exceptions.each { |ex| skip = true if e.kind_of? ex }
+			raise e unless skip
+		end
+	end
+
+end

data/lib/smklib/php_serialize.rb

@@ -0,0 +1,309 @@
+#!/usr/bin/env ruby
+# License and Copyright {{{
+# Copyright (c) 2003 Thomas Hurst <freaky@aagh.net>
+#
+# 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.
+# }}}
+
+# PHP serialize() and unserialize() workalikes
+#  First Released: 2003-06-02 (1.0.0)
+#  Prev Release: 2003-06-16 (1.0.1), by Thomas Hurst <tom@hur.st>
+#  This Release: 2004-09-17 (1.0.2), by Thomas Hurst <tom@hur.st>
+#                Switch all {}'s to explicit Hash.new's.
+#
+#  These two methods should, for the most part, be functionally identical
+#  to the respective PHP functions;
+#   http://www.php.net/serialize, http://www.php.net/unserialize
+#
+#
+#  string = PHP.serialize(mixed var[, bool assoc])
+#   Returns a string representing the argument in a form PHP.unserialize
+#   and PHP's unserialize() should both be able to load.
+#
+#   Array, Hash, Fixnum, Float, True/FalseClass, NilClass, String and Struct
+#   are supported; as are objects which support the to_assoc method, which
+#   returns an array of the form [['attr_name', 'value']..].  Anything else
+#   will raise a TypeError.
+#
+#   If 'assoc' is specified, Array's who's first element is a two value
+#   array will be assumed to be an associative array, and will be serialized
+#   as a PHP associative array rather than a multidimensional array.
+#
+#
+#
+#  mixed = PHP.unserialize(string serialized, [hash classmap, [bool assoc]])
+#   Returns an object containing the reconstituted data from serialized.
+#
+#   If a PHP array (associative; like an ordered hash) is encountered, it
+#   scans the keys; if they're all incrementing integers counting from 0,
+#   it's unserialized as an Array, otherwise it's unserialized as a Hash.
+#   Note: this will lose ordering.  To avoid this, specify assoc=true,
+#   and it will be unserialized as an associative array: [[key,value],...]
+#
+#   If a serialized object is encountered, the hash 'classmap' is searched for
+#   the class name (as a symbol).  Since PHP classnames are not case-preserving,
+#   this *must* be a .capitalize()d representation.  The value is expected
+#   to be the class itself; i.e. something you could call .new on.
+#
+#   If it's not found in 'classmap', the current constant namespace is searched,
+#   and failing that, a new Struct(classname) is generated, with the arguments
+#   for .new specified in the same order PHP provided; since PHP uses hashes
+#   to represent attributes, this should be the same order they're specified
+#   in PHP, but this is untested.
+#
+#   each serialized attribute is sent to the new object using the respective
+#   {attribute}=() method; you'll get a NameError if the method doesn't exist.
+#
+#   Array, Hash, Fixnum, Float, True/FalseClass, NilClass and String should
+#   be returned identically (i.e. foo == PHP.unserialize(PHP.serialize(foo))
+#   for these types); Struct should be too, provided it's in the namespace
+#   Module.const_get within unserialize() can see, or you gave it the same
+#   name in the Struct.new(<structname>), otherwise you should provide it in
+#   classmap.
+#
+# Note: StringIO is required for unserialize(); it's loaded as needed
+
+module PHP
+	def PHP.serialize(var, assoc = false) # {{{
+		s = ''
+		case var
+			when Array
+				s << "a:#{var.size}:{"
+				if assoc and var.first.is_a?(Array) and var.first.size == 2
+					var.each { |k,v|
+						s << PHP.serialize(k) << PHP.serialize(v)
+					}
+				else
+					var.each_with_index { |v,i|
+						s << "i:#{i};#{PHP.serialize(v)}"
+					}
+				end
+
+				s << '}'
+
+			when Hash
+				s << "a:#{var.size}:{"
+				var.each do |k,v|
+					s << "#{PHP.serialize(k)}#{PHP.serialize(v)}"
+				end
+				s << '}'
+
+			when Struct
+				# encode as Object with same name
+				s << "O:#{var.class.to_s.length}:\"#{var.class.to_s.downcase}\":#{var.members.length}:{"
+				var.members.each do |member|
+					s << "#{PHP.serialize(member)}#{PHP.serialize(var[member])}"
+				end
+				s << '}'
+
+			when String
+				s << "s:#{var.length}:\"#{var}\";"
+
+			when Fixnum # PHP doesn't have bignums
+				s << "i:#{var};"
+
+			when Float
+				s << "d:#{var};"
+
+			when NilClass
+				s << 'N;'
+
+			when FalseClass, TrueClass
+				s << "b:#{var ? 1 :0};"
+
+			else
+				if var.respond_to?(:to_assoc)
+					v = var.to_assoc
+					# encode as Object with same name
+					s << "O:#{var.class.to_s.length}:\"#{var.class.to_s.downcase}\":#{v.length}:{"
+					v.each do |k,v|
+						s << "#{PHP.serialize(k.to_s)}#{PHP.serialize(v)}"
+					end
+					s << '}'
+				else
+					raise TypeError, "Unable to serialize type #{var.class}"
+				end
+		end
+
+		s
+	end # }}}
+
+	def PHP.unserialize(string, classmap = nil, assoc = false) # {{{
+		require 'stringio'
+		string = StringIO.new(string)
+		def string.read_until(char)
+			val = ''
+			while (c = self.read(1)) != char
+				val << c
+			end
+			val
+		end
+
+		classmap ||= Hash.new
+
+		do_unserialize(string, classmap, assoc)
+	end
+
+	def PHP.do_unserialize(string, classmap, assoc)
+		val = nil
+		# determine a type
+		type = string.read(2)[0,1]
+		case type
+			when 'a' # associative array, a:length:{[index][value]...}
+				count = string.read_until('{').to_i
+				val = vals = Array.new
+				count.times do |i|
+					vals << [do_unserialize(string, classmap, assoc), do_unserialize(string, classmap, assoc)]
+				end
+				string.read(1) # skip the ending }
+
+				unless assoc
+					# now, we have an associative array, let's clean it up a bit...
+					# arrays have all numeric indexes, in order; otherwise we assume a hash
+					array = true
+					i = 0
+					vals.each do |key,value|
+						if key != i # wrong index -> assume hash
+							array = false
+							break
+						end
+						i += 1
+					end
+
+					if array
+						vals.collect! do |key,value|
+							value
+						end
+					else
+						val = Hash.new
+						vals.each do |key,value|
+							val[key] = value
+						end
+					end
+				end
+
+			when 'O' # object, O:length:"class":length:{[attribute][value]...}
+				# class name (lowercase in PHP, grr)
+				len = string.read_until(':').to_i + 3 # quotes, seperator
+				klass = string.read(len)[1...-2].capitalize.intern # read it, kill useless quotes
+
+				# read the attributes
+				attrs = []
+				len = string.read_until('{').to_i
+
+				len.times do
+					attr = (do_unserialize(string, classmap, assoc))
+					attrs << [attr.intern, (attr << '=').intern, do_unserialize(string, classmap, assoc)]
+				end
+				string.read(1)
+
+				val = nil
+				# See if we need to map to a particular object
+				if classmap.has_key?(klass)
+					val = classmap[klass].new
+				elsif Struct.const_defined?(klass) # Nope; see if there's a Struct
+					classmap[klass] = val = Struct.const_get(klass)
+					val = val.new
+				else # Nope; see if there's a Constant
+					begin
+						classmap[klass] = val = Module.const_get(klass)
+
+						val = val.new
+					rescue NameError # Nope; make a new Struct
+						classmap[klass] = val = Struct.new(klass.to_s, *attrs.collect { |v| v[0].to_s })
+					end
+				end
+
+				attrs.each do |attr,attrassign,v|
+					val.__send__(attrassign, v)
+				end
+
+			when 's' # string, s:length:"data";
+				len = string.read_until(':').to_i + 3 # quotes, separator
+				val = string.read(len)[1...-2] # read it, kill useless quotes
+
+			when 'i' # integer, i:123
+				val = string.read_until(';').to_i
+
+			when 'd' # double (float), d:1.23
+				val = string.read_until(';').to_f
+
+			when 'N' # NULL, N;
+				val = nil
+
+			when 'b' # bool, b:0 or 1
+				val = (string.read(2)[0] == ?1 ? true : false)
+
+			else
+				raise TypeError, "Unable to unserialize type '#{type}'"
+		end
+
+		val
+	end # }}}
+end
+
+
+if $0 == __FILE__
+	require 'tempfile'
+
+	class Foo
+		attr_accessor :foo, :bar, :wibble
+		def initialize
+			@foo    = 'a'
+			@bar    = 'b'
+			@wibble = 'c'
+		end
+
+		def to_assoc
+			[['foo', @foo], ['bar', @bar], ['wibble', @wibble]]
+		end
+	end
+
+	puts "The following should all be equivilent, taking into account our limitations."
+	puts " 1. Is the original Ruby data structure."
+	puts " >> Is our generated serialized string."
+	puts " << Is the serialized string after PHP's eaten it."
+	puts " 2. Is the reconstructed Ruby data structure"
+	puts "--"
+	T = Struct.new(:structures,:ass)
+	[
+		{5 => nil, "foo" => 1, "nana" => ["x","y","z"], 3 => false, "bar" => 2.4, 4 => true},
+		T.new('Kick','Dude!'),
+		['a','b','c',['z','y','x'],{'hash' => 'smoke'},"\"\\''\""],
+		"He said \"Damnit, I'm lame\", and then I kicked his ass.",
+		Foo.new
+	].each do |v|
+		print " 1. "
+		p v
+		out = PHP.serialize(v)
+
+		tmp = Tempfile.new('php')
+		tmp.print(out)
+		tmp.close
+
+		puts " >> #{out}"
+		ret = `php -r 'echo serialize(unserialize(join("\n", file("#{tmp.path}"))));'`
+		puts " << #{ret}"
+		print " 2. "
+		p PHP.unserialize(ret)
+		puts " == #{out == ret ? 'Perfect!' : 'Differ!'}", ''
+		tmp.close!
+	end
+end
+

data/lib/smklib/railtie.rb

@@ -0,0 +1,6 @@
+module SMKLib
+	class Railtie < Rails::Railtie
+		# rake_tasks do { require ... }
+	end
+end
+

data/lib/smklib/somekool_scaffold.rb

@@ -0,0 +1,198 @@
+################################################
+#
+# Usage:
+#
+# 	somekool_scaffold :agents, :ignore_columns => [:last_edit_at], :foreign_keys => [{:key => :sub_of_agent_id, :model => Agent, :title => _('Sub of')}], :css_class => :table_list_view
+#
+#
+#
+#
+#
+################################################
+
+module ActionView
+	module Helpers
+		module JavaScriptMacrosHelper
+			def in_place_collection_dropdown(field_id, options = {})
+				function =  "new Ajax.InPlaceCollectionEditor("
+				function << "'#{field_id}', "
+				function << "'#{url_for(options[:url])}'"
+
+				js_options = {}
+				js_options['cancelText'] = %('#{options[:cancel_text]}') if options[:cancel_text]
+				js_options['okText'] = %('#{options[:save_text]}') if options[:save_text]
+				js_options['loadingText'] = %('#{options[:loading_text]}') if options[:loading_text]
+				#js_options['rows'] = options[:rows] if options[:rows]
+				#js_options['cols'] = options[:cols] if options[:cols]
+				#js_options['size'] = options[:size] if options[:size]
+				js_options['collection'] = options[:collection] if options[:collection]
+				js_options['value'] = options[:value] if options[:value]
+				js_options['externalControl'] = "'#{options[:external_control]}'" if options[:external_control]
+				js_options['loadTextURL'] = "'#{url_for(options[:load_text_url])}'" if options[:load_text_url]
+				js_options['ajaxOptions'] = options[:options] if options[:options]
+				js_options['evalScripts'] = options[:script] if options[:script]
+				js_options['callback']   = "function(form) { return #{options[:with]} }" if options[:with]
+				function << (', ' + options_for_javascript(js_options)) unless js_options.empty?
+
+				function << ')'
+
+				javascript_tag(function)
+			end
+
+
+			def in_place_editor_dropdown(object, method, tag_options = {}, in_place_editor_options = {})
+				tag = ::ActionView::Helpers::InstanceTag.new(object, method, self)
+raise tag.inspect if tag_options[:crash]
+				front_val = tag_options.delete(:front_val)
+				tag_options = {:tag => "span", :id => "#{object}_#{method}_#{tag.object.id}_in_place_editor", :class => "in_place_editor_field"}.merge!(tag_options)
+				in_place_editor_options[:url] = in_place_editor_options[:url] || url_for({ :action => "set_#{object}_#{method}", :id => tag.object.id })
+				(front_val.to_s.empty? ? tag.to_content_tag(tag_options.delete(:tag), tag_options) : tag.content_tag(tag_options.delete(:tag), front_val, tag_options)) +
+				in_place_collection_dropdown(tag_options[:id], in_place_editor_options)
+			end
+		end
+	end
+end
+
+class ActionController::Base
+	# Get a metaclass for this class
+	#def self.metaclass; class << self; self; end; end
+
+	def self.somekool_scaffold(model, options = {})
+#raise Object.const_get(model.to_s.singularize.capitalize).inspect
+		instance_eval do
+			# required for in_place_editor_field
+			include ActionView::Helpers::TagHelper
+			include ActionView::Helpers::JavaScriptHelper
+			include ActionView::Helpers::JavaScriptMacrosHelper
+
+			# get model object
+			model_sym = model.to_s.singularize
+			object_model = Object.const_get(model_sym.capitalize)
+			model_sym = model_sym.downcase.to_sym
+
+			# call in_plate_edit_for all columns
+			columns = object_model.content_columns.collect do |c|
+				if options[:ignore_columns].include? c.name.to_sym
+					nil
+				else
+					in_place_edit_for model_sym, c.name.to_sym
+					c
+				end
+			end.compact
+			options[:foreign_keys].each do |fk|
+				in_place_edit_for model_sym, fk[:key].to_sym
+
+				define_method("set_#{model_sym}_#{fk[:key]}".to_sym) do
+					a = object_model.find(params[:id])
+					a[fk[:key].to_sym] = params[:value]
+					a.save
+					render :text => (a[fk[:key].to_sym].nil? ? _('NULL') : "#{a[fk[:key].to_sym]} - #{fk[:model].find(a[fk[:key].to_sym]).to_s}".nbsp)
+				end
+			end
+
+			# simple action index
+			define_method(:index) do
+				redirect_to :action => 'list'
+			end
+
+			# main action
+			define_method(:list) do
+				xml = Builder::XmlMarkup.new(:indent=>2)
+				xml.a(:class => "#{model_sym}_add_link", :href => "/#{model_sym.to_s.pluralize}/add") do
+					xml.img(:title => 'add_button', :alt => 'add_button', :border => 0, :src => '/smklib/images/add.png')
+					xml << _('Add new %s') % model_sym.to_s
+				end
+				xml.table(:cellpadding => 0, :cellspacing => 0, :border => 0, :class => "somekool_scaffold list #{model} #{options[:css_class]}") do
+					xml.tr do
+						xml.th _('ID') unless options[:no_id]
+						columns.each do |c|
+							xml.th { xml << c.human_name.to_s.nbsp}
+						end
+						options[:foreign_keys].each do |fk|
+							fk[:collection] = ([[nil, _('NULL')]] + fk[:model].find_all.collect { |item| [item.id, item.to_s] }).inspect.gsub(/nil/, 'null')
+							xml.th fk[:title]
+						end if options[:foreign_keys]
+						xml.th { xml << _('Delete') } unless options[:no_delete]
+					end
+					object_model.find_all.each_with_index do |row, row_index|
+						instance_variable_set("@#{model_sym}", row)
+						xml.tr(:class => row_index % 2 == 0 ? 'even' : 'odd') do
+							xml.td do
+								xml << instance_variable_get("@#{model_sym}")[:id].to_s
+							end unless options[:no_id]
+							columns.each do |c|
+								xml.td do
+									#xml << row.send(c.name)
+									instance_variable_get("@#{model_sym}")[c.name.to_sym] = " " if instance_variable_get("@#{model_sym}")[c.name.to_sym].to_s.empty?
+									xml << in_place_editor_field(model_sym, c.name)
+								end
+							end
+							options[:foreign_keys].each do |fk|
+								begin
+									front_val = "#{row[fk[:key]]} - #{fk[:model].find(row[fk[:key]]).to_s}".nbsp
+								rescue
+									front_val = _('NULL')
+								end
+								xml.td do
+									xml << in_place_editor_dropdown(model_sym, fk[:key], {:front_val => front_val}, {:value => row[fk[:key]], :collection => fk[:collection]})
+								end
+								#xml.td fk[:model].find(:first, :conditions => ["#{fk[:key]} = ?", row[fk[:key]]]).inspect ## same
+							end if options[:foreign_keys]
+							xml.td do
+								xml.a(:class => "#{model_sym}_delete_link", :href => "/#{model_sym.to_s.pluralize}/destroy/#{row.id}") do
+									xml.img(:title => 'delete_button', :alt => 'delete_button', :border => 0, :src => '/smklib/images/trashcan_empty.png')
+								end
+							end unless options[:no_delete]
+						end
+					end
+				end
+				render :text => xml.target!, :layout => 'main'
+			end
+			define_method(:add) do
+				xml = Builder::XmlMarkup.new(:indent=>2)
+				xml.form(:action => "/#{model_sym.to_s.pluralize}/create") do
+					xml.table(:cellpadding => 0, :cellspacing => 0, :border => 0, :class => "somekool_scaffold add #{model} #{options[:css_class]}") do
+						columns.each do |c|
+							xml.tr do
+								xml.th { xml << c.human_name.to_s.nbsp}
+								xml.td { xml.input(:type => 'text', :name => "#{model_sym}[#{c.name}]") }
+							end
+						end
+						options[:foreign_keys].each do |fk|
+							fk[:collection] = ([[nil, _('NULL')]] + fk[:model].find_all.collect { |item| [item.id, item.to_s] })
+							xml.tr do
+								xml.th fk[:title]
+								xml.td do
+									xml.select(:name => "#{model_sym}[#{fk[:key]}]") do
+										fk[:collection].each do |opt|
+											xml.option(:value => opt[0]) { xml << opt[1] }
+										end
+									end
+								end
+							end
+						end if options[:foreign_keys]
+						xml.tr do
+							xml.td(:colspan => 2) { xml.input(:type => 'submit', :value => _('Add'))}
+						end
+					end
+				end
+				render :text => xml.target!, :layout => 'main'
+			end
+			define_method(:create) do
+				object_model.create(params[model_sym])
+				flash[:notice] = _('New %s created') % model_sym.to_s
+				redirect_to_path "/#{model_sym.to_s.pluralize}/list"
+			end
+			#define_method(:edit) do
+			#end
+			#define_method(:update) do
+			#end
+			define_method(:destroy) do
+				object_model.find(params[:id]).destroy
+				flash[:notice] = _('%s %s has been destroyed') % [model_sym.to_s, params[:id].to_s]
+				redirect_to_path "/#{model_sym.to_s.pluralize}/list"
+			end
+		end
+	end
+end
+