hullio 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YzVkZjA3YzQ3OTA5MTA3NGJiZWFhOTA3NmZjMWE0ZDc4YmNjMTI3NA==
+  data.tar.gz: !binary |-
+    NTk3ZDA3NzVhZDg4ODk1Yzk0NzU3ZWJkNTA2OWI1NmU0MDE5ZmRjMg==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    MTRmM2YzNDY5YTk0YjlhYmZjYzdjN2VhZmI2ZTMxMjNjYjVmYjZhMzFhZDFj
+    ZThhZmE1MWIyZGMxM2NkYmViMmJhNjhkMzQzZTZkMzAwNTc3MDdkZjVmNThh
+    ZmQ0NmIyOTkzZGE2OWExNzUyNjNmMjRiZTliZDdhNGFmYzVhNzc=
+  data.tar.gz: !binary |-
+    ZDI0NjA5OTgyMjM4MTNlNTA4YmM0MWViOWJhMDcxY2ZiYzAzYTdmOWE5NTc1
+    NjhhNzA2NzA2MGNiZDI5NTY3MGVjZTkzMDQwZWYzNjQ2YzNkMjBkY2JjOWE2
+    MjljYjgyZWI1NDVhOGQ2ZTdkZTc3Y2U3MTdiZjg3YWZjOGU2OGM=

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in hullio.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Hull.io
+
+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,74 @@
+# Hull Ruby client
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'hullio'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install hullio
+
+## Usage
+
+### Configuration
+
+    Hull.configure do |c|
+      c.app_id      = "your-app-id"
+      c.app_secret  = "your-app-secret"
+      c.endpoint    = "http://ORG-NAMESPACE.hullapp.io"
+    end
+
+### Making API Calls
+
+`get`, `put`, `post` and `delete` methods are directly available on Hull.
+
+examples: 
+
+    # To get the current app
+    Hull.get('app')
+
+    # To get the a list of comments on the current app (with pagination)
+    Hull.get('app/comments', limit: 10, page: 2)
+
+    # To update an existing object
+    Hull.put('app', { name: 'My Super App' })
+
+with Hull entities :
+
+    Hull.get('entity', { uid: 'http://example.com' })
+    Hull.put('entity', { uid: 'http://example.com', name: 'My super Page' })
+    Hull.delete('entity', { uid: 'http://example.com' })
+
+
+### Bring your own users
+
+In addition to providing multiple social login options, Hull allows you to create and authenticate users that are registered within your own app.
+
+To use this feature, you just have to add a `userHash` key at the initialization of hull.js : 
+
+In you view : 
+
+    <script>
+      Hull.init({
+        appId:  "<%= Hull.app_id %>",
+        orgUrl: "<%= Hull.endpoint %>",
+        userHash: "<%= Hull.user_hash({ id: "123", email: "bill@hullapp.io", name: "Bill Evans" })  %>"
+      });
+    </script>
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/hullio.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/hull/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Stephane Bellity", "Hull"]
+  gem.email         = ["stephane@hull.io"]
+  gem.description   = %q{Hull Ruby Client}
+  gem.summary       = %q{Hull Ruby Client}
+  gem.homepage      = "http://hull.io"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "hullio"
+  gem.require_paths = ["lib"]
+  gem.version       = Hull::VERSION
+
+  # Dependencies
+  gem.add_dependency 'faraday',               '~> 0.8'
+  gem.add_dependency 'faraday_middleware',    '~> 0.9'
+  gem.add_dependency 'multi_json'
+  gem.add_dependency 'mime-types'
+
+  # Development Dependencies
+  gem.add_development_dependency 'activesupport',       ['>= 2.3.9', '< 4']
+
+end

data/lib/hull.rb

@@ -0,0 +1,30 @@
+require 'hull/core_ext/hash'
+require 'hull/client'
+require 'hull/config'
+
+module Hull
+  extend Config
+  class << self
+    # Alias for Hull::Client.new
+    #
+    # @return [Hull::Client]
+    def new(options={})
+      Hull::Client.new(options)
+    end
+
+    # Delegate to hull::Client
+    def method_missing(method, *args, &block)
+      return super unless new.respond_to?(method)
+      new.send(method, *args, &block)
+    end
+
+    def respond_to?(method, include_private=false)
+      new.respond_to?(method, include_private) || super(method, include_private)
+    end
+
+    def log msg, level=:debug
+      Hull.logger.send(level.to_sym, "[hull:#{Hull.domain}] #{msg}") if Hull.logger && Hull.logger.respond_to?(level.to_sym)
+    end
+  end
+
+end

