mode 0.0.5 → 0.0.7

data/lib/mode/connector/type_map.rb

@@ -0,0 +1,45 @@
+module Mode
+  module Connector
+    class TypeMap
+      include Enumerable
+
+      attr_reader :types
+
+      def initialize
+        @types = {}
+      end
+
+      def each(&block)
+        types.each do |name, value|
+          yield name, type?(name)
+        end
+      end
+
+      def insert(row)
+        row.each do |name, value|
+          types[name] ||= {}
+          types[name][type(value)] ||= 1
+        end
+      end
+
+      def type(value)
+        if value.kind_of?(Integer)
+          :integer
+        elsif value.kind_of?(Float)
+          :number
+        elsif value.kind_of?(Date) || value.kind_of?(Time)
+          :datetime
+        elsif value.kind_of?(TrueClass) || value.kind_of?(FalseClass)
+          :boolean
+        else
+          :string
+        end
+      end
+
+      def type?(name)
+        keys = types[name].keys
+        keys.compact.length == 1 ? keys.first : :string
+      end
+    end
+  end
+end

data/lib/mode/connector/uploader.rb

@@ -0,0 +1,50 @@
+module Mode
+  module Connector
+    class Uploader
+      attr_reader :path
+      attr_reader :dataset
+
+      def initialize(path, dataset)
+        @path = path
+        @dataset = dataset
+      end
+
+      def perform!
+        Mode::API::Request.put(
+          path,
+          :execution => {
+            :dataset => {
+              :content => content,
+              :columns => JSON.generate(columns)
+            }
+          }
+        )
+      end
+
+      class << self
+        def error!(path, message, detail = nil)
+          Mode::API::Request.put(path,
+            :execution => {
+              :error => {
+                :detail => detail,
+                :message => message
+              }
+            }
+          )
+        end
+      end
+
+      private
+
+      def columns
+        dataset.column_types.map do |name, type|
+          {:name => name, :type => type}
+        end
+      end
+
+      def content
+        Faraday::UploadIO.new(dataset.path, 'applicaton/octet-stream')
+      end
+    end
+  end
+end

data/lib/mode/logger.rb

