grails-mvc 0.1.0

data/grailedorm/spec/attr_accessor_object_spec.rb

@@ -0,0 +1,47 @@
+require '00_attr_accessor_object'
+
+describe AttrAccessorObject do
+  before(:all) do
+    class MyAttrAccessorObject < AttrAccessorObject
+      my_attr_accessor :x, :y
+    end
+  end
+
+  after(:all) do
+    Object.send(:remove_const, :MyAttrAccessorObject)
+  end
+
+  subject(:obj) { MyAttrAccessorObject.new }
+
+  describe '#my_attr_accessor' do
+    it 'defines getter methods' do
+      expect(obj).to respond_to(:x)
+      expect(obj).to respond_to(:y)
+    end
+
+    it 'defines setter methods' do
+      expect(obj).to respond_to(:x=)
+      expect(obj).to respond_to(:y=)
+    end
+
+    it 'getter methods get from associated ivars' do
+      x_val = 'value of @x'
+      y_val = 'value of @y'
+      obj.instance_variable_set('@x', x_val)
+      obj.instance_variable_set('@y', y_val)
+
+      expect(obj.x).to eq(x_val)
+      expect(obj.y).to eq(y_val)
+    end
+
+    it 'setter methods set associated ivars' do
+      x_val = 'value of @x'
+      y_val = 'value of @y'
+      obj.x = x_val
+      obj.y = y_val
+
+      expect(obj.instance_variable_get('@x')).to eq(x_val)
+      expect(obj.instance_variable_get('@y')).to eq(y_val)
+    end
+  end
+end

data/grailedorm/spec/searchable_spec.rb

@@ -0,0 +1,44 @@
+require '02_searchable'
+
+describe 'Searchable' do
+  before(:each) { DBConnection.reset }
+  after(:each) { DBConnection.reset }
+
+  before(:all) do
+    class Cat < SQLObject
+      finalize!
+    end
+
+    class Human < SQLObject
+      self.table_name = 'humans'
+
+      finalize!
+    end
+  end
+
+  it '#where searches with single criterion' do
+    cats = Cat.where(name: 'Breakfast')
+    cat = cats.first
+
+    expect(cats.length).to eq(1)
+    expect(cat.name).to eq('Breakfast')
+  end
+
+  it '#where can return multiple objects' do
+    humans = Human.where(house_id: 1)
+    expect(humans.length).to eq(2)
+  end
+
+  it '#where searches with multiple criteria' do
+    humans = Human.where(fname: 'Matt', house_id: 1)
+    expect(humans.length).to eq(1)
+
+    human = humans[0]
+    expect(human.fname).to eq('Matt')
+    expect(human.house_id).to eq(1)
+  end
+
+  it '#where returns [] if nothing matches the criteria' do
+    expect(Human.where(fname: 'Nowhere', lname: 'Man')).to eq([])
+  end
+end

data/grailedorm/spec/sql_object_spec.rb