data/lib/hull/client.rb

@@ -0,0 +1,69 @@
+require 'hull/config'
+require 'hull/connection'
+require 'hull/request'
+require 'base64'
+require 'openssl'
+
+module Hull
+  class Client
+
+    attr_accessor *Config::VALID_OPTIONS_KEYS
+
+    include Hull::Connection
+    include Hull::Request
+
+    # Initializes a new API object
+    #
+    # @param attrs [Hash]
+    # @return [Hull::Client]
+    def initialize(attrs={})
+      attrs = Hull.options.merge(attrs)
+      Config::VALID_OPTIONS_KEYS.each do |key|
+        instance_variable_set("@#{key}".to_sym, attrs[key])
+      end
+    end
+
+    def credentials
+      {
+        :app_id           => app_id,
+        :app_secret       => app_secret
+      }
+    end
+    
+    def app
+      return unless app_id
+      @app ||= get("/app", :app_id => app_id)
+    end
+
+
+    def read_cookie str
+      return if str.nil? || str.length == 0
+      JSON.parse(Base64.decode64(str)) rescue nil
+    end
+
+    def current_user_id user_id, user_sig
+      return unless user_id && user_sig
+      time, signature = user_sig.split(".")
+      data    = [time, user_id].join("-")
+      digest  = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::Digest.new('sha1'), self.app_secret, data)
+      return user_id if digest == signature
+    end
+
+    def authenticate_user env
+      require 'rack/request'  
+      request = Rack::Request.new(env)
+      cookie  = request.cookies["hull_#{self.app_id}"]
+      user_auth = read_cookie(cookie)
+      return unless user_auth
+      current_user_id(user_auth['Hull-User-Id'], user_auth['Hull-User-Sig'])
+    end
+
+    def user_hash user_infos
+      timestamp = Time.now.to_i.to_s
+      message = Base64.encode64(user_infos.to_json).gsub("\n", "")
+      sig = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::Digest.new('sha1'), app_secret, [message, timestamp].join(" "))
+      [message, sig, timestamp].join(" ")
+    end
+    
+  end
+end

data/lib/hull/config.rb

@@ -0,0 +1,85 @@
+require 'hull/version'
+
+module Hull
+  # Defines constants and methods related to configuration
+  module Config
+
+    # The HTTP connection adapter that will be used to connect if none is set
+    DEFAULT_ADAPTER = :net_http
+
+    # The Faraday connection options if none is set
+    DEFAULT_CONNECTION_OPTIONS = {}
+
+
+    # The client ID if none is set
+    DEFAULT_APP_SECRET = ENV['HULL_APP_SECRET']
+    DEFAULT_APP_ID =     ENV['HULL_APP_ID']
+
+  
+    # The endpoint that will be used to connect if none is set
+    #
+    DEFAULT_ENDPOINT = ENV['HULL_ORG_URL']
+
+    DEFAULT_CACHE_STORE = nil
+
+    DEFAULT_PROXY = nil
+    
+    # The value sent in the 'User-Agent' header if none is set
+    DEFAULT_USER_AGENT = "Hull Ruby Gem #{Hull::VERSION}"
+
+    DEFAULT_LOGGER = nil
+
+    # An array of valid keys in the options hash when configuring a {Hull::Client}
+    VALID_OPTIONS_KEYS = [
+      :proxy,
+      :adapter,
+      :connection_options,
+      :app_id,
+      :app_secret,
+      :endpoint,
+      :user_agent,
+      :cache_store,
+      :logger
+    ]
+
+    attr_accessor *VALID_OPTIONS_KEYS
+
+    def domain
+      @domain ||= URI.parse(endpoint).host unless endpoint.nil?
+    end
+
+    # When this module is extended, set all configuration options to their default values
+    def self.extended(base)
+      base.reset
+    end
+
+    # Convenience method to allow configuration options to be set in a block
+    def configure
+      yield self
+      self
+    end
+
+    # Create a hash of options and their values
+    def options
+      options = {}
+      VALID_OPTIONS_KEYS.each{|k| options[k] = send(k)}
+      options
+    end
+
+    # Reset all configuration options to defaults
+    def reset
+      @domain                 = nil
+      self.proxy              = DEFAULT_PROXY
+      self.logger             = DEFAULT_LOGGER
+      self.adapter            = DEFAULT_ADAPTER
+      self.connection_options = DEFAULT_CONNECTION_OPTIONS
+      self.app_id             = DEFAULT_APP_ID
+      self.app_secret         = DEFAULT_APP_SECRET
+      self.endpoint           = DEFAULT_ENDPOINT
+      self.user_agent         = DEFAULT_USER_AGENT
+      self.cache_store        = DEFAULT_CACHE_STORE
+      self
+    end
+
+  end
+end

