schemaless 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cc3e152ecd0dded8e8316950f59c6616276694e4
+  data.tar.gz: a4232d47f7faec46ac0886141b215c0eaac023ad
+SHA512:
+  metadata.gz: 131f65209c376f9976dbdd973ddf87bfda7ab27f6e29e16303c0f38dc7a3c564dfc077573953a4499a64f9a1b4ace3103e1f2dfe715f1786d5e867e1ffbddcba
+  data.tar.gz: 6ac58bc7b86799d04557a64cb2f3f7bdc4e2722354a1a6cbd122b4d6cbef967e273b84c69558d47f0d08c76a810e1364f74a4a6337b0839bf2ae6adb37825c9f

data/README.md

@@ -0,0 +1,93 @@
+Schemaless
+==========
+
+**On ActiveRecord | PostgreSQL**
+
+**Experimental, bugged code**, please use to submit bugs/requests.
+Needs more test code and scenarios also.
+
+
+```ruby
+class Bike < ActiveRecord::Base
+
+  # field column name, column type, null: limit: precision: scale:
+  field :name               # omit for String
+  field :cylinders, Integer # or Float, :decimal, :currency
+  field :bought_at, Date    # Time, :date, :time, :timestamp
+
+  # Adds 'default: to AR
+  field :three_wheeler, :boolean, default: false
+
+  # Adds Array/Hash in PG
+  field :tags, Hash  # hstore
+  field :tags, Array # hstore
+
+  # index columns, name: unique: orders: also supported.
+  index :name
+  index [:name, :cylinders]
+  ...
+end
+
+```
+
+# Why?
+
+* Schema is **defined in code**, not in the DB.
+(Plus no need for annotate models)
+
+* It's easier and **less time** consuming.
+Honestly, you never forgot that field and had to re-run a migration?
+
+* There's **no footprint** in production mode.
+No code executed in production mode.
+
+
+# How?
+
+Just include the gem and run:
+
+    rails g schemaless:setup
+
+
+## DEVELOPMENT | Realtime mode
+
+This mode runs only in development mode.
+
+It's when you are working, happy, without worry about schemas!
+And also now DB fields are nicely described in the model.rb.
+Logic is all in the ruby file now. It's like NoSQL: fun!
+
+
+## PRODUCTION | Migrate servers
+
+Schemaless only stubs the #fields and #index methods in production.
+There's nothing running/using resources in production.
+
+To commit your changes you have two options:
+
+## Safe mode
+
+In safe mode there's no change in the production perspective:
+
+    rails g schemaless:migrations
+
+You'll find a migration per changed table waiting for you in git.
+You simply review'em, and actually, there's no need to test them,
+as your test suite is using them.
+
+
+## Wild mode
+
+Schemaphobia? Very dangerous idea?
+
+    rake schemaless:run
+
+Here we don't use any migration **as files**.
+On the production servers a rake task ensures everything is up to date.
+Tests also use the schema on the models.
+
+
+
+---
+
+Have fun!

data/Rakefile

@@ -0,0 +1,18 @@
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+APP_RAKEFILE = File.expand_path('../spec/dummy/Rakefile', __FILE__)
+# load 'rails/tasks/engine.rake'
+
+Bundler::GemHelper.install_tasks
+
+# Dir[File.join(File.dirname(__FILE__), 'tasks/**/*.rake')].each {|f| load f }
+
+# RSpec::Core::RakeTask.new(:spec => 'app:db:test:prepare')
+RSpec::Core::RakeTask.new
+RuboCop::RakeTask.new
+
+task default: [:spec, :rubocop]

data/lib/generators/schemaless/migrations/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Explain the generator
+
+Example:
+    rails generate migration Thing
+
+    This will create:
+        what/will/it/create

data/lib/generators/schemaless/migrations/migrations_generator.rb

