mongous 0.1.0

data/Rakefile

@@ -0,0 +1,96 @@
+require "bundler/gem_helper"
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+class Bundler::GemHelper
+
+  def git_archive( dir = "../zip" )
+    FileUtils.mkdir_p  dir
+    dest_path  =  File.join(dir, "#{name}-#{version}.zip")
+    cmnd  =  "git archive --format zip --prefix=#{name}/ HEAD > #{dest_path}"
+
+    out, code = sh_with_status( cmnd )
+    raise "Couldn't archive gem,"  unless  code == 0
+
+    Bundler.ui.confirm "#{name} #{version} archived to #{dest_path}."
+  end
+
+  def git_push
+    ver  =  version.to_s
+
+    cmnd  =  "git push origin  #{ver} "
+    out, code = sh_with_status( cmnd )
+    raise "Couldn't git push origin."  unless  code == 0
+
+    cmnd  =  "git push "
+    out, code = sh_with_status( cmnd )
+    raise "Couldn't git push."         unless  code == 0
+
+    Bundler.ui.confirm "Git Push #{ver}."
+  end
+
+  def update_version( new_version )
+    version_filename  =  %x[ find . -type f -name "version.rb" | grep -v vendor | head -1 ].chomp
+    version_pathname  =  File.expand_path( version_filename )
+    lines  =  File.open( version_pathname ).read
+    lines  =  lines.gsub( /VERSION\s*=\s*\"\d+\.\d+\.\d+\"/, "VERSION = \"#{new_version}\"" )
+    File.open( version_pathname, "w" ) do |file|
+      file.write( lines )
+    end
+
+    cmnd  =  "git add  #{version_pathname} "
+    out, code = sh_with_status( cmnd )
+    raise "Couldn't git add,"  unless  code == 0
+
+    cmnd  =  "git commit -m  '#{new_version}' "
+    out, code = sh_with_status( cmnd )
+    raise "Couldn't git commit."  unless  code == 0
+
+    cmnd  =  "git tag        #{new_version} "
+    out, code = sh_with_status( cmnd )
+    raise "Couldn't git tag."          unless  code == 0
+
+    Bundler.ui.confirm "Update Tags to #{new_version}."
+  end
+
+end
+
+Bundler::GemHelper.new(Dir.pwd).instance_eval do
+
+  desc "Archive #{name}-#{version}.zip from repository"
+  task 'zip' do
+    git_archive
+  end
+
+  desc "Git Push"
+  task 'push' do
+    git_push
+  end
+
+  desc "Update Version Tiny"
+  task 'tiny' do
+    major, minor, tiny  =  version.to_s.split('.')
+    new_version  =  [major, minor, tiny.to_i + 1].join('.')
+    update_version( new_version )
+  end
+
+  desc "Update Version Minor"
+  task 'minor' do
+    major, minor, tiny  =  version.to_s.split('.')
+    new_version  =  [major, minor.to_i + 1, 0].join('.')
+    update_version( new_version )
+  end
+
+  desc "Update Version Major"
+  task 'major' do
+    major, minor, tiny  =  version.to_s.split('.')
+    new_version  =  [major.to_i + 1, 0, 0].join('.')
+    update_version( new_version )
+  end
+
+end
+

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "mongous"
+
+# 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 "irb"
+IRB.start(__FILE__)

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/lib/mongous.rb

@@ -0,0 +1,11 @@
+require "mongous/version"
+require "mongous/base"
+require "mongous/extention"
+require "mongous/filter"
+require "mongous/document"
+
+module Mongous
+  class  <<  self
+    include Mongous::Base
+  end
+end

data/lib/mongous/base.rb

@@ -0,0 +1,68 @@
+require "time"
+require "erb"
+require "yaml"
+require "json"
+require "mongo"
+
+module Mongous
+  class Error < StandardError; end
+
+  module Base
+    def connect( hosts_or_uri = nil, file: nil, mode: nil, loglevel: nil, **options )
+      case  hosts_or_uri
+      when  Array, String
+        ;
+
+      when  NilClass
+        if file
+          mode  ||=  "development"
+          text  =  ::File.open( file ).read    rescue  raise( Mongous::Error, "could not load #{ file }" )
+          yaml  =  ::ERB.new( text ).result    rescue  raise( Mongous::Error, "could not parse by ERB: #{ file }" )
+          hash  =  ::YAML.load( yaml )
+          conf  =  hash[mode]["clients"]["default"]
+
+          hosts_or_uri  =  conf["uri"]
+          if hosts_or_uri
+            conf.delete( "uri" )
+            options.merge!( conf )
+          else
+            hosts_or_uri  =  conf["hosts"]
+            conf.delete( "hosts" )
+            database  =  conf["database"]
+            conf.delete( "database" )
+            options.merge!( conf )
+            options["database"]  =  database
+          end
+
+        else
+          hosts_or_uri  =  [ "localhost:27017" ]
+          options[:database]  =  "test"    if options[:database].nil? || options[:database].empty?
+
+        end
+      end
+
+      ::Mongo::Logger.logger.level  =  loglevel || Logger::ERROR
+      ::Mongo::Client.new( hosts_or_uri, options )
+    end
+
+    def connect!( hosts_or_uri = nil, **options )
+      _client  =  connect( hosts_or_uri, **options )
+      self.class_variable_set( :@@client, _client )
+    end
+
+    def client
+      self.class_variable_get( :@@client )    rescue  nil
+    end
+
+    def client=( _client )
+      if  !_client.is_a?( ::Mongo::Client )
+        raise  Mongous::Error, "type invalid. :  #{ _client }"
+      end
+      self.class_variable_set( :@@client, _client )
+    end
+
+    def loger
+      ::Mongo::Logger.logger
+    end
+  end
+end

