From 669c5eec445ff097b765c387b92ae1f174134f75 Mon Sep 17 00:00:00 2001 From: Joshua Peek Date: Sun, 20 Dec 2009 18:44:13 -0600 Subject: Rename SchemaDefinition => Schema --- activeresource/lib/active_resource.rb | 3 +- activeresource/lib/active_resource/base.rb | 15 +++--- activeresource/lib/active_resource/schema.rb | 58 ++++++++++++++++++++++ .../lib/active_resource/schema_definition.rb | 58 ---------------------- activeresource/test/cases/base/schema_test.rb | 48 +++++++++--------- 5 files changed, 91 insertions(+), 91 deletions(-) create mode 100644 activeresource/lib/active_resource/schema.rb delete mode 100644 activeresource/lib/active_resource/schema_definition.rb diff --git a/activeresource/lib/active_resource.rb b/activeresource/lib/active_resource.rb index 84baf4227a..3e4a1dd4a1 100644 --- a/activeresource/lib/active_resource.rb +++ b/activeresource/lib/active_resource.rb @@ -37,7 +37,8 @@ module ActiveResource autoload :Connection autoload :CustomMethods autoload :Formats + autoload :HttpMock autoload :Observing + autoload :Schema autoload :Validations - autoload :HttpMock end diff --git a/activeresource/lib/active_resource/base.rb b/activeresource/lib/active_resource/base.rb index 60bd573911..b39f8fbd48 100644 --- a/activeresource/lib/active_resource/base.rb +++ b/activeresource/lib/active_resource/base.rb @@ -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 schema 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 define_schema) + # in define_schema) # # 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 diff --git a/activeresource/lib/active_resource/schema.rb b/activeresource/lib/active_resource/schema.rb new file mode 100644 index 0000000000..498b00ffef --- /dev/null +++ b/activeresource/lib/active_resource/schema.rb @@ -0,0 +1,58 @@ +require 'active_resource/exceptions' + +module ActiveResource # :nodoc: + class Schema # :nodoc: + + # attributes can be known to be one of these types. They are easy to + # cast to/from. + KNOWN_ATTRIBUTE_TYPES = %w( string integer float ) + + # An array of attribute definitions, representing the attributes that + # have been defined. + attr_accessor :attrs + + # 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: + # define_schema do |s| + # s.string :foo + # s.integer :bar + # end + # + # The schema stores the name and type of each attribute. That is then + # read out by the define_schema method to populate the actual + # Resource's schema + def initialize + @attrs = {} + end + + def attribute(name, type, options = {}) + 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 + #the_attr = [type.to_s] + #the_attr << options[:default] if options.has_key? :default + @attrs[name.to_s] = the_type + self + end + + # The following are the attribute types supported by Active Resource + # 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| + class_eval <<-EOV + def #{attr_type.to_s}(*args) # def string(*args) + options = args.extract_options! # options = args.extract_options! + attr_names = args # attr_names = args + # + attr_names.each { |name| attribute(name, '#{attr_type}', options) } # attr_names.each { |name| attribute(name, 'string', options) } + end # end + EOV + + end + + end +end diff --git a/activeresource/lib/active_resource/schema_definition.rb b/activeresource/lib/active_resource/schema_definition.rb deleted file mode 100644 index abcbf3ba4e..0000000000 --- a/activeresource/lib/active_resource/schema_definition.rb +++ /dev/null @@ -1,58 +0,0 @@ -require 'active_resource/exceptions' - -module ActiveResource # :nodoc: - class SchemaDefinition # :nodoc: - - # attributes can be known to be one of these types. They are easy to - # cast to/from. - KNOWN_ATTRIBUTE_TYPES = %w( string integer float ) - - # An array of attribute definitions, representing the attributes that - # have been defined. - attr_accessor :attrs - - # The internals of an Active Resource SchemaDefinition 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: - # define_schema do |s| - # s.string :foo - # s.integer :bar - # end - # - # The schema stores the name and type of each attribute. That is then - # read out by the define_schema method to populate the actual - # Resource's schema - def initialize - @attrs = {} - 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) - - the_type = type.to_s - # TODO: add defaults - #the_attr = [type.to_s] - #the_attr << options[:default] if options.has_key? :default - @attrs[name.to_s] = the_type - self - end - - # The following are the attribute types supported by Active Resource - # 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| - class_eval <<-EOV - def #{attr_type.to_s}(*args) # def string(*args) - options = args.extract_options! # options = args.extract_options! - attr_names = args # attr_names = args - # - attr_names.each { |name| attribute(name, '#{attr_type}', options) } # attr_names.each { |name| attribute(name, 'string', options) } - end # end - EOV - - end - - end -end diff --git a/activeresource/test/cases/base/schema_test.rb b/activeresource/test/cases/base/schema_test.rb index 398e7cf539..4a6e8bfbdb 100644 --- a/activeresource/test/cases/base/schema_test.rb +++ b/activeresource/test/cases/base/schema_test.rb @@ -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" -- cgit v1.2.3