groovy 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36ab3d8425ae05fd7b069e75b1cb3f168a8a31605e2bd54d3b44285f715dbc92
-  data.tar.gz: 7d48ca3d630488d52c0fd60e73ac753d5b1658601f6803566838c563231cce9a
+  metadata.gz: b2968c89f9c0019f1984b53b34a1d5c4520e82bede4f56020a7ef490c76897fe
+  data.tar.gz: 6de69f1590be6a8bddd69f60bed379e8e59e75dcd2a9a00c5696ef5160b211a5
 SHA512:
-  metadata.gz: 2dfafb96a0e3636a7e49c9319a40d7e7217d6c21ed48bc0be6e8a4a61aee9a7ce41f9d3499987a03d16e0dc15868988d6a03049a8aec401b70f96b4c405e47b4
-  data.tar.gz: 90e22b09f631228277f297c552f42bbdf0bfc9faaccbea13c769b2f68b91cc297c157a1557a101790d0497d2390ba466f4f44f97bf5ac1a3d4f267666b36465e
+  metadata.gz: 1b7be573999c72a9a5bb1a5b140388644702430c51a07a315d163c8a6f7db89058416ebcc252351498fd5d3b5e86d2cafeea06653e396bc6ddcf3d4bfaf6e6d3
+  data.tar.gz: 8693eb5c4472d634b62ad3be13e57e1c54172374aef7f8792807b107de068457bef293106437521b9200977db95122b524e2182438441fee780e72c15f129f1f

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/example/basic.rb

@@ -0,0 +1,25 @@
+require 'bundler/setup'
+require 'groovy'
+
+Groovy.open('./db/products')
+
+class Product
+  include Groovy::Model
+
+  schema do |t|
+    t.column :name, String
+    t.column :price, Integer
+    t.timestamps
+  end
+end
+
+50_000.times do |i|
+  puts "Creating product #{i}" if i % 1000 == 0
+  Product.create!(name: "A product with index #{i}", price: 10000 + i)
+end
+
+puts Product.count
+
+# 50_000 products: 50M
+# 100_000 products: 50M
+# 500_000 products: 62M

data/example/config.ru

@@ -1,15 +1,5 @@
-require 'bundler/setup'
-require 'groovy'
-Groovy.init('./db/test')
-
-class Place
-  include Groovy::Model
-
-  # table_options type: :hash
-  column :name, String
-  column :description, String, searchable: true
-  timestamps!
-end
+require './models'
+require 'groovy/middleware'
 
 Place.delete_all
 
@@ -20,8 +10,9 @@ end
 Place.last.delete
 
 app = Proc.new do |env|
-  body = Place.all.collect(&:as_json)
+  body = Place.all.collect(&:as_json).inspect
   [200, { 'Content-Type' => 'text/plain' }, [body]]
 end
 
+use Groovy::MemoryPoolMiddleware
 run app

data/example/relations.rb

@@ -0,0 +1,47 @@
+require 'bundler/setup'
+require 'groovy'
+
+Groovy.open('./db/2019', :current)
+Groovy.open('./db/2020', :next)
+
+module Groovy::Model::ClassMethods
+  def context_name
+    Time.now.year == 2019 ? :current : :next
+  end
+
+  def table
+    obj = db_context[table_name]
+    schema.sync(db_context) if obj.nil?
+    db_context[table_name]
+  end
+end
+
+class Category
+  include Groovy::Model
+
+  schema do |t|
+    t.column :name, String
+    t.timestamps
+  end
+end
+
+class Place
+  include Groovy::Model
+
+  schema do |t|
+    t.reference :categories, "Categories", type: :vector
+    t.column :name, String
+    t.column :description, String, index: true
+    t.timestamps
+  end
+end
+
+class Location
+  include Groovy::Model
+
+  schema do |t|
+    t.reference :place, "Places"
+    t.column :coords, String
+    t.timestamps
+  end
+end

data/lib/groovy.rb

