baza_models 0.0.0 → 0.0.1

data/lib/baza_models/query/inspector.rb

@@ -0,0 +1,74 @@
+class BazaModels::Query::Inspector
+  def initialize(args)
+    @query = args.fetch(:query)
+    @model = args.fetch(:model)
+    @argument = args.fetch(:argument)
+    @joins = args.fetch(:joins)
+    @joins_tracker = args.fetch(:joins_tracker)
+  end
+
+  def execute
+    inspect_argument(@argument)
+  end
+
+private
+
+  def inspect_argument(argument)
+    if argument.is_a?(Hash)
+      inspect_hash(argument)
+    elsif argument.is_a?(Array)
+      argument.each do |argument_i|
+        inspect_argument(argument_i)
+      end
+    elsif argument.is_a?(Symbol)
+      inspect_symbol(argument)
+    elsif argument.is_a?(String)
+      inspect_string(argument)
+    end
+  end
+
+  def inspect_string(argument)
+    @joins << argument
+  end
+
+  def inspect_symbol(argument)
+    return if @joins_tracker.include?(argument)
+
+    relationship_pair = @model.relationships.detect { |key, _value| key == argument }
+    raise "Could not find a relationship on #{@model.name} by that name: #{argument}" unless relationship_pair
+    relationship = relationship_pair[1]
+
+    table_name = relationship.fetch(:table_name)
+
+    if relationship.fetch(:type) == :belongs_to
+      column_left = :id
+      column_right = relationship.fetch(:foreign_key)
+    else
+      column_left = relationship.fetch(:foreign_key)
+      column_right = :id
+    end
+
+    orig_table = @model.table_name
+
+    @joins << "INNER JOIN `#{table_name}` ON `#{table_name}`.`#{column_left}` = `#{orig_table}`.`#{column_right}`"
+    @joins_tracker[argument] = {}
+  end
+
+  def inspect_hash(argument)
+    argument.each do |key, value|
+      inspect_symbol(key)
+
+      relationship_pair = @model.relationships.detect { |relationship_name, _relationship| relationship_name == key }
+      raise "Could not find a relationship on #{@model.name} by that name: #{value}" unless relationship_pair
+      relationship = relationship_pair[1]
+
+      BazaModels::Query::Inspector.new(
+        query: @query,
+        argument: value,
+        model: Object.const_get(relationship.fetch(:class_name)),
+        joins: @joins,
+        joins_tracker: @joins_tracker[key]
+      ).execute
+    end
+  end
+end

data/lib/baza_models/query/not.rb

@@ -0,0 +1,34 @@
+class BazaModels::Query::Not
+  def initialize(args)
+    @query = args.fetch(:query)
+    @model = @query.instance_variable_get(:@model)
+    @db = @query.instance_variable_get(:@db)
+    @wheres = @query.instance_variable_get(:@wheres)
+  end
+
+  def not(args)
+    args.each do |key, value|
+      if value.is_a?(Hash)
+        value.each do |hash_key, hash_value|
+          if hash_value.is_a?(Array)
+            values = hash_value.map { |hash_value_i| "'#{@db.esc(hash_value_i)}'" }.join(",")
+
+            @wheres << "`#{key}`.`#{hash_key}` NOT IN (#{values})"
+          else
+            @wheres << "`#{key}`.`#{hash_key}` != '#{@db.esc(hash_value)}'"
+          end
+        end
+      else
+        if value.is_a?(Array)
+          values = value.map { |value_i| "'#{@db.esc(value_i)}'" }.join(",")
+
+          @wheres << "`#{@model.table_name}`.`#{key}` NOT IN (#{values})"
+        else
+          @wheres << "`#{@model.table_name}`.`#{key}` != '#{@db.esc(value)}'"
+        end
+      end
+    end
+
+    @query
+  end
+end

data/lib/baza_models/ransacker.rb

@@ -0,0 +1,30 @@
+class BazaModels::Ransacker
+  def initialize(args)
+    @klass = args.fetch(:class)
+    @params = args.fetch(:params)
+    @query = @klass
+  end
+
+  def result
+    add_filters_to_query
+    @query
+  end
+
+private
+
+  def add_filters_to_query
+    return unless @params
+
+    @params.each do |key, value|
+      if (match = key.to_s.match(/\A(.+?)_eq\Z/))
+        column_name = match[1]
+        @query = @query.where("`#{@klass.table_name}`.`#{@klass.db.escape_column(column_name)}` = '#{@klass.db.esc(value)}'")
+      elsif (match = key.to_s.match(/\A(.+?)_cont\Z/))
+        column_name = match[1]
+        @query = @query.where("`#{@klass.table_name}`.`#{@klass.db.escape_column(column_name)}` LIKE '%#{@klass.db.esc(value)}%'")
+      else
+        raise "Unknown modifier: #{key}"
+      end
+    end
+  end
+end

data/lib/baza_models/test_database_cleaner.rb

