yogo-project 0.3.2

data/lib/yogo/collection/form.rb

@@ -0,0 +1,22 @@
+require 'dm-core'
+require 'dm-types/uuid'
+require 'dm-types/yaml'
+
+require 'yogo/collection/property'
+require 'yogo/collection/field_view'
+
+module Yogo
+  module Collection
+    class Form
+      include ::DataMapper::Resource
+      
+      property  :id,      UUID,         :key => true, :default => lambda { |p,r| Yogo::Configuration.random_uuid }
+      property  :name,   String,        :required => true
+      
+      belongs_to  :collection
+      has n,      :field_views
+      has n,      :fields,            :through => :field_views
+      has n,      :available_fields,  :through => :collection, :model => 'Yogo::Collection::Property'
+    end # FieldView
+  end # Collection
+end # Yogo

data/lib/yogo/collection/property.rb

@@ -0,0 +1,127 @@
+require 'dm-types/uuid'
+require 'dm-types/yaml'
+
+require 'yogo/configuration'
+
+module Yogo
+  module Collection
+    class Property
+      include ::DataMapper::Resource
+
+      property  :id,      UUID,         :key => true, :default => lambda { |p,r| Configuration.random_uuid }
+      property  :name,    String,       :required => true
+      property  :options, Yaml,         :default => {}.to_yaml
+      property  :type,    Discriminator
+      
+      property   :data_collection_id, UUID
+      belongs_to :data_collection, :model => 'Yogo::Collection::Data'
+      
+      # validates_uniqueness_of :name, :scope => :data_collection_id
+      
+      def field_name
+        self.to_s
+      end
+    
+      def to_s
+        'field_' + self.id.to_s.gsub('-','_')
+      end
+      
+      def as_json(opts=nil)
+        {
+          :id => self.id.to_s,
+          :type => self.type.to_s,
+          :field_name => self.to_s,
+          :name => self.name,
+          :options => self.options,
+          :data_collection => self.data_collection_id.to_s
+        }
+      end
+      
+      def update_attributes(hash)
+        attrs = {}
+        attrs[:name] = hash[:name] || hash['name'] || self.name
+        attrs[:type] = hash[:type] || hash['type'] || self.type || self.class.name
+        attrs[:options] = hash[:options] || hash['options'] || self.options
+        self.attributes = attrs
+      end
+      
+      def model_method
+        :property
+      end
+      
+      def add_to_model(model)
+        prop_name = self.to_s.intern
+        prop_type = self.class
+        prop_options   = self.options || {}
+        
+        model.send(model_method, prop_name, prop_type, prop_options)
+      end
+      
+      COMMON_PROPERTIES = [:String, :Text, :Integer, :Float, :Boolean, :Date, :Time, :DateTime]
+      COMMON_PROPERTIES.each do |type|
+        class_eval %{
+        class #{type} < Property; end
+        }
+      end
+    end # Property
+    
+    
+    class Relationship < Property
+      property    :target_collection_id, UUID
+      belongs_to  :target_collection, :model => 'Yogo::Collection::Data'
+      
+      def as_json(options=nil)
+        hash = super
+        hash[:target_collection_id] = self.target_collection_id.to_s
+        hash
+      end
+      
+      def target_model
+        target_collection.data_model
+      end
+      
+      def model_method
+        :has
+      end
+      
+      def check_target
+        raise ":target not set" unless self.target && !self.target.empty?
+      end
+      
+      def add_to_model(model, n, options={})
+        check_target
+        model.send(model_method, n, ActiveSupport::Inflector.tableize(self.target).intern, options.merge(self.options))
+      end
+      
+      class ManyToMany < self
+        def add_to_model(model)
+          super(model, Infinity, :through => ::DataMapper::Resource)
+        end
+      end
+      
+      class OneToMany < self
+        def add_to_model(model)
+          super(model)
+        end
+      end
+      
+      class OneToOne < self
+        def add_to_model(model)
+          super(model, 1)
+        end
+      end
+      
+      class ManyToOne < self
+        def model_method
+          :belongs_to
+        end
+        
+        def add_to_model(model)
+          check_target
+          model.send(model_method, ActiveSupport::Inflector.underscore(self.target).intern, options.merge(self.options))
+        end
+      end
+      
+    end
+  end # Collection
+end # Yogo