@@ -2,18 +2,59 @@ require 'groonga'
 require File.expand_path(File.dirname(__FILE__)) + '/groovy/model'
 
 module Groovy
-  VERSION = '0.1.0'.freeze
-
-  def self.init(db_path, opts = {})
-    if File.exist?(db_path)
-      puts "Opening DB"
-      Groonga::Database.open(db_path)
-    else
-      dir = File.dirname(db_path)
-      puts "Creating DB in #{dir}"
-      FileUtils.mkdir_p(dir)
-      Groonga::Database.create(path: db_path)
+  VERSION = '0.1.1'.freeze
+
+  class << self
+
+    def contexts
+      @contexts ||= {}
+    end
+
+    def [](key)
+      contexts[key.to_sym]
+    end
+    
+    def first_context_name
+      contexts.keys.first
+    end
+
+    def open(db_path, name = :default, opts = {})
+      raise "Context already defined: #{name}" if contexts[name.to_sym]
+      contexts[name.to_sym] = if name == :default
+        Groonga::Context.default.tap { |ctx| open_or_create_db(ctx, db_path) }
+      else
+        init_context(db_path, opts)
+      end
+    end
+
+    def logger=(obj)
+      @logger = obj
     end
+
+    def logger
+      @logger ||= Logger.new(STDOUT)
+    end
+
+    private
+
+    def init_context(db_path, opts)
+      Groonga::Context.new(opts).tap do |ctx|
+        open_or_create_db(ctx, db_path)
+      end
+    end
+
+    def open_or_create_db(ctx, path)
+      if File.exist?(path)
+        logger.info "Opening DB at #{path}"
+        ctx.open_database(path)
+      else
+        dir = File.dirname(path)
+        logger.info "Creating DB in #{dir}"
+        FileUtils.mkdir_p(dir)
+        ctx.create_database(path)
+      end
+    end
+
   end
 
-end
+end

data/lib/groovy/middleware.rb

@@ -0,0 +1,14 @@
+module Groovy
+  class MemoryPoolMiddleware
+    def initialize(app, options = {})
+      @app = app
+    end
+    
+    def call(env)
+      Groovy.contexts.each { |name, ctx| ctx.push_memory_pool }
+      code, headers, body = @app.call(env)
+      Groovy.contexts.each { |name, ctx| ctx.pop_memory_pool }
+      [code, headers, body]
+    end
+  end
+end

data/lib/groovy/model.rb

@@ -1,6 +1,6 @@
-require File.expand_path(File.dirname(__FILE__)) + '/query'
-require File.expand_path(File.dirname(__FILE__)) + '/types'
 require File.expand_path(File.dirname(__FILE__)) + '/schema'
+require File.expand_path(File.dirname(__FILE__)) + '/vector'
+require File.expand_path(File.dirname(__FILE__)) + '/query'
 
 class Hash
   def symbolize_keys
@@ -11,69 +11,52 @@ end unless {}.respond_to?(:symbolize_keys)
 module Groovy
   module Model
 
-    SEARCH_TABLE_NAME = 'Terms'
+    def self.initialize_from_record(obj)
+      model = model_from_table(obj.table.name)
+      model.new_from_record(obj)
+    end
+
+    def self.model_from_table(table_name)
+      Kernel.const_get(table_name.sub(/ies$/, 'y').sub(/s$/, ''))
+    end
 
     def self.included(base)  
       base.extend(ClassMethods)
       base.include(Forwardable)
-      base.table_name = base.name + 's'
-
-      if base.table.nil?
-        # abort "Please set up your database before declaring your models." 
-      else
-        base.extend(PatriciaTrieMethods) if base.table.is_a?(Groonga::PatriciaTrie)
-        base.class_eval do
-          attribute_names.each do |col|
-            add_accessor(col)
-          end
-        end # if base.table
-      end
+      base.table_name = base.name.sub(/y$/, 'ie') + 's'
     end
 
     module ClassMethods
       extend Forwardable
