ohm-contrib 0.1.2 → 1.0.rc0

data/lib/ohm/contrib/fulltext_searching.rb

@@ -1,80 +0,0 @@
-begin
-  require "text"
-rescue LoadError
-  raise LoadError,
-    "Type `[sudo] gem install text` to use Ohm::FulltextSearching."
-end
-
-module Ohm
-  module FulltextSearching
-    def self.included(model)
-      model.extend ClassMethods
-    end
-  
-    module ClassMethods
-      def search(hash)
-        find(hash_to_metaphones(hash))
-      end
-  
-      def hash_to_metaphones(hash)
-        ret = Hash.new { |h, k| h[k] = [] }
-
-        hash.each do |att, string|
-          metaphones(string).each { |m| ret[:"fulltext_#{att}"] << m }
-        end
-        
-        return ret
-      end
-  
-      def double_metaphone(str)
-        return [] if STOPWORDS.include?(str.to_s.downcase)
-
-        Text::Metaphone.double_metaphone(str).compact
-      end
-
-      def metaphones(str)
-        str.to_s.strip.split(/\s+/).map { |s| double_metaphone(s) }.flatten
-      end
-
-      def fulltext(att)
-        field = :"fulltext_#{att}"
-        
-        define_method(field) { self.class.metaphones(send(att)) }
-        index(field)
-      end
-    end
-
-    STOPWORDS = %w{a about above according across actually adj after 
-      afterwards again against all almost alone along already also although 
-      always among amongst an and another any anyhow anyone anything anywhere 
-      are aren't around as at b be became because become becomes becoming 
-      been before beforehand begin behind being below beside besides between
-      beyond both but by c can can't cannot caption co co. could couldn't d 
-      did didn't do does doesn't don't down during e each eg eight eighty 
-      either else elsewhere end ending enough etc even ever every everyone 
-      everything everywhere except f few first for found from further g h 
-      had has hasn't have haven't he he'd he'll he's hence her here here's 
-      hereafter hereby herein hereupon hers herself him himself his how 
-      however hundred i i'd i'll i'm i've ie if in inc. indeed instead into is
-      isn't it it's its itself j k l last later latter latterly least less let
-      let's like likely ltd m made make makes many maybe me meantime meanwhile 
-      might miss more moreover most mostly mr mrs much must my myself n namely 
-      neither never nevertheless next nine ninety no nobody none nonetheless 
-      noone nor not nothing now nowhere o of off often on once one one's only 
-      onto or other others otherwise our ours ourselves out over overall own 
-      p per perhaps q r rather recent recently s same seem seemed seeming 
-      seems seven several she she'd she'll she's should shouldn't since so 
-      some somehow someone something sometime sometimes somewhere still such 
-      t taking than that that'll that's that've the their them themselves then
-      thence there there'd there'll there're there's there've thereafter thereby 
-      therefore therein thereupon these they they'd they'll they're they've 
-      thirty this those though three through throughout thru thus to together 
-      too toward towards u under unless unlike unlikely until up upon us used 
-      using v very via w was wasn't we we'd we'll we're we've well were weren't 
-      what what'll what's what've whatever when whence whenever where where's 
-      whereafter whereas whereby wherein whereupon wherever whether which while 
-      whither who who'd who'll who's whoever whole whom whomever whose why will 
-      with within without won't would wouldn't x y yes yet you you'd you'll 
-      you're you've your yours yourself yourselves z}
-  end
-end

data/lib/ohm/contrib/length_validations.rb

@@ -1,32 +0,0 @@
-module Ohm
-  module LengthValidations
-
-    def assert_min_length(att, length, error = [att, :too_short])
-      if assert_present(att, error)
-        m = send(att).to_s
-        assert is_long_enough?(m, length), error
-      end
-    end
-
-    def assert_max_length(att, length, error = [att, :too_long])
-      if assert_present(att, error)
-        m = send(att).to_s
-        assert is_too_long?(m, length), error
-      end
-    end
-
-    private
-    def is_too_long?(string, length)
-      string.size <= length
-    rescue ArgumentError
-      return false
-    end
-
-    def is_long_enough?(string, length)
-      string.size >= length
-    rescue ArgumentError
-      return false
-    end
-  end
-end
-

data/lib/ohm/contrib/number_validations.rb