data/lib/hull/connection.rb

@@ -0,0 +1,36 @@
+require 'faraday'
+require 'hull/request/auth'
+require 'faraday_middleware/response/parse_json'
+require 'faraday_middleware/response/caching'
+
+module Hull
+  module Connection
+  private
+
+    # Returns a Faraday::Connection object
+    #
+    # @param options [Hash] A hash of options
+    # @return [Faraday::Connection]
+    def connection(options={})
+      default_options = {
+        :headers => {
+          :accept => 'application/json',
+          :user_agent => user_agent,
+        },
+        :ssl => {:verify => false},
+        :url => options.fetch(:endpoint, endpoint),
+        :timeout => 10,
+        :proxy => options.fetch(:proxy, proxy),
+        :open_timeout => 10
+      }
+      @connection ||= Faraday.new(default_options.deep_merge(connection_options)) do |builder|
+        builder.use Hull::Request::Auth, credentials
+        builder.use Faraday::Request::UrlEncoded
+        builder.use FaradayMiddleware::Caching, cache_store unless cache_store.nil?
+        builder.use FaradayMiddleware::ParseJson
+        builder.use Faraday::Response::RaiseError
+        builder.adapter(adapter)
+      end
+    end
+  end
+end

data/lib/hull/core_ext/hash.rb

@@ -0,0 +1,19 @@
+class Hash
+
+  # Merges self with another hash, recursively
+  #
+  # @param hash [Hash] The hash to merge
+  # @return [Hash]
+  def deep_merge(hash)
+    target = self.dup
+    hash.keys.each do |key|
+      if hash[key].is_a?(Hash) && self[key].is_a?(Hash)
+        target[key] = target[key].deep_merge(hash[key])
+        next
+      end
+      target[key] = hash[key]
+    end
+    target
+  end
+
+end

data/lib/hull/paywall.rb

@@ -0,0 +1,127 @@
+require 'json'
+
+module Hull
+
+  class Paywall
+
+
+    class Request
+
+      attr_reader :user_id, :authorized_contents
+
+      def initialize env, secret
+        @env      = env
+        @secret   = secret
+        @request  = Rack::Request.new(env)
+        @user_id  = Hull.authenticate_user(env)
+        @cookie_name = "_hull_p#{Hull.app_id}"
+        raw_cookie = @request.cookies[@cookie_name]
+        if raw_cookie
+          decoded_cookie = Base64.decode64(raw_cookie) rescue nil
+          sig, val = JSON.parse(decoded_cookie) rescue []
+          @authorized_contents = check_signature(sig, val) ? val : []
+        end
+        @authorized_contents ||= []
+      end
+
+      def sign val
+        OpenSSL::HMAC.hexdigest(OpenSSL::Digest::Digest.new('sha1'), @secret, val)
+      end
+
+      def check_signature sig, val
+        return false unless @user_id
+        return false if sig.nil? || val.nil?
+        sig == sign(val.to_json)
+      end
+
+      def fetch_authorized_contents
+        return [] if @user_id.nil?
+        badges = Hull.get("#{user_id}/badges") || []
+        @authorized_contents = badges.map do |badge|
+          if badge['data'] && badge['data']['transactions']
+            badge['data']['transactions'].map do |k,t|
+              t['permalink']
+            end
+          end
+        end.compact.flatten.uniq.sort
+        @authorized_contents
+      end
+
+      def check_authorization_for key
+        return false unless @user_id
+        @authorized_contents.include?(key) or fetch_authorized_contents.include?(key)
+      end
+
+      def set_cookie headers
+        if !@user_id.nil? && @authorized_contents.length > 0
+          signed_cookie = Base64.encode64([sign(@authorized_contents.to_json), @authorized_contents].to_json)
+          Rack::Utils.set_cookie_header!(headers, @cookie_name, {
+            :value => signed_cookie,
+            :path => "/"
+          })
+        else
+          Rack::Utils.delete_cookie_header!(headers, @cookie_name, {
+            :path => "/"
+          })
+        end
+      end
+
+    end
+
+    def initialize app, options={}
+      @app      = app
+      @options  = options
+      Hull.configure do |config|
+        config.app_id      = @options[:app_id]      || ENV['HULL_APP_ID']
+        config.app_secret  = @options[:app_secret]  || ENV['HULL_APP_SECRET']
+        config.endpoint    = @options[:endpoint]    || ENV['HULL_ORG_URL']
+      end
+      @paths = @options[:paths].map { |k,v| [Regexp.new(k), v] }
+    end
+
+    def secure_content env, rule
+      paywall = Hull::Paywall::Request.new(env, Hull.app_secret)
+      if paywall.check_authorization_for(rule[:permalink])
+        status, headers, body = @app.call(env)
+        paywall.set_cookie(headers)
+        [status, headers, body]
+      else
+        status  = 302
+        redirect_to = rule[:redirect] || '/'
+        headers = { 'Content-Type' => 'text/html' }
+        body = ''
+        if env['PATH_INFO'] != redirect_to
+          headers['Location'] = redirect_to
+        else
+          status  = 401
+          body    = "Access Denied..."
+        end
+        paywall.set_cookie(headers)
+        [status, headers, [body]]
+      end
+      
+    end
+
+    def content_rule_for(path)
+      ret = false
+      @paths.map do |p|
+        match, rule = p
+        break if ret
+        ret = rule if match && match =~ path
+      end
+      ret
+    end
+
+    def call env
+      rule = content_rule_for(env['PATH_INFO'])
+
+      if rule
+        secure_content(env, rule)
+      else
+        @app.call(env)
+      end
+    end
+
+  end
+
+end