data/lib/yogo/collection/static.rb

@@ -0,0 +1,13 @@
+require 'yogo/collection/data'
+
+module Yogo
+  module Collection
+    class Static < Data
+      require 'yogo/collection/static/model_configuration'
+      include Static::ModelConfiguration
+      
+      property :static_model,     String
+      
+    end # Asset
+  end # Collection
+end # Yogo

data/lib/yogo/collection/static/model_configuration.rb

@@ -0,0 +1,31 @@
+module Yogo
+  module Collection
+    class Static
+      module ModelConfiguration
+        def model_generate
+          model_name = self.static_model
+          ActiveSupport::Inflector.constantize(model_name)
+        end
+        
+        def before_model_generate
+        end
+        
+        def after_model_generate(model)
+          model
+        end
+        
+        def model_update(model)
+          model.extend(Base::ModelCollectionContext) unless model.respond_to?(:current_collection)
+        end
+
+        def before_model_update(model)
+          model
+        end
+
+        def after_model_update(model)
+          model
+        end
+      end # ModelConfiguration
+    end # Static
+  end # Collection
+end # Yogo

data/lib/yogo/configuration.rb

@@ -0,0 +1,9 @@
+require 'configatron'
+
+module Yogo
+  Configuration = Configatron::Store.new
+  Configuration.random_uuid = Configatron::Dynamic.new { UUIDTools::UUID.timestamp_create }
+  Configuration.collection.set_default(:data_repository_name, :collection_data)
+  Configuration.collection.asset.set_default(:storage_dir, 'asset_collection')
+end
+    

data/lib/yogo/datamapper/model/common/properties.rb

@@ -0,0 +1,16 @@
+require 'yogo/operation'
+require 'yogo/datamapper/model/operations/add'
+require 'dm-types/uuid'
+
+module Yogo
+  module DataMapper
+    module Model
+      module Common
+        module Properties
+          UUIDKey = Operations::Add::Property.partial(X, :id, ::DataMapper::Property::UUID, {:key => true, :default => lambda{|*args| UUIDTools::UUID.timestamp_create}})
+          
+        end # Properties
+      end # Common
+    end # Model
+  end # DataMapper
+end # Yogo

data/lib/yogo/datamapper/model/configuration.rb

@@ -0,0 +1,31 @@
+require 'yogo/datamapper/model/operations/clear'
+require 'yogo/datamapper/model/operations/add'
+
+module Yogo
+  module DataMapper
+    module Model
+      module Configuration
+        
+        def operation_definitions
+          @_operation_definitions ||= []
+        end
+        
+        def operation(op_name, *args)
+          op_def = [op_name.to_s, args].flatten
+          operation_definitions << op_def unless operation_definitions.include?(op_def)
+        end
+        
+        def to_proc
+          ops = operation_definitions.map{|op_def| Operations[op_def.first] }
+          partial_ops = []
+          ops.each_with_index do |op, i|
+            next unless op
+            partial_ops[i] = op.partial(X, *operation_definitions[i][1..-1])
+          end
+          partial_ops.compact!
+          partial_ops.reduce{|composed, partial_op| composed * partial_op}
+        end
+      end # Configuration
+    end # Model
+  end # DataMapper
+end # Yogo

data/lib/yogo/datamapper/model/operations/add.rb

@@ -0,0 +1,34 @@
+require 'yogo/operation'
+
+module Yogo
+  module DataMapper
+    module Model
+      module Operations
+        module Add
+          Property = Operation.on(::DataMapper::Model) do |model, name, type, options|
+            type ||= String
+            options ||= {}
+            model.property(name, type, options)
+            model
+          end
+          
+          
+          Relationship = Operation.on(::DataMapper::Model) do |model, method, *args|
+            model.send(method, *args)
+            model
+          end
+          
+          HasRelationship = Relationship.partial(X, :has, X, X, X)
+          
+          HasN = HasRelationship.partial(X, Infinity, X, X)
+          
+          HasOne = HasRelationship.partial(X, 1, X, X)
+          
+          BelongsTo = Relationship.partial(X, :belongs_to, X, X)
+          
+          
+        end # Add
+      end # Operations
+    end # Model
+  end # DataMapper
+end # Yogo

