opal_orm 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f1cd945fd3b9484b0580826d90a4d9bcd537ca4b
+  data.tar.gz: 0ba5cb818f4320bfce0660722fec1cab525dc0d1
+SHA512:
+  metadata.gz: c25f6c0b2496dc42e5d3429132290b191d587438b6ab77ba4747a3ce36b36bbe5fb9f6164d54958f7ed70e014e34fe581c511347956b63730f87037e0f515fa6
+  data.tar.gz: 11ef2d0c87d8a977877320b1e579f48ac15924b00207ab932c399dcabf2728ae0919264c429a8c2392d61f05dafe065fbc7dad06202134a4be038c5352eccc4b

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/db/
+opal_orm-*.gem
+
+notes

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.1.2
+before_install: gem install bundler -v 1.11.2

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in opal_orm.gemspec
+gemspec
+require 'pry'
+gem 'thor'
+gem 'rspec'
+gem 'activesupport'

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Nathan Matteson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,118 @@
+# OpalOrm
+
+Welcome to OpalORM! OpalORM is a lightweight object-relational mapper for Ruby. With it you
+can define a schema for your models, and then set up relations between them for easy access in your project.
+
+Note: this gem is in its early stages and should not be trusted with important data. If you want stronger validations,
+security, and more features, look no further than the library that inspired OpalORM: [ActiveRecord](https://github.com/rails/rails/tree/master/activerecord).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'opal_orm'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install opal_orm
+
+In the root folder of your project, create a file named `Rakefile` if you don't have one already.
+
+Paste the following into your Rakefile:
+
+```ruby
+spec = Gem::Specification.find_by_name 'opal_orm'
+load "#{spec.gem_dir}/lib/tasks/opal_db.rake"
+```
+
+## Usage
+
+### Database setup
+
+To start, run:
+
+    $ opal_orm create DATABASE_NAME
+
+which will create an empty Sqlite database in `./db/DATABASE_NAME.db`.
+
+Then, run:
+
+    $ opal_orm generate SCHEMA_NAME TABLE1 TABLE2 ...
+
+Where `SCHEMA_NAME` is the name of the new schema, `TABLE1`, `TABLE2` etc. are the names
+of the tables you'd like to generate. You can define more tables in the schema file if you
+need to.
+
+The schema file will be placed in `./db/SCHEMA_NAME.rb`.
+
+Inside your schema file, define each table in a `create_table` block.
+
+For example,
+
+```ruby
+create_table("cats") do |t|
+  t.string :name
+  t.integer :toy_count
+end
+```
+
+corresponds to
+
+```sql
+CREATE TABLE cats (
+  id INTEGER PRIMARY KEY,
+  name VARCHAR(255),
+  toy_count INTEGER
+);
+```
+
+(The primary key column is generated automatically.)
+
+Currently, the only supported column types are string and integer. More to come!
+
+Once your schema file is ready, run the following rake task to convert it to SQL
+and add it to the database:
+
+    $ rake opal_db:setup schema=SCHEMA_FILE
+
+### Using OpalORM::SQLObject
+
+To use OpalORM's core features, inherit your models from `OpalORM::SQLObject`:
+
+```ruby
+class Cat < OpalORM::SQLObject
+end
+```
+
+Instantiate a class like normal, then access data using `all`, `find`, and `where`:
+
+```ruby
+c = Cat.new
+c.name = "Mr. Bojangles"
+c.save
+
+puts Cat.find(1).name
+puts Cat.all
+puts Cat.where(name: "Mr. Bojangles")
+```
+
+<!-- ## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org). -->
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/nmatte/OpalORM.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "./lib/opal_orm"
+require_relative "lib/opal_orm/schema_manager"
+import "./lib/tasks/opal_db.rake"
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "opal_orm"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "pry"
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/opal_orm

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby -wU
+
+require 'opal_orm'
+
+OpalORM::DatabaseManager.start(ARGV)

data/lib/opal_orm.rb

@@ -0,0 +1,14 @@
+require "opal_orm/version"
+require_relative "opal_orm/cli"
+require_relative 'opal_orm/db_connection'
+require_relative 'opal_orm/sql_object'
+require_relative 'opal_orm/schema_manager'
+require_relative 'opal_orm/searchable'
+require_relative 'opal_orm/associatable'
+
+module OpalORM
+  CURRENT_PATH = Dir.pwd
+  CONFIG_PATH = File.join(CURRENT_PATH, 'db/opal_config.json')
+  DB_PATH = File.join(CURRENT_PATH, 'db')
+  # Your code goes here...
+end

data/lib/opal_orm/associatable.rb

@@ -0,0 +1,76 @@
+require_relative 'searchable'
+require 'active_support/inflector'
+
+class AssocOptions
+  attr_accessor(
+    :foreign_key,
+    :class_name,
+    :primary_key
+  )
+
+  def model_class
+    class_name.constantize
+  end
+
+  def table_name
+    class_name.underscore + "s"
+  end
+end
+
+class BelongsToOptions < AssocOptions
+  def initialize(name, options = {})
+    @foreign_key = options[:foreign_key] || "#{name}_id".to_sym
+    @class_name = options[:class_name] || name.to_s.camelcase
+    @primary_key = options[:primary_key] || :id
+  end
+end
+
+class HasManyOptions < AssocOptions
+  def initialize(name, self_class_name, options = {})
+    @foreign_key = options[:foreign_key] || "#{self_class_name.downcase}_id".to_sym
+    @class_name = options[:class_name] || name.to_s.camelcase.singularize
+    @primary_key = options[:primary_key] || :id
+  end
+end
+
+module Associatable
+  def belongs_to(name, options = {})
+    assoc_options[name] = BelongsToOptions.new(name,options)
+    define_method(name) do
+      # p "within class"
+      # p @assoc_options = BelongsToOptions.new(name,options)
+      opts = self.class.assoc_options[name]
+      opts.model_class.find(self.send("#{opts.foreign_key}"))
+    end
+  end
+
+
+  def has_many(name, options = {})
+    define_method(name) do
+      @options = HasManyOptions.new(name,self.class.to_s,options)
+      cats = @options.model_class.where(@options.foreign_key => id)
+    end
+  end
+
+  def assoc_options
+    @assoc_options ||= {}
+  end
+
+  def has_one_through(name, through_name, source_name)
+    define_method(name) do
+      through_options = self.class.assoc_options[through_name]
+      source_options = through_options.model_class.assoc_options[source_name]
+      pk = 1
+      through =
+        through_options.model_class
+        .where(through_options.primary_key => id)
+        .first
+
+      source_options.model_class.find(through.id)
+    end
+  end
+end
+
+class SQLObject
+  extend Associatable
+end

data/lib/opal_orm/cli.rb

@@ -0,0 +1,48 @@
+require 'thor'
+require_relative 'query_builder'
+require_relative 'db_connection'
+require_relative 'schema_manager'
+require_relative 'util'
+
+module OpalORM
+  class DatabaseManager < Thor
+    desc "new DATABASE_NAME", "Create the database to be used by OpalORM"
+    long_desc <<-CREATE
+    Create an empty SQLite database in /db/DATABASE_NAME.db.
+    CREATE
+
+    def new(db_name)
+      Util.ensure_db_dir
+      name_with_ext = "#{db_name}.db"
+      db_file_path = File.join(Util.db_path, name_with_ext)
+      puts "Creating db/#{name_with_ext} ..."
+      DBConnection.open(db_file_path)
+      if File.exist?(db_file_path)
+        Util.ensure_db_dir
+        puts Util.db_path
+        Util.save_config({db_name: name_with_ext})
+        puts "#{name_with_ext} successfully created."
+      end
+    end
+    # TODO define next command
+    desc "generate SCHEMA_NAME TABLE1 TABLE2 ... ", "Create a blank schema file to be edited"
+    long_desc <<-GENERATE
+    Create a blank schema file called schema.rb. In it you can use the OpalORM
+    DSL to create tables with different datatypes.
+    Then create the schema with ``.
+    You may optionally pass the table names that you want to create. Otherwise you
+    will have to add them yourself.
+    GENERATE
+
+    def generate(file_name, *table_names)
+      OpalORM::SchemaManager.generate(file_name, *table_names)
+    rescue FileExistsError => e
+      puts e.message
+      puts "Aborting."
+    rescue ForeignKeyMissingError => e
+      puts e.message
+      puts "Aborting."
+    end
+  end
+
+end

data/lib/opal_orm/db_connection.rb

@@ -0,0 +1,65 @@
+require 'sqlite3'
+require 'json'
+require_relative 'util'
+PRINT_QUERIES = ENV['PRINT_QUERIES'] == 'true'
+# https://tomafro.net/2010/01/tip-relative-paths-with-file-expand-path
+# ROOT_FOLDER = File.join(File.dirname(__FILE__), '..')
+# CATS_SQL_FILE = File.join(ROOT_FOLDER, 'cats.sql')
+# CATS_DB_FILE = File.join(ROOT_FOLDER, 'cats.db')
+
+
+module OpalORM
+  class DBConnection
+    def self.open(db_file_name)
+      @db = SQLite3::Database.new(db_file_name)
+      @db.results_as_hash = true
+      @db.type_translation = true
+      @db
+    end
+
+    # def self.reset
+    #   commands = [
+    #     "rm '#{CATS_DB_FILE}'",
+    #     "cat '#{CATS_SQL_FILE}' | sqlite3 '#{CATS_DB_FILE}'"
+    #   ]
+    #
+    #   commands.each { |command| `#{command}` }
+    #   DBConnection.open(CATS_DB_FILE)
+    # end
+    #
+    def self.instance
+      if Util.get_database_path
+        @db = open(Util.get_database_path)
+      end
+
+      @db
+    end
+
+    def self.execute(*args)
+      print_query(*args)
+      instance.execute(*args)
+    end
+
+    def self.execute2(*args)
+      print_query(*args)
+      instance.execute2(*args)
+    end
+
+    def self.last_insert_row_id
+      instance.last_insert_row_id
+    end
+
+    private
+
+    def self.print_query(query, *interpolation_args)
+      return unless PRINT_QUERIES
+
+      puts '--------------------'
+      puts query
+      unless interpolation_args.empty?
+        puts "interpolate: #{interpolation_args.inspect}"
+      end
+      puts '--------------------'
+    end
+  end
+end

data/lib/opal_orm/query_builder.rb

@@ -0,0 +1,75 @@
+require 'active_support/inflector'
+
+module OpalORM
+  class QueryBuilder
+    def self.create_table_query(name, &prc)
+      manager = new(name)
+      prc.call(manager)
+
+      manager.build!
+    end
+
+    attr_reader :query
+
+    def initialize(name)
+      @table_name = name
+      @columns = []
+      @foreign_keys = []
+    end
+
+    def string(name, *options)
+      @columns << {type: :string, name: name, options: options}
+    end
+
+    def integer(name, *options)
+      @columns << {type: :integer, name: name, options: options}
+    end
+
+    # def foreign_key(ref_name)
+    #   @foreign_keys << ref_name
+    # end
+
+    def build!
+      query_start = "CREATE TABLE #{@table_name} ("
+      column_queries = @columns.map do |col_info|
+        result = []
+        case col_info[:type]
+        when :string
+          result = "#{col_info[:name]} VARCHAR(255) "
+        when :integer
+          result = "#{col_info[:name]} INTEGER "
+        end
+        unless col_info[:options].nil?
+          col_info[:options].each do |key|
+            case col_info[:options]
+            when :null
+              result += "NOT NULL" unless col_info[:options][:null]
+            end
+          end
+        end
+        result
+      end
+      column_queries.unshift("id INTEGER PRIMARY KEY")
+
+      foreign_keys = @foreign_keys.map do |ref_name|
+        if foreign_key_valid?(ref_name)
+          "FOREIGN KEY(#{ref_name}) REFERENCES #{@table_name.singularize}(id)"
+        else
+          raise ForeignKeyMissingError, "Error adding foreign key contsraint for #{ref_name}: couldn't find column named #{ref_name}."
+        end
+      end
+
+      query_end = ");"
+
+      @query = query_start + column_queries.concat(foreign_keys).join(",\n") + query_end
+      @query
+    end
+
+    def foreign_key_valid?(key)
+      @columns.any? {|col| key == col[:name]}
+    end
+  end
+
+  class ForeignKeyMissingError < StandardError
+  end
+end

data/lib/opal_orm/schema_manager.rb

@@ -0,0 +1,63 @@
+require_relative 'util'
+require_relative 'query_builder'
+require_relative 'db_connection'
+module OpalORM
+  class SchemaManager
+    Util.ensure_db_dir
+
+    def self.generate(file_name, *table_names)
+      schema_path = File.join(Util.db_path, "#{file_name}.rb")
+      if File.exist?(schema_path)
+        raise FileExistsError, "#{file_name}.rb already exists. Please choose a different filename."
+      else
+        puts "Creating file 'db/#{file_name}.rb' ..."
+        File.open(schema_path, "w+") do |f|
+          contents = []
+          if table_names.empty?
+            contents << <<-RB
+create_table("table_name") do |t|
+end
+            RB
+          else
+            contents += table_names.map do |table_name|
+              puts "adding table #{table_name} ..."
+              create_table_from_name(table_name)
+          end
+            contents.unshift(comment_string)
+          end
+          f.write(contents.join)
+          puts "Done."
+        end
+      end
+    end
+
+    def self.create_table_from_name(table_name)
+      <<-RB
+create_table \'#{table_name}\' do |t|
+
+end
+      RB
+    end
+
+    def comment_string
+      <<-RB
+# Example usage:
+# create_table 'table_name' do |t|
+#   t.string column_name
+# end
+#
+# The primary key will be created automatically, with name 'id'.
+      RB
+    end
+
+    def create_table(table_name, &prc)
+      q = QueryBuilder.create_table_query(table_name, &prc)
+
+
+      DBConnection.execute(q)
+    end
+  end
+
+  class FileExistsError < StandardError
+  end
+end

data/lib/opal_orm/searchable.rb

@@ -0,0 +1,24 @@
+require_relative 'db_connection'
+require_relative 'sql_object'
+module OpalORM
+  module Searchable
+    def where(params)
+      where_clause = params.keys.map do |key|
+        "#{key.to_s} = ?"
+      end.join(" AND ")
+      results = DBConnection.execute(<<-SQL,params.values)
+      SELECT
+        *
+      FROM
+        #{table_name}
+      WHERE
+        #{where_clause}
+      SQL
+      results.map { |res| new(res)}
+    end
+  end
+end
+
+class OpalORM::SQLObject
+  extend OpalORM::Searchable
+end

data/lib/opal_orm/sql_object.rb

@@ -0,0 +1,147 @@
+require_relative 'db_connection'
+require 'active_support/inflector'
+
+module OpalORM
+  class SQLObject
+    def initialize(params = {})
+      params.each do |attribute,val|
+        col_sym = attribute.to_sym
+        if self.class.columns.include?(col_sym)
+          self.send("#{col_sym}=",val)
+        else
+          raise "unknown attribute '#{attribute}'"
+        end
+      end
+    end
+
+    def self.columns
+      @cols ||= DBConnection.execute2(<<-SQL).first.map(&:to_sym)
+      SELECT
+      *
+      FROM
+      #{table_name}
+      SQL
+    end
+
+    def insert
+      columns = self.class.columns#.reject { |c| c.nil?}
+      cols = columns.join(", ")
+      placeholders = (["?"] * columns.length).join(", ")
+      DBConnection.execute(<<-SQL,*attribute_values)
+      INSERT INTO
+        #{self.class.table_name}(#{cols})
+      VALUES
+        (#{placeholders})
+      SQL
+      attributes[:id] = DBConnection.last_insert_row_id
+    end
+
+    def self.finalize!
+      columns.each do |col_sym|
+        define_getter(col_sym)
+        define_setter(col_sym)
+      end
+    end
+
+    def self.define_getter(attr_name)
+      define_method(attr_name) do
+        attributes[attr_name]
+      end
+    end
+
+    def self.define_setter(attr_name)
+      define_method("#{attr_name}=") do |new_val|
+        attributes[attr_name] = new_val
+      end
+    end
+
+    def self.table_name=(table_name)
+      @table_name = table_name
+    end
+
+    def self.table_name
+      @table_name ||= self.to_s.downcase.pluralize
+    end
+
+    def self.all
+      query = <<-SQL
+      SELECT
+        *
+      FROM
+        #{self.table_name}
+      SQL
+      objs = DBConnection.execute(query)
+      parse_all(objs)
+    end
+
+    def self.parse_all(results)
+      objs = []
+      results.each do |obj|
+        objs << new(obj)
+      end
+      objs
+    end
+
+    def self.find(id)
+      result = DBConnection.execute(<<-SQL,id)
+      SELECT
+        *
+      FROM
+        #{table_name}
+      WHERE
+        id = ?
+      SQL
+      return nil if result.empty?
+      new(result.first)
+    end
+
+    def attributes
+      @attributes ||= {}
+    end
+
+    def attribute_values
+      self.class.columns.map do |col|
+        attributes[col]
+      end
+    end
+
+    def update
+      cols = self.class
+        .columns
+        .map { |col_name| "#{col_name} = ?"}
+        .join(", ")
+      DBConnection.execute(<<-SQL,*attribute_values - [:id], id)
+      UPDATE
+        #{self.class.table_name}
+      SET
+        #{cols}
+      WHERE
+        id = ?
+      SQL
+    end
+
+    def save
+      id.nil? ? insert : update
+    end
+
+    def self.is_column?(col_sym)
+      self.columns.include?(col_sym)
+    end
+
+    def method_missing(method_sym, *args)
+      if self.class.is_column?(method_sym)
+        self.class.define_getter(method_sym)
+        return send(method_sym)
+      end
+
+      setter_name = /(.*)=/.match(method_sym)
+      if setter_name && self.class.is_column?(setter_name[1].to_sym)
+        self.class.define_setter(setter_name[1].to_sym)
+        p method_sym
+        send(method_sym, args[0])
+      else
+        super(method_sym, args)
+      end
+    end
+  end
+end

data/lib/opal_orm/util.rb

@@ -0,0 +1,49 @@
+module OpalORM
+  class Util
+    def self.ensure_db_dir
+      unless Dir.exist?(self.db_path)
+        Dir.mkdir('db')
+      end
+    end
+
+    def self.current_path
+      Dir.pwd
+    end
+
+    def self.db_path
+      File.join(self.current_path, 'db')
+    end
+
+    def self.config_path
+      File.join(self.db_path, 'opal_config.json')
+    end
+
+    def self.get_config
+      if File.exists?(Util.config_path)
+        JSON.parse(File.read(Util.config_path))|| {}
+      end
+    end
+
+    def self.get_database_path
+      db_name = get_config["db_name"]
+      if db_name
+        File.join(db_path, db_name)
+      end
+    end
+
+    def self.make_config
+      Util.ensure_db_dir
+
+      unless File.exists?(Util.config_path)
+        File.new(Util.config_path, 'w')
+      end
+    end
+
+    def self.save_config(new_config)
+      File.open(Util.config_path, "w+") do |f|
+        f.write(new_config.to_json)
+      end
+    end
+  end
+
+end

data/lib/opal_orm/version.rb

@@ -0,0 +1,3 @@
+module OpalOrm
+  VERSION = "0.2.0"
+end

data/lib/tasks/opal_db.rake

@@ -0,0 +1,9 @@
+require_relative "../opal_orm/schema_manager.rb"
+
+namespace :opal_db do
+  desc "Resets the database with the given schema file."
+  task :setup do
+
+    OpalORM::SchemaManager.new.instance_eval File.read("./db/#{ENV["schema"]}")
+  end
+end

data/opal_orm.gemspec

@@ -0,0 +1,40 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'opal_orm/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "opal_orm"
+  spec.version       = OpalOrm::VERSION
+  spec.authors       = ["Nathan Matteson"]
+  spec.email         = ["nwmatteson@gmail.com"]
+
+  spec.summary       = %q{OpalORM is a small object-relational mapper for Ruby.}
+  spec.description   = %q{OpalORM is a lightweight object-relational mapper for Ruby. With it you
+  can define a schema for your models, and then set up relations between them for easy access in your project.}
+  spec.homepage      = "http://github.com/nmatte/OpalORM"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem 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 { |f| f.match(%r{^(test|spec|features)/}) }
+
+  spec.bindir        = "exe"
+  #  spec.executables   = ["./bin/opal_orm"]
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  # spec.executables << "opal_orm"
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'sqlite3', '1.3.11'
+  spec.add_dependency 'thor','0.19.1'
+  spec.add_dependency 'activesupport', '4.2.5'
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification
+name: opal_orm
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Nathan Matteson
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-03-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.3.11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.3.11
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.19.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.19.1
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.2.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.2.5
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: |-
+  OpalORM is a lightweight object-relational mapper for Ruby. With it you
+    can define a schema for your models, and then set up relations between them for easy access in your project.
+email:
+- nwmatteson@gmail.com
+executables:
+- opal_orm
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/opal_orm
+- lib/opal_orm.rb
+- lib/opal_orm/associatable.rb
+- lib/opal_orm/cli.rb
+- lib/opal_orm/db_connection.rb
+- lib/opal_orm/query_builder.rb
+- lib/opal_orm/schema_manager.rb
+- lib/opal_orm/searchable.rb
+- lib/opal_orm/sql_object.rb
+- lib/opal_orm/util.rb
+- lib/opal_orm/version.rb
+- lib/tasks/opal_db.rake
+- opal_orm.gemspec
+homepage: http://github.com/nmatte/OpalORM
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: OpalORM is a small object-relational mapper for Ruby.
+test_files: []