@@ -0,0 +1,240 @@
+require '01_sql_object'
+require 'db_connection'
+require 'securerandom'
+
+describe SQLObject do
+  before(:each) { DBConnection.reset }
+  after(:each) { DBConnection.reset }
+
+  context 'before ::finalize!' do
+    before(:each) do
+      class Cat < SQLObject
+      end
+    end
+
+    after(:each) do
+      Object.send(:remove_const, :Cat)
+    end
+
+    describe '::table_name' do
+      it 'generates default name' do
+        expect(Cat.table_name).to eq('cats')
+      end
+    end
+
+    describe '::table_name=' do
+      it 'sets table name' do
+        class Human < SQLObject
+          self.table_name = 'humans'
+        end
+
+        expect(Human.table_name).to eq('humans')
+
+        Object.send(:remove_const, :Human)
+      end
+    end
+
+    describe '::columns' do
+      it 'returns a list of all column names as symbols' do
+        expect(Cat.columns).to eq([:id, :name, :owner_id])
+      end
+
+      it 'only queries the DB once' do
+        expect(DBConnection).to(
+          receive(:execute2).exactly(1).times.and_call_original)
+        3.times { Cat.columns }
+      end
+    end
+
+    describe '#attributes' do
+      it 'returns @attributes hash byref' do
+        cat_attributes = {name: 'Gizmo'}
+        c = Cat.new
+        c.instance_variable_set('@attributes', cat_attributes)
+
+        expect(c.attributes).to equal(cat_attributes)
+      end
+
+      it 'lazily initializes @attributes to an empty hash' do
+        c = Cat.new
+
+        expect(c.instance_variables).not_to include(:@attributes)
+        expect(c.attributes).to eq({})
+        expect(c.instance_variables).to include(:@attributes)
+      end
+    end
+  end
+
+  context 'after ::finalize!' do
+    before(:all) do
+      class Cat < SQLObject
+        self.finalize!
+      end
+
+      class Human < SQLObject
+        self.table_name = 'humans'
+
+        self.finalize!
+      end
+    end
+
+    after(:all) do
+      Object.send(:remove_const, :Cat)
+      Object.send(:remove_const, :Human)
+    end
+
+    describe '::finalize!' do
+      it 'creates getter methods for each column' do
+        c = Cat.new
+        expect(c.respond_to? :something).to be false
+        expect(c.respond_to? :name).to be true
+        expect(c.respond_to? :id).to be true
+        expect(c.respond_to? :owner_id).to be true
+      end
+
+      it 'creates setter methods for each column' do
+        c = Cat.new
+        c.name = "Nick Diaz"
+        c.id = 209
+        c.owner_id = 2
+        expect(c.name).to eq 'Nick Diaz'
+        expect(c.id).to eq 209
+        expect(c.owner_id).to eq 2
+      end
+
+      it 'created getter methods read from attributes hash' do
+        c = Cat.new
+        c.instance_variable_set(:@attributes, {name: "Nick Diaz"})
+        expect(c.name).to eq 'Nick Diaz'
+      end
+
+      it 'created setter methods use attributes hash to store data' do
+        c = Cat.new
+        c.name = "Nick Diaz"
+
+        expect(c.instance_variables).to include(:@attributes)
+        expect(c.instance_variables).not_to include(:@name)
+        expect(c.attributes[:name]).to eq 'Nick Diaz'
+      end
+    end
+
+    describe '#initialize' do
+      it 'calls appropriate setter method for each item in params' do
+        # We have to set method expectations on the cat object *before*
+        # #initialize gets called, so we use ::allocate to create a
+        # blank Cat object first and then call #initialize manually.
+        c = Cat.allocate
+
+        expect(c).to receive(:name=).with('Don Frye')
+        expect(c).to receive(:id=).with(100)
+        expect(c).to receive(:owner_id=).with(4)
+
+        c.send(:initialize, {name: 'Don Frye', id: 100, owner_id: 4})
+      end
+
+      it 'throws an error when given an unknown attribute' do
+        expect do
+          Cat.new(favorite_band: 'Anybody but The Eagles')
+        end.to raise_error "unknown attribute 'favorite_band'"
+      end
+    end
+
+    describe '::all, ::parse_all' do
+      it '::all returns all the rows' do
+        cats = Cat.all
+        expect(cats.count).to eq(5)
+      end
+
+      it '::parse_all turns an array of hashes into objects' do
+        hashes = [
+          { name: 'cat1', owner_id: 1 },
+          { name: 'cat2', owner_id: 2 }
+        ]
+
+        cats = Cat.parse_all(hashes)
+        expect(cats.length).to eq(2)
+        hashes.each_index do |i|
+          expect(cats[i].name).to eq(hashes[i][:name])
+          expect(cats[i].owner_id).to eq(hashes[i][:owner_id])
+        end
+      end
+
+      it '::all returns a list of objects, not hashes' do
+        cats = Cat.all
+        cats.each { |cat| expect(cat).to be_instance_of(Cat) }
+      end
+    end
+
+    describe '::find' do
+      it 'fetches single objects by id' do
+        c = Cat.find(1)
+
+        expect(c).to be_instance_of(Cat)
+        expect(c.id).to eq(1)
+      end
+
+      it 'returns nil if no object has the given id' do
+        expect(Cat.find(123)).to be_nil
+      end
+    end
+
+    describe '#attribute_values' do
+      it 'returns array of values' do
+        cat = Cat.new(id: 123, name: 'cat1', owner_id: 1)
+
+        expect(cat.attribute_values).to eq([123, 'cat1', 1])
+      end
+    end
+
+    describe '#insert' do
+      let(:cat) { Cat.new(name: 'Gizmo', owner_id: 1) }
+
+      before(:each) { cat.insert }
+
+      it 'inserts a new record' do
+        expect(Cat.all.count).to eq(6)
+      end
+
+      it 'sets the id once the new record is saved' do
+        expect(cat.id).to eq(DBConnection.last_insert_row_id)
+      end
+
+      it 'creates a new record with the correct values' do
+        # pull the cat again
+        cat2 = Cat.find(cat.id)
+
+        expect(cat2.name).to eq('Gizmo')
+        expect(cat2.owner_id).to eq(1)
+      end
+    end
+
+    describe '#update' do
+      it 'saves updated attributes to the DB' do
+        human = Human.find(2)
+
+        human.fname = 'Matthew'
+        human.lname = 'von Rubens'
+        human.update
+
+        # pull the human again
+        human = Human.find(2)
+        expect(human.fname).to eq('Matthew')
+        expect(human.lname).to eq('von Rubens')
+      end
+    end
+
+    describe '#save' do
+      it 'calls #insert when record does not exist' do
+        human = Human.new
+        expect(human).to receive(:insert)
+        human.save
+      end
+
+      it 'calls #update when record already exists' do
+        human = Human.find(1)
+        expect(human).to receive(:update)
+        human.save
+      end
+    end
+  end
+end