data/lib/mongous/document.rb

@@ -0,0 +1,159 @@
+
+module Mongous
+  module Document
+    class  <<  self
+      def included( klass )
+        klass.extend  Extention
+      end
+    end
+
+    def initialize( **doc )
+      @doc  =  {}
+      doc.each do |label, value|
+        label  =  label.to_s
+        @doc[label]  =  value
+      end
+    end
+
+    def method_missing( sym, *args, **opts, &block )
+      m  =  /\A(\w+)([=])?\Z/.match( sym.to_s )
+      if  args.size == 0 && m[2].nil?
+        self[ m[1] ]
+      elsif  args.size == 1 && !m[2].nil?
+        self[ m[1] ]  =  args.shift
+      else
+        raise  Mongous::Error, "invalid parameter. #{sym} #{args.join(', ')}"
+      end
+    end
+
+    def having?( value )
+      case  value
+      when  NilClass
+        false
+      when  String
+        !value.strip.empty?
+      else
+        true
+      end
+    end
+
+    def save
+      self.class.fields.each do |label, field|
+        _must  =  field[:_args].include?(:must)
+        if  @doc.has_key?(label)
+          if  _must  &&  !having?( @doc[label] )
+            raise  Mongous::Error, "must and not having field. : #{ label }"
+          end
+        else
+          if  block  =  field[:_block]
+            self[label]  =  block.call
+          elsif  _must
+            raise  Mongous::Error, "must and unassigned field. : #{ label }"
+          elsif  self.class.symbols[:strict]
+            self[label]  =  nil
+          end
+        end
+      end
+
+      self.class.blocks.each do |call_from, block|
+        if  !self.instance_eval( &block )
+          raise  Mongous::Error, "violation detected on save. : #{ call_from }"
+        end
+      end
+
+      if  @doc["_id"]
+        _filter  =  { "_id"=> @doc["_id"] }
+        if  self.class.collection.find( _filter ).first
+          self.class.collection.update_one( _filter, { '$set' => @doc } )
+          return  self
+        end
+      end
+
+      self.class.collection.insert_one( @doc )
+      self
+    end
+
+    def []( label )
+      label  =  label.to_s
+
+      if  self.class.symbols[:strict]
+        if  !self.class.fields.keys.include?(label)
+          raise  Mongous::Error, "undefined field. : #{ label }"
+        end
+      end
+
+      return  @doc[label]    if @doc.has_key?(label)
+
+      field  =  self.class.fields[label]
+      return  nil    if field.nil?
+
+      case  default  =  field[:default]
+      when  Proc
+        self.instance_eval( &default )
+      else
+        default
+      end
+    end
+
+    def []=( label, value )
+      label  =  label.to_s
+      if  self.class.symbols[:strict]
+        labels  =  ["_id"] + self.class.fields.keys
+        if  !labels.include?( label )
+          raise  Mongous::Error, "undefined field. : #{ label }"
+        end
+      end
+
+      field  =  self.class.fields[label]
+      return  @doc[label]  =  value    if field.nil?
+
+      types  =  []
+      if  args  =  field[:_args]  ||  []
+        args.each do |arg|
+          if  arg.class == Class
+            types  <<  arg
+            args  -=  [arg]
+            break
+          end
+        end
+      end
+
+      if  !types.empty?
+        if  !(args & [:must, :not_null]).empty?
+          if  !types.include?( value.class )
+            raise  Mongous::Error, "invalid type. : #{ label } : #{ value.class }"
+          end
+        else
+          if  !(types + [NilClass] ).include?( value.class )
+            raise  Mongous::Error, "invalid type. : #{ label } : #{ value.class }"
+          end
+        end
+      else
+        if  !(args & [:must, :not_null]).empty?
+          if  [NilClass].include?( value.class )
+            raise  Mongous::Error, "invalid type. : #{ label } : #{ value.class }"
+          end
+        end
+      end
+
+      @doc[label]  =  value
+
+      args.each do |arg|
+        case  arg
+        when  Proc
+          if  !self.instance_eval( &arg )
+            raise  Mongous::Error, "violation detected. : #{ label } : #{ value }"
+          end
+        when  Array
+          if  !arg.include?( value )
+            raise  Mongous::Error, "not include. : #{ label } :#{ value }"
+          end
+        when  Range
+          if  !arg.cover?( value )
+            raise  Mongous::Error, "out of range. : #{ label } :#{ value }"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongous/extention.rb

