dm-reflection 0.0.5

data/lib/dm-reflection/builders/source_builder.rb

@@ -0,0 +1,326 @@
+module DataMapper
+  module Reflection
+    module Builders
+      module Source
+
+        def to_ruby
+          Model.to_ruby(self)
+        end
+
+        class Model
+
+          attr_accessor :model
+
+          def self.to_ruby(model)
+            builder = new(model)
+            raise DataMapper::IncompleteModelError unless builder.complete_model?
+            builder.to_ruby
+          end
+
+
+          def to_ruby
+            ruby  = "class #{model}\n"
+            ruby += "\n"
+            ruby += "  include DataMapper::Resource\n"
+            property_definitions(key_properties).each do |key_definition|
+              ruby += "\n  #{key_definition}"
+            end
+            ruby += "\n"
+            property_definitions(foreign_key_properties).each do |foreign_key_definition|
+              ruby += "\n  #{foreign_key_definition}"
+            end
+            property_definitions(regular_properties).each do |property_definition|
+              ruby += "\n  #{property_definition}"
+            end
+            ruby += "\n"
+            relationship_definitions(many_to_one_relationships).each do |relationship_definition|
+              ruby += "\n  #{relationship_definition}"
+            end
+            relationship_definitions(one_to_one_relationships).each do |relationship_definition|
+              ruby += "\n  #{relationship_definition}"
+            end
+            relationship_definitions(one_to_many_relationships).each do |relationship_definition|
+              ruby += "\n  #{relationship_definition}"
+            end
+            relationship_definitions(many_to_many_relationships).each do |relationship_definition|
+              ruby += "\n  #{relationship_definition}"
+            end
+            ruby += "\n"
+            ruby += "\nend\n"
+          end
+
+
+
+          def key_properties
+            model.key
+          end
+
+          def foreign_key_properties
+            []
+          end
+
+          def regular_properties
+            model.properties - model.key - foreign_key_properties
+          end
+
+
+          def many_to_one_relationships(repository = :default)
+            model.relationships(repository).select do |_, relationship|
+              relationship.is_a?(DataMapper::Associations::ManyToOne::Relationship)
+            end
+          end
+
+          def one_to_one_relationships(repository = :default)
+            model.relationships(repository).select do |_, relationship|
+              relationship.is_a?(DataMapper::Associations::OneToOne::Relationship)
+            end
+          end
+
+          def one_to_many_relationships(repository = :default)
+            model.relationships(repository).select do |_, relationship|
+              relationship.is_a?(DataMapper::Associations::OneToMany::Relationship) &&
+              !relationship.is_a?(DataMapper::Associations::ManyToMany::Relationship)
+            end
+          end
+
+          def many_to_many_relationships(repository = :default)
+            model.relationships(repository).select do |_, relationship|
+              relationship.is_a?(DataMapper::Associations::ManyToMany::Relationship)
+            end
+          end
+
+
+          def complete_model?
+            key_properties.any?
+          end
+
+
+          private
+
+          def initialize(model)
+            @model = model
+          end
+
+          def property_definitions(properties)
+            properties.map { |property| Property.for(property).to_ruby }
+          end
+
+          def relationship_definitions(relationships)
+            relationships.map { |_, relationship| Relationship.for(relationship).to_ruby }
+          end
+
+        end
+
+
+        module OptionBuilder
+
+          def options
+            option_string(prioritized_options + rest_options)
+          end
+
+          def option_priorities
+            []
+          end
+
+          def prioritized_options
+            []
+          end
+
+          def rest_options
+            backend_options.select { |k,v| !option_priorities.include?(k) && !irrelevant_options.include?(k) }
+          end
+
+          def irrelevant_options
+            []
+          end
+
+          def backend_options
+            @backend_options ||= backend.options.dup
+          end
+
+
+          private
+
+          def option_string(relevant_options)
+            relevant_options.map do |key, value|
+              ", #{key.inspect} => #{value == 'Resource' ? value : value.inspect}"
+            end.join
+          end
+
+        end
+
+
+        class Property
+
+          include OptionBuilder
+
+          attr_accessor :backend
+
+          def self.for(backend)
+            new(backend)
+          end
+
+          def to_ruby
+            "property :#{name}, #{type}#{options}"
+          end
+
+          def name
+            backend.name
+          end
+
+          def type
+            Extlib::Inflection.demodulize(backend.type)
+          end
+
+
+          def options
+            backend.type == DataMapper::Types::Serial ? '' : super
+          end
+
+          def option_priorities
+            [ :key, :required, :unique, :unique_index ]
+          end
+
+          def prioritized_options
+            option_priorities.inject([]) do |memo, name|
+              if name == :required
+                memo << [ name, backend_options[name] ] if backend_options[name] && !backend_options[:key]
+              else
+                memo << [ name, backend_options[name] ] if backend_options[name]
+              end
+              memo
+            end
+          end
+
+          def irrelevant_options
+            []
+          end
+
+          private
+
+          def initialize(backend)
+            @backend = backend
+          end
+
+        end
+
+        class Relationship
+
+          include OptionBuilder
+
+          attr_accessor :backend
+
+          def self.for(backend)
+            case backend
+            when DataMapper::Associations::ManyToOne::Relationship  then ManyToOne. new(backend)
+            when DataMapper::Associations::OneToOne::Relationship   then OneToOne.  new(backend)
+            when DataMapper::Associations::OneToMany::Relationship  then OneToMany. new(backend)
+            when DataMapper::Associations::ManyToMany::Relationship then ManyToMany.new(backend)
+            else
+              raise ArgumentError, "#{backend.class} is no valid datamapper relationship"
+            end
+          end
+
+          def to_ruby
+            "#{type} #{cardinality}, :#{name}#{options}"
+          end
+
+
+          def type
+            raise NotImplementedError
+          end
+
+          def name
+            backend.name
+          end
+
+
+          def cardinality
+            "#{min}..#{max}"
+          end
+
+          def min
+            backend.min
+          end
+
+          def max
+            backend.max
+          end
+
+
+          def option_priorities
+            [ :through, :constraint ]
+          end
+
+          def prioritized_options
+            option_priorities.inject([]) do |memo, name|
+              if name == :through && through = backend_options[:through]
+                value = through.is_a?(Symbol) ? through : Extlib::Inflection.demodulize(through)
+                memo << [ :through, value ]
+              end
+              memo
+            end
+          end
+
+          def irrelevant_options
+            [ :min, :max, :parent_repository_name, :child_repository_name ]
+          end
+
+          private
+
+          def initialize(backend)
+            @backend = backend
+          end
+
+        end
+
+        class ManyToOne < Relationship
+          def to_ruby
+            "#{type} :#{name}#{options}"
+          end
+          def type
+            :belongs_to
+          end
+          def cardinality
+            ''
+          end
+        end
+
+        class OneToOne < Relationship
+          def type
+            :has
+          end
+          def cardinality
+            min == 1 && max == 1 ? '1' : super
+          end
+        end
+
+        class OneToMany < Relationship
+          def type
+            :has
+          end
+          def cardinality
+            max_string = max == Infinity ? 'n' : max.to_s
+
+            if min == 0 || min == max
+              max_string
+            elsif max == Infinity
+              "#{min}..#{max_string}"
+            else
+              super
+            end
+          end
+        end
+
+        class ManyToMany < OneToMany
+        end
+
+
+      end
+    end
+  end
+
+  # Ensure activation when this file is required
+  Model.append_extensions(Reflection::Builders::Source)
+
+end

