ki 0.4.11 → 0.4.12

data/lib/ki/modules/model_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Ki
   class Model
     module ModelHelper

data/lib/ki/modules/query_interface.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Ki
   class Model
     # the query interface does not respect before/after filters,

data/lib/ki/modules/restrictions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Ki
   class Model
     module Restrictions
@@ -28,9 +30,10 @@ module Ki
       private
 
       def generic_restriction(method_name, attributes)
-        [:define_method, :define_singleton_method].each do |definition_means|
+        attributes += send(method_name) if defined? method_name
+        %i[define_method define_singleton_method].each do |definition_means|
           send definition_means, method_name do
-            attributes
+            attributes.sort.uniq
           end
         end
       end

data/lib/ki/orm.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'singleton'
 
 module Ki
@@ -29,14 +31,16 @@ module Ki
       # config.yml.
       #
       def establish_connection
+        Mongo::Logger.logger.level = Logger::FATAL
+        # Mongo::Logger.logger       = Logger.new('mongo.log')
+        # Mongo::Logger.logger.level = Logger::INFO
+
         @config = KiConfig.instance.database
-        if ENV['MONGODB_URI']
-          @connection = Mongo::Connection.new
-          @db = @connection.db
-        else
-          @connection = Mongo::Connection.new(@config['host'], @config['port'])
-          @db = @connection.db(@config['name'])
-        end
+        @db = if ENV['MONGODB_URI']
+                Mongo::Client.new
+              else
+                Mongo::Client.new('mongodb://' + connection_string)
+              end
         self
       end
 
@@ -76,8 +80,9 @@ module Ki
       #   db.insert 'users', { name: 'Homer' }
       #
       def insert(name, hash)
-        @db[name].insert(hash)
-        [hash].stringify_ids.first
+        item = @db[name].insert_one(hash)
+        hash['id'] = item.inserted_id.to_s
+        hash
       end
 
       # Find a hash in the database
@@ -137,7 +142,7 @@ module Ki
         hash = nourish_hash_id hash
         id = hash['_id'].to_s
         hash.delete('_id')
-        @db[name].update({ '_id' => BSON::ObjectId(id) }, hash)
+        @db[name].update_one({ '_id' => BSON::ObjectId(id) }, hash)
         hash['id'] = id
         hash
       end
@@ -161,9 +166,9 @@ module Ki
       #
       def delete(name, hash)
         hash = nourish_hash_id hash
-        r = @db[name].remove hash
+        r = @db[name].delete_many hash
         {
-          deleted_item_count: r['n'] || 0
+          deleted_item_count: r.documents[0]['n']
         }
       end
 
@@ -206,6 +211,7 @@ module Ki
         hash
       end
 
+      # TODO: write tests
       def nourish_hash_limit(hash)
         tmp = {}
         if hash['__limit']
@@ -217,6 +223,7 @@ module Ki
         [hash, tmp]
       end
 
+      # TODO: write tests
       def nourish_hash_sort(hash)
         tmp = {}
         if hash['__sort']
@@ -227,7 +234,7 @@ module Ki
             # TODO: validate value
             # TODO: handle sorting by id
             hash['__sort'].to_a.each do |e|
-              tmp[e[0].to_sym] = e[1].to_sym
+              tmp[e[0].to_sym] = e[1]
             end
           end
           hash.delete('__sort')

data/lib/ki/utils/annotations.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# https://stackoverflow.com/questions/3157426/how-to-simulate-java-like-annotations-in-ruby
+module Ki
+  module Annotations
+    def annotations(meth = nil)
+      return @__annotations__[meth] if meth
+      @__annotations__
+    end
+
+    private
+
+    def method_added(m)
+      (@__annotations__ ||= {})[m] = @__last_annotation__ if @__last_annotation__
+      @__last_annotation__ = nil
+      super
+    end
+
+    def method_missing(meth, *args)
+      return super unless /\A_/.match?(meth)
+      @__last_annotation__ ||= {}
+      @__last_annotation__[meth[1..-1].to_sym] = args.size == 1 ? args.first : args
+    end
+  end
+end
+
+class Module
+  private
+
+  def annotate!
+    extend Ki::Annotations
+  end
+end

