kotovalexarian-likes-github/rails--rails
1
0
Fork 0
mirror of https://github.com/rails/rails.git synced 2022-11-09 12:12:34 -05:00
Code Releases Activity

Rename SchemaDefinition => Schema

Browse source
This commit is contained in:
Joshua Peek 2009-12-20 18:44:13 -06:00
parent fc9b3e4a45
commit 669c5eec44
4 changed files with 38 additions and 38 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
activeresource/lib/active_resource.rb
View file

@ -37,7 +37,8 @@ module ActiveResource
autoload :Connection
autoload :CustomMethods
autoload :Formats
autoload :Observing
autoload :Validations
autoload :HttpMock
autoload :Observing
autoload :Schema
autoload :Validations
end

15
activeresource/lib/active_resource/base.rb
View file

@ -13,7 +13,6 @@ require 'set'
require 'uri'
require 'active_resource/exceptions'
require 'active_resource/schema_definition'
module ActiveResource
# ActiveResource::Base is the main class for mapping RESTful resources as models in a Rails application.
@ -270,9 +269,9 @@ module ActiveResource
# s.integer 'age'
# s.float 'height', 'weight'
#
# # unsupported types should be left as strings
# # unsupported types should be left as strings
# # overload the accessor methods if you need to convert them
# s.attribute 'created_at', 'string'
# s.attribute 'created_at', 'string'
# end
# end
#
@ -295,14 +294,14 @@ module ActiveResource
# string, integer, float
#
# Note: at present the attribute-type doesn't do anything, but stay
# tuned...
# tuned...
# Shortly it will also *cast* the value of the returned attribute.
# ie:
# j.age # => 34 # cast to an integer
# j.weight # => '65' # still a string!
#
def define_schema
schema_definition = SchemaDefinition.new
schema_definition = Schema.new
yield schema_definition if block_given?
# skip out if we didn't define anything
@ -317,7 +316,7 @@ module ActiveResource
end
schema
end
end
# Alternative, direct way to specify a <tt>schema</tt> for this
@ -326,7 +325,7 @@ module ActiveResource
#
# Pass the schema as a hash with the keys being the attribute-names
# and the value being one of the accepted attribute types (as defined
# in <tt>define_schema</tt>)
# in <tt>define_schema</tt>)
#
# example:
#
@ -342,7 +341,7 @@ module ActiveResource
# purposefully nulling out the schema
@schema = nil
@known_attributes = []
return
return
end
raise ArgumentError, "Expected a hash" unless the_schema.kind_of? Hash

8
activeresource/lib/active_resource/schema_definition.rb → activeresource/lib/active_resource/schema.rb
View file

@ -1,7 +1,7 @@
require 'active_resource/exceptions'
module ActiveResource # :nodoc:
class SchemaDefinition # :nodoc:
class Schema # :nodoc:
# attributes can be known to be one of these types. They are easy to
# cast to/from.
@ -11,7 +11,7 @@ module ActiveResource # :nodoc:
# have been defined.
attr_accessor :attrs
# The internals of an Active Resource SchemaDefinition are very simple -
# The internals of an Active Resource Schema are very simple -
# unlike an Active Record TableDefinition (on which it is based).
# It provides a set of convenience methods for people to define their
# schema using the syntax:
@ -28,7 +28,7 @@ module ActiveResource # :nodoc:
end
def attribute(name, type, options = {})
raise ArgumentError, "Unknown Attribute type: #{type.inspect} for key: #{name.inspect}" unless type.nil? || SchemaDefinition::KNOWN_ATTRIBUTE_TYPES.include?(type.to_s)
raise ArgumentError, "Unknown Attribute type: #{type.inspect} for key: #{name.inspect}" unless type.nil? || Schema::KNOWN_ATTRIBUTE_TYPES.include?(type.to_s)
the_type = type.to_s
# TODO: add defaults
@ -39,7 +39,7 @@ module ActiveResource # :nodoc:
end
# The following are the attribute types supported by Active Resource
# migrations.
# migrations.
# TODO: We should eventually support all of these:
# %w( string text integer float decimal datetime timestamp time date binary boolean ).each do |attr_type|
KNOWN_ATTRIBUTE_TYPES.each do |attr_type|

48
activeresource/test/cases/base/schema_test.rb
View file

