dynamic-fields 0.0.4

data/lib/dynamic_fields.rb

@@ -0,0 +1,21 @@
+require 'active_support'
+require 'rails/generators/base'
+
+module DynamicFields  
+  extend ActiveSupport::Concern
+  included do
+    include Fields
+  end
+  
+  def self.models
+    ActiveRecord::Base.subclasses.select do |ar|
+      ar.included_modules.include?(DynamicFields)
+    end
+  end
+
+end
+
+require 'dynamic_fields/field'
+require 'dynamic_fields/index'
+require 'dynamic_fields/fields'
+require 'dynamic_fields/railtie'

data/lib/dynamic_fields/field.rb

@@ -0,0 +1,41 @@
+module DynamicFields
+  class Field
+    attr_reader :name, :type, :type_class, :default, :options
+    # Create the new field with a name and optional additional options. Valid
+    # options are :default
+    #
+    # Options:
+    #
+    # name: The name of the field as a +Symbol+.
+    # options: A +Hash+ of options for the field.
+    #
+    # Example:
+    #
+    # <tt>Field.new(:score, :default => 0)</tt>
+    def initialize(name, options = {})
+      @name, @default = name, options.delete(:default)
+      @type = options.delete(:type) || :string
+      @options = options
+    end
+    
+    def options_with_default
+      has_default? ? options.merge(:default => default) : options
+    end
+    
+    def has_default?
+      default.present? || default == false || default == ''
+    end
+    
+    def migration_string_for table_state, action
+      args = [name.to_sym.inspect]
+      if action.to_sym == :add
+        args << type.inspect if table_state.to_sym == :update
+        args += options_with_default.map do |k, v|
+          "#{k.to_sym.inspect} => #{v.inspect}"
+        end
+      end
+      args.join(', ').gsub('\\', '')
+    end
+
+  end
+end

data/lib/dynamic_fields/fields.rb

