hobo 0.7.2 → 0.7.3

data/hobo_files/plugin/generators/hobo_migration/templates/migration.rb

@@ -1,9 +0,0 @@
-class <%= migration_name %> < ActiveRecord::Migration
-  def self.up
-    <%= up %>
-  end
-
-  def self.down
-    <%= down %>
-  end
-end

data/hobo_files/plugin/lib/active_record/table_definition.rb

@@ -1,34 +0,0 @@
-module ActiveRecord::ConnectionAdapters
-
-  class TableDefinition
-
-    def fkey(*args)
-      options = take_options!(args)
-      args.each {|col| column("#{col}_id".to_sym, :integer, options)}
-    end
-
-    def auto_dates
-      column :created_at, :datetime
-      column :updated_at, :datetime
-    end
-
-    def method_missing(name, *args)
-      if name.in? [:integer, :float, :decimal, :datetime, :date, :timestamp,
-                      :time, :text, :string, :binary, :boolean ]
-        options = take_options!(args)
-        args.each {|col| column(col, name, options)}
-      else
-        super
-      end
-    end
-
-
-    private
-
-    def take_options!(args)
-      args.last.is_a?(Hash) ? args.pop : {}
-    end
-
-  end
-
-end

data/hobo_files/plugin/lib/extensions.rb

