wayne-friendly 0.5.1

data/lib/friendly/uuid.rb

@@ -0,0 +1,148 @@
+require 'friendly/time'
+require 'friendly/attribute'
+
+# This class was extracted from the cassandra gem by Evan Weaver
+# As such, it is distributed under the terms of the apache license.
+# See the APACHE-LICENSE file in the root of this project for more information.
+#
+module Friendly
+  # UUID format version 1, as specified in RFC 4122, with jitter in place of the mac address and sequence counter.
+  class UUID
+
+    class InvalidVersion < StandardError; end
+    class TypeError < ::TypeError; end
+
+    GREGORIAN_EPOCH_OFFSET = 0x01B2_1DD2_1381_4000 # Oct 15, 1582
+
+    VARIANT = 0b1000_0000_0000_0000
+
+    def initialize(bytes = nil)
+      case bytes
+      when self.class # UUID
+        @bytes = bytes.to_s
+      when String
+        case bytes.size
+        when 16 # Raw byte array
+          @bytes = bytes
+        when 36 # Human-readable UUID representation; inverse of #to_guid
+          elements = bytes.split("-")
+          raise TypeError, "Expected #{bytes.inspect} to cast to a #{self.class} (malformed UUID representation)" if elements.size != 5
+          @bytes = Array(elements.join).pack('H32')
+        else
+          raise TypeError, "Expected #{bytes.inspect} to cast to a #{self.class} (invalid bytecount)"
+        end
+
+      when Integer
+        raise TypeError, "Expected #{bytes.inspect} to cast to a #{self.class} (integer out of range)" if bytes < 0 or bytes > 2**128
+        @bytes = [
+          (bytes >> 96) & 0xFFFF_FFFF,
+          (bytes >> 64) & 0xFFFF_FFFF,
+          (bytes >> 32) & 0xFFFF_FFFF,
+          bytes & 0xFFFF_FFFF
+        ].pack("NNNN")
+
+      when NilClass, Time
+        time = (bytes || Time).stamp * 10 + GREGORIAN_EPOCH_OFFSET
+        # See http://github.com/spectra/ruby-uuid/
+        @bytes = [
+          time & 0xFFFF_FFFF,
+          time >> 32,
+          ((time >> 48) & 0x0FFF) | 0x1000,
+          # Top 3 bytes reserved
+          rand(2**13) | VARIANT,
+          rand(2**16),
+          rand(2**32)
+        ].pack("NnnnnN")
+
+      else
+        raise TypeError, "Expected #{bytes.inspect} to cast to a #{self.class} (unknown source class)"
+      end
+    end
+
+    def to_i
+      ints = @bytes.unpack("NNNN")
+      (ints[0] << 96) +
+      (ints[1] << 64) +
+      (ints[2] << 32) +
+      ints[3]
+    end
+
+    def version
+      time_high = @bytes.unpack("NnnQ")[2]
+      version = (time_high & 0xF000).to_s(16)[0].chr.to_i
+      version > 0 and version < 6 ? version : -1
+    end
+
+    def variant
+      @bytes.unpack('QnnN')[1] >> 13
+    end
+
+    def to_guid
+      elements = @bytes.unpack("NnnCCa6")
+      node = elements[-1].unpack('C*')
+      elements[-1] = '%02x%02x%02x%02x%02x%02x' % node
+      "%08x-%04x-%04x-%02x%02x-%s" % elements
+    end
+
+    def to_json(*args)
+      to_guid.to_json(*args)
+    end
+
+    def seconds
+      total_usecs / 1_000_000
+    end
+
+    def usecs
+      total_usecs % 1_000_000
+    end
+
+    def <=>(other)
+      total_usecs <=> other.send(:total_usecs)
+    end
+
+    def inspect(long = false)
+      "<Friendly::UUID##{object_id} time: #{
+        Time.at(seconds).inspect
+      }, usecs: #{
+        usecs
+      } jitter: #{
+        @bytes.unpack('QQ')[1]
+      }" + (long ? ", version: #{version}, variant: #{variant}, guid: #{to_guid}>" :  ">")
+    end
+
+    def <=>(other)
+      self.to_i <=> other.to_i
+    end
+
+    def hash
+      @bytes.hash
+    end
+
+    def eql?(other)
+      other.is_a?(Comparable) and @bytes == other.to_s
+    end
+
+    def ==(other)
+      self.to_s == other.to_s
+    end
+
+    def to_s
+      @bytes
+    end
+
+    def sql_literal(dataset)
+      dataset.literal(to_s.to_sequel_blob)
+    end
+
+    private
+
+    def total_usecs
+      elements = @bytes.unpack("NnnQ")
+      (elements[0] + (elements[1] << 32) + ((elements[2] & 0x0FFF) << 48) - GREGORIAN_EPOCH_OFFSET) / 10
+    end
+  end
+end
+
+Friendly::Attribute.register_type(Friendly::UUID, 'binary(16)') do |s|
+  Friendly::UUID.new(s)
+end