-      attr_accessor :table_name
+      attr_accessor :context_name, :table_name
 
       def validatable!
         include(ActiveModel::Validations)
       end
 
       def table
-        # raise "Table name not set!" if table_name.nil?
-        # schema.table
-        Groonga[table_name]
-      end
-
-      def table_options(opts)
-        @table_options = opts
-      end
-
-      def schema
-        @schema ||= Schema.new(table_name, @table_options)
+        db_context[table_name]
       end
 
-      def column(name, type, options = {})
-        column_type = Types.map(type)
-        schema.column(name, column_type, options)
-        add_accessor(name)
+      def attribute_names
+        schema.attribute_columns
       end
 
-      def timestamps!(opts = {})
-        column(:created_at, 'Time')
-        column(:updated_at, 'Time')
-      end
+      def schema(options = {}, &block)
+        @schema ||= begin
+          self.context_name = options[:context] || Groovy.first_context_name
+          self.table_name = options[:table_name] if options[:table_name]
 
-      # def columns
-      #   table.columns # .collect { |x| x.name.split('.').last.to_sym }
-      # end
-
-      def add_accessor(col)
-        define_method(col) { self[col] }
-        define_method("#{col}=") { |val| self[col] = val }
-      end
+          s = Schema.new(db_context, table_name, {})
+          yield s if block
+          s.sync
 
-      def attribute_names
-        table.columns.select { |col| !col.reference_column? }.map { |x| x.name.split('.').last.to_sym }
+          extend(PatriciaTrieMethods) if table.is_a?(Groonga::PatriciaTrie)
+          s.attribute_columns.each { |col| add_attr_accessors(col) }
+          s.singular_references.each { |col| add_ref_accessors(col) }
+          s.plural_references.each { |col| add_vector_accessors(col) }
+          s
+        end
       end
 
       def scope(name, obj)
@@ -82,25 +65,20 @@ module Groovy
         end
       end
 
-      def find(id)
-        if record = table[id] and record.id
-          new(record.attributes, record)
-        end
+      # called from Query, so needs to be public
+      def new_from_record(record)
+        new(record.attributes, record)
       end
 
-      def insert(key, attributes = nil)
-        if table.support_key?
-          table.add(key, attributes)
-        else # key is attributes
-          set_timestamp(key, :created_at)
-          set_timestamp(key, :updated_at)
-          table.add(key)
+      def find(id)
+        if record = table[id] and record.id
+          new_from_record(record)
         end
       end
 
       def create(key, attributes = nil)
         if record = insert(key, attributes)
-          new(record.attributes, record)
+          new_from_record(record)
         end
       end
 
@@ -112,36 +90,15 @@ module Groovy
         schema.rebuild!
       end
 
-      def search_columns
-        @search_columns ||= []
-      end
-
-      def searchable_on(*fields)
-        fields.each { |f| add_index_on(f) }
-      end
-
-      def add_index_on(field)
-        ensure_search_table
-        search_columns.push(field)
-        Groonga::Schema.change_table(SEARCH_TABLE_NAME) do |table|
-          table.index([table_name, field].join('.'))
-        end
-      end
-
-      def ensure_search_table
-        return if Groonga[SEARCH_TABLE_NAME]
-        Groonga::Schema.create_table(SEARCH_TABLE_NAME, {
-          type: :patricia_trie,
-          normalizer: :NormalizerAuto,
-          default_tokenizer: "TokenBigram"
-        }) 
-      end
-
       # def column(name)
       #   Groonga["#{table_name}.#{name}"] # .search, .similar_search, etc
       # end
 
       def similar_search(col, q)
+        unless schema.index_columns.include?(col.to_sym)
+          raise "Column '#{col}' doesn't have an index set!"
+        end
+
         table.select { |r| r[col].similar_search(q) }
         # table.select("#{col}:#{q}", operator: Groonga::Operation::SIMILAR)
       end