@@ -0,0 +1,167 @@
+
+module Mongous
+  module Extention
+    def client
+      if self.class_variable_defined?( :@@client )
+        self.class_variable_get( :@@client )
+      else
+        _client  =  Mongous.client
+        self.class_variable_set( :@@client, _client )
+      end
+    end
+
+    def set_client( _client )
+      m  =  /(.*?):(\d+)/.match( caller()[0] )
+      call_from  =  [ m[1], m[2] ].join(":")
+      if  !_client.is_a?( Mongo::Client )
+        raise  Mongous::Error, "type invalid. :  #{ _client }"
+      end
+      self.class_variable_set( :@@client, _client )
+    end
+
+    def collection_name
+      if self.class_variable_defined?( :@@collection_name )
+        self.class_variable_get( :@@collection_name )
+      else
+        _client_name  =  self.name
+        self.class_variable_set( :@@collection_name, _client_name )
+      end
+    end
+
+    def set_collection_name( _collection_name )
+      self.class_variable_set( :@@collection_name, _collection_name )
+      if self.class_variable_defined?( :@@collection )
+        self.remove_class_variable( :@@collection )
+      end
+    end
+
+    def collection
+      if self.class_variable_defined?( :@@collection )
+        if  _collection  =  self.class_variable_get( :@@collection )
+          return  _collection
+        end
+      end
+
+      _collection_name  =  collection_name
+      _client  =  client
+
+      if  _client.database.collection_names.include?( _collection_name )
+        _collection  =  _client[ _collection_name ]
+      else
+        _collection  =  _client[ _collection_name ]
+        _collection.create
+      end
+
+      indexes.each do |keys, opts|
+        _collection.indexes.create_one( keys, opts )    rescue  nil
+      end
+
+      self.class_variable_set( :@@collection, _collection )
+    end
+
+    def fields
+      if self.class_variable_defined?( :@@fields )
+        self.class_variable_get( :@@fields )
+      else
+        self.class_variable_set( :@@fields, {} )
+      end
+    end
+
+    def symbols
+      if self.class_variable_defined?( :@@symbols )
+        self.class_variable_get( :@@symbols )
+      else
+        self.class_variable_set( :@@symbols, {} )
+      end
+    end
+
+    def blocks
+      if self.class_variable_defined?( :@@blocks )
+        self.class_variable_get( :@@blocks )
+      else
+        self.class_variable_set( :@@blocks, {} )
+      end
+    end
+
+    def indexes
+      if self.class_variable_defined?( :@@indexes )
+        self.class_variable_get( :@@indexes )
+      else
+        self.class_variable_set( :@@indexes, [] )
+      end
+    end
+
+    def create( **doc )
+      self.new( **doc ).save
+    end
+
+    def filter( **_filter )
+      Filter.new( self ).filter( _filter )
+    end
+
+    def first
+      Filter.new( self ).first
+    end
+
+    def all
+      Filter.new( self ).all
+    end
+
+    def each( &block )
+      Filter.new( self ).each( &block )
+    end
+
+    def delete
+      Filter.new( self ).delete
+    end
+
+    def field( label, *args, **opts, &block )
+      m  =  /(.*?):(\d+)/.match( caller()[0] )
+      call_from  =  [ m[1], m[2] ].join(":")
+
+      args.each do |arg|
+        if klass  =  arg.class 
+          if ![Class, Range, Array, Proc, Symbol].include?(klass)
+            raise  Mongous::Error, "field error. :  #{arg} on #{ label } at #{ call_from }"
+          end
+        end
+      end
+
+      opts.each do |key, value|
+        case  key
+        when  :default
+          case  value
+          when  Proc, String, Numeric
+          else
+            raise  Mongous::Error, "field error. : #{key} on #{ label } at #{ call_from }"
+          end
+        end
+      end
+
+      opts[:_args]  =  args
+      opts[:_block]  =  block
+      fields[label.to_s]  =  opts
+    end
+
+    def verify( *syms, &block )
+      if !syms.empty?
+        syms.each do |sym|
+          symbols[sym]  =  true
+        end
+      elsif block
+        m  =  /(.*?):(\d+)/.match( caller()[0] )
+        call_from  =  [ m[1], m[2] ].join(":")
+        blocks[call_from]  =  block
+      end
+    end
+
+    def index( *syms, **opts )
+      opts[:background]  =  true    unless opts.has_key?(:background)
+      keys  =  {}
+      syms.each do |sym|
+        keys[sym]  =  1
+      end
+      indexes.push  <<  [keys, opts]
+    end
+  end
+end