apiway 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e359eb647d0797382fe8d4960a74390d9e453527
+  data.tar.gz: a9bb742d1d44c02040161ed4332efe8cb5b425c1
+SHA512:
+  metadata.gz: 87bbe8b23efea6c9d3b9d97c41771e26331e139bcfe2bd122babd82481373093111deafdf7382da9f31c626d24617695c2f5877b170f3412ad1052056ae27145
+  data.tar.gz: 2375c4599a6acbcbd3434fc205692cb2362582fd1afa6e71bae644d3b71ae93b7de2a0e11c0bc67435e6428fd5c0d0a99f5a0580eac67efcdab66ea614dd4ff0

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 4urbanoff
+
+MIT License
+
+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 @@
+## Apiway

data/bin/apiway

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require 'erb'
+require 'fileutils'
+require 'logger'
+require 'apiway/path'
+require 'apiway/logger'
+require 'apiway/version'
+require 'apiway/extensions'
+require 'apiway/generator'
+require 'apiway/commands'
+
+Apiway::Commands.run *ARGV

data/lib/apiway/application.rb

@@ -0,0 +1,53 @@
+module Apiway
+
+  class Application < Sinatra::Base
+
+
+    set root:              File.expand_path( '.' )
+    set static:            true
+    set apiway_log:        true
+    set active_record_log: true
+    set log_level:         :debug
+    set database_file:     File.join( root, 'config/database.yml' )
+
+
+    register Sinatra::ActiveRecordExtension
+
+
+    configure :development do
+      register Sinatra::Reloader
+      also_reload File.join( root, '**/*.rb' )
+      # also_reload File.join( Apiway.path, '**/*.rb' )
+    end
+
+
+    get '*' do
+      request.websocket? ? request.websocket{ |ws| Apiway::Client.new ws } : pass
+    end
+
+
+    %W(
+      lib/**/*.rb
+      config/environments/#{ environment.to_s }.rb
+      config/initializers/**/*.rb
+      app/base/**/*.rb
+      app/controllers/application.rb
+      app/resources/application.rb
+      app/**/*.rb
+    )
+    .map{ |path| Dir[ File.join( root, path ) ] }
+    .flatten.uniq.each{ |path| require path }
+    
+    
+    LoggerBase::apiway_log_level       apiway_log
+    LoggerBase::activerecord_log_level activerecord_log
+    
+
+    def self.tasks
+      require 'sinatra/activerecord/rake'
+    end
+
+
+  end
+
+end

data/lib/apiway/client.rb