data/grails-mvc.gemspec

@@ -0,0 +1,40 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "grails-mvc"
+  spec.version       = Grails::VERSION
+  spec.authors       = ["Victor Wu"]
+  spec.email         = ["victor.wu.1@vanderbilt.edu"]
+
+  spec.summary       = %q{Grails is a lightweight MVC framework based on Rails!}
+  spec.description   = %q{Build web applications easily with Grails!}
+  spec.homepage      = "https://github.com/victorwu3/grails/tree/master/bin"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "thor", "~> 0.20"
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry", "~> 0.10", ">= 0.10.3"
+  spec.add_development_dependency "activesupport", "< 5.0"
+end

data/lib/commands.rb

@@ -0,0 +1,112 @@
+require 'thor'
+require 'pathname'
+require 'fileutils'
+require_relative 'version'
+
+module Grails
+
+  def self.project_root
+    current_dir = Pathname.new(Dir.pwd)
+    current_dir.ascend do |dir|
+      gemfile = File.exist?(File.join(dir, 'Gemfile'))
+      app_folder = Dir.exist?(File.join(dir, 'app'))
+      return dir if gemfile && app_folder
+    end
+  end
+
+  class Generate < Thor
+    desc "migration NAME", "creates a migration file with name"
+    def migration(name)
+      file_name = name
+      timestamp = Time.now.to_i
+      path = File.join(project_root, "db/migrations/#{timestamp}_#{name}.sql")
+      File.new(path, "w")
+
+      puts "New migration file #{name} can be found at #{path}"
+    end
+
+    desc "model NAME", "creates model and migration files"
+    def model(name)
+      path = File.join(project_root, "app/models/#{name.underscore}.rb")
+      raise "Model already exists" if File.exist?(path)
+
+      File.open(path, "w") do |file|
+        file.write("class #{name.camelcase}" < GrailedORM::Base\n)
+        file.write("   self.finalize!\n")
+        file.write("end\n")
+      end
+
+      migration(name)
+      puts "New migration file #{name} can be found at #{path}"
+    end
+
+    desc "controller NAME", "creates a controller file and view folder"
+    def controller(name)
+      controller_path = File.join(project_root, "app/controllers/#{file.pluralize.underscore}_controlller.rb"
+      controller_name = "#{name.pluralize.camelcase}Controller"
+      view_dir = File.join(project_root, "app/views/#{file.pluralize.underscore}")
+      raise "Controller already exists" if File.exist?(controller_path)
+
+      File.open(controller_path, "w") do |file|
+        file.write("class #{controller_name} < ApplicationController\n")
+        file.write("end")
+      end
+      Dir.mkdir(view_dir) unless Dir.exist?(view_dir)
+      puts "New controller file #{name} can be found at #{controller_path}"
+    end
+  end
+
+  class DB < Thor
+    desc "reset", "resets the database and remigrates and reseeds"
+    def reset
+      DBConnection.reset
+    end
+
+    desc "seed", "seeds the database with seed file"
+    def seed
+      DBConnection.seed
+    end
+
+    desc "migrate", "runs all pending migrations if any"
+    def migrate
+      DBConnection.migrate
+    end
+  end
+
+  class CLI < Thor
+    desc "new", "'new' will generate a new Grails application in the working directory"
+
+    def new(app_name)
+      app_dir = File.join(Dir.pwd, name)
+      Raise "Directory of #{app_name} already exists" if Dir.exist?(app_dir)
+
+      Dir.mkdir(File.join(app_dir, "app/models"))
+      Dir.mkdir(File.join(app_dir, "app/controllers"))
+      Dir.mkdir(File.join(app_dir, "app/views"))
+      Dir.mkdir(File.join(app_dir, "db/migrations"))
+      File.new(File.join(app_dir, "config/routes.rb"))
+      File.new(File.join(app_dir, "Gemfile"))
+
+    end
+
+
+    desc "generate COMMAND ...args", "Generates migration, model, or controller"
+    subcommand "g", Generate
+
+    desc "generate COMMAND ...args", "Generates migration, model, or controller"
+    subcommand "generate", Generate
+
+    desc "db COMMAND", "execute an action with the database"
+    subcommand "db", DB
+
+    desc "server", "starts a grails server, with default port of 3000"
+    def server
+      raise "Cannot find Grails app" unless project_root
+      require_relative "#{project_root}/config/routes"
+      require_relative '../bin/server'
+      server = GrailsServer.new(3000)
+      server.start
+    end
+
+  end
+end