@@ -1,14 +0,0 @@
-module Ohm
-  # This module will include all numeric validation needs.
-  # As of VERSION 0.0.27, Ohm::NumberValidations#assert_decimal
-  # is the only method provided.
-  module NumberValidations
-    DECIMAL_REGEX = /^(\d+)?(\.\d+)?$/
-
-  protected
-    def assert_decimal(att, error = [att, :not_decimal])
-      assert_format att, DECIMAL_REGEX, error
-    end
-  end
-end
-

data/lib/ohm/contrib/timestamping.rb

@@ -1,38 +0,0 @@
-module Ohm
-  # Provides created_at / updated_at timestamps.
-  #
-  # @example
-  #
-  #   class Post < Ohm::Model
-  #     include Ohm::Timestamping
-  #   end
-  #
-  #   post = Post.create
-  #   post.created_at.to_s == Time.now.utc.to_s
-  #   # => true
-  #
-  #   post = Post[post.id]
-  #   post.save
-  #   post.updated_at.to_s == Time.now.utc.to_s
-  #   # => true
-  module Timestamping
-    def self.included(base)
-      base.attribute :created_at
-      base.attribute :updated_at
-    end
-
-    def create
-      self.created_at ||= Time.now.utc.to_s
-
-      super
-    end
-
-  protected
-    def write
-      self.updated_at = Time.now.utc.to_s
-
-      super
-    end
-  end
-end
-

data/lib/ohm/contrib/typecast.rb