data/lib/yogo/datamapper/model/operations/clear.rb

@@ -0,0 +1,29 @@
+require 'yogo/operation'
+
+module Yogo
+  module DataMapper
+    module Model
+      module Operations
+        module Clear
+          Properties = Operation.on(::DataMapper::Model) do |model|
+            model.properties.clear
+            model.properties.instance_variable_get(:@properties).clear #clear out the name index
+            model
+          end
+        
+          Relationships = Operation.on(::DataMapper::Model) do |model|
+            model.relationships.clear
+            model
+          end
+        
+          Validators = Operation.on(::DataMapper::Model) do |model|
+            model.validators.clear!
+            model
+          end
+          
+          All = Properties * Relationships * Validators
+        end # Clear
+      end # Operations
+    end # Model
+  end # DataMapper
+end # Yogo

data/lib/yogo/datamapper/model/stored/configuration.rb

@@ -0,0 +1,25 @@
+require 'yogo/configuration'
+require 'yogo/datamapper/model/configuration'
+require 'yogo/datamapper/model/common/properties'
+
+require 'dm-types/uuid'
+require 'dm-types/yaml'
+
+module Yogo
+  module DataMapper
+    module Model
+      module Stored
+        module Configuration
+          include ::DataMapper::Resource
+          include Dynamic::Configuration
+        
+          is :remixable
+          
+          Common::Properties::UUIDKey[self]
+          
+          property :operation_definitions,       Yaml,       :default => lambda {|*args| []}
+        end # Configuration
+      end # Stored
+    end # Model
+  end # DataMapper
+end # Yogo

data/lib/yogo/datamapper/repository_manager.rb

@@ -0,0 +1,30 @@
+require 'yogo/datamapper/repository_manager/model'
+require 'yogo/datamapper/repository_manager/resource'
+
+module Yogo
+  module DataMapper
+    module RepositoryManager
+      def self.included(base)
+        base.class_eval do
+          extend(RepositoryManager::Model)
+          include(RepositoryManager::Resource)
+        end
+      end
+    end # RepositoryManager
+  end # DataMapper
+end # Yogo
+
+module DataMapper
+  module Is
+    module RepositoryManager
+      def is_repository_manager
+        include(Yogo::DataMapper::RepositoryManager)
+      end
+    end # RepositoryManager
+  end # Is
+
+  if const_defined?("Model")
+    Model.append_extensions(Is::RepositoryManager)
+  end
+end # module DataMapper
+

data/lib/yogo/datamapper/repository_manager/model.rb

@@ -0,0 +1,40 @@
+module Yogo
+  module DataMapper
+    module RepositoryManager
+      module Model
+        # Class method for informing Project instances about what kinds of models
+        # might be stored inside thier Project#managed_repository.
+        #
+        # @param [DataMapper::Model] model class that might be stored in Project managed_repositories
+        # @return [Array<DataMapper::Model>] list of currently managed models
+        def manage(*args)
+          @managed_models ||= []
+          models = args
+
+          @managed_models += models
+          @managed_models.uniq!
+
+          @managed_models
+        end
+        
+        # Models that are currently managed by Project instances.
+        # @return [Array<DataMapper::Model>] list of currently managed models
+        def managed_models
+          @managed_models
+        end
+        
+        # Ensure that Relation models are also managed
+        def finalize_managed_models!
+          models = []
+          @managed_models.each do |m|
+            models += m.relationships.values.map{|r| r.child_model }
+            models += m.relationships.values.map{|r| r.parent_model }
+          end
+          @managed_models += models
+          @managed_models.uniq!
+          @managed_models
+        end
+      end # Model
+    end # RepositoryManager
+  end # DataMapper
+end # Yogo

data/lib/yogo/datamapper/repository_manager/resource.rb

