webmate 0.1.0

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.rspec
+.ruby-version
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/GUIDE.md

@@ -0,0 +1,115 @@
+#webmate app skeleton
+see working example on https://github.com/evgeniypetrov/webmate-app-skeleton
+
+## Quick start
+
+to start application, run
+  webmate start  
+application will be available on localhost:3000 url
+
+to run irb/console
+  webmate console
+
+type webmate without params to know all options
+
+show all available routes [ without assets ]
+rake routes k
+
+## Tutorial
+### Skeleton
+require files
+
+to create file, add following gem to Gemfile
+
+Gemfile
+  gem 'webmate'
+  gem 'slim'
+  gem 'sass', group: assets
+  gem 'alphasights-sinatra-sprockets', require: 'sinatra-sprockets', group: assets
+
+base required files:
+
+config.ru
+  require './config/environment'
+  if configatron.assets.compile
+    map '/assets' do
+      run Sinatra::Sprockets.environment
+    end
+  end
+  run ExampleApp
+
+config/config.rb
+  Webmate::Application.configure do |config|
+    # add directory to application load paths
+    #config.app.load_paths << ["app/uploaders"]
+    config.app.cache_classes = true
+    config.assets.compile = false
+
+    config.websockets.namespace = 'api'
+    config.websockets.enabled = true
+    config.websockets.port = 9020
+  end
+
+Webmate::Application.configure(:development) do |config|
+  config.app.cache_classes = false
+  config.assets.compile = true
+  config.websockets.port = 3503
+end
+
+config/application.rb
+  require 'digest/sha1'
+  require 'base64'
+
+  class ExampleApp < Webmate::Application
+    # do other things)
+  end
+
+config/environment.rb
+  WEBMATE_ROOT = File.expand_path('.')
+  require 'webmate'
+
+  Dir[File.join(WEBMATE_ROOT, 'app', 'routes', '**', '*.rb')].each do |file|
+    require file
+  end
+
+### Hello world
+  adding route
+    app/routes/facade_routes.rb
+      ExampleApp.define_routes do
+        get '/', to: 'pages#index', transport: [:http]
+      end
+
+  adding  responder to this route
+  create files in app/responders
+    base_responder
+      class BaseResponder < Webmate::Responders::Base
+        # Available options
+        # before_filter :do_something
+
+        rescue_from Webmate::Responders::ActionNotFound do
+          render_not_found
+        end
+      end
+
+    pages_responder
+      class PagesResponder < BaseResponder
+        include Webmate::Responders::Templates
+
+        def index
+          slim :index, layout: 'application'
+        end
+      end
+
+    also, required files
+      app/views/layouts/application.html.slim
+      app/views/pages/index.html.slim
+
+### Assets
+  assets will be searched in app/assets folder, so place them to
+  app/assets/javascripts
+  app/assets/stylesheets
+
+### Utilities - rake task, scripts
+  Rakefile
+    require File.expand_path('../config/environment', __FILE__)
+    Webmate::Application.load_tasks

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in webmate.gemspec
+gemspec
+
+group :development do
+  gem 'rake'
+  gem 'rspec'
+  gem 'webmate-sprockets'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Iskander Haziev
+
+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,47 @@
+# Webmate
+
+TODO: Write a gem description
+
+## Prerequisites
+  git
+  mongo
+  redis
+
+  sinatra 4.2
+  to make this, use sinatra-contrib at least 1.4.0 version
+    Specify in your Gemfile 
+      gem 'sinatra-contrib', git: 'git://github.com/sinatra/sinatra-contrib.git'
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'webmate'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install webmate
+
+## Usage
+
+TODO: Write usage instructions here
+
+start server as 
+  webmate server [-p port]
+
+running interactive console
+  webmate console [environment]
+  or 
+  webmate console [-e environment]
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/webmate

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+# -*- encoding: utf-8 -*-
+
+require 'optparse'
+require 'ostruct'
+
+options = OpenStruct.new(
+  port: 3000,
+  environment: 'development',
+  daemon: false,
+  rackup: 'config.ru'
+)
+
+opt_parser = OptionParser.new do |opt|
+  opt.banner = "Usage: webmate COMMAND [OPTIONS]"
+  opt.separator  ""
+  opt.separator  "Commands"
+  opt.separator  "     server: start server"
+  opt.separator  "     console [environment]: application console"
+  opt.separator  "     generate [app_name]: do something useful"
+  opt.separator  ""
+  opt.separator  "Options"
+
+  opt.on("-e","--environment ENVIRONMENT","which environment you want to run") do |environment|
+    options.environment = environment
+  end
+
+  opt.on("-d","--daemon","daemon mode") do |daemon|
+    options.daemon = daemon
+  end
+
+  opt.on("-p","--port PORT", Integer, "port number") do |port|
+    options.port = port
+  end
+
+  opt.on("-R","--rackup FILE", "rackup file") do |file|
+    options.rackup_file = file
+  end
+end
+
+opt_parser.parse!
+
+command = ARGV.shift
+case command
+when 'server'
+  #TODO refactor to
+  # require 'lib/commands/server'
+  # with options
+  require './config/environment'
+  require 'thin'
+
+  cmd = ["start"]
+  cmd += ["-p", options.port.to_s]
+
+  Thin::Runner.new(cmd).run!
+when 'console'
+  require 'irb'
+  ENV["RACK_ENV"] ||= ARGV.first || options.environment || 'development'
+  puts "Running Webmate console with env: #{ENV["RACK_ENV"]}"
+  require './config/environment'
+  ARGV.clear
+  IRB.start
+
+when 'generate'
+  puts 'not yet implemented'
+  puts opt_parser
+
+else
+  puts opt_parser
+end

