hobo 0.7.2 → 0.7.3

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

@@ -1,43 +0,0 @@
-module Hobo
-  
-  class FieldDeclarationsDsl
-    
-    def initialize(model)
-      @model = model
-    end
-    
-    attr_reader :model
-    
-    def timestamps
-      field(:created_at, :datetime)
-      field(:updated_at, :datetime)
-    end
-    
-    def field(name, *args)
-      type = args.shift
-      options = args.extract_options!
-      
-      @model.name_attribute            = name.to_sym if options.delete(:name)
-      @model.primary_content_attribute = name.to_sym if options.delete(:description)
-      @model.creator_attribute         = name.to_sym if options.delete(:creator)
-
-      @model.send(:login_attribute=, name.to_sym, options.delete(:validate)) if @model < User && options.delete(:login)
-      
-      @model.send(:set_field_type, name => type) unless
-        type.in?(@model.connection.native_database_types.keys - [:text])
-      @model.field_specs[name] = FieldSpec.new(@model, name, type, options)
-      
-      @model.send(:validates_presence_of, name)   if :required.in?(args)
-      @model.send(:validates_uniqueness_of, name) if :unique.in?(args)
-    end
-    
-    def method_missing(name, *args)
-      field(name, *args)
-    end
-    
-    undef_method :type
-    
-    
-  end
-  
-end

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

@@ -1,68 +0,0 @@
-module Hobo
-  
-  class FieldSpec
-    
-    class UnknownSqlTypeError < RuntimeError; end
-  
-    def initialize(model, name, type, options={})
-      raise ArgumentError, "you cannot provide a field spec for the primary key" if name == model.primary_key
-      self.model = model
-      self.name = name.to_sym
-      self.type = type.is_a?(String) ? type.to_sym : type
-      self.options = options
-      self.position = model.field_specs.length
-    end
-    
-    attr_accessor :model, :name, :type, :position, :options
-    
-    def sql_type
-      options[:sql_type] or begin
-                              native_types = model.connection.native_database_types.keys - [:primary_key]
-                              if type.in?(native_types)
-                                type
-                              else
-                                field_type = type.is_a?(Class) ? type : Hobo.field_types[type]
-                                field_type && field_type::COLUMN_TYPE or raise UnknownSqlTypeError, [model, name, type]
-                              end
-                            end
-    end
-    
-    def limit
-      options[:limit] || types[sql_type][:limit]
-    end
-    
-    def precision
-      options[:precision]
-    end
-    
-    def scale
-      options[:scale]
-    end
-    
-    def null
-      :null.in?(options) ? options[:null] : true
-    end
-    
-    def default
-      options[:default]
-    end
-    
-    def different_to?(col_spec)
-      sql_type != col_spec.type ||
-        begin
-          check_cols = [:null, :default]
-          check_cols += [:precision, :scale] if sql_type == :decimal
-          check_cols << :limit if sql_type.in?([:string, :text, :binary, :integer])
-          check_cols.any? { |k| col_spec.send(k) != self.send(k) }
-        end
-    end
-    
-    private
-    
-    def types
-      @types ||= model.connection.native_database_types
-    end
-    
-  end
-  
-end

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

@@ -1,7 +0,0 @@
-class Hobo::HtmlString < String
-  
-  COLUMN_TYPE = :text
-
-end
-
-Hobo.field_types[:html] = Hobo::HtmlString

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

@@ -1,40 +0,0 @@
-class Hobo::LazyHash < Hash
-  
-  def initialize(hash=nil)
-    if hash.is_a?(Hash)
-      update(hash)
-    else
-      super
-    end
-  end
-  
-  
-  def [](key)
-    val = super
-    if val.is_a?(Proc)
-      self[val] = val.call
-    else
-      val
-    end
-  end
-  
-  
-  def delete(key)
-    val = super
-    val.is_a?(Proc) ? val.call : val
-  end
-  
-  
-  def inspect
-    pairs = map do |k, v|
-      "#{k.inspect} => #{v.is_a?(Proc) ? '??' : v.inspect}"
-    end
-    "{#{pairs * ', '}}"
-  end
-  
-  
-  def to_s
-    inspect
-  end
-  
-end

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