@@ -0,0 +1,202 @@
+require 'logger'
+
+#
+# LEVEL [TIME] COMPONENT: MESSAGE
+# ! Detail Line 1
+# ! Detail Line 2
+#
+# All timestamps are in UTC and ISO 8601 format.
+#
+# You can grep for messages of a specific level really easily:
+#
+# tail -f mode.log | grep '^WARN'
+# You can grep for messages from a specific component really easily:
+#
+# tail -f mode.log | grep 'Connector::Config'
+# You can even pull out full exception stack traces, plus the accompanying log message:
+#
+# tail -f mode.log | grep -B 1 '^\!'
+#
+
+#
+# Modified singleton that allows replacement which is very useful for testing
+#
+
+module Mode
+  class Logger
+    # For Convenience
+    DEBUG = ::Logger::DEBUG
+    WARN  = ::Logger::WARN
+    INFO  = ::Logger::INFO
+    ERROR = ::Logger::ERROR
+    FATAL = ::Logger::FATAL
+
+    attr_reader :logger
+    attr_reader :mutex
+
+    attr_reader :enabled
+
+    def initialize(options = {})
+      @enabled = true
+      @mutex = Mutex.new # Keep it secret, keep it safe
+
+      path = options[:path] || self.class.default_path
+      level = options[:level] || self.class.default_level
+      formatter = options[:formatter] || self.class.default_formatter
+
+      @logger = ::Logger.new(path, rotate_freq)
+
+      set_log_level(level)
+      set_log_formatter(formatter)
+    end
+
+    def disable!
+      mutex.synchronize { @enabled = false }
+    end
+
+    def enable!
+      mutex.synchronize { @enabled = true }
+    end
+
+    def debug(component, message, detail = [])
+      log_with_formatting(Logger::DEBUG, component, message, detail)
+    end
+
+    def debug!
+      set_log_level(Logger::DEBUG)
+    end
+
+    def info(component, message, detail = [])
+      log_with_formatting(Logger::INFO, component, message, detail)
+    end
+
+    def info!
+      set_log_level(Logger::INFO)
+    end
+
+    def warn(component, message, detail = [])
+      log_with_formatting(Logger::WARN, component, message, detail)
+    end
+
+    def warn!
+      set_log_level(Logger::WARN)
+    end
+
+    def error(component, message, detail = [])
+      log_with_formatting(Logger::ERROR, component, message, detail)
+    end
+
+    def error!
+      set_log_level(Logger::ERROR)
+    end
+
+    def fatal(component, message, detail = [])
+      log_with_formatting(Logger::FATAL, component, message, detail)
+    end
+
+    def fatal!
+      set_log_level(Logger::FATAL)
+    end
+
+    class << self
+      attr_reader :mutex
+      attr_reader :instance
+
+      def instance(logger = nil)
+        @mutex ||= Mutex.new
+
+        if logger
+          mutex.synchronize do
+            @instance = logger
+          end
+        else
+          @instance ||= new
+        end
+      end
+
+      def default_level
+        Logger::INFO
+      end
+
+      def default_path
+        File.join(mode_path, 'mode.log') # This should come from config
+      end
+
+      def default_rotate_freq
+        'weekly'
+      end
+
+      def default_formatter
+        @default_formatter ||= Proc.new do |severity, datetime, progname, message|
+          "#{severity} [#{format_time(datetime)}]: #{message}\n"
+        end
+      end
+
+      def format_time(time)
+        time_to_datetime(time).new_offset(0).iso8601
+      end
+
+      def time_to_datetime(time)
+        #
+        # http://stackoverflow.com/questions/279769/convert-to-from-datetime-and-time-in-ruby
+        #
+        seconds = time.sec + Rational(time.usec, 10**6)
+        offset = Rational(time.utc_offset, 60 * 60 * 24)
+        DateTime.new(time.year, time.month, time.day, time.hour, time.min, seconds, offset)
+      end
+
+      private
+
+      def mode_path
+        FileUtils.mkdir_p(File.expand_path("~/.mode"))
+      end
+    end
+
+    private
+
+    def rotate_freq
+      self.class.default_rotate_freq
+    end
+
+    def set_log_level(level)
+      @logger.level = level
+    end
+
+    def set_log_formatter(formatter)
+      @logger.formatter = formatter
+    end
+
+    def log_with_formatting(severity, component, message, detail = [])
+      mutex.synchronize do
+        return unless enabled
+
+        set_log_formatter(component_formatter(component))
+
+        logger.add(severity, message)
+
+        if detail.length > 0
+          set_log_formatter(detail_formatter)
+
+          detail.each do |message|
+            logger.add(severity, message)
+          end
+        end
+
+        set_log_formatter(self.class.default_formatter)
+      end
+    end
+
+    def component_formatter(component)
+      @component_formatter ||= Proc.new do |severity, datetime, progname, message|
+        datetime = self.class.format_time(datetime)
+        "#{severity} [#{datetime}] #{component}: #{message}\n"
+      end
+    end
+
+    def detail_formatter
+      @detail_formatter ||= Proc.new do |severity, datetime, progname, message|
+        "! #{message}\n"
+      end
+    end
+  end
+end

data/lib/mode/version.rb

@@ -1,3 +1,3 @@
 module Mode
-  VERSION = "0.0.5"
+  VERSION = "0.0.7"
 end

data/mode.gemspec

@@ -18,14 +18,25 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  # Runtime Dependencies
+  # CLI
   spec.add_runtime_dependency "thor"
   spec.add_runtime_dependency "terminal-table"
 
-  # Our Libraries
+  # Data Packaging
   spec.add_runtime_dependency "data_kit"
   spec.add_runtime_dependency "data_package"
 
+  # HTTP
+  spec.add_runtime_dependency "faraday"
+  spec.add_runtime_dependency "uri_template"
+
+  # Connectivity
+  spec.add_runtime_dependency "sequel"
+
+  # Concurrency & Processes
+  spec.add_runtime_dependency "daemon-spawn"
+  spec.add_runtime_dependency "rufus-scheduler"
+  
   # Development Dependencies
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"

data/spec/api/form_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Mode::API::Link do
+  let(:content) {
+    {
+      'method' => 'post',
+      'action' => '/resources',
+      'input' => {
+        'resource' => {
+          'name' => {
+            'type' => 'text',
+            'value' => ''
+          },
+          'widgets' => {
+            'type' => 'text',
+            'value' => '500'
+          }
+        }
+      }
+    }
+  }
+  
+  before do
+    initialize_logger
+  end
+
+  it "initializes with content" do
+    form = Mode::API::Form.new(content)
+    form.method.should == content['method']
+    form.action.should == content['action']
+    form.input('resource').should == content['input']['resource']
+  end
+
+  it "submits with params" do
+    params = {
+      'resource' => {
+        'name' => 'test'
+      }
+    }
+
+    Mode::API::Request.should_receive(:post).with('/resources', {
+      'resource' => {
+        'name' => 'test',
+        'widgets' => '500'
+      }
+    }).and_return(:response)
+
+    form = Mode::API::Form.new(content)
+    form.submit!(params).should == :response
+  end
+end