@@ -0,0 +1,23 @@
+class BazaModels::TestDatabaseCleaner
+  def self.clean
+    BazaModels::TestDatabaseCleaner.new.truncate_all_tables
+  end
+
+  def initialize
+    raise "Not in test-environment" unless Rails.env.test?
+
+    @db = BazaModels.primary_db
+
+    raise "No primary database on BazaModels?" unless @db
+
+    truncate_all_tables
+  end
+
+  def truncate_all_tables
+    @db.transaction do
+      @db.tables.list do |table|
+        table.truncate unless table.name == "baza_schema_migrations"
+      end
+    end
+  end
+end

data/lib/baza_models/validators/base_validator.rb

@@ -5,4 +5,18 @@ class BazaModels::Validators::BaseValidator
     @attribute_name = attribute_name
     @args = args
   end
+
+  def fire?(model)
+    result = true
+
+    if @args[:if]
+      if @args.fetch(:if).is_a?(Symbol)
+        result = model.__send__(@args.fetch(:if))
+      else
+        raise "Unknown 'if'-argument: #{@args[:if]} (#{@args[:if].class.name})"
+      end
+    end
+
+    result
+  end
 end

data/lib/baza_models/validators/confirmation_validator.rb

@@ -0,0 +1,12 @@
+class BazaModels::Validators::ConfirmationValidator < BazaModels::Validators::BaseValidator
+  def validate(model, value)
+    confirmation_attribute_name = "#{attribute_name}_confirmation"
+    confirmation_value = model.__send__(confirmation_attribute_name)
+
+    if value && !confirmation_value
+      model.errors.add(attribute_name, "hasn't been confirmed")
+    end
+
+    model.errors.add(attribute_name, "was not the same as the confirmation") if value && confirmation_value && confirmation_value != value
+  end
+end

data/lib/baza_models/validators/format_validator.rb

@@ -0,0 +1,11 @@
+class BazaModels::Validators::FormatValidator < BazaModels::Validators::BaseValidator
+  def validate(model, value)
+    model.errors.add(attribute_name, "has an invalid format") unless value.to_s.match(format_regex)
+  end
+
+private
+
+  def format_regex
+    @args.fetch(:format)[:with]
+  end
+end

data/lib/baza_models/validators/length_validator.rb

@@ -0,0 +1,16 @@
+class BazaModels::Validators::LengthValidator < BazaModels::Validators::BaseValidator
+  def validate(model, value)
+    model.errors.add(attribute_name, "is too long") if max_length && value.to_s.length > max_length
+    model.errors.add(attribute_name, "is too short") if min_length && value.to_s.length < min_length
+  end
+
+private
+
+  def max_length
+    @args.fetch(:length)[:maximum]
+  end
+
+  def min_length
+    @args.fetch(:length)[:minimum]
+  end
+end

data/lib/baza_models/validators/uniqueness_validator.rb

@@ -0,0 +1,21 @@
+class BazaModels::Validators::UniquenessValidator < BazaModels::Validators::BaseValidator
+  def validate(model, value)
+    query_same = model.class.where(attribute_name => value)
+
+    if scope
+      scope.each do |scope_part|
+        query_same = query_same.where(scope_part => model.__send__(scope_part))
+      end
+    end
+
+    model.errors.add(attribute_name, "isn't unique") if query_same.any?
+  end
+
+private
+
+  def scope
+    scope = @args.fetch(:uniqueness)[:scope]
+    scope = [scope] if scope && !scope.is_a?(Array)
+    scope
+  end
+end

data/shippable.yml

@@ -2,8 +2,10 @@ language: ruby
 cache: bundler
 archive: true
 rvm:
-  - 2.1.2
+  - ruby-2.1.2
+  - jruby-1.7.13
 script:
   - CODECLIMATE_REPO_TOKEN=b91c00ba044df16a09d7120a2449a43ccad754de9271a7ecf594e3b0cf432eeb bundle exec rspec
+  - bundle exec rake best_practice_project:run
 notifications:
    email: false

