chimps-cli 0.0.1

data/lib/chimps-cli/utils.rb

@@ -0,0 +1,13 @@
+module Chimps
+
+  # Raised when the user provides bad input on the command line.
+  CLIError = Class.new(Error)
+  
+  module Utils
+    autoload :ActsOnResource,     'chimps-cli/utils/acts_on_resource'
+    autoload :UsesParamValueData, 'chimps-cli/utils/uses_param_value_data'
+    autoload :HttpFormat,         'chimps-cli/utils/http_format'
+    autoload :ExplicitPath,       'chimps-cli/utils/explicit_path'
+  end
+
+end

data/lib/chimps-cli/utils/acts_on_resource.rb

@@ -0,0 +1,93 @@
+module Chimps
+  module Utils
+
+    # Defines methods which can be included by a Chimps::Command to
+    # let it interpret an optional first argument as the name of a
+    # resource to act on.
+    module ActsOnResource
+
+      def self.included klass
+        klass.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def default_resources_type
+          'datasets'
+        end
+
+        def default_resource_type
+          normalize_resource_name(default_resources_type)
+        end
+
+        def allowed_resources
+          %w[dataset collection source license]
+        end
+        
+        def resources_listing
+          doc = <<DOC
+In addition to #{default_resources_type}, this command can operate on
+other resources at Infochimps as well.  If the first
+argument passed is one of
+
+DOC
+          allowed_resources.each do |resource|
+            doc << "  #{resource}\n"
+          end
+
+          doc << "\nthen this command will act on that resource instead."
+        end
+
+        def normalize_resource_name string
+          string.to_s.downcase.gsub(/s$/,'')
+        end
+        
+      end
+
+      def first_arg_is_resource_type?
+        return false if config.argv.size < 2
+        self.class.allowed_resources.include?(self.class.normalize_resource_name(config.argv[1]))
+      end
+
+      def resource_type
+        (first_arg_is_resource_type? && self.class.normalize_resource_name(config.argv[1])) || self.class.default_resource_type
+      end
+
+      def plural_resource
+        # i miss you DHH
+        if resource_type[-1].chr == 'y'
+          resource_type[1..-1] + 'ies'
+        else
+          resource_type + 's'
+        end
+      end
+
+      def has_resource_identifier?
+        if first_arg_is_resource_type?
+          config.argv.size >= 2 && (! config.argv[1].empty?) && config.argv[2]
+        else
+          config.argv.size >= 1 && (! config.argv.first.empty?) && config.argv[1]
+        end
+      end
+
+      def resource_identifier
+        raise CLIError.new(self.class::USAGE) unless has_resource_identifier?
+        first_arg_is_resource_type? ? config.argv[2] : config.argv[1]
+      end
+      
+      def resources_path
+        if config[:my]
+          "/my/#{plural_resource}"
+        else
+          "/#{plural_resource}"
+        end
+      end
+
+      def resource_path
+        "#{plural_resource}/#{resource_identifier}"
+      end
+      
+    end
+  end
+end
+
+    

data/lib/chimps-cli/utils/explicit_path.rb

@@ -0,0 +1,30 @@
+module Chimps
+  module Utils
+
+    module ExplicitPath
+
+      def raw_path
+        raise CLIError.new(self.class::USAGE) unless config.argv.size > 1
+        config.argv[1]
+      end
+
+      def query_params
+        return {} unless raw_path.include?('?')
+        {}.tap do |h|
+          raw_path.split('?')[1].split('&').each do |pair|
+            name, value = pair.split('=').map { |string| CGI::unescape(string) }
+            h[name] = value
+          end
+        end
+      end
+
+      def path
+        p = raw_path.split('?').first
+        p =~ /\.(\w+)$/i ? p : "#{p}.#{response_fmt}"
+      end
+
+    end
+  end
+end
+
+    

data/lib/chimps-cli/utils/http_format.rb

@@ -0,0 +1,51 @@
+module Chimps
+  module Utils
+
+    module HttpFormat
+
+      def self.included klass
+        klass.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        [:request, :response].each do |type|
+          define_method("default_#{type}_fmt")  { 'json'            }
+          define_method("allowed_#{type}_fmts") { %w[json xml yaml] }
+        end
+        def mime_type_for fmt
+          case fmt.to_s.tr('.','').downcase.to_sym
+          when :json then 'application/json'
+          when :yaml then 'application/x-yaml'
+          when :tsv  then 'text/tab-separated-values'
+          else            'application/json' # default
+          end
+        end
+      end
+
+      def normalize_fmt string
+        string.to_s.downcase.tr('.','')
+      end
+
+      def headers
+        {
+          :content_type => self.class.mime_type_for(request_fmt),
+          :accept       => self.class.mime_type_for(response_fmt)
+        }
+      end
+
+      [:request, :response].each do |type|
+        define_method "#{type}_fmt" do
+          param_name = "#{type}_format".to_sym
+          if config[param_name] && self.class.send("allowed_#{type}_fmts").include?(normalize_fmt(config[param_name]))
+            normalize_fmt(config[param_name])
+          else
+            self.class.send("default_#{type}_fmt")
+          end
+        end
+      end
+
+    end
+  end
+end
+
+    