data/lib/hull/request.rb

@@ -0,0 +1,52 @@
+module Hull
+  # Defines HTTP request methods
+  module Request
+    
+    # Perform an HTTP DELETE request
+    def delete(path, params={}, options={})
+      request(:delete, api_path(path), params, options)
+    end
+
+    # Perform an HTTP GET request
+    def get(path, params={}, options={})
+      request(:get, api_path(path), params, options)
+    end
+
+    # Perform an HTTP POST request
+    def post(path, params={}, options={})
+      request(:post, api_path(path), params, options)
+    end
+
+    # Perform an HTTP PUT request
+    def put(path, params={}, options={})
+      request(:put, api_path(path), params, options)
+    end
+
+  private
+
+    def api_path path
+      if path =~ /^\//
+        path.to_s
+      else
+        "/api/v1/#{path.to_s.gsub(/^\//, '')}"
+      end
+    end
+
+    # Perform an HTTP request
+    def request(method, path, params={}, options={})
+      Hull.log("#{method.upcase} #{path} - params: #{params.to_json}")
+      response = connection(options).run_request(method, nil, nil, nil) do |request|
+        request.options[:raw] = true if options[:raw]
+        case method.to_sym
+        when :delete, :get
+          request.url(path, params)
+        when :post, :put
+          request.path = path
+          request.body = params unless params.empty?
+        end
+      end
+      options[:raw] ? response : response.body
+    end
+
+  end
+end

data/lib/hull/request/auth.rb

@@ -0,0 +1,19 @@
+require 'digest/md5'
+
+module Hull
+  module Request
+    class Auth  < Faraday::Middleware
+
+      def call(env)
+        env[:request_headers]["Hull-Access-Token"] = @credentials[:app_secret]
+        env[:request_headers]["Hull-App-id"] = @credentials[:app_id]
+        @app.call(env)
+      end
+
+      def initialize(app, credentials)
+        @app, @credentials = app, credentials
+      end
+
+    end
+  end
+end

data/lib/hull/version.rb

@@ -0,0 +1,3 @@
+module Hull
+  VERSION = "0.1.0"
+end

data/lib/hullio.rb

@@ -0,0 +1 @@
+require 'hull'

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: hullio
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Stephane Bellity
+- Hull
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mime-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.3.9
+    - - <
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.3.9
+    - - <
+      - !ruby/object:Gem::Version
+        version: '4'
+description: Hull Ruby Client
+email:
+- stephane@hull.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- hullio.gemspec
+- lib/hull.rb
+- lib/hull/client.rb
+- lib/hull/config.rb
+- lib/hull/connection.rb
+- lib/hull/core_ext/hash.rb
+- lib/hull/paywall.rb
+- lib/hull/request.rb
+- lib/hull/request/auth.rb
+- lib/hull/version.rb
+- lib/hullio.rb
+homepage: http://hull.io
+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.0.3
+signing_key: 
+specification_version: 4
+summary: Hull Ruby Client
+test_files: []