@@ -153,7 +110,7 @@ module Groovy
       def_instance_delegators :all, :first, :last
 
       def find_by(params)
-        where(params).first
+        where(params).limit(1).first
       end
 
       [:search, :where, :not, :sort_by, :limit, :offset].each do |scope_method|
@@ -172,17 +129,45 @@ module Groovy
 
       def_instance_delegators :table, :count, :size
 
+      private
+
+      def db_context
+        Groovy.contexts[context_name] or raise "Context not defined: #{context_name}"
+      end
+
+      def insert(key, attributes = nil)
+        if table.support_key?
+          table.add(key, attributes)
+        else # key is attributes
+          set_timestamp(key, :created_at)
+          set_timestamp(key, :updated_at)
+          table.add(key)
+        end
+      end
+
       def set_timestamp(obj, key_name)
         obj[key_name] = Time.now if attribute_names.include?(key_name.to_sym)
       end
 
+      def add_attr_accessors(col)
+        define_method(col) { self[col] }
+        define_method("#{col}=") { |val| self[col] = val }
+      end
+
+      def add_ref_accessors(key)
+        define_method(key) { get_ref(key) }
+        define_method("#{key}=") { |val| set_ref(key, val) }
+      end
+
+      def add_vector_accessors(key)
+        define_method(key) { @vectors[key] ||= Vector.new(self, key) }
+        define_method("#{key}=") { |items| self.public_send(key).set(items) }
+      end
     end
 
     module PatriciaTrieMethods
       extend Forwardable
-
-      # def_instance_delegators :@table, :scan, :search, :prefix_search, :open_prefix_cursor, :tag_keys
-      def_instance_delegators :table, :scan, :search, :prefix_search, :open_prefix_cursor, :tag_keys
+      def_instance_delegators :table, :scan, :prefix_search, :open_prefix_cursor, :tag_keys
 
       def each_with_prefix(prefix, options = {}, &block)
         table.open_prefix_cursor(prefix, options) do |cursor|
@@ -191,15 +176,22 @@ module Groovy
       end
     end
 
-    attr_reader :attributes, :record, :changes
+    attr_reader :attributes, :refs, :record, :changes
+
+    def initialize(attributes = nil, record = nil)
+      @attributes = (attributes || {}).symbolize_keys.slice(*self.class.attribute_names)
+      @refs, @vectors = {}, {}
+      
+      if @record = record 
+        # TODO: lazy load this
+        self.class.schema.singular_references.each { |col| set_ref(col, record.public_send(col)) }
+      end
 
-    def initialize(attributes, record = nil)
-      @attributes = attributes.symbolize_keys.slice(*self.class.attribute_names)
-      @record = record
       @changes = {}
     end
 
     def key
+      return unless record
       record.respond_to?(:_key) ? record._key : record.id
     end
 
@@ -208,9 +200,13 @@ module Groovy
     end
 
     def []=(key, val)
-      raise "Invalid attribute: #{key}" unless attributes.has_key?(key.to_sym)
-      changes[key.to_sym] = [self[key], val]
-      attributes[key.to_sym] = val
+      return set_ref(key, val) if val.respond_to?(:record) || val.is_a?(Groonga::Record)
+
+      unless self.class.attribute_names.include?(key.to_sym)
+        raise "Invalid attribute: #{key}" 
+      end
+
+      set_attribute(key, val)
     end
 
     def increment(values, do_save = true)
@@ -244,8 +240,8 @@ module Groovy
     def reload
       raise "Not persisted" if key.nil?
       record = self.class.table[key]
-      @attributes = record.attributes.symbolize_keys
-      @changes = {}
+      attributes = record.attributes.symbolize_keys
+      changes = {}
       self
     end
 
@@ -255,6 +251,24 @@ module Groovy
 
     private
 
