groovy 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 36ab3d8425ae05fd7b069e75b1cb3f168a8a31605e2bd54d3b44285f715dbc92
+  data.tar.gz: 7d48ca3d630488d52c0fd60e73ac753d5b1658601f6803566838c563231cce9a
+SHA512:
+  metadata.gz: 2dfafb96a0e3636a7e49c9319a40d7e7217d6c21ed48bc0be6e8a4a61aee9a7ce41f9d3499987a03d16e0dc15868988d6a03049a8aec401b70f96b4c405e47b4
+  data.tar.gz: 90e22b09f631228277f297c552f42bbdf0bfc9faaccbea13c769b2f68b91cc297c157a1557a101790d0497d2390ba466f4f44f97bf5ac1a3d4f267666b36465e

data/.gitignore

@@ -0,0 +1,6 @@
+*~
+*.gem
+test
+log
+pkg
+example/db

data/Gemfile

@@ -0,0 +1,4 @@
+source :rubygems
+
+# specified in groovy.gemspec
+gemspec

data/example/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+gem 'rack'
+gem 'groovy', path: '..'

data/example/Gemfile.lock

@@ -0,0 +1,43 @@
+PATH
+  remote: ..
+  specs:
+    groovy (0.1.0)
+      rroonga (~> 7.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    archive-zip (0.12.0)
+      io-like (~> 0.3.0)
+    gqtp (1.0.6)
+    groonga-client (0.6.0)
+      gqtp (>= 1.0.4)
+      groonga-command (>= 1.2.8)
+      groonga-command-parser (>= 1.1.0)
+      hashie
+    groonga-command (1.4.1)
+      json
+    groonga-command-parser (1.1.4)
+      groonga-command (>= 1.4.0)
+      json-stream
+    hashie (3.6.0)
+    io-like (0.3.0)
+    json (2.2.0)
+    json-stream (0.2.1)
+    pkg-config (1.3.7)
+    rack (2.0.6)
+    rroonga (7.1.1)
+      archive-zip
+      groonga-client (>= 0.0.3)
+      json
+      pkg-config
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  groovy!
+  rack
+
+BUNDLED WITH
+   1.16.1

data/example/config.ru

@@ -0,0 +1,27 @@
+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
+
+Place.delete_all
+
+10.times do |i|
+  Place.create!(name: "Place #{i}", description: "A nice place")
+end
+
+Place.last.delete
+
+app = Proc.new do |env|
+  body = Place.all.collect(&:as_json)
+  [200, { 'Content-Type' => 'text/plain' }, [body]]
+end
+
+run app

data/groovy.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path("../lib/groovy", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "groovy"
+  s.version     = Groovy::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Tomás Pollak']
+  s.email       = ['tomas@forkhq.com']
+  s.homepage    = "https://github.com/tomas/groovy"
+  s.summary     = "A wrapper around Groonga/Rroonga"
+  s.description = "Allows using Groonga in your models a-la ActiveRecord."
+
+  # s.required_rubygems_version = ">= 1.3.6"
+  # s.rubyforge_project         = "groovy"
+
+  s.add_development_dependency "bundler", ">= 1.0.0"
+  s.add_runtime_dependency "rroonga", "~> 7.1"
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.require_path = 'lib'
+end

data/lib/groovy.rb

@@ -0,0 +1,19 @@
+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)
+    end
+  end
+
+end

data/lib/groovy/model.rb

@@ -0,0 +1,275 @@
+require File.expand_path(File.dirname(__FILE__)) + '/query'
+require File.expand_path(File.dirname(__FILE__)) + '/types'
+require File.expand_path(File.dirname(__FILE__)) + '/schema'
+
+class Hash
+  def symbolize_keys
+    self.inject({}) { |memo, (k,v)| memo[k.to_sym] = v; memo }
+  end
+end unless {}.respond_to?(:symbolize_keys)
+
+module Groovy
+  module Model
+
+    SEARCH_TABLE_NAME = 'Terms'
+
+    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
+    end
+
+    module ClassMethods
+      extend Forwardable
+      attr_accessor :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)
+      end
+
+      def column(name, type, options = {})
+        column_type = Types.map(type)
+        schema.column(name, column_type, options)
+        add_accessor(name)
+      end
+
+      def timestamps!(opts = {})
+        column(:created_at, 'Time')
+        column(:updated_at, 'Time')
+      end
+
+      # 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
+
+      def attribute_names
+        table.columns.select { |col| !col.reference_column? }.map { |x| x.name.split('.').last.to_sym }
+      end
+
+      def scope(name, obj)
+        define_singleton_method(name) do |*args|
+          obj.respond_to?(:call) ? obj.call(*args) : obj
+        end
+      end
+
+      def find(id)
+        if record = table[id] and record.id
+          new(record.attributes, record)
+        end
+      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 create(key, attributes = nil)
+        if record = insert(key, attributes)
+          new(record.attributes, record)
+        end
+      end
+
+      def create!(key, attributes = nil)
+        create(key, attributes) or raise "Invalid!"
+      end
+
+      def delete_all
+        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)
+        table.select { |r| r[col].similar_search(q) }
+        # table.select("#{col}:#{q}", operator: Groonga::Operation::SIMILAR)
+      end
+
+      def all
+        Query.new(self, table)
+      end
+
+      def_instance_delegators :all, :first, :last
+
+      def find_by(params)
+        where(params).first
+      end
+
+      [:search, :where, :not, :sort_by, :limit, :offset].each do |scope_method|
+        define_method scope_method do |*args|
+          Query.new(self, table).tap do |q|
+            q.public_send(scope_method, *args)
+          end
+        end
+      end
+      
+      # this seems to be the same as: `table[id]`
+      # def search(key, options = nil)
+      #   raise "Not supported!" unless table.respond_to?(:search)
+      #   table.search(key, options)
+      # end
+
+      def_instance_delegators :table, :count, :size
+
+      def set_timestamp(obj, key_name)
+        obj[key_name] = Time.now if attribute_names.include?(key_name.to_sym)
+      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 each_with_prefix(prefix, options = {}, &block)
+        table.open_prefix_cursor(prefix, options) do |cursor|
+          cursor.each { |r| yield r }
+        end
+      end
+    end
+
+    attr_reader :attributes, :record, :changes
+
+    def initialize(attributes, record = nil)
+      @attributes = attributes.symbolize_keys.slice(*self.class.attribute_names)
+      @record = record
+      @changes = {}
+    end
+
+    def key
+      record.respond_to?(:_key) ? record._key : record.id
+    end
+
+    def [](key)
+      attributes[key.to_sym]
+    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
+    end
+
+    def increment(values, do_save = true)
+      values.each { |key, num| self[key] += num }
+      save if do_save
+    end
+
+    def dirty?
+      changes.any?
+    end
+
+    def update_attributes(obj)
+      obj.each { |k,v| self[k] = v }
+      update
+    end
+
+    def save(options = {})
+      return false if respond_to?(:invalid) and invalid?
+      @record ? update : create
+    end
+
+    def save!(options = {})
+      raise "Invalid!" unless save
+    end
+
+    def delete
+      record.delete
+      self
+    end
+
+    def reload
+      raise "Not persisted" if key.nil?
+      record = self.class.table[key]
+      @attributes = record.attributes.symbolize_keys
+      @changes = {}
+      self
+    end
+
+    def as_json(options = {})
+      attributes
+    end
+
+    private
+
+    def create
+      @record = self.class.insert(attributes)
+      self
+    end
+
+    def update
+      raise "Not persisted" unless key
+      changes.merge.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 = {}
+      self
+    end
+
+  end
+end