@@ -0,0 +1,154 @@
+module DynamicFields
+  module Fields
+    extend ActiveSupport::Concern
+    
+    included do
+      # Set up the class attributes that must be available to all subclasses.
+      class_inheritable_accessor :fields
+      self.fields = []
+      
+      class_inheritable_accessor :indices
+      self.indices = []
+      
+      
+      delegate :fields, :indices, :to => "self.class"
+    end
+    
+    module ClassMethods #:nodoc
+      # Defines all the fields that are accessible on the model
+      #
+      # Options:
+      #
+      # name: The name of the field, as a +Symbol+.
+      # options: A +Hash+ of options to supply to the +Field+.
+      #
+      # Example:
+      #
+      # <tt>field :score, :default => 0</tt>
+      def field name, options = {}
+        fields << ::DynamicFields::Field.new(name, options) unless field_names.include?(name.to_s)
+      end
+      
+      # All field names (as defined in the model)
+      def field_names
+        fields.map(&:name).map(&:to_s)
+      end
+      
+      # All pre-existing field names
+      def real_field_names
+        table_exists? ? column_names : []
+      end
+      
+      # All pre-existing fields
+      def real_fields
+        return [] unless table_exists?
+        columns.map do |c|
+          next if c.primary == true
+          ::DynamicFields::Field.new(c.name, :type => c.type, :default => c.default)
+        end.compact
+      end
+      
+      # Any fields which have not been add to the table
+      def new_fields
+        fields.reject {|f| real_field_names.include?(f.name.to_s) }
+      end
+      
+      # Any fields in the table, but not in the model
+      def old_fields
+        real_fields.reject { |f| field_names.include?(f.name.to_s) }
+      end
+
+      # Defines all the indices on the model
+      #
+      # Options:
+      #
+      # name: The name of the index, as a +String+.
+      # options: A +Hash+ of options to supply to the +Index+.
+      #
+      # Example:
+      #
+      # <tt>index :user_id</tt>
+      # <tt>index [:user_id, :user_group_id], :name => "user_groups", :unique => true</tt>
+      def index field_or_fields, options={}
+        options[:name] = options.delete(:as) || options.delete(:name) || connection.index_name(table_name, :column => field_or_fields)
+        idx = ::DynamicFields::Index.new(field_or_fields, options)
+        indices << idx unless index_ids.include?(idx.id)
+      end
+      
+      # All index ids (as defined in the model)
+      def index_ids
+        indices.map(&:id)
+      end
+      
+      # All pre-existing index ids
+      def real_index_ids
+        real_indices.map(&:id)
+      end
+      
+      # All pre-existing indices
+      def real_indices
+        return [] unless table_exists?
+        unless connection.respond_to?(:indexes)
+          p "Dynamic indices not supported - remove old indices manually"
+          return []
+        else
+          connection.indexes(table_name).map do |idx|
+            idxs = idx.columns.size > 1 ? idx.columns : idx.columns.first
+            ::DynamicFields::Index.new(idxs, {:name => idx.name, :unique => idx.unique})
+          end.compact
+        end
+      end
+      
+      # Any indicies which have not been add to the table
+      def new_indices
+        indices.reject { |idx| real_index_ids.include?(idx.id) }
+      end
+      
+      # Any indices in the table, but not in the model
+      def old_indices
+        real_indices.reject { |idx| index_ids.include?(idx.id) }
+      end
+      
+      # Check in the model requires a migration (any new or old fields/indices?) 
+      def requires_migration?
+        (new_fields + new_indices + old_fields + old_indices).any?
+      end
+
+      def migration_name
+        return "create_#{table_name}" unless table_exists?
+        "update_#{table_name}_" + [
+          new_fields_migration_name, 
+          new_indices_migration_name, 
+          old_fields_migration_name, 
+          old_indices_migration_name
+        ].compact.join("_and_")
+      end
+
+      protected
+        
+        def new_fields_migration_name #:nodoc
+          migration_name_for_collection new_fields, "add"
+        end
+
+        def old_fields_migration_name #:nodoc
+          migration_name_for_collection old_fields, "remove"
+        end
+        
+        def new_indices_migration_name #:nodoc
+          new_migration_name = migration_name_for_collection(new_indices, "add_#{new_indices.size > 1 ? 'indices' : 'index'}")
+          new_migration_name.present? ? new_migration_name.gsub("index_#{table_name}_on_", '') : nil
+        end
+
+        def old_indices_migration_name #:nodoc
+          new_migration_name = migration_name_for_collection(old_indices, "remove_#{old_indices.size > 1 ? 'indices' : 'index'}")
+          new_migration_name.present? ? new_migration_name.gsub("index_#{table_name}_on_", '') : nil
+        end
+        
+        def migration_name_for_collection collection, prefix=nil #:nodoc
+          new_migration_name = collection.map {|i| i.name.to_s }.to_sentence.gsub(/,?\W/, '_')
+          new_migration_name.present? ? [prefix, new_migration_name].compact.join('_') : nil
+        end
+
+    end
+  end
+end

data/lib/dynamic_fields/index.rb

@@ -0,0 +1,40 @@
+module DynamicFields
+  class Index
+    attr_reader :name, :fields, :options
+    
+    def initialize field_or_fields, options={}
+      @fields  = field_or_fields   
+      @name    = options[:name]
+      @unique  = options.delete(:unique) == true
+      @options = options
+    end
+    
+    def id
+      name
+    end
+    
+    def to_s
+      name
+    end
+    
+    def unique?
+      @unique == true
+    end
+   
+    def migration_string_for table_state, action
+      args = []
+      case action = action.to_sym
+      when :add
+        args << (fields.is_a?(Array) ? fields : fields.to_sym).inspect
+        args << ":name => #{name.inspect}" if fields.is_a?(Array)
+        args << ":unique => true" if unique?
+      when :remove
+        args << fields.to_sym.inspect unless fields.is_a?(Array)
+        args << ":name => #{name.to_sym.inspect}" if fields.is_a?(Array)
+      end
+      args.join(', ').gsub('\\', '')
+    end
+    
+  end
+  
+end