+    def set_attribute(key, val)
+      changes[key.to_sym] = [self[key], val] if changes # nil when initializing
+      attributes[key.to_sym] = val
+    end
+
+    def get_ref(name)
+      @refs[name]
+    end
+
+    def set_ref(name, obj)
+      unless obj.nil? || obj.respond_to?(:record) 
+        obj = Model.initialize_from_record(obj)
+      end
+
+      @refs[name] = obj
+      set_attribute(name, obj.nil? ? nil : obj.key)
+    end
+
     def create
       @record = self.class.insert(attributes)
       self
@@ -262,12 +276,12 @@ module Groovy
 
     def update
       raise "Not persisted" unless key
-      changes.merge.each do |key, values|
+      changes.each do |key, values|
         # puts "Updating #{key} from #{values[0]} to #{values[1]}"
         record[key] = values.last
       end
       self.class.set_timestamp(record, :updated_at)
-      @changes = {}
+      changes = {}
       self
     end
 

data/lib/groovy/query.rb

@@ -7,17 +7,6 @@ module Groovy
 
     attr_reader :parameters, :sorting
 
-    # options:
-    #  - "operator"
-    #  - "result"
-    #  - "name"
-    #  - "syntax"
-    #  - "allow_pragma"
-    #  - "allow_column"
-    #  - "allow_update"
-    #  - "allow_leading_not"
-    #  - "default_column"
-
     def initialize(model, table, options = {})
       @model, @table, @options = model, table, options
       @parameters = options.delete(:parameters) || []

data/lib/groovy/schema.rb

@@ -1,122 +1,161 @@
+require File.expand_path(File.dirname(__FILE__)) + '/types'
+
 module Groovy
   class Schema
-    attr_reader :table, :table_name
 
-    def initialize(table_name, opts = {})
-      @table_name, @opts = table_name, opts
-      @columns = {}
+    SEARCH_TABLE_NAME = 'Terms'.freeze
+    COLUMN_DEFAULTS = {
+      compress: :zstandard
+    }.freeze
+
+    attr_reader :index_columns
+
+    def initialize(context, table_name, opts = {})
+      @context, @table_name, @opts = context, table_name, opts || {}
+      @spec, @index_columns = {}, []
     end
 
     def table
-      @table ||= Groonga[table_name]
+      @table ||= context[table_name]
     end
 
-    def rebuild!
-      remove_table! if table
-      create_table!
-      @columns.each do |name, spec|
-        check_and_add_column(name, spec[:type], spec[:options])
-      end
-      puts "done rebuilding"
+    def search_table
+      @search_table ||= context[SEARCH_TABLE_NAME]
     end
 
-    def ensure_created!
-      create_table! if table.nil?
+    def column_names
+      get_names table.columns
+    end
+
+    def singular_references
+      get_names table.columns.select(&:reference_column?).reject(&:vector?)
+    end
+
+    def plural_references
+      get_names table.columns.select(&:vector?)
+    end
+
+    def attribute_columns
+      get_names table.columns.select(&:column?)
+    end
+
+    def rebuild!
+      log("Rebuilding!")
+      # remove_table! if table
+      remove_columns_not_in([])
+      sync
     end
 
     def column(name, type, options = {})
+      groonga_type = Types.map(type)
+      @index_columns.push(name) if options.delete(:index)
+      @spec[name.to_sym] = { type: groonga_type, args: [COLUMN_DEFAULTS.merge(options)] }
+    end
+
+    def reference(name, table_name = nil, options = {})
+      table_name = "#{name}s" if table_name.nil?
+      @spec[name.to_sym] = { type: :reference, args: [table_name, options] }
+    end
+
+    def timestamps(opts = {})
+      column(:created_at, 'Time')
+      column(:updated_at, 'Time')
+    end
+
+    def sync(db_context = nil)
+      switch_to_context(db_context) if db_context
+
       ensure_created!