data/lib/tasks/friendly.rake

@@ -0,0 +1,7 @@
+namespace :friendly do
+  task :build_index do
+    klass  = ENV['KLASS'].constantize
+    fields = ENV['FIELDS'].split(',').map { |f| f.to_sym }
+    Friendly::Indexer.populate(klass, *fields)
+  end
+end

data/rails/init.rb

@@ -0,0 +1,3 @@
+config = YAML.load(File.read(RAILS_ROOT + "/config/friendly.yml"))[RAILS_ENV]
+Friendly.configure(config)
+

data/spec/config.yml.example

@@ -0,0 +1,7 @@
+test:
+  :adapter:  "mysql"
+  :host:     "localhost"
+  :user:     "root"
+  :password: "swordfish"
+  :database: "friendly_test"
+

data/spec/fakes/data_store_fake.rb

@@ -0,0 +1,29 @@
+class DataStoreFake
+  attr_writer :insert, :all, :first
+  attr_reader :inserts, :updates
+
+  def initialize(opts = {})
+    opts.each { |k,v| send("#{k}=", v) }
+    @inserts = []
+    @updates = []
+  end
+
+  def insert(*args)
+    @inserts << args
+    @insert
+  end
+
+  def update(*args)
+    @updates << args
+    @update
+  end
+
+  def all(*args)
+    @all[args]
+  end
+
+  def first(*args)
+    @first[args]
+  end
+end
+

data/spec/fakes/database_fake.rb

@@ -0,0 +1,12 @@
+class DatabaseFake
+  attr_accessor :from
+
+  def initialize(from)
+    @from = from
+  end
+
+  def from(table)
+    @from[table]
+  end
+end
+

data/spec/fakes/dataset_fake.rb

@@ -0,0 +1,28 @@
+class DatasetFake
+  attr_accessor :where, :insert, :inserts, :update, :updates, :first
+
+  def initialize(opts = {})
+    opts.each { |k,v| send("#{k}=", v) }
+    @inserts ||= []
+    @updates ||= []
+  end
+
+  def where(conditions)
+    @where.detect { |k,v| k == conditions }.last
+  end
+
+  def insert(attributes)
+    inserts << attributes
+    @insert
+  end
+
+  def update(attributes)
+    updates << attributes
+    @update
+  end
+
+  def first(conditions)
+    @first.detect { |k,v| k == conditions }.last
+  end
+end
+

data/spec/fakes/document.rb

@@ -0,0 +1,18 @@
+class FakeDocument
+  attr_accessor :id, :created_at, :to_hash, :new_record, :table_name,
+                :indexes, :name, :updated_at, :where_clause
+
+  def initialize(opts = {})
+    opts.each { |k,v| send("#{k}=", v) }
+    new_record = true if new_record.nil?
+  end
+
+  def new_record?
+    new_record
+  end
+
+  def attributes=(attrs)
+    attrs.each { |k,v| send("#{k}=", v) }
+  end
+end
+

data/spec/fakes/serializer_fake.rb

@@ -0,0 +1,12 @@
+class SerializerFake
+  attr_writer :generate
+
+  def initialize(opts = {})
+    opts.each { |k,v| send("#{k}=", v) }
+  end
+
+  def generate(args)
+    @generate[args]
+  end
+end
+

data/spec/fakes/time_fake.rb

@@ -0,0 +1,12 @@
+class TimeFake
+  attr_writer :time
+
+  def initialize(time)
+    @time = time
+  end
+
+  def new
+    @time
+  end
+end
+

data/spec/integration/ad_hoc_scopes_spec.rb