@@ -0,0 +1,171 @@
+module Apiway
+
+  class Client
+
+
+    HANDLERS = Hash[
+      API::ALIVE,        :alive,
+      API::QUERY,        :run_controller,
+      RESOURCE::SYNC,    :sync_resource,
+      RESOURCE::DESTROY, :destroy_resource
+    ]
+
+
+    class << self
+
+      def all
+        @@all ||= []
+        @@all.each { |client| yield client } if block_given?
+        @@all
+      end
+
+      def sync_changes( changed_models )
+        all { |client| client.sync_changes changed_models }
+      end
+
+      def on_connected( &block )
+        block_given? ? @@on_connected    = block : @@on_connected    ||= Proc.new {}
+      end
+
+      def on_message( &block )
+        block_given? ? @@on_message      = block : @@on_message      ||= Proc.new {}
+      end
+
+      def on_disconnected( &block )
+        block_given? ? @@on_disconnected = block : @@on_disconnected ||= Proc.new {}
+      end
+
+    end
+
+
+    def initialize( ws )
+      @ws = ws
+      @ws.onopen    {       on_connected    }
+      @ws.onmessage { |msg| on_message msg  }
+      @ws.onclose   {       on_disconnected }
+      @storage    = {}
+      @resources  = {}
+    end
+
+    def []( name = nil )
+      @storage[ name ]
+    end
+
+    def []=( name, value )
+      @storage[ name ] = value
+      Thread.current[ :changed_models ].concat Apiway::Model.all
+      value
+    end
+
+    def sync_changes( changed_models )
+      @resources.values.each { |resource| resource.sync_changes changed_models }
+    end
+
+    def trigger( *args )
+      send_event API::TRIGGER, args: args
+    end
+
+
+    private
+
+    def processing
+      begin
+        Thread.new {
+          Thread.current[ :changed_models ]  = []
+          Thread.current[ :methods_to_call ] = []
+          yield
+          self.class.sync_changes Thread.current[ :changed_models ].uniq
+          call_methods Thread.current[ :methods_to_call ]
+        }.join
+      rescue Exception => e
+        Log.error "#{ e.message }\n#{ e.backtrace.join "\n" }"
+      end
+    end
+
+    def on_connected
+      processing do
+        self.class.all << self
+        instance_eval &self.class.on_connected
+      end
+      Log.info "Client connected"
+    end
+
+    def on_message( msg )
+      @msg = parseMessage( msg ) rescue { event: API::ALIVE, data: nil }
+      Log.debug "New message: \n#{ JSON.pretty_generate( @msg ) }" if Log.debug?
+      processing do
+        instance_exec @msg, &self.class.on_message
+        handler = HANDLERS[ @msg[ :event ] ] or raise EventHandlerNotExists, @msg[ :event ]
+        send handler, @msg[ :data ]
+      end
+    end
+
+    def on_disconnected
+      processing do
+        self.class.all.delete self
+        instance_eval &self.class.on_disconnected
+      end
+      Log.info "Client disconnected"
+    end
+
+    def parseMessage( msg )
+      msg = JSON.parse msg, quirks_mode: true
+      msg.keys_to_sym!
+    end
+
+    def send_json( msg )
+      @ws.send JSON.generate( msg, quirks_mode: true )
+      Log.debug "Send message: \n#{ JSON.pretty_generate( msg ) }" if Log.debug?
+    end
+
+    def send_event( event, data = nil )
+      send_json event: event, data: data
+    end
+
+    def success( result )
+      send_event API::SUCCESS, result: result, query_id: @msg[ :data ][ :query_id ]
+    end
+
+    def failure( result )
+      send_event API::FAILURE, result: result, query_id: @msg[ :data ][ :query_id ]
+    end
+
+    def call_methods( methods )
+      methods.each { |method, args| send method, *args }
+    end
+
+    def alive( data )
+      send_event API::ALIVE
+    end
+
+    def run_controller( data )
+      name, action, params = data.values_at :name, :action, :params
+      name = "#{ name }Controller"
+      begin
+        controller = Object.const_get( name ).new action.to_sym, self, params
+      rescue NameError
+        raise ControllerNotExists, name
+      else
+        controller.run
+      end
+    end
+
+    def sync_resource( data )
+      id, name, params = data.values_at :id, :name, :params
+      name = "#{ name }Resource"
+      begin
+        @resources[ id ] ||= Object.const_get( name ).new id, self
+      rescue
+        raise ResourceNotExists, name
+      else
+        @resources[ id ].set_params( params ).sync
+      end
+    end
+
+    def destroy_resource( data )
+      @resources.delete data[ :id ]
+    end
+
+  end
+
+end

data/lib/apiway/commands.rb