-      @columns[name] = { type: type, options: options }
-      check_and_add_column(name, type, options)
+      remove_columns_not_in(@spec.keys)
+      @spec.each do |col, spec|
+        check_and_add_column(col, spec[:type], spec[:args])
+      end
+      @index_columns.each do |col|
+        add_index_on(col)
+      end
+    end
+
+    private
+    attr_reader :context, :table_name
+
+    def switch_to_context(db_context)
+      log("Switching context to #{db_context}")
+      @context = db_context 
+      @table = @search_table = nil # clear cached vars
+    end
+
+    def add_index_on(col)
+      ensure_search_table!
+      return false if search_table.have_column?([table_name, col].join('_'))
+
+      log "Adding index on #{col}"
+      Groonga::Schema.change_table(SEARCH_TABLE_NAME, context: context) do |table|
+        table.index([table_name, col].join('.'))
+      end
+    end
+
+    def ensure_search_table!
+      return if search_table
+      opts = (@opts[:search_table] || {}).merge({
+        type: :patricia_trie,
+        normalizer: :NormalizerAuto,
+        default_tokenizer: "TokenBigram"
+      })
+      log("Creating search table with options: #{opts.inspect}")
+      Groonga::Schema.create_table(SEARCH_TABLE_NAME, opts.merge(context: context)) 
+    end
+
+    def remove_columns_not_in(list)
+      column_names.each do |col|
+        remove_column(col) unless list.include?(col)
+      end
+    end
+
+    def ensure_created!
+      create_table! if table.nil?
     end
 
     def check_and_add_column(name, type, options)
       add_column(name, type, options) unless has_column?(name, type)
     end
 
-    def has_column?(name, type)
+    def has_column?(name, type = nil)
       table.columns.any? do |col| 
-        col.name == "#{table_name}.#{name}"
+        col.name == "#{table_name}.#{name}" # && (type.nil? or col.type == type)
+      end
+    end
+
+    def add_column(name, type, args = [])
+      log "Adding column #{name} with type #{type}, args: #{args.inspect}"
+      Groonga::Schema.change_table(table_name, context: context) do |table|
+        table.public_send(type, name, *args)
       end
     end
 
-    def add_column(name, type, options = {})
-      # puts "Adding column #{name}"
-      Groonga::Schema.change_table(table_name) do |table|
-        table.public_send(type, name, options)
+    def remove_column(name)
+      log "Removing column #{name}"
+      Groonga::Schema.change_table(table_name, context: context) do |table|
+        table.remove_column(name)
       end
     end
 
     def create_table!
-      # puts "creating table!"
-      Groonga::Schema.create_table(table_name, @opts)
+      log "Creating table!"
+      Groonga::Schema.create_table(table_name, context: context)
     end
 
     def remove_table!
-      # puts "removing table!"
-      Groonga::Schema.remove_table(table_name)
+      log "Removing table!"
+      Groonga::Schema.remove_table(table_name, context: context)
       @table = nil
     end
-  end
-end
-
-def load_schema!
-  Groonga::Schema.create_table("Sources")
-  Groonga::Schema.create_table("Topics")
-  Groonga::Schema.create_table("Tags", type: :patricia_trie)
-  Groonga::Schema.create_table("Links", type: :hash)
-  Groonga::Schema.create_table("Tweeters", type: :hash)
-  Groonga::Schema.create_table("Mentions")
-  Groonga::Schema.create_table("Subscribers")
-
-  Groonga::Schema.change_table("Sources") do |table|
-    table.short_text("name")
-    table.short_text("twitter_user_name")
-  end
-
-  Groonga::Schema.change_table("Topics") do |table|
-    table.reference("most_mentioned", "Links")
-    table.uint32("mentions_count")
-    table.uint32("links_count")
-  end
-
-  Groonga::Schema.change_table("Links") do |table|
-    table.reference("source", "Sources")
-    table.reference("topic", "Topics")
-    table.reference("tags", "Tags", type: :vector)
-    # table.short_text("url")
-    table.short_text("title")
-    table.short_text("image")
-    table.short_text("description") # less than 4K bytes
-    table.uint32("mentions_count")
-    table.uint32("hits_count")
-    table.boolean("posted")
-    table.boolean("removed")
-    table.short_text("snapshot")
-    table.uint32("posted_tweet_id")
-  end
-
-  Groonga::Schema.change_table("Tweeters") do |table|
-    table.short_text("name")
-    table.short_text("twitter_name")
-    table.uint32("mentions_count")
-  end
 