@@ -0,0 +1,124 @@
+module Yogo
+  module DataMapper
+    module RepositoryManager
+      module Resource
+        # Ensure that models that we might store in the Project#managed_repository
+        # are properly migrated/upgrade whenever the Project changes.
+        # @author Ryan Heimbuch
+        # @see Project#prepare_models
+        def self.included(base)
+          base.class_eval do
+            after :save, :prepare_models
+            after :create, :create_storage
+            before :destroy, :destroy_storage
+          end
+        end
+
+        def create_storage
+          ::DataMapper.repository.adapter.create_db(managed_repository_database_name)
+          puts "Making new storage"
+        end
+
+        def destroy_storage
+          puts "Nuking storage"
+        end
+
+        # @author Ryan Heimbuch
+        #
+        # Override required from Yogo::DataMapper::Repository#managed_repository_name
+        #
+        # @return [Symbol] the name for the DataMapper::Repository that the Project manages
+        def managed_repository_name
+          ActiveSupport::Inflector.tableize(id.to_s).to_sym
+        end
+
+        def managed_repository_database_name
+          "voeis_project_#{managed_repository_name}"
+        end
+
+        # @author Ryan Heimbuch
+        #
+        # @return [Hash] The adapter configuration for the Project managed_repository
+        # @see DataMapper.setup
+        def adapter_config
+          # Read the configuration from the existing database.yml file
+          config = Rails.configuration.database_configuration
+          adapter_conf = config['yogo-db'].dup
+          adapter_conf['database'] = "#{adapter_conf['path']}#{managed_repository_database_name}"
+          adapter_conf.delete("path")
+          return adapter_conf
+        end
+
+        def adapter
+          begin
+            ::DataMapper.repository(managed_repository_name).adapter
+          rescue ::DataMapper::RepositoryNotSetupError
+            ::DataMapper.setup(managed_repository_name, adapter_config)
+            retry
+          end
+        end
+
+        def managed_repository(&block)
+          adapter # ensure the adapter get's setup or exists
+          if block_given?
+            ::DataMapper.repository(managed_repository_name, &block)
+          else
+            ::DataMapper.repository(managed_repository_name)
+          end
+        end
+
+        # Ensure that models that models managed by the Project
+        # are properly migrated/upgraded inside the Project managed repository.
+        #
+        # @author Ryan Heimbuch
+        # @todo Refactor this method into a module in yogo-project
+        def prepare_models
+          adapter # ensure the adapter exists or is setup
+          managed_repository.scope {
+            self.class.finalize_managed_models!
+            self.class.managed_models.each do |klass|
+              klass.auto_upgrade!
+            end
+          }
+        end
+
+        # Builds a "new", unsaved datamapper resource, that is explicitly
+        # bound to the Project#managed_repository.
+        # If you want to create a new resource that will be saved inside the
+        # repository of a Project, you should always use this method.
+        #
+        # @example Create a new site that is stored in myProject.managed_repository
+        #   managedSite = myProject.build_managed(Voeis::Site, :name => ...)
+        #
+        # @example Doing any of these will NOT work consistently (if at all)
+        #   managedSite1 = Voeis::Site.new(:name => ...)
+        #   managedSite1.save # WILL NOT save in myProject.managed_repository
+        #
+        #   managedSite2 = myProject.managed_repository{Voeis::Site.new(:name => ...)}
+        #   managedSite2.save # WILL NOT save in myProject.managed_repository
+        #
+        # Boring Details:
+        #   Initially "new" model resources do not bind themselves to any repository.
+        #   At some point a "new" resource will persist itself and bind itself exclusively
+        #   to the repository that it "persisted into". This step is fiddly to catch, and
+        #   happens deep inside the DataMapper code. It is MUCH easier to explictly bind
+        #   the "new" resource to a particular repository immediately after calling #new.
+        #   This requires using reflection to modify the internal state of the resource object,
+        #   so it is best sealed inside a single method, rather than scattered throughout
+        #   the codebase.
+        #
+        # @todo Refactor into module in yogo-project
+        # @author Ryan Heimbuch
+        def build_managed(model_klass, attributes={})
+          unless self.class.managed_models.include? model_klass
+            self.class.manage(model_klass)
+            prepare_models
+          end
+          res = model_klass.new(attributes)
+          res.instance_variable_set(:@_repository, managed_repository)
+          res
+        end
+      end # RepositoryModels
+    end # RepositoryManager
+  end # DataMapper
+end # Yogo