data/lib/groovy/query.rb

@@ -0,0 +1,182 @@
+module Groovy
+
+  class Query
+    include Enumerable
+    AND = '+'.freeze
+    NOT = '-'.freeze
+
+    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) || []
+      @sorting = { limit: -1, offset: 0 }
+      @default_sort_key = table.is_a?(Groonga::Hash) ? '_key' : '_id'
+    end
+
+    def merge_with!(another)
+      # parameters.merge!(another.parameters)
+      parameters.concat(another.parameters)
+      sorting.merge!(another.sorting)
+      self
+    end
+
+    def search(obj)
+      obj.each do |col, q|
+        raise "Not a full-text search column: #{col}" unless model.search_columns.include?(col)
+        parameters.push(AND + "(#{col}:@#{q})")
+      end
+    end
+
+    # http://groonga.org/docs/reference/grn_expr/query_syntax.html
+    # TODO: support match_columns (search value in two or more columns)
+    def where(conditions = nil)
+      case conditions
+        when String # "foo:bar"
+          parameters.push(AND + "(#{map_operator(conditions)})")
+        when Hash # { foo: 'bar' } or { views: 1..100 }
+          conditions.each do |key, val|
+            if val.is_a?(Range)
+              parameters.push(AND + [key, val.min].join(':>=')) if val.min # lte
+              parameters.push(AND + [key, val.max].join(':<=')) if val.max # gte
+            elsif val.is_a?(Regexp)
+              str = val.source.gsub(/[^a-z]/, '')
+              param = val.source[0] == '^' ? ':^' : ':~' # starts with or regexp
+              parameters.push(AND + [key, str].join(param))
+            else
+              parameters.push(AND + [key, val.to_s].join(':'))
+            end
+          end
+        # when Array # ["foo:?", val]
+          # parameters.push(conditions.first.sub('?', conditions.last))
+        when NilClass
+          # doing where.not probably
+        else
+          raise 'not supported'
+      end
+      self
+    end
+
+    def not(conditions = {})
+      case conditions
+        when String # "foo:bar"
+          parameters.push(NOT + "(#{map_operator(conditions)})")
+        when Hash # { foo: 'bar' }
+          conditions.each do |key, val|
+            if val.is_a?(Range)
+              parameters.push(AND + [key, val.min].join(':<=')) if val.min # gte
+              parameters.push(AND + [key, val.max].join(':>=')) if val.max # lte
+            else
+              parameters.push(AND + [key, val.to_s].join(':!')) # not
+            end
+          end
+        # when Array # ["foo:?", val]
+          # parameters.push(conditions.first.sub('?', conditions.last))
+        else
+          raise 'not supported'
+      end
+      self
+    end
+      
+    def limit(num)
+      @limit = num
+      self
+    end
+
+    def offset(num)
+      @offset = num
+      self
+    end
+
+    # sort_by(title: :asc)
+    def sort_by(hash)
+      sorting[:by] = hash.keys.map do |key|
+        { key: key.to_s, order: hash[key] }
+      end
+      self
+    end
+
+    def all
+      @all ||= results.map { |r| model.new(r.attributes['_value']['_key'], r) }
+    end
+
+    def size
+      results.size
+    end
+
+    alias_method :count, :size
+
+    def to_a
+      all
+    end
+
+    def [](index)
+      all[index]
+    end
+
+    def each(&block)
+      all.each { |r| block.call(r) }
+    end
+
+    def last
+      all[size-1]
+    end
+
+    private
+    attr_reader :model, :table, :options
+
+    def results
+      @results ||= execute
+    end
+
+    def execute
+      set = if parameters.any?
+        query = parameters.join(" ").gsub(/\s(\w)/, '\ \1')
+        puts query if ENV['DEBUG']
+        table.select(query, options)
+      else
+        table.select(options)
+      end
+
+      set.sort(sort_key_and_order, { 
+        limit: sorting[:limit], 
+        offset: sorting[:offset] 
+      })
+    end
+
+    def map_operator(str)
+      str.sub(' = ', ':')
+         .sub(' != ', ':!')
+         .sub(' ~ ', ':~')
+         .sub(' < ', ':<')
+         .sub(' > ', ':>')
+         .sub(' <= ', ':<=')
+         .sub(' >= ', ':>=')
+    end
+
+    def sort_key_and_order
+      sorting[:by] or [{ key: @default_sort_key, order: :asc }]
+    end
+
+    def method_missing(name, *args)
+      if model.respond_to?(name)
+        other = model.public_send(name, *args)
+        merge_with!(other)
+      else
+        super
+      end
+    end
+  end
+
+end