data/lib/webmate/application.rb

@@ -0,0 +1,138 @@
+module Webmate
+  class Application < Sinatra::Base
+    # override sinatra's method
+    def route!(base = settings, pass_block = nil) 
+      transport = @request.websocket? ? 'WS' : 'HTTP'
+
+      route_info = base.routes.match(@request.request_method, transport, @request.path)
+
+      # no route case - use default sinatra's processors
+      if !route_info
+        route_eval(&pass_block) if pass_block
+        route_missing
+      end
+
+      if @request.websocket?
+        unless authorized_to_open_connection?(route_info[:params][:scope])
+          return  [401, {}, []]
+        end
+
+        session_id = route_info[:params][:session_id].inspect
+        Webmate::Websockets.subscribe(session_id, @request) do |message|
+          if route_info = base.routes.match(message['method'], 'WS', message.path)
+            request_info = {
+              path: message.path,
+              metadata: message.metadata || {},
+              action: route_info[:action],
+              params: message.params.merge(route_info[:params]),
+              request: @request
+            }
+            # here we should create subscriber who can live
+            # between messages.. but not between requests.
+            response = route_info[:responder].new(request_info).respond
+
+            # result of block will be sent back to user
+            response
+          end
+        end
+
+        # this response not pass to user - so we keep connection alive.
+        # passing other response will close connection and socket
+        non_pass_response = [-1, {}, []]
+        return non_pass_response
+
+      else # HTTP
+        # this should return correct Rack response..
+        request_info = params_for_responder(route_info)
+        response = route_info[:responder].new(request_info).respond
+
+        return response.rack_format
+      end
+    end
+
+    # this method prepare data for responder
+    # {
+    #   path: '/', 
+    #   metadata: {}, 
+    #   action: 'index', 
+    #   params: { test: true } 
+    # }
+    def params_for_responder(route_info)
+      # create unified request info 
+      # request_info = { path: '/', metadata: {}, action: 'index', params: { test: true } }
+      request_params = parsed_request_params
+      metadata = request_params.delete(:metadata)
+      {
+        path: @request.path,
+        metadata: metadata || {},
+        action: route_info[:action],
+        params: request_params.merge(route_info[:params]),
+        request: @request
+      }
+    end
+
+    # @request.params  working only for get params
+    # and params in url line ?key=value
+    def parsed_request_params
+      request_params = HashWithIndifferentAccess.new
+      request_params.merge!(@request.params || {})
+
+      # read post or put params. this will erase  params
+      # {code: 123, mode: 123}
+      # "code=123&mode=123"
+      request_body = @request.body.read
+      if request_body.present?
+        body_params = begin
+          JSON.parse(request_body) # {code: 123, mode: 123}
+        rescue JSON::ParserError
+          Rack::Utils.parse_nested_query(request_body) # "code=123&mode=123"
+        end
+      else
+        body_params = {}
+      end
+
+      request_params.merge(body_params) 
+    end
+
+    # update this method to create auth restrictions
+    def authorized_to_open_connection?(scope = :user)
+      return true
+    end
+
+    class << self
+      def configure(env = nil, &block)
+        if !env || Webmate.env?(env)
+          block.call(configatron)
+        end
+      end
+
+      def define_routes(&block)
+        settings = Webmate::Application
+        unless settings.routes.is_a?(RoutesCollection)
+          routes = RoutesCollection.new()
+          settings.set(:routes, routes)
+        end
+        settings.routes.define_routes(&block)
+
+        routes
+      end
+
+      def get_channel_name_for(user_id)
+        channel_name = "some-unique-key-for-app-#{user_id}"
+      end
+
+      def dump(obj)
+        Yajl::Encoder.encode(obj)
+      end
+
+      def restore(str)
+        Yajl::Parser.parse(str)
+      end
+
+      def load_tasks
+        file_path = Pathname.new(__FILE__)
+        load File.join(file_path.dirname, "../../tasks/routes.rake")
+      end
+    end
+  end
+end

