mode 0.0.5 → 0.0.7

data/lib/mode/auth/access_token.rb

@@ -0,0 +1,23 @@
+module Mode
+  module Auth
+    class AccessToken
+      attr_reader :resource
+
+      def initialize(resource)
+        @resource = resource
+      end
+
+      def name
+        resource.name
+      end
+
+      def token
+        resource.token
+      end
+
+      def account_name
+        resource.account_name
+      end
+    end
+  end
+end

data/lib/mode/cli.rb

@@ -1,7 +1,7 @@
 require 'mode/cli/helpers'
 
 require 'mode/cli/base'
-require 'mode/cli/setup'
-require 'mode/cli/import'
+require 'mode/cli/login'
 require 'mode/cli/analyze'
-require 'mode/cli/package'
+require 'mode/cli/import'
+require 'mode/cli/connect'

data/lib/mode/cli/analyze.rb

@@ -1,7 +1,7 @@
 module Mode
   module CLI
     class Base < Thor
-      desc "analyze PATH [--field=POSITION] [--match-type=TYPE]", "Analyzes a dataset or a field "
+      desc "analyze PATH [--field=POSITION] [--match-type=TYPE]", "Analyze a CSV file"
       option :sample, :banner => 'RATE', :desc => "Proportion of rows to inspect. Example: 0.5"
       option :field, :banner => 'POSITION', :desc => "Field positions begin at 0. Example: 10"
       option :match_type, :banner => 'TYPE', :desc => "One of the following: string, number, integer, datetime, boolean"

data/lib/mode/cli/base.rb

@@ -7,6 +7,11 @@ module Mode
       #  And then I'd have an explicit list of the commands we were including
       #
 
+      desc "version", "Print the version of the mode installed mode CLI"
+      def version
+        say "Mode CLI Version #{Mode::VERSION}"
+      end
+
       private
       
       include Mode::CLI::Helpers

data/lib/mode/cli/connect.rb

@@ -0,0 +1,18 @@
+module Mode
+  module CLI
+    class Base < Thor
+      desc "connect start|stop|restart [-c CONCURRENCY]", "Connect external databases to Mode"
+      option :concurrency, :aliases => :c, :default => 4
+      option :host, :default => 'www.modeanalytics.com'
+      def connect(command)
+        if ['start', 'stop', 'restart'].include?(command)
+          Mode::Commands::Connect.new(command, options).execute
+        else
+          say "Error: valid commands for connect are start, stop and restart"
+        end
+      rescue => err
+        say "Error: #{err.message}"
+      end
+    end
+  end
+end

data/lib/mode/cli/helpers.rb

@@ -8,15 +8,6 @@ module Mode
       def valid_table?(table)
         table =~ /[\w\d\_\-]+\/[\w\d\_\-]+/
       end
-
-      def pkg_name(path)
-        path.split('/').last.split('.').first
-      end
-
-      def sample_rate(path)
-        file_size = File.size(path)
-        DataKit::CSV::Analyzer.sample_rate(file_size)
-      end
     end
   end
 end

data/lib/mode/cli/import.rb

@@ -1,28 +1,22 @@
 module Mode
   module CLI
     class Base < Thor
-      desc "import SOURCE ACCOUNT/TABLENAME [--update | --replace]", "Import a flat file into the Mode data warehouse"
+      desc "import SOURCE ACCOUNT/TABLENAME [--replace]", "Import a flat file into the Mode data warehouse", :hide => true
       long_desc <<-LONGDESC
-        The import commands allows you to create, update and
-        replace tables in the Mode data warehouse with data from
-        flat files and data packages. The default action is create
-        with optional flags to update or replace a table.
+        The import commands allows you to create or replace tables 
+        in the Mode data warehouse with data from flat files and
+        data packages. The default action is create with an optional
+        flag to replace the table.
 
-        Data can be imported from one of three source types
+        Data can be imported from CSV files or data packages with the following command
 
         1. CSV File
         \x5> $ mode import gdp_quarterly.csv besquared/gdp_quarterly
 
