dolzenko 0.0.10 → 0.0.11

data/lib/dolzenko/django_f_object.rb

@@ -0,0 +1,213 @@
+# Django F object for Rails 3
+# http://docs.djangoproject.com/en/dev/topics/db/queries/#query-expressions
+#
+# Let's you reference columns (and do simple calculations on them)
+# from conditions and updates.
+#
+# User.where(:updated_at => F(:created_at))
+#
+#   instead of User.where("updated_at = created_at")
+#
+# User.where(:updated_at => F(:created_at) + 1)
+#
+#   instead of User.where("updated_at = created_at + 1")
+#
+# User.where(:updated_at => F(:created_at) + F(:updated_at))
+#
+#   instead of User.where("updated_at = created_at + updated_at")
+#
+# User.update_all(:mirror_id => F(:id))
+#
+#   instead of User.update_all("mirror_id = id")
+#
+# user = User.find(1)
+# user.mirror_id = F(:id) + 1
+# user.save
+#
+#   issues UPDATE `users` SET `mirror_id` = `users`.`id` + 1 WHERE (`users`.`id` = 1)
+#
+#
+
+require "require_gist"; require_gist "383954/ea5a41269aac073b596b21fe392098827186a32b/alias_method_chain_once.rb", "a6f068593bb45fe6c9956205f672ac4a0c2e1671" # http://gist.github.com/383954
+
+class F
+  attr_accessor :attr_name
+  attr_accessor :klass
+  attr_accessor :operator
+  attr_accessor :operand
+
+  def initialize(attr_name)
+    self.attr_name = attr_name.to_s
+  end
+
+  def to_sql(formatter = nil)
+    self.klass ||= formatter.environment.relation.klass
+    sql = klass.my_quote_columns(attr_name)
+    if operator && operand
+      operand.klass = klass if operand.is_a?(F)
+      sql << " #{ operator } #{ operand.is_a?(F) ? operand.to_sql(formatter) : klass.connection.quote(operand) }"
+    end
+    sql
+  end
+
+  def empty?
+    false
+  end
+
+  %w(+ - * /).each do |op|
+    define_method(op) do |arg|
+      self.operator = op
+      self.operand = arg
+      self
+    end
+  end
+end
+
+def F(attr_name)
+  F.new(attr_name)
+end
+
+if $PROGRAM_NAME == __FILE__
+  require File.expand_path('../../config/environment', __FILE__)
+end
+
+module ActiveRecord
+  class Base
+    def self.my_quote_columns(*column_names)
+      quoted_table_name = connection.quote_table_name(table_name)
+      column_names.map { |column_name| "#{ quoted_table_name }.#{ connection.quote_column_name(column_name) }" }.join(", ")
+    end
+  end
+end
+
+module ActiveRecord
+  module ConnectionAdapters #:nodoc:
+    class Column
+      def type_cast_with_f_object(value)
+        return value if value.is_a?(F)
+        type_cast_without_f_object(value)
+      end
+      
+      alias_method_chain_once :type_cast, :f_object
+    end
+  end
+  
+
+  class Relation
+    def build_where_with_f_object(*args)
+      if args.size == 1 && args[0].is_a?(Hash)
+        hash_conditions = args[0]
+        hash_conditions.each { |_, v| v.klass = klass if v.is_a?(F) }
+      end
+
+      build_where_without_f_object(*args)
+    end
+
+    alias_method_chain_once :build_where, :f_object
+  end
+
+  class Base
+    class << self
+      def sanitize_sql_hash_for_assignment_with_f_object(assignments)
+        f_assignments, normal_assignments = assignments.partition { |_, v| v.is_a?(F) }
+        
+        f_sql = f_assignments.map do |attr, f_obj|
+          "#{connection.quote_column_name(attr)} = #{connection.quote_column_name(f_obj.attr_name)}"
+        end.join(", ")
+
+        normal_sql = sanitize_sql_hash_for_assignment_without_f_object(normal_assignments)
+        
+        [(f_sql if f_sql.present?), (normal_sql if normal_sql.present?)].compact.join(", ")
+      end
+
+      alias_method_chain_once :sanitize_sql_hash_for_assignment, :f_object
+    end
+  end
+
+  module AttributeMethods
+    module Write
+      def write_attribute_with_f_object(attr_name, value)
+        write_attribute_without_f_object(attr_name, value)
+
+        # cancel number and any other type of conversions
+        if value.is_a?(F)
+          value.klass = self.class
+          @attributes[attr_name] = value
+        end
+      end
+
+      alias_method_chain_once :write_attribute, :f_object
+    end
+    
+    module TimeZoneConversion
+      module ClassMethods
+        def define_method_attribute_with_f_object=(attr_name)
+          send(:define_method_attribute_without_f_object=, attr_name)
+
+          method_body, line = <<-EOV, __LINE__ + 1
+            def #{attr_name}_with_f_object=(time)
+              if time.is_a?(F)
+                time.klass = self.class
+                write_attribute(:#{attr_name}, time)
+              else
+                send(:#{attr_name}_without_f_object=, time)
+              end
+            end
+
+            alias_method_chain_once :#{attr_name}=, :f_object unless respond_to?(:#{attr_name}_without_f_object=)
+          EOV
+          generated_attribute_methods.module_eval(method_body, __FILE__, line)
+        end
+        
+        alias_method_chain_once :define_method_attribute=, :f_object
+      end
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  class User < ActiveRecord::Base
+  end
+
+  require 'rspec/core'
+  require 'rspec/expectations'
+  require 'rspec/matchers'
+
+  Rspec.configure do |c|
+    c.mock_with :rspec
+  end
+
+  describe F do
+    Rspec::Matchers.define :end_with do |expected|
+      match do |actual|
+        actual.end_with?(expected) 
+      end
+    end
+
+    specify { User.where(:updated_at => F(:created_at)).to_sql.should
+    end_with("(`users`.`updated_at` = `users`.`created_at`)") }
+    
+    specify { User.where(:updated_at => F(:created_at) + 1).to_sql.should
+    end_with("(`users`.`updated_at` = `users`.`created_at` + 1)") }
+
+    specify { User.where(:updated_at => F(:created_at) + F(:updated_at)).to_sql.should
+    end_with("(`users`.`updated_at` = `users`.`created_at` + `users`.`updated_at`)") }
+
+    specify { User.where(:updated_at => F(:created_at) + F(:updated_at)).to_sql.should
+    end_with("(`users`.`updated_at` = `users`.`created_at` + `users`.`updated_at`)") }
+
+    def update_sql(f_obj)
+      id_attr = User.scoped.arel_table.find_attribute_matching_name("id")
+      Arel::Update.new(User.scoped, id_attr => f_obj).to_sql.strip
+    end
+
+    specify { update_sql(F(:di)).should
+    end_with("SET `id` = `users`.`di`") }
+
+    specify { update_sql(F(:di) + 1).should
+    end_with("SET `id` = `users`.`di` + 1") }
+    
+    specify { update_sql(F(:di) + F(:id)).should
+    end_with("SET `id` = `users`.`di` + `users`.`id`") }
+  end
+end

data/lib/dolzenko/django_q_object.rb

@@ -0,0 +1,176 @@
+# Django Q object for Rails 2, 3
+# http://docs.djangoproject.com/en/dev/topics/db/queries/#complex-lookups-with-q-objects
+#
+# Let's you build ORed, ANDed, and negated conditions without dropping to
+# writing SQL.
+#
+# User.where(~Q(:user_id => nil))
+#
+#   instead of User.where("user_id IS NOT NULL")
+#
+# User.where(Q(:user_id => nil) | Q(:id => nil))
+#
+#   instead of User.where("user_id IS NULL OR id IS NULL")
+#
+# User.where(~(Q(:user_id => nil) & Q(:id => nil)))
+#
+#   instead of User.where("user_id IS NOT NULL AND id IS NOT NULL")
+#
+# On Ruby 1.9 Object#! can be used to negate conditions
+#
+# User.where(!Q(:user_id => nil))
+#
+
+require "require_gist"; require_gist "383954/ea5a41269aac073b596b21fe392098827186a32b/alias_method_chain_once.rb", "a6f068593bb45fe6c9956205f672ac4a0c2e1671" # http://gist.github.com/383954
+
+class Q
+  def |(other)
+    OrQ.new(self, other)
+  end
+
+  def &(other)
+    AndQ.new(self, other)
+  end
+
+  def ~
+    NotQ.new(self)
+  end
+
+  alias_method "!", "~"
+end
+
+class BinaryQ < Q
+  attr_accessor :op1, :op2
+
+  def initialize(op1, op2)
+    self.op1, self.op2 = op1, op2
+  end
+
+  def empty?
+    false
+  end
+end
+
+class UnaryQ < Q
+  attr_accessor :op1
+
+  def initialize(*args)
+    self.op1 = (args.size == 1 ? args[0] : args)
+  end
+
+  def to_q_sql(klass)
+    klass.send(:sanitize_sql, op1)
+  end
+
+  def empty?
+    op1.empty?
+  end
+end
+
+class AndQ < BinaryQ
+  def to_q_sql(klass)
+    "(#{ op1.to_q_sql(klass) }) AND (#{ op2.to_q_sql(klass) })"
+  end
+end
+
+class NotQ < UnaryQ
+  def to_q_sql(klass)
+    "(NOT (#{ op1.to_q_sql(klass) }))"
+  end
+end
+
+class OrQ < BinaryQ
+  def to_q_sql(klass)
+    "(#{ op1.to_q_sql(klass) }) OR (#{ op2.to_q_sql(klass) })"
+  end
+end
+
+def Q(*args)
+  UnaryQ.new(*args)
+end
+
+if $PROGRAM_NAME == __FILE__
+  require File.expand_path('../../config/environment', __FILE__)
+end
+
+module ActiveRecord
+  if defined?(Relation)
+    # Rails 3
+    class Relation
+      def build_where_with_q_object(*args)
+        if args.size == 1 && args[0].is_a?(Q)
+          return args[0].to_q_sql(klass)
+        end
+
+        build_where_without_q_object(*args)
+      end
+
+      alias_method_chain_once :build_where, :q_object
+    end
+  else
+    # Rails 2
+    class Base
+      class << self
+        def sanitize_sql_for_conditions_with_q_object(*args)
+          if args.size == 1 && args[0].is_a?(Q)
+            return args[0].to_q_sql(klass)
+          end
+
+          sanitize_sql_for_conditions_without_q_object(*args)
+        end
+
+        alias_method_chain_once :sanitize_sql_for_conditions, :q_object
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  class Base
+    def self.Q(*args)
+      UnaryQ.new(*args).to_q_sql(self)
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  class User < ActiveRecord::Base
+  end
+
+  require 'rspec/expectations'
+  require 'rspec/core'
+
+  Rspec.configure do |c|
+    c.mock_with :rspec
+  end
+
+  describe Q do
+    Rspec::Matchers.define :be_like_conditions do |expected|
+      match do |actual|
+        actual.to_q_sql(User) == expected
+      end
+    end
+
+    it { Q(:email => nil).should
+    be_like_conditions("`users`.`email` IS NULL") }
+
+    it { (~Q(:user_id => nil)).should
+    be_like_conditions("(NOT (`users`.`user_id` IS NULL))") }
+
+    it { (!Q(:user_id => nil)).should
+    be_like_conditions("(NOT (`users`.`user_id` IS NULL))") }
+
+    it { (User.Q(:is_avatar => nil)).should == "`users`.`is_avatar` IS NULL" }
+
+    it { (User.Q("name LIKE :like OR email LIKE :like", :like => "%#{ 42 }%")).should == "name LIKE '%42%' OR email LIKE '%42%'" }
+
+    it { (Q(:league_id => nil) & Q("path LIKE ?", "prefix/%")).should
+    be_like_conditions("(`users`.`league_id` IS NULL) AND (path LIKE 'prefix/%')") }
+
+    it { (Q(:to_account_id => 2) | Q(:from_account_id => 1)).should
+    be_like_conditions("(`users`.`to_account_id` = 2) OR (`users`.`from_account_id` = 1)") }
+
+    it { (!Q(:user_id => nil) & Q(:email => nil)).should
+    be_like_conditions("((NOT (`users`.`user_id` IS NULL)) AND (`users`.`email` IS NULL)") }
+  end
+end

data/lib/dolzenko/error_print.rb

@@ -0,0 +1,169 @@
+# Formats the Exception so that it looks *familiar*,
+# i.e. exactly like your interpreter does it.
+#
+# Port of MRI native `error_print` function.
+class Exception
+  require "English"
+  
+  def self.error_print(e = $ERROR_INFO)
+    warn_print = ""
+    backtrace = e.backtrace
+    backtrace = [ backtrace ] if backtrace.is_a?(String) # 1.9 returns single String for SystemStackError
+
+    warn_print << backtrace[0]
+    if e.is_a?(RuntimeError) && e.message.empty?
+      warn_print << ": unhandled exception\n"
+    else
+      if e.message.empty?
+        warn_print << ": #{ e.class.name }\n"
+      else
+        split_message = e.message.split("\n")
+        warn_print << ": "
+        if split_message.size == 1
+          warn_print << "#{ e.message } (#{ e.class.name })\n"
+        else
+          warn_print << split_message[0]
+          warn_print << " (#{ e.class.name })\n"
+          warn_print << split_message[1..-1].join("\n").chomp << "\n"
+        end
+      end
+    end
+
+    len = backtrace.size
+
+# int skip = eclass == rb_eSysStackError;
+    skip = e.is_a?(SystemStackError)
+
+# #define TRACE_MAX (TRACE_HEAD+TRACE_TAIL+5)
+# #define TRACE_HEAD 8
+# #define TRACE_TAIL 5
+    trace_head = 8
+    trace_tail = 5
+    trace_max = (trace_head + trace_tail + 5)
+#
+#	for (i = 1; i < len; i++) {
+    i = 1
+    while i < len
+#	    if (TYPE(ptr[i]) == T_STRING) {
+#		warn_printf("\tfrom %s\n", RSTRING_PTR(ptr[i]));
+#	    }
+      warn_print << "\tfrom %s\n" % e.backtrace[i]
+
+#	    if (skip && i == TRACE_HEAD && len > TRACE_MAX) {
+      if skip && i == trace_head && len > trace_max
+#		warn_printf("\t ... %ld levels...\n",
+#			    len - TRACE_HEAD - TRACE_TAIL);
+        warn_print << "\t ... %d levels...\n" % (len - trace_head - trace_tail)
+#		i = len - TRACE_TAIL;
+        i = len - trace_tail
+#	    }
+      end
+#	}
+      i += 1
+    end
+    warn_print
+  end
+end
+
+
+if $PROGRAM_NAME == __FILE__
+  if ARGV.empty?
+    # Main test suite runner
+    require "spec"
+    require "require_gist"; require_gist "371861/7dbcff4b266451b70cca183ce24917340587e8d3/shell_out.rb", "1e8bbc0ef3d1d078a4e57eb03225913c3a1e4fe5" # http://gist.github.com/371861
+
+    describe "Exception.error_print" do
+      include ShellOut
+      %w(normal
+          multiline
+          empty_message
+          non_empty_message
+          runtime_empty
+          runtime_non_empty
+          sys_stack).each do |type|
+        it "outputs the same message as the native interpreter does for #{ type } exception" do
+          native = shell_out("ruby #{ __FILE__ } native raise_#{ type }", :out => :return)
+
+          native.should include(__FILE__)
+
+          error_printed = shell_out("ruby #{ __FILE__ } error_print raise_#{ type }", :out => :return)
+
+          error_printed.should include(__FILE__)
+
+          error_printed.should == native
+        end
+      end
+
+    end
+    exit ::Spec::Runner::CommandLine.run
+  else
+    # Helper
+    def raise_normal
+      f10
+    end
+
+    def raise_multiline
+      raise "qwe\nasd\nzxc"
+    end
+
+    def raise_empty_message
+      raise ArgumentError, ""
+    end
+
+    def raise_non_empty_message
+      raise ArgumentError, "qwe"
+    end
+
+    def raise_runtime_empty
+      raise
+    end
+
+    def raise_runtime_non_empty
+      raise RuntimeError, "runtime non empty"
+    end
+
+    def raise_sys_stack
+      baz
+    end
+
+    # puts (0..20).map { |i| "def f#{i}() f#{i+1}(); end"}.join("\n")
+    def f0() f1(); end
+    def f1() f2(); end
+    def f2() f3(); end
+    def f3() f4(); end
+    def f4() f5(); end
+    def f5() f6(); end
+    def f6() f7(); end
+    def f7() f8(); end
+    def f8() f9(); end
+    def f9() f10(); end
+    def f10() f11(); end
+    def f11() f12(); end
+    def f12() f13(); end
+    def f13() f14(); end
+    def f14() f15(); end
+    def f15() f16(); end
+    def f16() f17(); end
+    def f17() f18(); end
+    def f18() f19(); end
+    def f19() f20(); end
+    def f20
+      raise(ArgumentError, "multi\nline\nerror")
+    end
+
+
+    def foo; bar; end; def bar; foo; end; def baz; foo; end;
+
+    class NonExistingException < Exception
+    end
+
+    begin
+      eval ARGV[1]
+      # we need to keep the same backtraces to make comparison adequate
+      # since NonExistingException will never be raised - the exception
+      # will propagate to the top level and interpreter will do it's job
+    rescue (ARGV[0] == "native" ? NonExistingException : Exception) => e
+      puts Exception.error_print
+    end
+  end
+end

data/lib/dolzenko/gist_readme.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+#
+# Usage: ./gist_readme.rb source_file.rb [README.md]
+#
+# Extracts first comment block from source_file.rb into README.md file
+#
+#
+raise "source_file should be specified" if ARGV.empty?
+
+File.open(File.expand_path(File.join("../", ARGV[1] || "README.md") , __FILE__), "w") do |f|
+  first_comment = []
+  IO.read(File.expand_path(File.join("../", ARGV[0]), __FILE__)).each_line do |l|
+    if l =~ /\s*#/
+      first_comment << l.sub(/^\s*#\s/, "").rstrip
+    elsif !first_comment.empty?
+      break
+    end
+  end
+  f.write(first_comment.join("\n"))
+end

data/lib/dolzenko/includable_with_options.rb

@@ -0,0 +1,106 @@
+# Check Thomas Sawyer take on the problem http://github.com/rubyworks/paramix
+module IncludableWithOptions
+  class << self
+    attr_accessor :last_default_options
+  end
+
+  def self.included(includable_with_options)
+    %w(string/methodize kernel/constant module/basename module/spacename).each { |facets_core_ext| require "facets/#{ facets_core_ext }" }
+
+    raise "IncludableWithOptions should be included by the Module" unless includable_with_options.instance_of?(Module)
+
+    options_class_var_name = "@@#{ includable_with_options.basename.methodize }_options"
+
+    unless IncludableWithOptions.last_default_options.nil?
+      includable_with_options.send(:class_variable_set, options_class_var_name, IncludableWithOptions.last_default_options)
+      IncludableWithOptions.last_default_options = nil
+    end
+
+    context = Kernel.constant(includable_with_options.spacename)
+
+    option_setting_duplicator = <<-CODE
+      def #{ context != Kernel ? "self." : "" }#{ includable_with_options.basename }(options = nil)
+        m = Kernel.constant("#{ includable_with_options.name }").dup
+        m.send(:class_variable_set, "#{ options_class_var_name }", options)
+        m
+      end    
+    CODE
+
+    context.module_eval(option_setting_duplicator)
+  end
+end
+
+def IncludableWithOptions(options = {})
+  m = Kernel.const_get(:IncludableWithOptions).dup
+  # Because of Ruby bug (?) model function +included+ won't be able to access @@default_options:
+  # http://redmine.ruby-lang.org/issues/show/3080
+  # m.send(:class_variable_set, :@@default_options, options[:default])
+  IncludableWithOptions.last_default_options = options[:default] 
+  m
+end
+
+if $PROGRAM_NAME == __FILE__
+
+  module MyStuff
+    module SystemWithTweaks
+      include IncludableWithOptions(:default => {})
+
+      def system(*args)
+        puts "@@system_with_tweaks_options #{ @@system_with_tweaks_options }"
+        puts "Executing command: #{ args.join(" ") }" if @@system_with_tweaks_options[:echo]
+        result = Kernel.system(*args)
+        raise "Command #{ args.join(" ") } exited with a nonzero exit status" if @@system_with_tweaks_options[:raise_exceptions]
+        result
+      end
+    end
+  end
+
+  module MyStuff
+    class D
+      include MyStuff::SystemWithTweaks(:asd => 123)
+
+      def m
+        system "echo 'just echoing'"
+      end
+    end
+  end
+
+
+  module SystemWithTweaks
+    include IncludableWithOptions(:default => { :echo => true })
+
+    def system(*args)
+      puts "Executing command: #{ args.join(" ") }" if @@system_with_tweaks_options[:echo]
+      result = Kernel.system(*args)
+      raise "Command #{ args.join(" ") } exited with a nonzero exit status" if @@system_with_tweaks_options[:raise_exceptions]
+      result
+    end
+  end
+
+  class C
+    include SystemWithTweaks(:echo => true)
+
+    def m
+      system "ls"
+    end
+  end
+
+  module MyStuff 
+    class B
+      include MyStuff::SystemWithTweaks(:raise_exceptions => true)
+
+      def m
+        system "does_not_exist"
+      end
+    end
+  end
+
+  puts "Top level include with options"
+  C.new.m
+
+  puts "Namespaced include without options"
+  MyStuff::D.new.m
+
+  puts "Namespaced include with options"
+  MyStuff::B.new.m
+end