data/lib/chimps-cli/utils/uses_param_value_data.rb

@@ -0,0 +1,90 @@
+require 'yaml'
+require 'json'
+
+module Chimps
+  module Utils
+    module UsesParamValueData
+
+      def self.included klass
+        klass.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def how_to_input_data
+          <<DOC
+Properties and values can be supplied directly on the command line or
+from an input file with the --data option.
+DOC
+        end
+      end
+
+      def data
+        @data ||= merge_all(*(data_from_stdin + data_from_file + data_from_command_line)) || {}
+      end
+      
+      protected
+
+      def merge_all *objs
+        objs.compact!
+        return if objs.blank?   # raising an error here is left to the caller
+        klasses = objs.map(&:class).uniq
+        raise CLIError.new("Mismatched YAML data types -- Hashes can only be combined with Hashes, Arrays with Arrays") if klasses.size > 1
+        data_type = klasses.first.new
+        case data_type
+        when Array
+          # greater precedence at the end so iterate in order
+          [].tap do |d|
+            objs.each do |obj|
+              d.concat(obj)
+            end
+          end
+        when Hash
+          # greater precedence at the end so iterate in order
+          {}.tap do |d|
+            objs.each do |obj|
+              d.merge!(obj)
+            end
+          end
+        else raise CLIError.new("Incompatible YAML data type #{data_type} -- can only combine Hashes and Arrays")
+        end
+      end
+
+      def data_from_command_line
+        [].tap do |d|
+          config.argv.each_with_index do |arg, index|
+            next unless arg =~ /^(\w+) *=(.*)$/
+            name, value = $1.downcase, $2.strip
+            d << { name => value } # always a hash
+          end
+        end
+      end
+            
+      def data_from_file
+        return [] unless config[:data]
+        [].tap do |d|
+          config[:data].split(',').map { |p| File.expand_path(p) }.each do |path|
+            d << (path =~ /\.ya?ml$/ ? YAML.load_file(path) : JSON.parse(File.read(path)))
+          end
+        end
+      end
+
+      def data_from_stdin
+        return [] unless $stdin.stat.size > 0
+        [].tap do |d|
+          begin
+            YAML.load_stream($stdin).each do |document|
+              d << document
+            end
+          rescue
+            d << JSON.parse($stdin.read)
+          end
+        end
+      end
+
+      def ensure_data_is_present!
+        raise CLIError.new(self.class::USAGE) if data.empty?
+      end
+      
+    end
+  end
+end

data/spec/chimps-cli/commands/delete_spec.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Chimps::Commands::Delete do
+
+  it_behaves_like "a request to an explicit path"
+  it_behaves_like "it can set its response format"
+  
+end
+

data/spec/chimps-cli/commands/get_spec.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Chimps::Commands::Get do
+  it_behaves_like "a request to an explicit path"
+  it_behaves_like "it can set its response format"
+  
+end
+

data/spec/chimps-cli/commands/help_spec.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Chimps::Commands::Help do
+
+  it "should display a default help message when called without arguments" do
+    run_argv("help").stderr.should include("usage: chimps help")
+  end
+
+  it "should display a default help message when called with arguments it doesn't recognize" do
+    run_argv("help", "foobar").stderr.should include("usage: chimps help")
+  end
+  
+  it "should display help on a specific command when called with that command name" do
+    run_argv("help", "show").stderr.should include("usage: chimps show")
+  end
+
+end
+

data/spec/chimps-cli/commands/list_spec.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Chimps::Commands::List do
+  it_behaves_like "it can set its response format"
+  it_behaves_like "it acts on a resource", nil
+end
+

data/spec/chimps-cli/commands/post_spec.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Chimps::Commands::Post do
+
+  it_behaves_like "a request to an explicit path"
+  it_behaves_like "it can set its response format"
+  it_behaves_like "it uses data", nil
+  
+end
+

data/spec/chimps-cli/commands/put_spec.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Chimps::Commands::Put do
+
+  it_behaves_like "a request to an explicit path"
+  it_behaves_like "it can set its response format"
+  it_behaves_like "it uses data", nil
+  
+end
+