-        2. JSON File (LD-JSON)
-        \x5> $ mode import gdp_quarterly.json besquared/gdp_quarterly 
+        2. Data Package File
+        \x5> $ mode import gdp/data/quarterly.json besqaured/quarterly_gdp
 
-        3. Data Package
-        \x5> $ mode import gdp_us/quarterly besquared/gdp_quarterly
-
-
-        Note: If you do not specify a data package resource name we'll attempt to use the first resource in the package.
       LONGDESC
-      option :update, :type => :boolean
       option :replace, :type => :boolean
       option :primary_key, :banner => 'pos1[,pos2,...] (ex: 0,2)'
       def import(source, table)
@@ -31,31 +25,8 @@ module Mode
           return
         end
 
-        if File.directory?(source)
-          unless Mode::Package::Base.exist?(source)
-            error "Error: Invalid package given"
-            return
-          end
-
-          package, resource_name = *source.split('/')
-          package = Mode::Package::Base.open(source)
-        else
-          unless valid_file?(source)
-            error "Error: Invalid source file given"
-            return
-          end
-
-          dst_path = Dir.mktmpdir
-          src_data = Mode::CSV::Parser.new(source)
-          builder = Mode::Package::Builder.new(src_data, dst_path, pkg_name(source), sample_rate(source))
-
-          package = builder.execute # make the package
-        end
-
         account, table_name = *table.split('/')
-        resource_name = package.resources.first.name
-        
-        Mode::Commands::Import.new(account, table_name, package, resource_name).execute
+        Mode::Commands::Import.new(source, account, table_name).execute
       end
     end
   end

data/lib/mode/cli/login.rb

@@ -0,0 +1,13 @@
+module Mode
+  module CLI
+    class Base < Thor
+      desc "login", "Setup a new mode configuration in the given directory (defaults to home)"
+      option :host, :default => 'www.modeanalytics.com'
+      option :staging, :type => :boolean
+      option :development, :type => :boolean
+      def login
+        Mode::Commands::Login.new(options).execute
+      end
+    end
+  end
+end

data/lib/mode/cli/package.rb

@@ -4,11 +4,8 @@ module Mode
       desc "package SOURCE PACKAGEPATH [--name=NAME] [--resource-name=NAME]", "Creates a new data package from a csv file"
       option :name, :desc => 'The name of the package'
       option :resource_name, :default => 'data', :desc => 'The name of the resource in package'
-      def package(source, dest)
-        parts = dest.split(File::Separator)
-
-        name = options[:name] || parts.last
-        package_path = parts.length == 1 ? parts.first : parts[0, parts.length - 1]
+      def package(source, package_path)
+        name = options[:name] || package_path.split(File::Separator).last
         Mode::Commands::Package.new(source, package_path, name, options[:resource_name]).execute
       end
     end

data/lib/mode/commands/analyze_field.rb

@@ -2,7 +2,9 @@ require 'terminal-table'
 
 module Mode
   module Commands
-    class AnalyzeField < Thor
+    class AnalyzeField
+      include Mode::Commands::Helpers
+
       attr_accessor :path
       attr_accessor :field_pos
       attr_accessor :options
@@ -13,34 +15,31 @@ module Mode
         @options = options
       end
 
-      no_commands do
-        include Mode::Commands::Helpers
-
-        def execute
-          if path.nil? || !File.exist?(path)
-            error "Couldn't find file at #{path}"
-            return
-          end
+      def execute
+        if path.nil? || !File.exist?(path)
+          puts "Error: Couldn't find file at #{path}"
+          return
+        end
 
-          csv = DataKit::CSV::Parser.new(path)
+        csv = DataKit::CSV::Parser.new(path)
 
-          field_name = csv.headers[field_pos]
+        field_name = csv.headers[field_pos]
 