@@ -0,0 +1,62 @@
+module Apiway
+
+  module Commands
+
+
+    class << self
+
+      HANDLERS = {
+        version:  [ '-v', 'v', 'version'  ],
+        server:   [ '-s', 's', 'server'   ],
+        generate: [ '-g', 'g', 'generate' ],
+        create:   [ '-n', 'n', 'new'      ],
+        help:     [ '-h', 'h', 'help'     ]
+      }
+      
+      DESC = {
+        version:  'Show gem version',
+        server:   'Launch thin server, alias for `bundle exec thin start`',
+        generate: 'Launch generator, run `apiway generator help` to show commands of generator',
+        create:   'Creating a new application',
+        help:     'Show list of commands'
+      }
+
+
+      def run( command = nil, *args )
+        return help unless command
+        HANDLERS.each { |handler, commands| return send( handler, *args ) if commands.include? command }
+        puts "Apiway: Unknown command `#{ args.unshift( command ).join " " }`"
+      end
+
+
+      private
+
+      def version( *args )
+        puts "Apiway version #{ Apiway::VERSION }"
+      end
+
+      def server( *args )
+        exec "bundle exec thin start #{ args.join " " }"
+      end
+
+      def generate( *args )
+        Generator.run *args
+      end
+
+      def create( *args )
+        generate "app", *args
+      end
+      
+      def help( *args )
+        puts "\n Apiway commands: \n\n"
+        HANDLERS.each do |handler, commands| 
+          puts "  [#{ commands.join( "], [" ) }]".ljust(30) << "# #{ DESC[ handler ] } "
+        end
+      end
+
+    end
+
+
+  end
+
+end

data/lib/apiway/controller.rb

@@ -0,0 +1,124 @@
+module Apiway
+
+  module Controller
+
+
+
+    class << self
+
+      def included( base )
+        base.class_eval do
+          extend  ClassMethods
+          include InstanceMethods
+        end
+      end
+
+    end
+
+
+
+    module ClassMethods
+
+      def action( name, &block )
+        block_given? ? actions[ name ] = block : actions[ name ] or raise ControllerActionNotExists.new( self.name, name )
+      end
+
+      def before_action( method_name, only: [], except: [] )
+        register_filter :before, method_name, only, except
+      end
+
+      def after_action( method_name, only: [], except: [] )
+        register_filter :after, method_name, only, except
+      end
+
+      def select_filters( type, action_name )
+        filters( type ).select do |method_name, only, except|
+          ( only.empty? || only.include?( action_name ) ) && ( except.empty? || !except.include?( action_name ) )
+        end
+      end
+
+
+      private
+
+      def actions
+        @actions ||= {}
+      end
+
+      def filters( type )
+        ( @filters ||= {} )[ type ] ||= []
+      end
+
+      def register_filter( type, method_name, only, except )
+        only   = [].push( only ).flatten
+        except = [].push( except ).flatten
+        filters( type ) << [ method_name, only, except ]
+      end
+
+    end
+
+
+
+    module InstanceMethods
+
+      def initialize( action_name, client, params = {} )
+        @action_name = action_name
+        @action      = self.class.action @action_name
+        @client      = client
+        @params      = params
+      end
+
+      def run
+        begin
+          run_filters :before
+          result = run_action
+          run_filters :after
+        rescue ControllerError => e
+          failure e.params
+        else
+          success result
+        end
+      end
+
+
+      protected
+
+      attr_reader :client, :params
+
+      def trigger( *args )
+        add_method_to_call :trigger, args
+      end
+
+      def error( params )
+        raise ControllerError, params
+      end
+
+
+      private
+
+      def run_action
+        instance_eval &@action
+      end
+
+      def run_filters( type )
+        self.class.select_filters( type, @action_name ).each { |method_name, only, except| send method_name }
+      end
+
+      def add_method_to_call( method, args )
+        Thread.current[ :methods_to_call ] << [ method, args ]
+      end
+
+      def success( *args )
+        add_method_to_call :success, args
+      end
+
+      def failure( *args )
+        add_method_to_call :failure, args
+      end
+
+    end
+
+
+
+  end
+
+end

data/lib/apiway/diff.rb

@@ -0,0 +1,84 @@
+module Apiway
+
+  class Diff
+
+
+    def initialize( source, target )
+      @del, @add, @del_c, @add_c = {}, {}, 0, 0
+      calculate source.to_s, target.to_s
+    end
+
+    def patch
+      [ @del, @add ]
+    end
+
+
+    private
+
+    def calculate( source, target )
+
+      if found = find_middle( source, target )
+
+        source_l, target_l, source, source_r, target_r = found
+        calculate source_l, target_l
+        @del_c += source.size
+        @add_c += source.size
+        calculate source_r, target_r
+
+      else
+
+        unless source.empty?
+         @del[ @del_c ]  = source.size
+        end
+
+        unless target.empty?
+          @add[ @add_c ] = target
+          @add_c        += target.size
+        end
+
+      end
+
+    end
+
+    def find_middle( source, target, min = 0, max = nil )
+
+      return nil if source.empty? || target.empty?
+
+      max  = source.size unless max
+      size = min + ( ( max - min ) / 2.to_f ).round
+
+      subsets_each( source, size ) do |subset, first, last|
+
+        if found = target.index( subset )
+
+          return (
+            size != min && find_middle( source, target, size, max ) ||
+            (
+              source_l = source[ 0...first ]
+              target_l = target[ 0...found ]
+              source_r = source[ last...source.size ]
+              target_r = target[ found + subset.size...target.size ]
+              [ source_l, target_l, subset, source_r, target_r ]
+            )
+          )
+
+        end
+
+      end
+
+      size != max && find_middle( source, target, min, size ) || nil
+
+    end
+
+    def subsets_each( source, size )
+      ( source.size - size + 1 ).times do |first|
+        last     = first + size
+        subset = source[ first...last ]
+        yield subset, first, last
+      end
+    end
+
+
+  end
+
+end

data/lib/apiway/errors.rb

@@ -0,0 +1,62 @@
+module Apiway
+
+
+  class EventHandlerNotExists < StandardError
+
+    def initialize( name )
+      super "Event handler \"#{ name }\" not exists"
+    end
+
+  end
+
+
+  class ControllerNotExists < StandardError
+
+    def initialize( name )
+      super "\"#{ name }\" not exists"
+    end
+
+  end
+
+
+  class ControllerActionNotExists < StandardError
+
+    def initialize( controller_name, action_name )
+      super "Action \"#{ action_name }\" not exists in \"#{ controller_name }\""
+    end
+
+  end
+
+
+  class ResourceNotExists < StandardError
+
+    def initialize( name )
+      super "\"#{ name }\" not exists"
+    end
+
+  end
+
+
+  class ResourceError < StandardError
+
+    attr_reader :params
+
+    def initialize( params = nil )
+      @params = params
+    end
+
+  end
+
+
+  class ControllerError < StandardError
+
+    attr_reader :params
+
+    def initialize( params = nil )
+      @params = params
+    end
+
+  end
+
+
+end

data/lib/apiway/events.rb

@@ -0,0 +1,23 @@
+module Apiway
+
+
+  module API
+
+    ALIVE   = 'alv'
+    QUERY   = 'que'
+    SUCCESS = 'sus'
+    FAILURE = 'fai'
+    TRIGGER = 'trg'
+
+  end
+
+
+  module RESOURCE
+
+    SYNC    = 'snc'
+    DESTROY = 'dst'
+
+  end
+
+
+end

data/lib/apiway/extensions.rb

@@ -0,0 +1,29 @@
+class Hash
+
+  def keys_to_sym!
+    self.keys.each do |key|
+      self[ key ].keys_to_sym! if self[ key ].is_a? Hash
+      self[ ( key.to_sym rescue key ) ] = self.delete key
+    end
+    self
+  end
+
+end
+
+
+class String
+
+  def underscore!
+    gsub!( /(.)([A-Z])/, '\1_\2' )
+    downcase!
+  end
+
+  def underscore
+    dup.tap { |s| s.underscore! }
+  end
+
+  def camelize
+    self.split( '_' ).collect( &:capitalize ).join
+  end
+
+end