data/spec/baza_models/autoloader_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+
+describe BazaModels::Autoloader do
+  include DatabaseHelper
+
+  let!(:organization) { Organization.create! }
+  let!(:another_user) { User.create!(email: "another@example.com") }
+  let!(:user) { User.create!(email: "test@example.com", organization: organization) }
+  let!(:user_passport) { UserPassport.create!(user: user) }
+  let(:role_user) { Role.new(user: user, role: "user") }
+  let!(:role_admin) { Role.create!(user: user, role: "administrator") }
+
+  it "autoloads via includes on has_many relations" do
+    query = User.includes(:roles).to_a
+    user_from_query = query.detect { |user| user.email == "test@example.com" }
+
+    expect(user_from_query.autoloads.fetch(:roles)).to eq [role_admin]
+    expect(user_from_query.roles.__send__(:any_mods?)).to eq false
+    expect(user_from_query.roles.__send__(:any_wheres_other_than_relation?)).to eq false
+    expect(user_from_query.roles.__send__(:autoloaded_on_previous_model?)).to eq true
+    expect(user_from_query.roles.to_enum).to eq [role_admin]
+  end
+
+  it "autoloads via includes on belongs_to relations" do
+    query = Role.includes(:user).to_a
+    role = query.first
+
+    allow(role.autoloads).to receive(:[]).and_call_original
+    expect(role.user).to eq user
+    expect(role.autoloads).to have_received(:[]).with(:user)
+    expect(role.autoloads[:user]).to eq user
+  end
+
+  it "autoloads via includes on has_one relations" do
+    query = User.includes(:user_passport).to_a
+    user = query.detect { |user_i| user_i.email == "test@example.com" }
+
+    allow(user.autoloads).to receive(:[]).and_call_original
+    expect(user.user_passport).to eq user_passport
+    expect(user.autoloads).to have_received(:[]).with(:user_passport)
+    expect(user.autoloads[:user_passport]).to eq user_passport
+  end
+
+  it "autoloads sub models" do
+    organizations = Organization.includes(users: :roles).to_a
+    organization = organizations.first
+
+    expect(organization.autoloads.fetch(:users)).to eq [user]
+
+    expect(organization.users.to_a).to eq [user]
+    org_user = organization.autoloads.fetch(:users).first
+    expect(org_user.autoloads.fetch(:roles)).to eq [role_admin]
+
+    org_user = organization.users.first
+    expect(org_user.autoloads.fetch(:roles)).to eq [role_admin]
+  end
+end

data/spec/baza_models/baza_orm_adapter_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+describe BazaModels::Query do
+  include DatabaseHelper
+
+  let(:user) { User.new(email: "test@example.com") }
+
+  it "#get" do
+    user.save!
+    expect(User.to_adapter.get([1])).to eq user
+    expect(User.to_adapter.get(1)).to eq user
+    expect(User.to_adapter.get(5)).to eq nil
+  end
+
+  it "#get!" do
+    user.save!
+    expect(User.to_adapter.get!([1])).to eq user
+    expect(User.to_adapter.get!(1)).to eq user
+
+    expect do
+      User.to_adapter.get!(5)
+    end.to raise_error(BazaModels::Errors::RecordNotFound)
+  end
+
+  it "#create!" do
+    expect { User.to_adapter.create!(email: "test@example.com") }.to change(User, :count).by(1)
+  end
+
+  it "#destroy" do
+    user.save!
+
+    expect do
+      expect(User.to_adapter.destroy(user)).to eq true
+    end.to change(User, :count).by(-1)
+
+    expect { user.reload }.to raise_error(BazaModels::Errors::RecordNotFound)
+  end
+
+  it "#find_first" do
+    user.save!
+    expect(User.to_adapter.find_first(id: 1)).to eq user
+  end
+
+  it "#find_all" do
+    user.save!
+    expect(User.to_adapter.find_all(id: 1).to_a).to eq [user]
+  end
+
+  it "#column_names" do
+    expect(User.to_adapter.column_names).to eq %w(id organization_id email email_confirmation created_at updated_at)
+  end
+end

data/spec/baza_models/class_translation_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+describe BazaModels::ClassTranslation do
+  include DatabaseHelper
+
+  it "#model_name" do
+    expect(User.model_name.human).to eq "User"
+  end
+
+  it "#param_key" do
+    expect(User.model_name.param_key).to eq "user"
+  end
+
+  it "#route_key" do
+    expect(User.model_name.route_key).to eq "users"
+  end
+
+  it "#singular_route_key" do
+    expect(User.model_name.singular_route_key).to eq "user"
+  end
+
+  it "#i18n_key" do
+    expect(User.model_name.i18n_key).to eq :user
+  end
+end

data/spec/baza_models/factory_girl_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe "factory girl with baza models" do
+  include DatabaseHelper
+
+  let(:user) { create :user, organization: organization }
+  let(:organization) { create :organization }
+
+  it "creates the user" do
+    expect(user.email).to eq "user@example.com"
+    expect(user.organization).to eq organization
+  end
+end

data/spec/baza_models/model/belongs_to_relations_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+
+describe BazaModels::Model::BelongsToRelations do
+  include DatabaseHelper
+
+  let(:user) { User.new(email: "test@example.com") }
+  let(:role_user) { Role.new(user: user, role: "user") }
+  let(:role_admin) { Role.new(user: user, role: "administrator") }
+
+  context "relationships" do
+    before do
+      user.save!
+      role_user.save!
+      role_admin.save!
+    end
+
+    it "#belongs_to" do
+      expect(role_user.user).to eq user
+    end
+
+    it "joins correctly" do
+      roles = Role.joins(:user).where(role: "administrator", users: {email: "test@example.com"})
+      expect(roles.to_a).to eq [role_admin]
+    end
+  end
+end