data/lib/ki/utils/api_error.rb

@@ -1,14 +1,21 @@
+# frozen_string_literal: true
+
 module Ki
   class ApiError < StandardError #:nodoc:
+    extend Descendants
+
     attr_reader :status
 
-    def initialize(body, status = 400)
-      super body
+    def initialize(body = nil, status = 400)
+      super body.nil? ? to_s : body
       @status = status
     end
 
     def result
-      { 'error' => to_s }
+      {
+        'error' => to_s,
+        'status' => @status
+      }
     end
   end
 
@@ -34,8 +41,11 @@ module Ki
   end
 
   class PartialNotFoundError < ApiError #:nodoc:
-    def initialize(s)
+    def initialize(s = '"partial"')
       super "partial #{s} not found", 404
     end
   end
 end
+
+class CustomError < Ki::ApiError
+end

data/lib/ki/utils/descendants.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Ki
+  module Descendants
+    def descendants
+      ObjectSpace.each_object(Class).select { |klass| klass < self }
+    end
+  end
+end

data/lib/ki/utils/extra_irb.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # http://jasonroelofs.com/2009/04/02/embedding-irb-into-your-ruby-application/
 require 'irb'
 
@@ -15,7 +17,7 @@ module IRB # :nodoc:
 
     irb = Irb.new(workspace)
 
-    @CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC]
+    @CONF[:IRB_RC]&.call(irb.context)
     @CONF[:MAIN_CONTEXT] = irb.context
 
     catch(:IRB_EXIT) do

data/lib/ki/utils/extra_ruby.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class String
   # Converts a string to a class
   #
@@ -45,3 +47,13 @@ class NilClass
     false
   end
 end
+
+class Object
+  def try(*a, &b)
+    if a.empty? && block_given?
+      yield self
+    else
+      __send__(*a, &b)
+    end
+  end
+end

data/lib/ki/utils/indifferent_hash.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class IndifferentHash < Hash
   def []=(key, val)
     key = key.to_sym

data/lib/ki/utils/logger.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class ::Logger
+  alias write <<
+end

data/lib/ki/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Ki
-  VERSION = '0.4.11'
+  VERSION = '0.4.12'
 end

data/lib/ki/views/instadoc.haml

@@ -5,12 +5,52 @@
     %li
       %div
         %h2= model.to_s
-        %p
-          Required attributes:
-          = model.required_attributes
-        %p
-          Forbidden actions:
-          = model.forbidden_actions
-        %p
-          Unique attributes:
-          = model.unique_attributes
+        - unless model.annotations.nil?
+          - unless model.annotations[:doc].nil?
+            %p= model.annotations[:doc][:desc]
+        %sub
+          Endpoint:
+          = "/#{model.to_s.downcase}.json"
+        -# TODO: if any attributes
+        %h3 Attributes
+        - [ { items: model.required_attributes, key: :required_attributes }, { items: model.forbidden_actions, key: :forbidden_actions }, { items: model.unique_attributes, key: :unique_attributes }].each do |array|
+          - if array[:items].any?
+            %p
+              %b= array[:key]
+              - array[:items].each do |item|
+                %p
+                  = item
+                  - unless model.annotations.nil?
+                    - unless model.annotations[array[:key]].nil?
+                      %i= model.annotations[array[:key]][item]
+        -# TODO: if any callbacks
+        %h3 Callbacks
+        - Ki::Model::Callbacks.public_instance_methods.each do |pim|
+          - unless model.annotations.nil?
+            - unless model.annotations[pim].nil?
+              %b= pim
+              - model.annotations[pim].keys.each do |pim_key|
+                %p
+                  = pim_key
+                  %i= model.annotations[pim][pim_key]
+        -# %p{style: 'color: gray'}
+          -# = model.annotations
+  %li
+    %div
+      %h2 Errors
+      %h3 Api Errors
+      %ul
+        %li
+          = Ki::ApiError
+        - Ki::ApiError.descendants.each do |error|
+          %li
+            = error
+      %h3 Custom Errors
+      %ul
+        - CustomError.descendants.each do |error|
+          %li
+            = error
+
+      %h3 Sample response
+      %pre
+        = Ki::ApiError.new('Bad request').result.to_json