@@ -0,0 +1,108 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+module Schemaless
+  # Generates migrations for schemaless safe mode
+  class MigrationsGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+    source_root File.expand_path('../templates', __FILE__)
+    argument :models, type: :array, default: [] # , banner: 'path'
+    desc 'Schemaless migration files generator!'
+
+    def create_migration_files
+      Rails.application.eager_load!
+      all_tables = Schemaless::Worker.all_tables
+      if models.empty?
+        tables = all_tables
+      else
+        tables = all_tables.select { |t| models.include?(t.model.to_s.downcase) }
+      end
+      tables.each do |table|
+        puts "Generating migrations for #{table}"
+        create_migration_for table
+      end
+    end
+
+    protected
+
+    attr_reader :table_name, :fields, :indexes, :migration_action, :join_tables
+
+    def build_file_name(name = [])
+      if @table.fields.add.any?
+        name << :add
+        name << (@table.fields.add.size > 3 ? :many : @table.fields.add)
+        name << (@table.fields.remove.any? ? :and : :to)
+      end
+      if @table.fields.remove.any?
+        name << :remove
+        name << (@table.fields.remove.size > 3 ? :many : @table.fields.remove)
+        name << :from
+      end
+      name << table_name
+    end
+
+    def file_name
+      return @file_name if @file_name
+      return "create_#{@table_name}" unless @table.exists?
+      @file_name = build_file_name.flatten.join('_')
+    end
+
+    def create_migration_for table
+      @table   = table
+      @fields  = @table.fields
+      @indexes = @table.indexes
+      @table_name = @table.name
+
+      template = file_name =~ /^create_(.+)/ ? 'create' : 'change'
+      migration_template "#{template}_table.rb", "db/migrate/#{file_name}.rb"
+
+      # case file_name
+      # when /join_table/
+      #   if attributes.length == 2
+      #     @migration_action = 'join'
+      #     @join_tables      = if pluralize_table_names?
+      #                           attributes.map(&:plural_name)
+      #                         else
+      #                           attributes.map(&:singular_name)
+      #                         end
+
+      #     set_index_names
+      #   end
+    end
+
+    def set_index_names
+      attributes.each_with_index do |att, i|
+        att.index_name = [att, attributes[i - 1]].map { |a| index_name_for(a) }
+      end
+    end
+
+    def index_name_for(attribute)
+      if attribute.foreign_key?
+        attribute.name
+      else
+        attribute.name.singularize.foreign_key
+      end.to_sym
+    end
+
+    private
+
+    # def attributes_with_index
+    #   attributes.select { |a| !a.reference? && a.has_index? }
+    # end
+
+    def old_migrations
+      ActiveRecord::Migrator.get_all_versions
+    end
+
+    # def validate_file_name!
+    #   unless file_name =~ /^[_a-z0-9]+$/
+    #     fail IllegalMigrationNameError, file_name
+    #   end
+    # end
+
+    def self.next_migration_number(dirname)
+      next_migration_number = current_migration_number(dirname) + 1
+      ActiveRecord::Migration.next_migration_number(next_migration_number)
+    end
+  end
+end

data/lib/generators/schemaless/migrations/templates/change_table.rb

@@ -0,0 +1,34 @@
+class <%= migration_class_name %> < ActiveRecord::Migration
+  def change
+<%- fields.add.each do |field| -%>
+  <%- if field.reference? -%>
+    add_reference :<%= table_name %>, :<%= field.name %><%= field.opts_text %>
+    <%- unless field.polymorphic? -%>
+    add_foreign_key :<%= table_name %>, :<%= field.name.pluralize %>
+    <%- end -%>
+  <%- end -%>
+    add_column :<%= table_name %>, :<%= field.name %>, :<%= field.type %><%= field.opts_text %>
+<%- end -%>
+<%- fields.change.each do |field| -%>
+    change_column :<%= table_name %>, :<%= field.name %>, :<%= field.type %><%= field.opts_text %>
+<%- end -%>
+
+<%- indexes.remove do |index| -%>
+    remove_index :<%= table_name %>, <%= index.fields_text %>
+<%- end -%>
+<%- fields.remove.each do |field| -%>
+    remove_column :<%= table_name %>, :<%= field.name %>
+<%- end -%>
+<%- indexes.add.each do |index| -%>
+    add_index :<%= table_name %>, <%= index.fields_text %><%= index.opts_text %>
+<%- end -%>
+  end
+<%- if migration_action == 'join' -%>
+    create_join_table :<%= join_tables.first %>, :<%= join_tables.second %> do |t|
+    <%- fields.each do |field| -%>
+      <%= '# ' unless field.has_index? -%>t.index <%= field.index_name %><%= field.opts_text %>
+    <%- end -%>
+    end
+  end
+<%- end -%>
+end