@@ -1,11 +0,0 @@
-class Hobo::MarkdownString < String
-  
-  COLUMN_TYPE = :text
-  
-  def to_html
-    blank? ? "" : BlueCloth.new(self).to_html
-  end
-
-end
-
-Hobo.field_types[:markdown] = Hobo::MarkdownString

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

@@ -1,12 +0,0 @@
-module Hobo::Migrations
-  
-  class << self
-    attr_accessor :ignore_tables
-    attr_accessor :ignore_models
-    attr_accessor :ignore
-  end
-  self.ignore_tables = []
-  self.ignore_models = []
-  self.ignore = []
-  
-end

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

@@ -1,117 +0,0 @@
-module Hobo
-
-  class ModelQueries
-
-    def initialize(model)
-      @model = model
-    end
-
-
-    attr_reader :model
-
-    def not_(fragment)
-      WhereFragment.new("not (#{fragment.to_sql})")
-    end
-
-
-    def is_in(association)
-      association = Hobo.object_from_dom_id(association) if association.is_a? String
-      refl = association.proxy_reflection
-      raise HoboError.new("association #{refl.name} is not a collection of #{model.name.pluralize}") unless
-        refl.klass == model and refl.macro == :has_many
-
-      WhereFragment.new(_association_finder_sql(association))
-    end
-    
-    
-    def not_in(association)
-      not_(is_in(association))
-    end
-    
-    
-    def sql(s)
-      WhereFragment.new(s)
-    end
-    
-    def block(b)
-      b && instance_eval(&b)
-    end
-    
-    
-    def all?(*args)
-      args.inject { |m, a| m & a }
-    end
-
-    def any?(*args)
-      args.inject { |m, a| m | a }
-    end
-
-    def method_missing(name, *args)
-      check_column = proc do |col|
-        raise HoboError.new("no such column '#{col}' in query") unless
-          model.columns.every(:name).include? col
-      end
-
-      m, field = *name.to_s.match(/^(.*)_is$/)
-      if m
-        if (refl = model.reflections[field.to_sym]) && refl.macro == :belongs_to
-          field = refl.primary_key_name
-          val = args[0] && args[0].id
-          raise HoboError.new("don't use self in query blocks") if val == self
-        else 
-          check_column[field]
-          val = args[0]
-        end
-        return (if val.nil?
-                  WhereFragment.new("#{_query_table}.#{field} IS NULL")
-                else
-                  WhereFragment.new("#{_query_table}.#{field} = ?", val)
-                end)
-      end
-
-      m, field = *name.to_s.match(/^(.*)_contains$/)
-      if m
-        check_column[field]
-        return WhereFragment.new("#{_query_table}.#{field} like ?", "%#{args[0]}%")
-      end
-
-      m, field = *name.to_s.match(/^(.*)_starts$/)
-      if m
-        check_column[field]
-        return WhereFragment.new("#{_query_table}.#{field} like ?", "#{args[0]}%")
-      end
-
-      m, field = *name.to_s.match(/^(.*)_ends$/)
-      if m
-        check_column[field]
-        return WhereFragment.new("#{_query_table}.#{field} like ?", "%#{args[0]}")
-      end
-      
-      if (refl = model.reflections[name.to_sym]) && refl.macro == :belongs_to
-        return ModelQueries.new(refl.klass)
-      end
-
-      return WhereFragment.new(@model.send(name, *args))
-    end
-
-    def _association_finder_sql(assoc)
-      refl = assoc.proxy_reflection
-      if refl.through_reflection
-        conditions = assoc.send(:construct_conditions)
-        from       = assoc.send(:construct_from)
-        joins      = assoc.send(:construct_joins)
-
-        table = "#{model.table_name}"
-        "id in (select #{table}.id from #{table} #{joins} where #{conditions})"
-      else
-        Object.instance_method(:instance_variable_get).bind(assoc).call("@finder_sql")
-      end
-    end
-    
-    def _query_table
-      model.table_name
-    end
-
-  end
-
-end

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