-  Groonga::Schema.change_table("Mentions") do |table|
-    table.reference("source", "Sources")
-    table.reference("link", "Links")
-    table.reference("tweeter", "Tweeters")
-    table.uint32("tweet_id")
-    table.short_text("content")
-    table.time("created_at")
-  end
+    def get_names(columns)
+      columns.map { |col| col.name.split('.').last.to_sym }
+    end
 
-  Groonga::Schema.change_table("Subscribers") do |table|
-    table.short_text("name")
-    table.short_text("email")
-    table.short_text("timezone")
-    table.short_text("token")
-    table.uint32("received_count")
-    table.time("last_received_at")
+    def log(str)
+      puts "[#{table_name}] #{str}" if ENV['DEBUG']
+    end
   end
-end
+end

data/lib/groovy/vector.rb

@@ -0,0 +1,52 @@
+module Groovy
+  class Vector
+    include Enumerable
+
+    def initialize(obj, key)
+      @obj, @key = obj, key
+    end
+
+    def count
+      records.count
+    end
+
+    def each(&block)
+      items.each { |r| block.call(r) }
+    end
+
+    def clear
+      set([])
+    end
+
+    def set(items)
+      raise "Please save parent record first" unless obj.record
+      obj.record[key] = items
+    end
+
+    def push(item)
+      raise "Please save parent record first" unless obj.record
+      obj.record[key] = obj.record[key].concat([item.record])
+    end
+
+    def remove(item)
+      raise "Please save parent record first" unless obj.record
+      recs = obj.record[key].delete_if { |r| r == item.record }
+      obj.record[key] = recs
+    end
+
+    alias_method :<<, :push
+
+    private
+    attr_reader :obj, :key
+
+    def items
+      return [] unless obj.record
+      records.map { |r| Model.initialize_from_record(r) }
+    end
+
+    def records
+      obj.record[key]
+    end
+
+  end
+end

data/spec/groovy_spec.rb

@@ -1,3 +1,61 @@
 require './lib/groovy'
 require 'rspec/mocks'
 
+describe Groovy::Model do
+
+  describe '.schema' do
+  end
+
+  describe '.scope' do
+  end
+
+  describe '.create' do
+  end
+
+  describe '.find' do
+  end
+
+  describe '.find_by' do
+  end
+
+  describe '.delete_all' do
+  end
+
+  describe '#[]' do
+  end
+
+  describe '#[]=' do
+  end
+
+  describe '#increment' do
+  end
+
+  describe '#dirty' do
+  end
+
+  describe '#update_attributes' do
+  end
+
+  describe '#save' do
+  end
+
+  describe '#delete' do
+  end
+
+  describe '#reload' do
+  end
+
+  describe 'attributes accessors' do
+
+  end
+
+  describe 'singular refs' do
+
+  end
+
+  describe 'plural refs' do
+
+  end
+
+end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: groovy
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Tomás Pollak
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-02 00:00:00.000000000 Z
+date: 2019-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -47,15 +47,20 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - Gemfile
+- Rakefile
 - example/Gemfile
 - example/Gemfile.lock
+- example/basic.rb
 - example/config.ru
+- example/relations.rb
 - groovy.gemspec
 - lib/groovy.rb
+- lib/groovy/middleware.rb
 - lib/groovy/model.rb
 - lib/groovy/query.rb
 - lib/groovy/schema.rb
 - lib/groovy/types.rb
+- lib/groovy/vector.rb
 - spec/groovy_spec.rb
 homepage: https://github.com/tomas/groovy
 licenses: []