@@ -1,375 +0,0 @@
-class Module
-  
-  def inheriting_attr_accessor(*names)
-    for name in names
-      class_eval %{
-        def #{name}
-          if defined? @#{name}
-            @#{name}
-          elsif superclass.respond_to?('#{name}')
-            superclass.#{name}
-          end
-        end
-      }
-    end
-  end
-  
-  # Custom alias_method_chain that won't cause inifinite recursion if
-  # called twice.
-  # Calling alias_method_chain on alias_method_chain
-  # was just way to confusing, so I copied it :-/
-  def alias_method_chain(target, feature)
-    # Strip out punctuation on predicates or bang methods since
-    # e.g. target?_without_feature is not a valid method name.
-    aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
-    yield(aliased_target, punctuation) if block_given?
-    without = "#{aliased_target}_without_#{feature}#{punctuation}"
-    unless instance_methods.include?(without)
-      alias_method without, target
-      alias_method target, "#{aliased_target}_with_#{feature}#{punctuation}"
-    end
-  end
-
-  
-  # Fix delegate so it doesn't go bang if 'to' is nil
-  def delegate(*methods)
-    options = methods.pop
-    unless options.is_a?(Hash) && to = options[:to]
-      raise ArgumentError, "Delegation needs a target. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, :to => :greeter)."
-    end
-
-    methods.each do |method|
-      module_eval(<<-EOS, "(__DELEGATION__)", 1)
-        def #{method}(*args, &block)
-          (_to = #{to}) && _to.__send__(#{method.inspect}, *args, &block)
-        end
-      EOS
-    end
-  end
-    
-  private
-  
-  def bool_attr_accessor(*args)
-    options = extract_options_from_args!(args)
-    (args + options.keys).each {|n| class_eval "def #{n}=(x); @#{n} = x; end" }
-    
-    args.each {|n| class_eval "def #{n}?; !!@#{n}; end" }
-
-    options.keys.each do |n|
-      class_eval %(def #{n}?
-                     if @#{n}.nil? && !instance_variables.include?("@\#{@#{n}}")
-                       @#{n} = #{options[n].inspect}
-                     else
-                       @#{n}
-                     end
-                   end)
-      set_field_type(n => TrueClass) if respond_to?(:set_field_type)
-    end
-  end
-
-end
-
-module Kernel
-
-  def extract_options_from_args!(args) #:nodoc:
-    args.last.is_a?(Hash) ? args.pop : {}
-  end
-  
-  def it() It.new end
-  alias its it
-  
-end
-
-
-class It
-
-  undef_method(*(instance_methods - %w*__id__ __send__*))
-
-  def initialize
-    @methods = []
-  end
-
-  def method_missing(*args, &block)
-    @methods << [args, block] unless args == [:respond_to?, :to_proc]
-    self
-  end
-
-  def to_proc
-    lambda do |obj|
-      @methods.inject(obj) do |current,(args,block)|
-        current.send(*args, &block)
-      end
-    end
-  end
-end
-
-
-class Object
-
-  def in?(array)
-    array.include?(self)
-  end
-
-  def not_in?(array)
-    not array.include?(self)
-  end
-  
-  alias_method :is_a_without_multiple_args?, :is_a?
-  def is_a?(*args)
-    args.any? {|a| is_a_without_multiple_args?(a) }
-  end
-  
-  # metaid
-  def metaclass; class << self; self; end; end
-  def meta_eval &blk; metaclass.instance_eval &blk; end
-
-  # Adds methods to a metaclass
-  def meta_def name, &blk
-    meta_eval { define_method name, &blk }
-  end
-
-  # Defines an instance method within a class
-  def class_def name, &blk
-    class_eval { define_method name, &blk }
-  end
-  
-  def _?()
-    self
-  end
-
-end
-
-
-class NilClass
-  def _?()
-    SafeNil.instance
-  end
-end
-
-
-class SafeNil
-  include Singleton
-  
-  def method_missing(method, *args, &b)
-    return nil unless nil.respond_to? method
-    nil.send(method, *args, &b) rescue nil
-  end
-end
-
-alias DelegateClass_without_safe_nil DelegateClass 
-def DelegateClass(klass)
-  c = DelegateClass_without_safe_nil(klass)
-  c.class_eval do 
-    def _?
-      self
-    end
-  end
-  c
-end
-
-
-
-class TrueClass
-  
-  def implies(x)
-    x 
-  end
-  
-end
-
-class FalseClass
-  
-  def implies(x)
-    true
-  end
-  
-end
-
-
-module Enumerable
-
-  def search(not_found=nil)
-    each do |x|
-      val = yield(x)
-      return val if val
-    end
-    not_found
-  end
-
-  def every(method, *args)
-    map { |x| x.send(method, *args) }
-  end
-    
-  def map_with_index
-    res = []
-    each_with_index {|x, i| res << yield(x, i)}
-    res
-  end
-  
-  def build_hash
-    res = {}
-    each do |x|
-      k, v = yield x
-      res[k] = v
-    end
-    res
-  end
-  
-  def map_hash
-    res = {}
-    each do |x|
-      v = yield x
-      res[x] = v
-    end
-    res
-  end
-
-end
-
-class Hash
-
-  def self.build(array)
-    array.inject({}) do |res, x|
-      k, v = yield x
-      res[k] = v
-      res
-    end
-  end
-
-  def select_hash(new_keys=nil)
-    res = {}
-    if block_given?
-      each {|k,v| res[k] = v if yield(k,v) }
-    else
-      new_keys.each {|k| res[k] = self[k] if self.has_key?(k)}
-    end
-    res
-  end
-  
-  def map_hash(&b)
-    res = {}
-    each {|k,v| res[k] = b.arity == 1 ? yield(v) : yield(k, v) }
-    res
-  end
-
-  #alias_method :hobo_original_reject, :reject
-  def rejectX(keys=nil, &b)
-    if b
-      hobo_original_reject(&b)
-    else
-      res = {}.update(self) # can't use dup because it breaks with symbols
-      keys.each {|k| res.delete(k)}
-      res
-    end
-  end
-
-  def partition_hash(keys=nil)
-    yes = {}
-    no = {}
-    each do |k,v|
-      if block_given? ? yield(k,v) : keys.include?(k)
-        yes[k] = v
-      else
-        no[k] = v
-      end
-    end
-    [yes, no]
-  end
-  
-  def -(keys)
-    res = {}
-    each_pair {|k, v| res[k] = v unless k.in?(keys)}
-    res
-  end
-  
-  def &(keys)
-    res = {}
-    keys.each {|k| res[k] = self[k] if has_key?(k)}
-    res    
-  end
-  
-end
-
-
-class HashWithIndifferentAccess
-  
-  def -(keys)
-    res = HashWithIndifferentAccess.new
-    keys = keys.map {|k| k.is_a?(Symbol) ? k.to_s : k }
-    each_pair { |k, v| res[k] = v unless k.in?(keys) }
-    res
-  end
-  
-  def &(keys)
-    res = HashWithIndifferentAccess.new
-    keys.each do |k|
-      k = k.to_s if k.is_a?(Symbol)
-      res[k] = self[k] if has_key?(k)
-    end
-    res    
-  end
-  
-  def partition_hash(keys=nil)
-    keys = keys._?.map {|k| k.is_a?(Symbol) ? k.to_s : k }
-    yes = HashWithIndifferentAccess.new
-    no = HashWithIndifferentAccess.new
-    each do |k,v|
-      if block_given? ? yield(k,v) : keys.include?(k)
-        yes[k] = v
-      else
-        no[k] = v
-      end
-    end
-    [yes, no]
-  end
-
-
-end
-
-
-class <<ActiveRecord::Base
-  alias_method :[], :find
-end
-
-
-# --- Fix Chronic - can't parse '12th Jan' --- #
-begin
-  require 'chronic'
-  
-  module Chronic
-    
-    class << self
-      def parse_with_hobo_fix(s)
-        parse_without_hobo_fix(if s =~ /^\s*\d+\s*(st|nd|rd|th)\s+[a-zA-Z]+(\s+\d+)?\s*$/
-                                 s.sub(/\s*\d+(st|nd|rd|th)/) {|s| s[0..-3]}
-                               else
-                                 s
-                               end)
-      end
-      alias_method_chain :parse, :hobo_fix
-    end
-  end
-rescue MissingSourceFile; end
-
-
-
-# --- Fix pp dumps - these break sometimes without this --- #
-require 'pp'
-module PP::ObjectMixin
-
-  alias_method :orig_pretty_print, :pretty_print
-  def pretty_print(q)
-    orig_pretty_print(q)
-  rescue
-    "[#PP-ERROR#]"
-  end
-
-end
-
-class Proc
-  
-  def call_with_block(*args, &b)
-    call(*args + [b])
-  end
-  
-end

data/hobo_files/plugin/lib/hobo/email_address.rb

@@ -1,12 +0,0 @@
-class Hobo::EmailAddress < String
-  
-  COLUMN_TYPE = :string
-  
-  def validate
-    "is not a valid email address" unless 
-      self.blank? || self =~ /^\s*([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\s*$/i
-  end
-
-end
-
-Hobo.field_types[:email_address] = Hobo::EmailAddress

data/hobo_files/plugin/lib/hobo/enum_string.rb

@@ -1,50 +0,0 @@
-module Hobo
-  
-  class EnumString < String
-    
-    module Helper
-      
-      def enum_string(*values)
-        EnumString.for(*values)
-      end
-      
-    end
-    
-    class << self 
-      
-      def with_values(*values)
-        @values = values.every(:to_s)
-      end
-      
-      attr_accessor :values
-      
-      def for(*values)
-        values = values.every(:to_s)
-        c = Class.new(EnumString) do
-          values.each do |v|
-            define_method("#{v.underscore}?") { self == v }
-            meta_def("#{v.underscore}") { v }
-          end
-        end
-        c.with_values(*values)
-        c
-      end
-      
-      def inspect
-        name.blank? ? "#<EnumString #{(values || []) * ' '}>" : name
-      end
-      alias_method :to_s, :inspect
-      
-    end
-
-    COLUMN_TYPE = :string
-    
-    def validate
-      "must be one of #{self.class.values * ', '}" unless self.in?(self.class.values)
-    end
-    
-  end
-  
-end
-
-Hobo::FieldDeclarationsDsl.send(:include, Hobo::EnumString::Helper)