@@ -1,7 +0,0 @@
-class Hobo::PasswordString < String
-  
-  COLUMN_TYPE = :string
-
-end
-
-Hobo.field_types[:password] = Hobo::PasswordString

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

@@ -1,14 +0,0 @@
-module Hobo
-  
-  class Percentage < DelegateClass(Fixnum)
-    
-    COLUMN_TYPE = :integer
-    
-    def validate
-      "must be from 0 to 100" unless self.in?(0..100)
-    end
-        
-  end
-
-end
-Hobo.field_types[:percentage] = Hobo::Percentage

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

@@ -1,78 +0,0 @@
-module Hobo::PredicateDispatch
-  
-  def self.included(base)
-    base.extend(ClassMethods)
-  end
-  
-  module ClassMethods
-    
-    def default_method_for(method)
-      "_default_#{method}"
-    end
-    
-    def defp(name, predicate=nil, &block)
-      ivar = "@@#{name}_predicates"
-      default_method_name = default_method_for(name).to_sym
-      methods = ivar.in?(class_variables) && class_variable_get(ivar)
-
-      if !methods
-        # It's the first defp for this name...
-
-        methods = class_variable_set(ivar, [])
-        
-        if name.to_s.in?(instance_methods) and predicate
-          # There's already a normal method with this name - it
-          # becomes the default.
-          alias_method default_method_name, name
-        end
-        
-      end
-      
-      if predicate
-        pname = "#{name}_p#{methods.length}"
-        methods << [pname, predicate.arity == 1, block.arity == 2]
-        define_method(pname, block)
-        define_method(pname + "_predicate", &predicate)
-      else
-        # It's the default - if there's already one, overwrite it
-        define_method(default_method_name, block)
-      end
-      
-      module_eval <<-END, __FILE__, __LINE__+1
-        def #{name}(options={}, &block)
-          methods = #{ivar}
-          for method_name, predicate_wants_options, wants_block in methods
-            pred = method_name + "_predicate"
-            if (predicate_wants_options ? send(pred, options) : send(pred))
-              return (if wants_block
-                        send(method_name, options, block)
-                      else
-                        send(method_name, options) 
-                      end)
-            end
-          end
-          if respond_to?(:#{default_method_name})
-            if method(:#{default_method_name}).arity == 2
-               #{default_method_name}(options, block) 
-            else
-               #{default_method_name}(options) 
-            end
-          end
-        end
-      END
-    end
-    
-    alias :p :proc
-    
-    def predicate_method?(method_name)
-      "@@#{method_name}_predicates".in?(class_variables)
-    end
-    
-    def predicate_has_default?(method_name)
-      default_method_for(method_name).in?(instance_methods)
-    end
-    
-  end
-  
-  
-end

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

@@ -1,32 +0,0 @@
-module Hobo
-
-  class ProcBinding
-
-    def self.eval(proc, self_, locals)
-      ProcBinding.new(self_, locals).instance_eval(&proc)
-    end
-
-    def initialize(self_, locals)
-      @self_ = self_
-      @locals = locals
-      locals.symbolize_keys!
-    end
-
-    def method_missing(name, *args, &block)
-      if @locals.has_key?(name)
-        @locals[name]
-      else
-        @self_.send(name, *args, &block)
-      end
-    end
-
-  end
-
-  (Object.instance_methods + 
-   Object.private_instance_methods +
-   Object.protected_instance_methods).each do |m|
-    ProcBinding.send(:undef_method, m) unless
-      %w{initialize method_missing send instance_eval}.include?(m) || m.starts_with?('_')
-  end
-
-end

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

@@ -1,3 +0,0 @@
-class Hobo::Text < String; end
-
-Hobo.field_types[:text] = Hobo::Text