data/spec/api/link_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Mode::API::Link do
+  let(:content) {
+    {
+      'templated' => true,
+      'href' => '/path/to{/thing}{?q}',      
+    }
+  }
+  
+  before do
+    initialize_logger
+  end
+
+  it "initializes with content" do
+    link = Mode::API::Link.new(content)
+    link.href.should == content['href']
+    link.templated.should == content['templated']
+
+    link.expand(:thing => 't').should == "/path/to/t"
+    link.expand(:thing => 't', :q => 'query').should == "/path/to/t?q=query"
+  end
+end

data/spec/api/request_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe Mode::API::Request do
+  let(:username) { 'besquared' }
+  let(:access_token) { 'access_token '}
+
+  before do
+    Mode::API::Request.configure(:test, {
+      :credentials => {
+        :username => username,
+        :access_token => access_token
+      }
+    })
+  end
+  
+  before do
+    initialize_logger
+  end
+
+  it 'initializes with default values' do
+    request = Mode::API::Request.new(:get, '/packages')
+    request.method.should == :get
+    request.path.should == '/packages'
+    request.params.should == {}
+
+    http = double(:http)
+    request.should_receive(:http).and_return(http)
+
+    response = double(:response,
+      :body => '{}', :success? => true, :status => 200)
+    http.should_receive(:get).and_return(response)
+
+    request.perform.should be_instance_of(Mode::API::Resource)
+  end
+
+  it 'validates configuration' do
+    Mode::API::Request.should_receive(:valid?).and_return(false)
+    expect { Mode::API::Request.validate! }.to raise_error
+  end
+
+  it 'has environment host' do
+    hosts = {
+      'test'        => 'test',
+      'development' => 'localhost',
+      'staging'     => 'staging.modeanalytics.com',
+      'production'  => 'www.modeanalytics.com'
+    }
+
+    hosts.each do |env, host|
+      Mode::API::Request.configure(env, {})
+      Mode::API::Request.send(:env_host).should == host
+    end
+  end
+
+  it "has bookmarked paths" do
+    Mode::API::Request.access_tokens_path.should == \
+      '/api/besquared/access_tokens'
+
+    Mode::API::Request.packages_path.should == \
+      '/api/besquared/packages'
+
+    Mode::API::Request.data_source_connections_path.should == \
+      '/api/besquared/data_source_connections'
+
+    Mode::API::Request.data_source_connection_path.should == \
+      '/api/besquared/data_source_connections/access_token'
+
+    Mode::API::Request.data_source_connection_messages_path.should == \
+      '/api/besquared/data_source_connections/access_token/messages'
+  end
+
+  it 'has http object' do
+    # make this more robust
+    Mode::API::Request.send(:http).should_not == nil
+  end
+
+  it 'has shortcut methods' do
+    response = { :body => '{}', :success? => true, :status => 200 }
+
+    http = double(:http, {
+      :head => double(:head, response),
+      :get => double(:get, response),
+      :post => double(:post, response),
+      :put => double(:put, response),
+      :delete => double(:delete, response)
+    })
+
+    Mode::API::Request.should_receive(:http).exactly(5).times.and_return(http)
+
+    Mode::API::Request.head('/packages/1')
+    Mode::API::Request.get('/packages/1')
+    Mode::API::Request.post('/packages')
+    Mode::API::Request.put('/packages/1')
+    Mode::API::Request.delete('/packages/1')
+  end
+
+  it 'return log error and return raw response on request errors' do
+    response = double(:get, { 
+      :status => 500,
+      :success? => false,
+      :body => '{"error": "failed"}'
+    })
+
+    http = double(:http, { :get => response })
+    Mode::API::Request.should_receive(:http).and_return(http)
+
+    request = Mode::API::Request.new(:get, '/packages/1')
+    Mode::Logger.instance.should_receive(:error)
+    request.perform.should == response
+  end
+end