@@ -0,0 +1,42 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Querying with an ad-hoc scope" do
+  before do
+    User.all(:name => "Fred").each { |u| u.destroy }
+    @users = (1..10).map { User.create(:name => "Fred") }
+  end
+
+  it "can return all the objects matching the scope" do
+    User.scope(:name => "Fred").all.should == @users
+  end
+
+  it "can return the first object matching the scope" do
+    User.scope(:name => "Fred").first.should == User.first(:name => "Fred")
+  end
+
+  it "can paginate over the matching objects" do
+    found = User.scope(:name => "Fred").paginate(:per_page! => 5)
+    found.should == User.paginate(:name => "Fred", :per_page! => 5)
+  end
+
+  it "can build an object at scope" do
+    User.scope(:name => "Fred", :limit! => 5).build.name.should == "Fred"
+  end
+
+  it "supports overriding parameters when building" do
+    scope = User.scope(:name => "Fred", :limit! => 5)
+    scope.build(:name => "Joe").name.should == "Joe"
+  end
+
+  it "can create an object at scope" do
+    user = User.scope(:name => "Joe").create
+    user.should_not be_new_record
+    user.name.should == "Joe"
+  end
+
+  it "supports overriding parameters when creating" do
+    user = User.scope(:name => "Joe").create(:name => "Fred")
+    user.should_not be_new_record
+    user.name.should == "Fred"
+  end
+end

data/spec/integration/basic_object_lifecycle_spec.rb

@@ -0,0 +1,114 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Creating and retrieving an object" do
+  before do
+    @user       = User.new :name => "Stewie Griffin",
+                           :age  => 3
+    @user.save
+    @found_user = User.find(@user.id)
+  end
+
+  it "finds the user in the database" do
+    @found_user.name.should == @user.name
+    @found_user.age.should  == @user.age
+    @found_user.id.should   == @user.id
+  end
+
+  it "locates an object that is == to the created object" do
+    @found_user.should == @user
+  end
+
+  it "sets the created_at timestamp for the record" do
+    @user.created_at.should_not be_nil
+    @user.created_at.should be_instance_of(Time)
+  end
+
+  it "sets the created_at on the way out of the database" do
+    @found_user.created_at.should_not be_nil
+    @found_user.created_at.to_i.should == @user.created_at.to_i
+  end
+
+  it "sets the updated_at on the way out of the database" do
+    @found_user.updated_at.should_not be_nil
+    @found_user.updated_at.to_i.should == @user.updated_at.to_i
+  end
+
+  it "sets the updated_at" do
+    @user.updated_at.to_i.should == @user.created_at.to_i
+  end
+
+  it "doesn't serialize id, created_at, or updated_at in the attributes column" do
+    result = $db.from("users").first(:id => @user.id)
+    attrs  = JSON.parse(result[:attributes])
+    attrs.keys.should_not include("id")
+    attrs.keys.should_not include("created_at")
+    attrs.keys.should_not include("updated_at")
+  end
+
+  it "has an id of type Friendly::UUID" do
+    @user.id.should be_kind_of(Friendly::UUID)
+  end
+end
+
+describe "Updating an object" do
+  before do
+    @user = User.new :name => "Stewie Griffin",
+                     :age  => 3
+    @user.save
+    @created_id = @user.id
+    @created_at = @user.created_at
+
+    sleep(0.1)
+    @user.name = "Brian Griffin"
+    @user.age  = 8
+    @user.save
+
+    @found_user = User.find(@created_id)
+  end
+
+  it "sets the updated_at column" do
+    @user.updated_at.should_not be_nil
+    @user.updated_at.should_not == @user.created_at
+    @user.updated_at.should > @user.created_at
+  end
+
+  it "doesn't change the created_at" do
+    @user.created_at.should == @created_at
+  end
+
+  it "doesn't change the id" do
+    @user.id.should == @created_id
+  end
+
+  it "saves the new attrs to the db" do
+    @found_user.name.should == "Brian Griffin"
+    @found_user.age.should  == 8
+  end
+end
+
+describe "destroying a document" do
+  before do
+    @user = User.new :name => "Stewie Griffin"
+    @user.save
+    @user.destroy
+  end
+
+  it "removes it from the database" do
+    User.first(:id => @user.id).should be_nil
+  end
+end
+
+describe "Finding an object by id" do
+  it "raises Friendly::RecordNotFound if it doesn't exist" do
+    lambda { User.find(12345) }.should raise_error(Friendly::RecordNotFound)
+  end
+end
+
+describe "An object that has a foreign key" do
+  it "is saveable in the database" do
+    lambda {
+        Address.create :user_id => Friendly::UUID.new
+    }.should_not raise_error
+  end
+end
+