data/lib/generators/schemaless/migrations/templates/create_table.rb

@@ -0,0 +1,18 @@
+class <%= migration_class_name %> < ActiveRecord::Migration
+  def change
+    create_table :<%= table_name %> do |t|
+<% fields.add.each do |field| -%>
+      t.<%= field.type %> :<%= field.name %><%= field.opts_text %>
+<% end -%>
+<% if options[:timestamps] %>
+      t.timestamps null: false
+<% end -%>
+    end
+<% indexes.add.each do |index| -%>
+    add_index :<%= table_name %>, <%= index.fields_text %><%= index.opts_text %>
+<% end -%>
+<% fields.add.select(&:reference?).reject(&:polymorphic?).each do |field| -%>
+    add_foreign_key :<%= table_name %>, :<%= field.name.pluralize %>
+<% end -%>
+  end
+end

data/lib/generators/schemaless/setup/setup_generator.rb

@@ -0,0 +1,17 @@
+module Schemaless
+  # Generates schemaless setup for rails app
+  class SetupGenerator < Rails::Generators::Base
+    source_root File.expand_path('../templates', __FILE__)
+    argument :attributes, type: :array, default: [], banner: 'path'
+    desc 'Schemaless config files generator!'
+
+    def create_config_file
+      application 'end'
+      application '  Schemaless::Worker.run!'
+      application '  Rails.application.eager_load!'
+      application 'config.to_prepare do'
+      # initializer | application
+      # copy 'schemaless.rb'
+    end
+  end
+end

data/lib/generators/schemaless/setup/templates/schemaless.rb

@@ -0,0 +1,3 @@
+module Schemaless
+  <%= comments %>
+end

data/lib/schemaless/ar/fields.rb

@@ -0,0 +1,76 @@
+require 'active_support/concern'
+require 'active_support/core_ext/hash/keys'
+
+module Schemaless
+  #
+  # Extend ActiveRecord for #field
+  #
+  module Fields
+    extend ActiveSupport::Concern
+
+    # Schemaless ActiveRecord fields
+    module ClassMethods
+      AR_OPTS = ::Schemaless::Field::VALID_OPTS - [:index, :type]
+
+      def schemaless_fields
+        @schemaless_fields ||= []
+      end
+
+      #
+      # field(*)
+      #
+      # Gets all fields in the model in the schamless_fields array.
+      #
+      #     field :name                # Defaults String
+      #     field :cylinders, Integer  # Use Class or :symbols
+      #     field :type, index: true, default: nil, limit: 5
+      #
+      #
+      def field(*params)
+        config = params.extract_options!
+        config.assert_valid_keys(*::Schemaless::Field::VALID_OPTS)
+        type = config.delete(:type)
+        type ||= params.size > 1 ? params.pop : :string # TBD
+        name = params.join
+        schemaless_fields <<
+          ::Schemaless::Field.new(name, type, config)
+      end
+
+      #
+      # Create the belongs_to foreign keys
+      #
+      def belongs_to(*params)
+        config = params.extract_options!
+        name = "#{params.join}_id"
+        schemaless_fields <<
+          ::Schemaless::Field.new(name, :integer, config)
+        super(*params)
+      end
+
+      #
+      # Helper for timestamps
+      #
+      def timestamps(*params)
+        config = params.extract_options!
+        type = config[:type] || :timestamp
+        schemaless_fields << ::Schemaless::Field.new(:created_at, type, null: false)
+        schemaless_fields << ::Schemaless::Field.new(:updated_at, type, null: true)
+        return unless config[:paranoid]
+        schemaless_fields << ::Schemaless::Field.new(:deleted_at, type, null: true)
+      end
+
+      #
+      # Get all fields in a schemaless way
+      #
+      def current_attributes
+        columns_hash.map do |k, v|
+          next if v.primary
+          opts = AR_OPTS.reduce({}) do |a, e|
+            v.send(e) ? a.merge(e => v.send(e)) : a
+          end
+          ::Schemaless::Field.new(k, v.type, opts)
+        end.reject!(&:nil?)
+      end
+    end
+  end
+end