data/lib/dm-reflection/reflection.rb

@@ -0,0 +1,73 @@
+module DataMapper
+  module Reflection
+    ##
+    # Main reflection method reflects models out of a repository.
+    # @param [Slug] repository is the key to the repository that will be reflected.
+    # @param [Constant] namespace is the namespace into which the reflected models will be added
+    # @param [Boolean] overwrite indicates the reflected models should replace existing models or not.
+    # @return [DataMapper::Model Array] the reflected models.
+    #
+    def self.reflect(repository, namespace = Object, overwrite = false)
+      adapter = DataMapper.repository(repository).adapter
+
+      models  = []
+
+      adapter.get_storage_names.each do |storage_name|
+        namespace_parts = storage_name.split('__').map do |part|
+          Extlib::Inflection.classify(part)
+        end
+
+        model_name = namespace_parts.pop
+
+        namespace = if namespace_parts.any?
+          Object.make_module(namespace_parts.join('::'))
+        else
+          Object
+        end
+
+        next if namespace.const_defined?(model_name) && !overwrite
+
+        anonymous_model = DataMapper::Model.new do
+          class_eval <<-RUBY, __FILE__, __LINE__
+            storage_names[#{repository.inspect}]='#{storage_name}'
+          RUBY
+          unless repository == DataMapper::Repository.default_name
+            class_eval <<-RUBY, __FILE__, __LINE__
+              def self.default_repository_name
+                #{repository.inspect}
+              end
+            RUBY
+          end
+        end
+
+        model = namespace.const_set(model_name, anonymous_model)
+
+        adapter.get_properties(storage_name).each do |attribute|
+          attribute.delete_if { |k,v| v.nil? }
+          model.property(attribute.delete(:name).to_sym, attribute.delete(:type), attribute)
+        end
+
+        models << model
+      end
+      models
+    end
+  end # module Reflection
+
+  module Adapters
+    extendable do
+      ##
+      # Glue method that will register reflection extensions for adapters if the adapters are loaded.
+      #
+      # @param [Constant] const_name is the constant defined by the adapter.
+      # 
+      # @api private
+      def const_added(const_name)
+        if DataMapper::Reflection.const_defined?(const_name)
+          adapter = const_get(const_name)
+          adapter.send(:include, DataMapper::Reflection.const_get(const_name))
+        end
+        super
+      end # const_added
+    end # extendable block
+  end # module Adapters
+end # module DataMapper

data/lib/dm-reflection/version.rb

@@ -0,0 +1,5 @@
+module DataMapper
+  module Reflection
+    VERSION = '0.0.5'.freeze
+  end
+end

data/lib/dm-reflection.rb

@@ -0,0 +1,6 @@
+require 'dm-reflection/reflection'
+require 'dm-reflection/adapters/sqlite3'
+require 'dm-reflection/adapters/persevere'
+require 'dm-reflection/adapters/mysql'
+require 'dm-reflection/adapters/postgres'
+require 'dm-reflection/builders/source_builder'

data/spec/persevere_reflection_spec.rb

@@ -0,0 +1,86 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+if ENV['ADAPTER'] == 'persevere'
+  
+  POST = <<-RUBY
+  class Post
+
+    include DataMapper::Resource
+
+    property :id, Serial
+
+    property :created_at, DateTime
+    property :body, Text, :length => 65535, :lazy => true
+    property :updated_at, DateTime
+
+
+  end
+  RUBY
+
+  POST_COMMENT = <<-RUBY
+  class PostComment
+
+    include DataMapper::Resource
+
+    property :id, Serial
+
+    property :created_at, DateTime
+    property :body, Text, :length => 65535, :lazy => true
+    property :updated_at, DateTime
+    property :score, Integer
+    property :blog_post, DataMapper::Types::JsonReference, :reference => :Post
+
+
+  end
+  RUBY
+  
+  PERSEVERE_REFLECTION_SOURCES = [ POST, POST_COMMENT ]
+  
+  describe 'The Persevere DataMapper reflection module' do
+  
+    before(:each) do
+      @adapter = repository(:default).adapter
+      
+       PERSEVERE_REFLECTION_SOURCES.each { |source| eval(source) }
+
+        @models = {
+          :Post            => POST,
+          :PostComment     => POST_COMMENT,
+        }
+
+        @models.each_key { |model| Extlib::Inflection.constantize(model.to_s).auto_migrate! }
+        Post.send(:property, :comments, DataMapper::Types::JsonReferenceCollection, :reference => :PostComment)
+        Post.auto_upgrade!
+        @models.each_key { |model| remove_model_from_memory( Extlib::Inflection.constantize(model.to_s) ) }
+    end
+    
+    after(:each) do
+      @models.each_key do |model_name|
+        next unless Object.const_defined?(model_name)
+        model = Extlib::Inflection.constantize(model_name.to_s)
+        remove_model_from_memory(model)
+      end
+      @models.each_key do |model_name|
+        next unless Object.const_defined?(model_name)
+        model = Extlib::Inflection.constantize(model_name.to_s)
+        remove_model_from_memory(model)
+      end
+    end
+  
+    it "should return an array of tables" do
+      @adapter.get_storage_names.should be_kind_of(Array)
+    end
+  
+    it "should return a table definition" do
+      result = @adapter.get_properties("post")
+      result.should be_kind_of(Array)
+    end
+    
+    it "should reflect out JsonReference types" do
+      DataMapper::Reflection.reflect(:default)
+      PostComment.properties[:blog_post].type.should eql DataMapper::Types::JsonReference
+      Post.properties[:comments].type.should eql DataMapper::Types::JsonReferenceCollection
+    end
+
+  end
+end

data/spec/rcov.opts

@@ -0,0 +1,6 @@
+--exclude "spec"
+--sort coverage
+--callsites
+--xrefs
+--profile
+--text-summary

data/spec/reflection_spec.rb

@@ -0,0 +1,108 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'dm-reflection/builders/source_builder'
+
+BLOGPOST = <<-RUBY
+class BlogPost
+
+  include DataMapper::Resource
+
+  property :id, Serial
+
+  property :created_at, DateTime
+  property :body, Text, :length => 65535, :lazy => true
+  property :updated_at, DateTime
+
+
+end
+RUBY
+
+COMMENT = <<-RUBY
+class Comment
+
+  include DataMapper::Resource
+
+  property :id, Serial
+
+  property :created_at, DateTime
+  property :body, Text, :length => 65535, :lazy => true
+  property :updated_at, DateTime
+  property :score, Integer
+
+
+end
+RUBY
+
+REFLECTION_SOURCES = [ BLOGPOST, COMMENT ]
+
+describe 'The DataMapper reflection module' do
+
+  before(:each) do
+    @adapter = repository(:default).adapter
+
+    REFLECTION_SOURCES.each { |source| eval(source) }
+
+    @models = {
+      :BlogPost      => BLOGPOST,
+      :Comment     => COMMENT,
+    }
+    
+    @models.each_key { |model| Extlib::Inflection.constantize(model.to_s).auto_migrate! }
+    @models.each_key { |model| remove_model_from_memory( Extlib::Inflection.constantize(model.to_s) ) }
+  end
+
+  after(:each) do
+    @models.each_key do |model_name|
+      next unless Object.const_defined?(model_name)
+      model = Extlib::Inflection.constantize(model_name.to_s)
+      model.auto_migrate_down!
+      remove_model_from_memory(model)
+    end
+  end
+
+  describe 'repository(:name).reflect' do
+    it 'should reflect all the models in a repository' do      
+      # Reflect the models back into memory.
+      DataMapper::Reflection.reflect(:default)
+      
+      # Iterate through each model in memory and verify the source is the same as the original.
+      # using model.to_ruby
+      @models.each_pair do |model_name, source|
+        model = Extlib::Inflection.constantize(model_name.to_s)
+        reflected_source = model.to_ruby
+        model.to_ruby.should == source
+      end
+    end
+  end
+
+  describe 'reflected model instance' do
+    it 'should respond to default_repository_name and return the correct repo for a reflected model' do
+      # Reflect the models back into memory.
+      DataMapper::Reflection.reflect(:default)
+      
+      @models.each_key do |model_name|
+        model = Extlib::Inflection.constantize(model_name.to_s)
+        model.should respond_to(:default_repository_name)
+        model.default_repository_name.should == :default
+      end
+    end
+  end
+
+  describe 'reflective adapter' do
+    it 'should respond to get_storage_names and return an array of models' do
+      @adapter.should respond_to(:get_storage_names)
+      @adapter.get_storage_names.should be_kind_of(Array)
+    end
+    
+    it "should respond to get_properties and return an array of properties" do
+      @adapter.should respond_to(:get_properties)
+      tables = @adapter.get_storage_names
+      properties = @adapter.get_properties(tables[0])
+      properties.should be_kind_of(Array)
+      a_property = properties[0]
+      a_property.should be_kind_of(Hash)
+      a_property.keys.should include(:name)
+      a_property.keys.should include(:type)
+    end
+  end
+
+end