data/lib/dynamic_fields/migration_generator.rb

@@ -0,0 +1 @@
+require File.expand_path(File.dirname(__FILE__)+'/../generators/dynamic_fields/migration/migration_generator')

data/lib/dynamic_fields/railtie.rb

@@ -0,0 +1,9 @@
+require 'dynamic_fields'
+require 'rails'
+module DynamicFields
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load "tasks/dynamic_fields.rake"
+    end
+  end
+end

data/lib/generators/dynamic_fields/migration/USAGE

@@ -0,0 +1,13 @@
+Description:
+    Generate a migration file for a specific Model using DynamicFields
+
+Usage:
+    Pass the name of the Model using DynamicFields, either CamelCased or under_scored
+
+Examples:
+    rails generate dynamic_fields:migration Post
+        
+        If the Post model has no table yet, will create a migration called "create_posts"
+        containing a create_table migration. However, if the Post model already has a table, 
+        will create a migration called "update_posts" containing all the add_column and 
+        remove_column migrations.

data/lib/generators/dynamic_fields/migration/migration_generator.rb

@@ -0,0 +1,58 @@
+require 'rails/generators'
+
+module DynamicFields
+  class MigrationGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+    
+    argument :model, :type => :string, :default => nil, :banner => "Model"
+
+    def create_migration_file
+      set_local_assigns!
+      parse_attributes!
+      migration_template "#{migration_action}_table.rb", "db/migrate/#{migration_name}.rb"
+    end
+    
+    protected
+      attr_reader :migration_action, :migration_klass, :table_name, :attributes, :indices, :migration_name
+      
+      def parse_attributes! #:nodoc:
+        if migration_action == 'create'
+          @attributes = migration_klass.new_fields
+          @indices    = migration_klass.new_indices
+        else
+          @attributes           = {}
+          @attributes[:add]     = migration_klass.new_fields
+          @attributes[:remove]  = migration_klass.old_fields
+          @indices              = {}
+          @indices[:add]        = migration_klass.new_indices
+          @indices[:remove]     = migration_klass.old_indices
+        end
+      end
+
+      def set_local_assigns!
+        @migration_klass  = model.camelize.constantize
+        @migration_action = @migration_klass.table_exists? ? 'update' : 'create'
+        @table_name       = @migration_klass.table_name
+        @migration_name   = @migration_klass.migration_name
+      end
+      
+      # Set the current directory as base for the inherited generators.
+      def self.base_root
+        File.dirname(__FILE__)
+      end
+
+      def self.source_root
+        File.expand_path(base_root + '/templates')
+      end
+
+      # Implement the required interface for Rails::Generators::Migration.
+      def self.next_migration_number(dirname) #:nodoc:
+        next_migration_number = current_migration_number(dirname) + 1
+        if ActiveRecord::Base.timestamped_migrations
+          [Time.now.utc.strftime("%Y%m%d%H%M%S"), "%.14d" % next_migration_number].max
+        else
+          "%.3d" % next_migration_number
+        end
+      end
+  end
+end

data/lib/generators/dynamic_fields/migration/templates/create_table.rb

@@ -0,0 +1,20 @@
+class <%= migration_class_name %> < ActiveRecord::Migration
+  def self.up
+    create_table :<%= table_name %> do |t|
+<% attributes.each do |attribute| -%>
+      t.<%= attribute.type %> <%= attribute.migration_string_for :create, :add %>
+<% end -%>
+    end
+    
+<% indices.each do |index| -%>
+    add_index :<%= table_name %>, <%= index.migration_string_for :create, :add %>
+<% end -%>
+  end
+
+  def self.down
+<% indices.each do |index| -%>
+    remove_index :<%= table_name %>, <%= index.migration_string_for :create, :remove %>
+<% end -%>
+    drop_table :<%= table_name %>
+  end
+end