data/lib/schemaless/ar/indexes.rb

@@ -0,0 +1,46 @@
+require 'active_support/concern'
+require 'active_support/core_ext/hash/keys'
+
+module Schemaless
+  #
+  # Extend ActiveRecord for #index
+  #
+  module Indexes
+    extend ActiveSupport::Concern
+
+    # Schemaless ActiveRecord indexes
+    module ClassMethods
+
+      def schemaless_indexes
+        @schemaless_indexes ||= []
+      end
+
+      #
+      # index(*)
+      #
+      #     index :name
+      #     index [:one, :other]
+      #     index :name, unique: true
+      #
+      #
+      def index(*params)
+        config = params.extract_options!
+        name = config.delete(:name)
+        schemaless_indexes <<
+          ::Schemaless::Index.new(params, name, config)
+      end
+
+      #
+      # Get all indexes in a schemaless way
+      #
+      def current_indexes
+        ::ActiveRecord::Base.connection.indexes(table_name).map do |i|
+          opts = ::Schemaless::Index::VALID_OPTS.reduce({}) do |a, e|
+            i.send(e) ? a.merge(e => i.send(e)) : a
+          end
+          ::Schemaless::Index.new(i.columns, i.name, opts)
+        end
+      end
+    end
+  end # ActiveRecord
+end # Schemaless

data/lib/schemaless/ar/stubs.rb

@@ -0,0 +1,15 @@
+require 'active_support/concern'
+
+module Schemaless
+  # Stubs for production mode
+  module Stubs
+    extend ActiveSupport::Concern
+
+    # Schemaless ActiveRecord Stub
+    module ClassMethods
+      def field(*)     end
+
+      def index(*)     end
+    end
+  end # Stubs
+end # Schemaless

data/lib/schemaless/field.rb