@@ -1,350 +0,0 @@
-require 'bigdecimal'
-require 'time'
-require 'date'
-require 'forwardable'
-require "json"
-
-module Ohm
-  # Provides all the primitive types. The following are included:
-  #
-  # * String
-  # * Decimal
-  # * Integer
-  # * Float
-  # * Date
-  # * Time
-  # * Hash
-  # * Array
-  # * Boolean
-  module Types
-    def self.defined?(type)
-      @_constants ||= constants.map { |c| c.to_sym }
-      @_constants.include?(type.to_sym)
-    end
-
-    def self.[](type)
-      const_get(type.to_s.split('::').last)
-    end
-
-    class Base < BasicObject
-      class Exception < ::Exception; end
-
-      extend ::Forwardable
-
-      @@delegation_blacklist = [
-        :==, :to_s, :initialize, :inspect, :object_id, :__send__, :__id__,
-        :respond_to?
-      ]
-
-      def self.[](value)
-        return empty  if value.to_s.empty?
-
-        new(value)
-      end
-
-      def self.empty
-        defined?(self::RAW) ? self::RAW.new : nil
-      end
-
-      def self.delegate_to(klass, except = @@delegation_blacklist)
-        methods = klass.public_instance_methods.map { |e| e.to_sym } - except
-        def_delegators :object, *methods
-      end
-
-      def inspect
-        @raw.inspect
-      end
-    end
-
-    class Primitive < Base
-      def initialize(value)
-        @raw = value
-      end
-
-      def to_s
-        @raw.to_s
-      end
-
-      def ==(other)
-        to_s == other.to_s
-      end
-
-      def respond_to?(method)
-        object.respond_to?(method)
-      rescue ::ArgumentError
-        @raw.respond_to?(method)
-      end
-
-      def object
-        @raw
-      end
-    end
-
-    class String < Primitive
-      delegate_to ::String
-
-      def type
-        ::String
-      end
-    end
-
-    class Decimal < Primitive
-      delegate_to ::BigDecimal
-
-      def object
-        ::Kernel::BigDecimal(@raw)
-      end
-
-      def type
-        ::BigDecimal
-      end
-    end
-
-    class Integer < Primitive
-      delegate_to ::Fixnum
-
-      def object
-        ::Kernel::Integer(@raw)
-      end
-
-      def type
-        ::Fixnum
-      end
-    end
-
-    class Float < Primitive
-      delegate_to ::Float
-
-      def object
-        ::Kernel::Float(@raw)
-      end
-
-      def type
-        ::Float
-      end
-    end
-
-    class Time < Primitive
-      delegate_to ::Time
-
-      def object
-        ::Time.parse(@raw).utc
-      end
-
-      def type
-        ::Time
-      end
-    end
-
-    class Date < Primitive
-      delegate_to ::Date
-
-      def object
-        ::Date.parse(@raw)
-      end
-
-      def type
-        ::Date
-      end
-    end
-
-    class Boolean
-      def self.[](value)
-        case value
-        when 'false', false, '0', 0 then false
-        when 'true',  true,  '1', 1  then true
-        end
-      end
-    end
-
-    class Serialized < Base
-      attr :object
-
-      def initialize(raw)
-        @object = case raw
-        when self.class::RAW
-          raw
-        when ::String
-          begin
-            ::JSON.parse(raw)
-          rescue ::JSON::ParserError
-            raw
-          end
-        when self.class
-          raw.object
-        else
-          ::Kernel.raise ::TypeError,
-            "%s does not accept %s" % [self.class, raw.inspect]
-        end
-      end
-
-      def ==(other)
-        object == other
-      end
-
-      def to_s
-        object.to_json
-      end
-      alias :inspect :to_s
-
-      def respond_to?(method)
-        object.respond_to?(method)
-      end
-
-      def type
-        self.class::RAW
-      end
-    end
-
-    class Hash < Serialized
-      RAW = ::Hash
-
-      delegate_to ::Hash
-
-      # @private since basic object doesn't include a #class we need
-      # to define this manually
-      def class
-        ::Ohm::Types::Hash
-      end
-    end
-
-    class Array < Serialized
-      RAW = ::Array
-
-      delegate_to ::Array
-
-      # @private since basic object doesn't include a #class we need
-      # to define this manually
-      def class
-        ::Ohm::Types::Array
-      end
-    end
-  end
-
-  # Provides unobtrusive, non-explosive typecasting. Instead of exploding on
-  # set of an invalid value, this module takes the approach of just taking in
-  # parameters and letting you do validation yourself. The only thing this
-  # module does for you is the boilerplate casting you might need to do.
-  #
-  # @example
-  #
-  #   # without typecasting
-  #   class Item < Ohm::Model
-  #     attribute :price
-  #     attribute :posted
-  #   end
-  #
-  #   item = Item.create(:price => 299, :posted => Time.now.utc)
-  #   item = Item[item.id]
-  #
-  #   # now when you try and grab `item.price`, its a string.
-  #   "299" == item.price
-  #   # => true
-  #
-  #   # you can opt to manually cast everytime, or do it in the model, i.e.
-  #
-  #   class Item
-  #     def price
-  #       BigDecimal(read_local(:price))
-  #     end
-  #   end
-  #
-  # The Typecasted way
-  # ------------------
-  #
-  #   class Item < Ohm::Model
-  #     include Ohm::Typecast
-  #
-  #     attribute :price, Decimal
-  #     attribute :posted, Time
-  #   end
-  #
-  #   item = Item.create(:price => "299", :posted => Time.now.utc)
-  #   item = Item[item.id]
-  #   item.price.class == BigDecimal
-  #   # => true
-  #
-  #   item.price.to_s == "299"
-  #   # => true
-  #
-  #   item.price * 2 == 598
-  #   # => true
-  #
-  #   item.posted.strftime('%m/%d/%Y')
-  #   # => works!!!
-  module Typecast
-    def self.included(base)
-      base.extend ClassMethods
-    end
-
-    module ClassMethods
-      # Defines a typecasted attribute.
-      #
-      # @example
-      #
-      #   class User < Ohm::Model
-      #     include Ohm::Typecast
-      #
-      #     attribute :birthday, Date
-      #     attribute :last_login, Time
-      #     attribute :age, Integer
-      #     attribute :spending, Decimal
-      #     attribute :score, Float
-      #   end
-      #
-      #   user = User.new(:birthday => "2000-01-01")
-      #   user.birthday.month == 1
-      #   # => true
-      #
-      #   user.birthday.year == 2000
-      #   # => true
-      #
-      #   user.birthday.day == 1
-      #   # => true
-      #
-      #   user = User.new(:age => 20)
-      #   user.age - 1 == 19
-      #   => true
-      #
-      # @param [Symbol] name the name of the attribute to define.
-      # @param [Class] type (defaults to Ohm::Types::String) a class defined in
-      #                Ohm::Types. You may define custom types in Ohm::Types if
-      #                you need to.
-      # @return [Array] the array of attributes already defined.
-      # @return [nil] if the attribute is already defined.
-      def attribute(name, type = Ohm::Types::String, klass = Ohm::Types[type])
-        # Primitive types maintain a reference to the original object
-        # stored in @_attributes[att]. Hence mutation works for the
-        # Primitive case. For cases like Hash, Array where the value
-        # is `JSON.parse`d, we need to set the actual Ohm::Types::Hash
-        # (or similar) to @_attributes[att] for mutation to work.
-        if klass.superclass == Ohm::Types::Primitive
-          define_method(name) { klass[read_local(name)] }
-        else
-          define_method(name) { write_local(name, klass[read_local(name)]) }
-        end
-
-        define_method(:"#{name}=") do |value|
-          write_local(name, klass[value].to_s)
-        end
-
-        attributes << name unless attributes.include?(name)
-        types[name] = type
-      end
-      alias :typecast :attribute
-
-      def types
-        @types ||= {}
-      end
-
-    private
-      def const_missing(name)
-        if Ohm::Types.defined?(name)
-          Ohm::Types[name]
-        else
-          super
-        end
-      end
-    end
-  end
-end