-          say "Analyzing #{field_name} at #{path || 'input'}"
+        puts "Analyzing #{field_name} at #{path || 'input'}"
 
-          analysis, total_time = timer_block do
-            DataKit::CSV::FieldAnalyzer.analyze(csv, field_pos, {
-              :match_type => match_type, :sampling_rate => 1
-            })
-          end
+        analysis, total_time = timer_block do
+          DataKit::CSV::FieldAnalyzer.analyze(csv, field_pos, {
+            :match_type => match_type, :sampling_rate => 1
+          })
+        end
 
-          say "Analyzed #{analysis.row_count} rows in #{'%.2f' % total_time} seconds\n"
+        puts "Analyzed #{analysis.row_count} rows in #{'%.2f' % total_time} seconds\n"
 
-          display(analysis)
-        end
+        display(analysis)
       end
 
       private
+
       def display(analysis)
         table = Terminal::Table.new(:headings => [
           'Row No.', 'Type', 'Value'
@@ -52,7 +51,7 @@ module Mode
           end
         end
 
-        say table
+        puts table
       end
 
       def match_type

data/lib/mode/commands/analyze_schema.rb

@@ -2,7 +2,9 @@ require 'terminal-table'
 
 module Mode
   module Commands
-    class AnalyzeSchema < Thor
+    class AnalyzeSchema
+      include Mode::Commands::Helpers
+
       attr_accessor :path
       attr_accessor :options
 
@@ -11,79 +13,98 @@ module Mode
         @options = options
       end
 
-      no_commands do
-        include Mode::Commands::Helpers
-
-        def execute
-          if path.nil? || !File.exist?(path)
-            error "Couldn't find file at #{path}"
-            return
-          end
-
-          csv = DataKit::CSV::Parser.new(path)
+      def execute
+        if path.nil? || !File.exist?(path)
+          puts "Error: Couldn't find file at #{path}"
+          return
+        end
 
-          say "Analyzing #{path || 'input'} (Sampling #{'%.2f' % (100 * sampling_rate)}%)..."
+        csv = build_csv
+        analysis = build_analysis(csv)
+        display_analysis(analysis)
+      end
 
-          analysis, total_time = timer_block do
-            DataKit::CSV::SchemaAnalyzer.analyze(csv, :sampling_rate => sampling_rate)
-          end
+      private
 
-          puts analysis.use_type_hints
+      def build_csv
+        DataKit::CSV::Parser.new(path)
+      end
 
-          say "Analyzed #{analysis.sample_count} of #{analysis.row_count} rows in #{'%.2f' % total_time} seconds\n"
+      def build_analysis(csv)
+        puts "Analyzing #{path || 'input'} (Sampling #{'%.2f' % (100 * sampling_rate)}%)..."
 
-          display(analysis)
+        analysis, total_time = timer_block do
+          DataKit::CSV::SchemaAnalyzer.analyze(csv, :sampling_rate => sampling_rate)
         end
-      end
 
-      private
+        puts "Analyzed #{analysis.sample_count} of #{analysis.row_count} rows in #{'%.2f' % total_time} seconds\n"
 
-      def format_percentage_cell(numerator, denominator)
-        cell = { :alignment => :right }
+        analysis
+      end
 
-        if numerator == 0
-          cell[:value] = nil
-        else
-          cell[:value] = '%.2f' % (100 * (numerator / denominator.to_f)) + '%'
-        end
+      def sampling_rate
+        file_size = File.size(path)
+        (options[:sample] || DataKit::CSV::SchemaAnalyzer.sampling_rate(file_size)).to_f
+      end
 
-        cell
+      def display_analysis(analysis)
+        table = build_table
+        populate_table(analysis, table)
+        puts table
       end
 
-      def display(analysis)
-        table = Terminal::Table.new(:headings => [
+      def build_table
+        Terminal::Table.new(:headings => [
           'Field No.', 'Field', 'Type', 
           'String (%)', 'Integer (%)', 'Number (%)',
           'Date/Time (%)', 'Boolean (%)', 'Empty (%)'
         ])
+      end
 
+      def populate_table(analysis, table)
         analysis.fields.each_with_index do |field_name, index|
-          row = [index, field_name]
+          build_table_row(analysis, table, field_name, index)
+        end
+      end
 
-          field_type = analysis.type?(field_name)
+      def build_table_row(analysis, table, field_name, index)
+        row = [index, field_name]
 
-          if analysis.has_single_type?(field_name)
-            row << field_type
-          elsif analysis.has_only_numeric_types?(field_name)
-            row << field_type
-          else
-            row << '** ' + field_type.to_s
-          end
+        append_row_type(analysis, field_name, row)
+        append_row_type_counts(analysis, field_name, row)
 
-          DataKit::Dataset::Field::Types.each do |type|
-            type_count = analysis.type_count(field_name, type)
-            row << format_percentage_cell(type_count, analysis.sample_count)
-          end
+        table.add_row(row)
+      end
+
+      def append_row_type(analysis, field_name, row)
+        field_type = analysis.type?(field_name)
 
-          table.add_row(row)
+        if analysis.has_single_type?(field_name)
+          row << field_type
+        elsif analysis.has_only_numeric_types?(field_name)
+          row << field_type
+        else
+          row << '** ' + field_type.to_s
         end
+      end
 
-        say table
+      def append_row_type_counts(analysis, field_name, row)
+        DataKit::Dataset::Field::Types.each do |type|
+          type_count = analysis.type_count(field_name, type)
+          row << format_percentage_cell(type_count, analysis.sample_count)
+        end
       end
 
-      def sampling_rate
-        file_size = File.size(path)
-        (options[:sample] || DataKit::CSV::SchemaAnalyzer.sampling_rate(file_size)).to_f
+      def format_percentage_cell(numerator, denominator)
+        cell = { :alignment => :right }
+
+        if numerator == 0
+          cell[:value] = nil
+        else
+          cell[:value] = '%.2f' % (100 * (numerator / denominator.to_f)) + '%'
+        end
+
+        cell
       end
     end
   end

data/lib/mode/commands/connect.rb

@@ -0,0 +1,78 @@
+module Mode
+  module Commands
+    class Connect
+
+      include Mode::Commands::Helpers
+
+      attr_reader :command
+      attr_reader :concurrency
+      attr_reader :configuration
+
+      def initialize(command, options = {})
+        @command = command
+        @concurrency = options[:concurrency] || 4
+
+        validate!
+
+        @configuration = Mode::Connector::Config.new(config_dir)
+      end
+
+      def execute
+        register! if ['start', 'restart'].include?(command)
+        spawn!
+      end
+
+      private
+
+      def validate!
+        require_config!
+        require_credentials!
+        require_connect_config!
+        configure_api_requests!
+      end
+
+      def register!
+        Mode::Connector::Registrar.new(configuration).perform!
+      end
+
+      def spawn!
+        if command == 'restart'
+          spawn_restart!
+        elsif ['stop', 'start'].include?(command)
+          spawn_command!(command)
+        else
+          raise "Unknown command #{command}"
+        end
+      end
+
+      def spawn_restart!
+        begin
+          spawn_command!('stop')
+        ensure
+          spawn_command!('start')
+        end
+      end
+
+      def spawn_command!(command)
+        Mode::Connector::Daemon.spawn!(spawn_opts, spawn_args(command))
+      end
+
+      def spawn_opts
+        {
+          :sync_log => true,
+          :working_dir => working_dir,
+          :log_file => File.join(working_dir, 'connect.log'),
+          :pid_file => File.join(working_dir, 'connect.pid')
+        }
+      end
+
+      def spawn_args(command)
+        [command, concurrency, configuration.data_sources]
+      end
+
+      def working_dir
+        @working_dir ||= File.expand_path('~/.mode')
+      end
+    end
+  end
+end