@ -92,7 +92,7 @@ class SchemaTest < ActiveModel::TestCase
test "schema should accept all known attribute types as values" do
# I'd prefer to use here...
ActiveResource::SchemaDefinition::KNOWN_ATTRIBUTE_TYPES.each do |the_type|
ActiveResource::Schema::KNOWN_ATTRIBUTE_TYPES.each do |the_type|
assert_nothing_raised("should have accepted #{the_type.inspect}"){ Person.schema = {'my_key' => the_type }}
end
end
@ -171,13 +171,13 @@ class SchemaTest < ActiveModel::TestCase
matz = Person.find(1)
assert !matz.schema.blank?, "should have some sort of schema on an instance variable"
assert_not_equal new_schema, matz.schema, "should not have the class-level schema until it's been added to the class!"
assert_nothing_raised {
Person.schema = new_schema
assert_equal new_schema, matz.schema, "class-level schema should override instance-level schema"
}
end
#####################################################
# Using the define_schema syntax
@ -188,11 +188,11 @@ class SchemaTest < ActiveModel::TestCase
assert_nothing_raised("Should allow the define_schema to take a block") do
Person.define_schema do |s|
assert s.kind_of?(ActiveResource::SchemaDefinition), "the 's' should be a schema definition or we're way off track..."
assert s.kind_of?(ActiveResource::Schema), "the 's' should be a schema definition or we're way off track..."
end
end
end
test "schema definition should store and return attribute set" do
assert_nothing_raised do
Person.define_schema do |s|
@ -202,13 +202,13 @@ class SchemaTest < ActiveModel::TestCase
end
end
end
test "should be able to add attributes through define_schema" do
assert_nothing_raised do
Person.define_schema do |s|
assert s.attribute('foo', 'string'), "should take a simple attribute"
assert s.attrs.has_key?('foo'), "should have saved the attribute name"
assert_equal 'string', s.attrs['foo'], "should have saved the attribute type"
assert_equal 'string', s.attrs['foo'], "should have saved the attribute type"
end
end
end
@ -218,23 +218,23 @@ class SchemaTest < ActiveModel::TestCase
Person.define_schema do |s|
assert s.attribute(:foo, :integer), "should take a simple attribute as symbols"
assert s.attrs.has_key?('foo'), "should have saved the attribute name as a string"
assert_equal 'integer', s.attrs['foo'], "should have saved the attribute type as a string"
assert_equal 'integer', s.attrs['foo'], "should have saved the attribute type as a string"
end
end
end
test "should be able to add all known attribute types" do
Person.define_schema do |s|
ActiveResource::SchemaDefinition::KNOWN_ATTRIBUTE_TYPES.each do |the_type|
ActiveResource::Schema::KNOWN_ATTRIBUTE_TYPES.each do |the_type|
assert_nothing_raised do
assert s.attribute('foo', the_type), "should take a simple attribute of type: #{the_type}"
assert s.attrs.has_key?('foo'), "should have saved the attribute name"
assert_equal the_type.to_s, s.attrs['foo'], "should have saved the attribute type of: #{the_type}"
assert_equal the_type.to_s, s.attrs['foo'], "should have saved the attribute type of: #{the_type}"
end
end
end
end
test "attributes should not accept unknown values" do
bad_values = [ :oogle, :blob, 'thing']
@ -251,20 +251,20 @@ class SchemaTest < ActiveModel::TestCase
end
end
test "should accept attribute types as the type's name as the method" do
Person.define_schema do |s|
ActiveResource::SchemaDefinition::KNOWN_ATTRIBUTE_TYPES.each do |the_type|
ActiveResource::Schema::KNOWN_ATTRIBUTE_TYPES.each do |the_type|
assert s.respond_to?(the_type), "should recognise the attribute-type: #{the_type} as a method"
assert_nothing_raised("should take the method #{the_type} with the attribute name") do
s.send(the_type,'foo') # eg s.string :foo
end
assert s.attrs.has_key?('foo'), "should now have saved the attribute name"
assert_equal the_type.to_s, s.attrs['foo'], "should have saved the attribute type of: #{the_type}"
assert_equal the_type.to_s, s.attrs['foo'], "should have saved the attribute type of: #{the_type}"
end
end
end
test "should accept multiple attribute names for an attribute method" do
names = ['foo','bar','baz']
Person.define_schema do |s|
@ -273,7 +273,7 @@ class SchemaTest < ActiveModel::TestCase
end
names.each do |the_name|
assert s.attrs.has_key?(the_name), "should now have saved the attribute name: #{the_name}"
assert_equal 'string', s.attrs[the_name], "should have saved the attribute as a string"
assert_equal 'string', s.attrs[the_name], "should have saved the attribute as a string"
end
end
end
@ -282,13 +282,13 @@ class SchemaTest < ActiveModel::TestCase
# What a schema does for us
####
# respond_to?
# respond_to?
test "should respond positively to attributes that are only in the schema" do
new_attr_name = :my_new_schema_attribute
new_attr_name_two = :another_new_schema_attribute
assert Person.schema.blank?, "sanity check - should have a blank class schema"
assert !Person.new.respond_do?(new_attr_name), "sanity check - should not respond to the brand-new attribute yet"
assert !Person.new.respond_do?(new_attr_name_two), "sanity check - should not respond to the brand-new attribute yet"
@ -306,7 +306,7 @@ class SchemaTest < ActiveModel::TestCase
new_attr_name_two = :another_new_schema_attribute
assert Person.schema.blank?, "sanity check - should have a blank class schema"
assert !Person.new.respond_do?(new_attr_name), "sanity check - should not respond to the brand-new attribute yet"
assert !Person.new.respond_do?(new_attr_name_two), "sanity check - should not respond to the brand-new attribute yet"
@ -328,10 +328,10 @@ class SchemaTest < ActiveModel::TestCase
assert Person.schema.blank?, "sanity check - should have a blank class schema"
assert_raises(NoMethodError, "should not have found the attribute: #{new_attr_name} as a method") do
Person.new.send(new_attr_name)
Person.new.send(new_attr_name)
end
assert_raises(NoMethodError, "should not have found the attribute: #{new_attr_name_two} as a method") do
Person.new.send(new_attr_name_two)
Person.new.send(new_attr_name_two)
end
Person.schema = {new_attr_name.to_s => :float}
@ -348,9 +348,9 @@ class SchemaTest < ActiveModel::TestCase
# Known attributes
#
# Attributes can be known to be attributes even if they aren't actually
# 'set' on a particular instance.
# 'set' on a particular instance.
# This will only differ from 'attributes' if a schema has been set.
test "new model should have no known attributes" do
assert Person.known_attributes.blank?, "should have no known attributes"
assert Person.new.known_attributes.blank?, "should have no known attributes on a new instance"