data/lib/ohm/contrib/web_validations.rb

@@ -1,52 +0,0 @@
-module Ohm
-  # All credit goes to gnrfan of github
-  # Basically an extraction from http://github.com/gnrfan/ohm_extra_validations
-  #
-  # * 2010-05-29 Updated Email Regex, Extracted out regexs to constants
-  #
-  # This module provides the following:
-  # * assert_slug
-  # * assert_email
-  # * assert_url
-  # * assert_ipv4
-  module WebValidations
-    # @see http://fightingforalostcause.net/misc/2006/compare-email-regex.php
-    EMAIL_REGEX = /^([\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~]+\.)*[\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~]+@((((([a-z0-9]{1}[a-z0-9\-]{0,62}[a-z0-9]{1})|[a-z])\.)+[a-z]{2,6})|(\d{1,3}\.){3}\d{1,3}(\:\d{1,5})?)$/i
-
-    SLUG_REGEX  = /^[-\w]+$/
-
-    URL_REGEX   = /^(http|https):\/\/([a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}|(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}|localhost)(:[0-9]{1,5})?(\/.*)?$/ix
-
-    IPV4_REGEX  = /^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$/
-
-  protected
-    def assert_slug(att, error = [att, :not_slug])
-      if assert_present(att, error) and assert_unique(att)
-        assert_format(att, SLUG_REGEX, error)
-      end
-    end
-
-    def assert_email(att, error = [att, :not_email])
-      if assert_present(att, error)
-        assert_format(att, EMAIL_REGEX, error)
-      end
-    end
-
-    def assert_url(att, error = [att, :not_url])
-      if assert_present(att, error)
-        assert_format(att, URL_REGEX, error)
-      end
-    end
-
-    def assert_ipv4(att, error = [att, :not_ipv4])
-      if assert_present(att, error)
-        assert_format(att, IPV4_REGEX, error)
-      end
-    end
-
-    def assert_ipaddr(att, error = [att, :not_ipaddr])
-      assert_ipv4(att, error)
-    end
-  end
-end
-

data/test/activemodel_test.rb

@@ -1,27 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("./helper", File.dirname(__FILE__))
-
-require "test/unit"
-require "active_model"
-
-class ActiveModelTest < Test::Unit::TestCase
-  include ActiveModel::Lint::Tests
-
-  class Post < Ohm::Model
-    include Ohm::ActiveModelExtension
-
-    attribute :body
-    list :related, Post
-
-    def validate
-      assert_present :body
-    end
-  end
-
-  def setup
-    @model = Post.new
-  end
-end
-
-

data/test/boundaries_test.rb

@@ -1,45 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("./helper", File.dirname(__FILE__))
-
-class Person < Ohm::Model
-  include Ohm::Boundaries
-
-  attribute :name
-  index :name
-end
-
-test "first / last are nil when no records" do
-  assert nil == Person.first
-  assert nil == Person.last
-end
-
-test "first / last returns the only record when just 1 record" do
-  matz = Person.create(:name => "matz")
-
-  assert matz == Person.first
-  assert matz == Person.last
-end
-
-test "has chronological order by default" do
-  matz  = Person.create(:name => "matz")
-  linus = Person.create(:name => "linus")
-
-  assert matz == Person.first
-  assert linus == Person.last
-end
-
-test "respects filters passed in" do
-  matz  = Person.create(:name => "matz")
-  linus = Person.create(:name => "linus")
-
-  assert matz == Person.first(:name => "matz")
-  assert matz == Person.last(:name => "matz")
-
-  assert linus == Person.first(:name => "linus")
-  assert linus == Person.last(:name => "linus")
-
-  assert nil == Person.first(:name => "quentin")
-  assert nil == Person.last(:name => "quentin")
-end
-