data/lib/groovy/schema.rb

@@ -0,0 +1,122 @@
+module Groovy
+  class Schema
+    attr_reader :table, :table_name
+
+    def initialize(table_name, opts = {})
+      @table_name, @opts = table_name, opts
+      @columns = {}
+    end
+
+    def table
+      @table ||= Groonga[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"
+    end
+
+    def ensure_created!
+      create_table! if table.nil?
+    end
+
+    def column(name, type, options = {})
+      ensure_created!
+      @columns[name] = { type: type, options: options }
+      check_and_add_column(name, type, options)
+    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)
+      table.columns.any? do |col| 
+        col.name == "#{table_name}.#{name}"
+      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)
+      end
+    end
+
+    def create_table!
+      # puts "creating table!"
+      Groonga::Schema.create_table(table_name, @opts)
+    end
+
+    def remove_table!
+      # puts "removing table!"
+      Groonga::Schema.remove_table(table_name)
+      @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
+
+  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")
+  end
+end

data/lib/groovy/types.rb

@@ -0,0 +1,44 @@
+module Groovy
+
+  module Types
+
+    # BIGRAM
+    # BOOL
+    # BOOLEAN
+    # DELIMIT
+    # FLOAT
+    # INT16
+    # INT32
+    # INT64
+    # INT8
+    # LONG_TEXT
+    # MECAB
+    # OBJECT
+    # SHORT_TEXT
+    # TEXT
+    # TIME
+    # TRIGRAM
+    # UINT16
+    # UINT32
+    # UINT64
+    # UINT8
+    # UNIGRAM
+
+    MAPPINGS = {
+      'String' => 'short_text',
+      'Text' => 'text',
+      'Float' => 'float',
+      'Bool' => 'boolean',
+      'Boolean' => 'boolean',
+      'Integer' => 'int32',
+      'BigDecimal' => 'int64',
+      'Time' => 'time'
+    }
+
+    def self.map(type)
+      MAPPINGS[type.to_s] or raise "Invalid type: #{type}"
+    end
+
+  end
+
+end

data/spec/groovy_spec.rb

@@ -0,0 +1,3 @@
+require './lib/groovy'
+require 'rspec/mocks'
+

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: groovy
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tomás Pollak
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-04-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: rroonga
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+description: Allows using Groonga in your models a-la ActiveRecord.
+email:
+- tomas@forkhq.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- example/Gemfile
+- example/Gemfile.lock
+- example/config.ru
+- groovy.gemspec
+- lib/groovy.rb
+- lib/groovy/model.rb
+- lib/groovy/query.rb
+- lib/groovy/schema.rb
+- lib/groovy/types.rb
+- spec/groovy_spec.rb
+homepage: https://github.com/tomas/groovy
+licenses: []
+metadata: {}
+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.7.3
+signing_key: 
+specification_version: 4
+summary: A wrapper around Groonga/Rroonga
+test_files: []