@@ -0,0 +1,94 @@
+module Schemaless
+  #
+  # Fields
+  #
+  class Field
+    attr_accessor :name, :type, :opts, :default, :index
+    VALID_OPTS = [:type, :limit, :precision, :scale, :null, :default, :index]
+
+    #
+    # Field - name, type, opts: [:default, :null, :unique]
+    #
+    def initialize(name, type, opts = {})
+      fail InvalidArgument, 'opts must be a hash' unless opts.is_a?(Hash)
+      @name = name.to_s
+      @type = map_field type
+      @opts = opts.select { |_k, v| v.present? }
+      @opts[:null] = true unless @opts[:null].present?
+      @opts[:limit] = 255 unless @opts[:limit].present? || @type != :string
+    end
+
+    def ==(other)
+      name == other.name #  && type == other.type
+    end
+
+    def reference?
+    end
+
+    def opts_text
+      txt = opts.map { |k, v| "#{k}: #{v}" }.join(', ')
+      txt.empty? ? '' : ", #{txt}"
+    end
+
+    def to_s
+      name
+    end
+
+    #
+    # Add Fields
+    #
+    def add!(table)
+      puts "++ Adding '#{self}' to '#{table}'"
+      return if Schemaless.sandbox
+      ::ActiveRecord::Migration.add_column(table.name, name, type, opts)
+    end
+
+    #
+    # Delete Fields
+    #
+    def remove!(table)
+      puts "-- Removing '#{self}' from '#{table}'"
+      return if Schemaless.sandbox
+      ::ActiveRecord::Migration.remove_column(table.name, name)
+    end
+
+    #
+    # Change Fields
+    #
+    def change!(table)
+      return if Schemaless.sandbox
+      # ::ActiveRecord::Migration.change_column(table, name)
+      # ::ActiveRecord::Migration.change_column_null(table, name)
+      # ::ActiveRecord::Migration.change_column_default(table, name)
+      ::ActiveRecord::Migration.change_column(table.name, name, type, opts)
+    end
+
+    #
+    # binary    # boolean
+    # date      # datetime
+    # time      # timestamp
+    # integer   # primary_key    # references
+    # decimal   # float
+    # string    # text
+    # hstore
+    # json
+    # array
+    # cidr_address
+    # ip_address
+    # mac_address
+    #
+    def map_field(field) # rubocop:disable Metrics/MethodLength
+      return field if field.is_a?(Symbol)
+      case field.to_s
+      when /Integer|Fixnum|Numeric/ then :integer
+      when /BigDecimal|Rational/ then :decimal
+      when /Float/      then :float
+      when /DateTime/   then :datetime
+      when /Date/       then :date
+      when /Time/       then :timestamp
+      else
+        :string
+      end
+    end
+  end
+end

data/lib/schemaless/index.rb

@@ -0,0 +1,59 @@
+module Schemaless
+  #
+  # Stores indexes
+  #
+  class Index
+    attr_accessor :fields, :name, :opts
+    VALID_OPTS = [:unique, :orders]
+
+    def initialize(fields, name = nil, opts = {})
+      @fields = [fields].flatten
+      @fields = @fields.first if @fields.size == 1
+      @name = name || opts[:name]
+      @opts = opts.select { |_k, v| v.present?  }
+      @opts.merge!(name: @name) if @name
+    end
+
+    def opts_text
+      txt = opts.map { |k, v| "#{k}: #{v}" }.join(', ')
+      txt.empty? ? '' : ", #{txt}"
+    end
+
+    def fields_text
+      @fields.inspect
+    end
+
+    def to_s
+      name
+    end
+
+    def ==(other)
+      name == other.name
+    end
+
+    #
+    # Add Indexes
+    #
+    def add!(table)
+      return if Schemaless.sandbox
+      ::ActiveRecord::Migration.add_index(table.name, fields, opts)
+    end
+
+    #
+    # Delete Indexes
+    #
+    def remove!(table)
+      return if Schemaless.sandbox
+      key = name ? { name: name } : { column: fields }
+      ::ActiveRecord::Migration.remove_index(table.name, key)
+    end
+
+    #
+    # Change Indexes
+    #
+    def change!(table)
+      return if Schemaless.sandbox
+      ::ActiveRecord::Migration.change_index(table.name, name, type, opts)
+    end
+  end
+end

data/lib/schemaless/railtie.rb

@@ -0,0 +1,23 @@
+# Rails 3 initialization
+module Schemaless
+  require 'rails'
+  # Rails include
+  class Railtie < Rails::Railtie
+    initializer 'schemaless.insert_into_active_record' do
+      ActiveSupport.on_load :active_record do
+        if Rails.env =~ /production/
+          require 'schemaless/ar/stubs'
+          ::ActiveRecord::Base.send :include, Schemaless::Stubs
+        else
+          require 'schemaless/ar/fields'
+          require 'schemaless/ar/indexes'
+          ::ActiveRecord::Base.send :include, Schemaless::Fields
+          ::ActiveRecord::Base.send :include, Schemaless::Indexes
+        end
+      end
+    end
+    rake_tasks do
+      load 'tasks/schemaless_tasks.rake'
+    end
+  end
+end