data/lib/webmate/config.rb

@@ -0,0 +1,23 @@
+Webmate::Application.configure do |config|
+  config.app.load_paths = ["app/responders", "app/models", "app/services", "app/observers", "app/decorators"]
+  config.app.cache_classes = false
+
+  config.app.name = 'webmate'
+  config.app.host = 'localhost'
+  config.app.port = 80
+  config.app.host_with_port = Configatron::Delayed.new { "#{configatron.app.host}:#{configatron.app.port}" }
+
+  config.logger.path = "#{Webmate.root}/log"
+
+  config.assets.debug = false
+  config.assets.compress = false
+  config.assets.compile = true
+  config.assets.digest = false
+
+  config.cookies.key = Configatron::Delayed.new { "_#{configatron.app.name}_session" }
+  config.cookies.domain = nil
+  config.cookies.secret = "65e604cae451847ff2722ba84cb13db90f1b0a9ddc35a37169bec"
+
+  config.websockets.enabled = true
+  config.websockets.port = 80
+end

data/lib/webmate/decorators/base.rb

@@ -0,0 +1,38 @@
+module Webmate::Decorators
+  class Base
+    attr_reader :entity, :options
+
+    def initialize(entity, options = {})
+      @entity, @options = entity, options
+    end
+
+    class << self
+      def decorate(entity_or_collection, options = {})
+        if entity_or_collection.respond_to?(:map)
+          entity_or_collection.map { |e| self.decorate(e, options) }
+        else
+          self.new(entity_or_collection, options)
+        end
+      end
+    end
+
+    def id
+      entity.id.to_s
+    end
+
+    def method_missing(method, *args, &block)
+      if entity.respond_to?(method)
+        self.class.send :define_method, method do |*args, &blokk|
+          entity.send method, *args, &blokk
+        end
+
+        send method, *args, &block
+      else
+        super
+      end
+    rescue NoMethodError => no_method_error
+      super if no_method_error.name == method
+      raise no_method_error
+    end
+  end
+end

data/lib/webmate/env.rb

@@ -0,0 +1,17 @@
+module Webmate
+  def self.root
+    WEBMATE_ROOT
+  end
+
+  def self.env
+    ENV["RACK_ENV"]
+  end
+
+  def self.env?(env)
+    self.env == env.to_s
+  end
+
+  def self.logger
+    @logger ||= Webmate::Logger.new
+  end
+end