data/spec/config.yml.example

@@ -7,7 +7,7 @@ development:
 test:
   middleware: [
     'ApiHandler',
-    'DocGenerator',
+    'InstaDoc',
     'AdminInterfaceGenerator',
     'CoffeeCompiler',
     'SassCompiler',

data/spec/examples/base/client.rb

@@ -0,0 +1,20 @@
+require 'faye/websocket'
+require 'eventmachine'
+
+EM.run {
+  ws = Faye::WebSocket::Client.new('ws://localhost:1337/faye')
+
+  ws.on :open do |event|
+    p [:open]
+    ws.send('Hello, world!')
+  end
+
+  ws.on :message do |event|
+    p [:message, event.data]
+  end
+
+  ws.on :close do |event|
+    p [:close, event.code, event.reason]
+    ws = nil
+  end
+}

data/spec/examples/base/public/javascripts/app.js

@@ -0,0 +1,12 @@
+// var client = new Faye.Client('/faye');
+// client.disable('autodisconnect');
+// client.publish('/message', {text: 'Hi there'});
+// var subscription = client.subscribe('/message', function(message) {
+  // console.log(message);
+// }).then(function () {
+  // console.log('active');
+// });
+
+var socket = new WebSocket("ws://localhost:1337/faye");
+socket.onmessage = function(m) {console.log(m);}
+socket.onclose   = function()  {console.log('socket closed');}

data/spec/examples/json.northpole.ro/.ruby-version

@@ -1 +1 @@
-2.1.2
+2.4.3

data/spec/examples/json.northpole.ro/public/javascripts/app.coffee

@@ -36,6 +36,7 @@ window.syntaxHighlight = (json) ->
     "<span class=\"" + cls + "\">" + match + "</span>"
 
 $(document).ready ->
+  jNorthPole.BASE_URL = 'http://localhost:1337/'
   setActiveMenuClass()
   setInterval(randomlyFlipBear, 1000)
 

data/spec/functional_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe 'the app' do

data/spec/lib/ki/base_request_spec.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Ki::BaseRequest do
   let(:req) { Ki::BaseRequest }
 
   it 'knows if current path is root' do
-    req.new({ 'PATH_INFO' => '/' }).root?.should be_true
-    req.new({ 'PATH_INFO' => '/foo' }).root?.should be_false
+    expect(req.new({ 'PATH_INFO' => '/' })).to be_root
+    expect(req.new({ 'PATH_INFO' => '/foo' })).to_not be_root
   end
 
   it 'coverts path to class' do
@@ -13,37 +15,37 @@ describe Ki::BaseRequest do
     class Bar < Ki::Model; end
     class FooBar < Ki::Model; end
 
-    req.new({ 'PATH_INFO' => '' }).to_ki_model_class.should be nil
-    req.new({ 'PATH_INFO' => '/' }).to_ki_model_class.should be nil
-    req.new({ 'PATH_INFO' => 'foo' }).to_ki_model_class.should be Foo
-    req.new({ 'PATH_INFO' => '/foo' }).to_ki_model_class.should be Foo
-    req.new({ 'PATH_INFO' => '/Foo.json' }).to_ki_model_class.should be Foo
-    req.new({ 'PATH_INFO' => '/bar.json' }).to_ki_model_class.should be Bar
-    req.new({ 'PATH_INFO' => '/Foo/bar.json' }).to_ki_model_class.should be nil
-    req.new({ 'PATH_INFO' => '/Foo/bar' }).to_ki_model_class.should be nil
-    req.new({ 'PATH_INFO' => '/Foo_bar' }).to_ki_model_class.should be FooBar
-    req.new({ 'PATH_INFO' => '/foo_bar' }).to_ki_model_class.should be FooBar
-    req.new({ 'PATH_INFO' => '/foo_bar.json' }).to_ki_model_class.should be FooBar
+    expect(req.new({ 'PATH_INFO' => '' }).to_ki_model_class).to be nil
+    expect(req.new({ 'PATH_INFO' => '/' }).to_ki_model_class).to be nil
+    expect(req.new({ 'PATH_INFO' => 'foo' }).to_ki_model_class).to be Foo
+    expect(req.new({ 'PATH_INFO' => '/foo' }).to_ki_model_class).to be Foo
+    expect(req.new({ 'PATH_INFO' => '/Foo.json' }).to_ki_model_class).to be Foo
+    expect(req.new({ 'PATH_INFO' => '/bar.json' }).to_ki_model_class).to be Bar
+    expect(req.new({ 'PATH_INFO' => '/Foo/bar.json' }).to_ki_model_class).to be nil
+    expect(req.new({ 'PATH_INFO' => '/Foo/bar' }).to_ki_model_class).to be nil
+    expect(req.new({ 'PATH_INFO' => '/Foo_bar' }).to_ki_model_class).to be FooBar
+    expect(req.new({ 'PATH_INFO' => '/foo_bar' }).to_ki_model_class).to be FooBar
+    expect(req.new({ 'PATH_INFO' => '/foo_bar.json' }).to_ki_model_class).to be FooBar
   end
 
   it 'converts verb to action' do
-    req.new({ 'REQUEST_METHOD' => 'GET' }).to_action.should be :find
-    req.new({ 'REQUEST_METHOD' => 'POST' }).to_action.should be :create
-    req.new({ 'REQUEST_METHOD' => 'PUT' }).to_action.should be :update
-    req.new({ 'REQUEST_METHOD' => 'DELETE' }).to_action.should be :delete
-    req.new({ 'REQUEST_METHOD' => 'SEARCH' }).to_action.should be :find
+    expect(req.new({ 'REQUEST_METHOD' => 'GET' }).to_action).to be :find
+    expect(req.new({ 'REQUEST_METHOD' => 'POST' }).to_action).to be :create
+    expect(req.new({ 'REQUEST_METHOD' => 'PUT' }).to_action).to be :update
+    expect(req.new({ 'REQUEST_METHOD' => 'DELETE' }).to_action).to be :delete
+    expect(req.new({ 'REQUEST_METHOD' => 'SEARCH' }).to_action).to be :find
   end
 
   context 'json' do
     it 'considers application/json content type as a json request' do
-      req.new({ 'CONTENT_TYPE' => 'application/xml' }).json?.should be_false
-      req.new({}).json?.should be_false
-      req.new({ 'CONTENT_TYPE' => 'application/json' }).json?.should be_true
+      expect(req.new({ 'CONTENT_TYPE' => 'application/xml' })).to_not be_json
+      expect(req.new({})).to_not be_json
+      expect(req.new({ 'CONTENT_TYPE' => 'application/json' })).to be_json
     end
 
     it 'considers .json url format as a json request' do
-      req.new({ 'PATH_INFO' => '/foo' }).json?.should be_false
-      req.new({ 'PATH_INFO' => '/foo.json' }).json?.should be_true
+      expect(req.new({ 'PATH_INFO' => '/foo' })).to_not be_json
+      expect(req.new({ 'PATH_INFO' => '/foo.json' })).to be_json
     end
 
     # context 'params' do