data/spec/chimps-cli/commands/show_spec.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Chimps::Commands::Show do
+  it_behaves_like "it can set its response format"
+  it_behaves_like "it acts on a resource", nil
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,52 @@
+CHIMPS_CLI_ROOT_DIR = File.join(File.expand_path(File.dirname(__FILE__)), '..')     unless defined? CHIMPS_CLI_ROOT_DIR
+CHIMPS_CLI_SPEC_DIR = File.join(CHIMPS_CLI_ROOT_DIR, 'spec')                        unless defined? CHIMPS_CLI_SPEC_DIR
+CHIMPS_CLI_LIB_DIR  = File.join(CHIMPS_CLI_ROOT_DIR, 'lib')                         unless defined? CHIMPS_CLI_LIB_DIR
+$: << CHIMPS_CLI_LIB_DIR
+
+require 'rubygems'
+require 'rspec'
+require 'chimps-cli'
+
+Dir[File.dirname(__FILE__) + "/support/*.rb"].each { |path| require path }
+
+TMP_DIR   = "/tmp/chimps_cli_test" unless defined?(TMP_DIR)
+
+def in_tmp_dir &block
+  FileUtils.mkdir_p TMP_DIR
+  FileUtils.cd(TMP_DIR, &block)
+end
+
+def clean_tmp_dir!
+  FileUtils.rm_rf TMP_DIR
+end
+
+def set_argv *args
+  $0 = 'chimps'
+  ::ARGV.replace args
+  Chimps.boot!
+  Chimps.config.command_settings.resolve! if Chimps::CLI.command
+end
+
+def command
+  Chimps::CLI.command
+end
+
+def run
+  old_stdout = $stdout
+  old_stderr = $stderr
+  new_stdout = StringIO.new
+  new_stderr = StringIO.new
+  $stdout = new_stdout
+  $stderr = new_stderr
+  exit_code = Chimps::CLI.execute!
+  $stdout.flush
+  $stderr.flush
+  $stdout = old_stdout
+  $stderr = old_stderr
+  OpenStruct.new(:stdout => new_stdout.string, :stderr => new_stderr.string, :exit_code => exit_code)
+end
+
+def run_argv *args
+  set_argv *args
+  run
+end

data/spec/support/acts_on_resource.rb

@@ -0,0 +1,22 @@
+shared_examples_for 'it acts on a resource' do |required_arg|
+
+  def described_class_command_name
+    described_class.to_s.split('::').last.downcase
+  end
+
+  it "should use the default resource type when not passed any arguments" do
+    set_argv(described_class_command_name, required_arg)
+    command.resource_type.should == described_class.default_resource_type
+  end
+
+  it "should not accept a resource type that isn't allowed" do
+    set_argv(described_class_command_name, required_arg, 'foobar')
+    command.resource_type.should == described_class.default_resource_type
+  end
+
+  it "should accept a resource type that is allowed" do
+    set_argv(described_class_command_name, required_arg, described_class.allowed_resources.first)
+    command.resource_type.should == described_class.allowed_resources.first
+  end
+  
+end

data/spec/support/explicit_path.rb

@@ -0,0 +1,42 @@
+shared_examples_for 'a request to an explicit path' do
+
+  def described_class_command_name
+    described_class.to_s.split('::').last.downcase
+  end
+
+  it "should display usage when called without a path" do
+    run_argv(described_class_command_name).stderr.should include("usage: chimps #{described_class_command_name}")
+    run_argv(described_class_command_name).exit_code.should == 1
+  end
+
+  describe "constructing the path to send a request to" do
+
+    it "should append a .json extension by default" do
+      set_argv(described_class_command_name, "/datasets")
+      command.path.should == '/datasets.json'
+    end
+    
+    it "should an extension if given one" do
+      set_argv(described_class_command_name, "/datasets.xml")
+      command.path.should == '/datasets.xml'
+    end
+
+    it "should be able to extract the path when given a path with query string" do
+      set_argv(described_class_command_name, "/datasets.xml?some=query&string=true")
+      command.path.should == '/datasets.xml'
+    end
+  end
+
+  describe "constructing the query params to send with the request" do
+    it "should not set any query params by default" do
+      set_argv(described_class_command_name, "/datasets.xml")
+      command.query_params.should == {}
+    end
+
+    it "should detect and unescape query params when given" do
+      set_argv(described_class_command_name, "/datasets.xml?withSpaces=foo+bar")
+      command.query_params.should == {'withSpaces' => 'foo bar'}
+    end
+  end
+  
+end