data/lib/webmate/logger.rb

@@ -0,0 +1,20 @@
+module Webmate
+  class Logger < Rack::CommonLogger
+    cattr_accessor :logger_file
+    def initialize(app = nil)
+      @app = app
+      Dir.mkdir(configatron.logger.path) unless File.exists?(configatron.logger.path)
+      @@logger_file ||= File.new(File.join(configatron.logger.path, "#{Webmate.env}.log"), 'a')
+    end
+
+    def log(env, status, header, began_at)
+      dump(%Q{HTTP #{env["REQUEST_METHOD"]}: #{env["PATH_INFO"]} #{status} \nParams: #{env['rack.request.query_hash']}})
+    end
+
+    def dump(text)
+      [@@logger_file, STDOUT].each do |out|
+        out.write %Q{[#{Time.now.strftime("%D %H:%M:%S")}] #{text} \n\n}
+      end
+    end
+  end
+end

data/lib/webmate/observers/base.rb

@@ -0,0 +1,24 @@
+module Webmate::Observers
+  class Base
+    class << self
+      cattr_accessor :subscriptions
+
+      def subscribe(action, &block)
+        Webmate::Observers::Base.subscribe!(action, &block)
+      end
+
+      def subscribe!(action, &block)
+        self.subscriptions ||= {}
+        self.subscriptions[action] ||= []
+        self.subscriptions[action] << block
+      end
+
+      def execute_all(action, data)
+        self.subscriptions ||= {}
+        (self.subscriptions[action] || []).each do |block|
+          block.call(data)
+        end
+      end
+    end
+  end
+end

data/lib/webmate/presenters/base.rb

@@ -0,0 +1,69 @@
+module Webmate::Presenters
+  class Base
+    attr_reader :attrs
+
+    def initialize(object, options = {})
+      @object, @options = object, options.with_indifferent_access
+      @attrs = {}
+    end
+
+    def namespace(name, &block)
+      serializer = self.class.new(@object, @options)
+      serializer.instance_exec(@object, &block)
+      self.attrs[name] = serializer.attrs
+    end
+
+    def resource(name, object = nil, &block)
+      raise "You should set name for resource" if name.blank?
+      raise "You should specify object" if @object.nil? && object.nil?
+      nested_name = name.to_s
+      nested_object = object || @object.send(nested_name)
+      if nested_object.blank?
+        self.attrs[nested_name] = {}
+      else
+        self.attrs[nested_name] = nested_resource(nested_name, nested_object, @options, &block)
+      end
+    end
+
+    def resources(name, objects = nil, &block)
+      raise "You should specify object" if @object.nil? && objects.nil?
+      objects = objects.flatten unless objects.nil?
+      nested_objects = objects || @object.send(name.to_s)
+      if nested_objects.blank?
+        self.attrs[name.to_s] = []
+      else
+        self.attrs[name.to_s] = (nested_objects || []).inject([]) do |result, obj|
+          resource = nested_resource(name, obj, @options, &block)
+          resource.empty? ? result : (result << resource)
+        end
+      end
+    end
+
+    def attributes(*attrs, &block)
+      if @object.blank?
+        object = attrs.last
+        attrs.delete(attrs.last)
+        raise ArgumentError, "Object was not specified" if object.is_a?(Symbol)
+      end
+
+      target = object || @object
+      Array.wrap(attrs).flatten.each do |attribute|
+        self.attrs[attribute.to_s] = target.send(attribute.to_s)
+      end
+    end
+
+    def attribute(attr, &block)
+      self.attrs[attr.to_s] = yield
+    end
+
+    protected
+
+    def nested_resource(name, object, options, &block)
+      return nil if !object || object.blank?
+      serializer = self.class.new(object, options)
+      serializer.instance_exec(object, &block)
+      serializer.attrs
+    end
+
+  end
+end