data/lib/generators/dynamic_fields/migration/templates/update_table.rb

@@ -0,0 +1,15 @@
+class <%= migration_class_name %> < ActiveRecord::Migration
+  def self.up<% attributes.each do |action, attrs| %><% attrs.each do |attribute| %>
+    <%= action %>_column :<%= table_name %>, <%= attribute.migration_string_for :update, action %><% end -%>
+  <% end %><% indices.each do |action, idxs| %><% idxs.each do |index| %>
+    <%= action %>_index :<%= table_name %>, <%= index.migration_string_for :update, action %><% end -%>
+  <% end %>
+  end
+
+  def self.down<% indices.each do |action, idxs| %><% idxs.each do |index| %>
+    <%= action == :add ? 'remove' : 'add' %>_index :<%= table_name %>, <%= index.migration_string_for(:update, action == :add ? :remove : :add ) %><% end -%>
+  <% end %><% attributes.each do |action, attrs| %><% attrs.reverse.each do |attribute| %>
+    <%= action == :add ? 'remove' : 'add' %>_column :<%= table_name %>, <%= attribute.migration_string_for(:update, action == :add ? :remove : :add ) %><% end -%>
+  <% end %>
+  end
+end

data/lib/tasks/dynamic_fields.rake

@@ -0,0 +1,49 @@
+require 'dynamic_fields/migration_generator'
+
+namespace :dynamic_fields do
+  
+  desc "Generate a migration for the specified MODEL"
+  task :migration => :environment do
+    generate_migration_for ENV["MODEL"].classify.constantize
+  end
+  
+  desc "Generate migrations for all Models"
+  task :migrations => :load_models do
+    DynamicFields.models.each do |model|
+      generate_migration_for model
+    end
+  end
+
+  desc "Generate migrations for all Models and migrate the database"
+  task :migrate => :migrations do
+    Rake::Task['db:migrate'].invoke
+  end
+
+  task :load_models => :environment do
+    Dir["#{Rails.root}/app/models/**/*.rb"].each { |model| require_or_load model }
+    Rails::Engine.subclasses.each do |engine|
+      engine_load_path = engine.paths.app.models.paths.first
+      Dir[engine_load_path + '/*.rb', engine_load_path + '/**/*.rb'].each { |model| require_or_load model rescue LoadError }
+    end
+  end
+
+end
+
+namespace :df do
+  desc "Generate a migration for the specified MODEL"
+  task :migration => "dynamic_fields:migration"
+  desc "Generate migrations for all Models"
+  task :migrations => "dynamic_fields:migrations"
+  desc "Generate migrations for all Models and migrate the database"
+  task :migrate => "dynamic_fields:migrate"
+end
+
+def generate_migration_for(klass)
+  return unless klass.name.present? # no annoymous classes
+  if klass.requires_migration?
+    puts "Generating a migration for #{klass.name}"
+    DynamicFields::MigrationGenerator.start klass.name
+  else
+    puts "#{klass.name} is up to date!"
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: dynamic-fields
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 4
+  version: 0.0.4
+platform: ruby
+authors: 
+- Alex Neill
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-02 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Allows for automatic migrations with ActiveRecord
+email: alex@featureless.co.uk
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/dynamic_fields.rb
+- lib/dynamic_fields/field.rb
+- lib/dynamic_fields/fields.rb
+- lib/dynamic_fields/index.rb
+- lib/dynamic_fields/migration_generator.rb
+- lib/dynamic_fields/railtie.rb
+- lib/generators/dynamic_fields/migration/USAGE
+- lib/generators/dynamic_fields/migration/migration_generator.rb
+- lib/generators/dynamic_fields/migration/templates/create_table.rb
+- lib/generators/dynamic_fields/migration/templates/update_table.rb
+- lib/tasks/dynamic_fields.rake
+has_rdoc: true
+homepage: http://github.com/ajn/dynamic-fields
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Auto-migrate ActiveRecord models
+test_files: []
+