alf-shell 0.13.0

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+# 0.13.0 / 2013-07-29
+
+The 0.13.0 version is a new birthday for alf. See `alf` main for CHANGELOG
+history.

data/Gemfile

@@ -0,0 +1,17 @@
+source 'http://rubygems.org'
+
+group :runtime do
+  #gem "alf-core", :git => "git://github.com/alf-tool/alf-core.git"
+  #gem "alf-core", :path => "../alf-core"
+  gem "alf-core", "~> 0.13.0"
+  gem "quickl", "~> 0.4.3"
+end
+
+group :development do
+  gem "rake", "~> 10.1"
+  gem "rspec", "~> 2.14"
+end
+
+group :extra do
+  gem "highline", "~> 1.6"
+end

data/Gemfile.lock

@@ -0,0 +1,35 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    alf-core (0.13.0)
+      domain (~> 1.0)
+      myrrha (~> 3.0)
+      path (~> 1.3)
+      sexpr (~> 0.5.1)
+    diff-lcs (1.2.4)
+    domain (1.0.0)
+    highline (1.6.19)
+    myrrha (3.0.0)
+      domain (~> 1.0)
+    path (1.3.1)
+    quickl (0.4.3)
+    rake (10.1.0)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.4)
+    rspec-expectations (2.14.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.1)
+    sexpr (0.5.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  alf-core (~> 0.13.0)
+  highline (~> 1.6)
+  quickl (~> 0.4.3)
+  rake (~> 10.1)
+  rspec (~> 2.14)

data/LICENCE.md

@@ -0,0 +1,22 @@
+# The MIT Licence
+
+    Copyright (c) 2013 - Bernard Lambeau
+
+    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/Manifest.txt

@@ -0,0 +1,13 @@
+shell.gemspec
+shell.noespec
+CHANGELOG.md
+Gemfile
+Gemfile.lock
+bin/**/*
+lib/**/*
+LICENCE.md
+Manifest.txt
+Rakefile
+README.md
+spec/**/*
+tasks/**/*

data/README.md

@@ -0,0 +1,11 @@
+# Alf::Shell
+
+[![Build Status](https://secure.travis-ci.org/blambeau/alf-shell.png)](http://travis-ci.org/blambeau/alf-shell)
+[![Dependency Status](https://gemnasium.com/blambeau/alf-shell.png)](https://gemnasium.com/blambeau/alf-shell)
+
+Bring Alf's relational algebra to the shell
+
+## Links
+
+http://github.com/blambeau/alf-shell
+http://github.com/blambeau/alf

data/Rakefile

@@ -0,0 +1,11 @@
+# We run tests by default
+task :default => :test
+
+#
+# Install all tasks found in tasks folder
+#
+# See .rake files there for complete documentation.
+#
+Dir["tasks/*.rake"].each do |taskfile|
+  load taskfile
+end

data/bin/alf

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+module AlfLauncher
+
+  def self.load
+    require "alf-shell"
+  end
+  
+  def self.start(argv)
+    load
+    if ENV["ALF_OPTS"]
+      argv = Quickl.parse_commandline_args(ENV["ALF_OPTS"]) + argv
+    end
+    Alf::Shell::Main.run(argv, __FILE__)
+  end
+
+end # module AlfLaucher
+AlfLauncher.start(ARGV)

data/lib/alf-shell.rb

@@ -0,0 +1 @@
+require_relative "alf/shell"

data/lib/alf/shell.rb

@@ -0,0 +1,48 @@
+require_relative 'shell/version'
+require_relative 'shell/loader'
+require_relative 'shell/ext/signature'
+require_relative 'shell/doc_manager'
+module Alf
+  module Shell
+
+    # This is the main documentation extractor
+    DOC_EXTRACTOR = DocManager.new
+
+    # Delegator command factory
+    def self.Delegator()
+      Quickl::Delegator(){|builder|
+        builder.doc_extractor = DOC_EXTRACTOR
+        builder.class_module Command::ClassMethods
+        yield(builder) if block_given?
+      }
+    end
+
+    # Command factory
+    def self.Command()
+      Quickl::Command(){|builder|
+        builder.command_parent = Alf::Shell::Main
+        builder.doc_extractor  = DOC_EXTRACTOR
+        builder.class_module Command::ClassMethods
+        builder.instance_module Shell::Support
+        yield(builder) if block_given?
+      }
+    end
+
+    # Operator factory
+    def self.Operator()
+      Quickl::Command(){|builder|
+        builder.command_parent = Alf::Shell::Main
+        builder.doc_extractor  = DOC_EXTRACTOR
+        builder.class_module    Operator::ClassMethods
+        builder.instance_module Shell::Support
+        builder.instance_module Operator::InstanceMethods
+        yield(builder) if block_given?
+      }
+    end
+
+  end # module Shell
+end # module Alf
+require_relative 'shell/from_argv'
+require_relative 'shell/support'
+require_relative 'shell/command'
+require_relative 'shell/operator'

data/lib/alf/shell/command.rb

@@ -0,0 +1,21 @@
+module Alf
+  module Command
+    module ClassMethods
+
+      # @return true
+      def command?
+        true
+      end
+
+      # @return false
+      def operator?
+        false
+      end
+
+    end # module ClassMethods
+  end # module Command
+end # module Alf
+require_relative 'command/main'
+require_relative 'command/exec'
+require_relative 'command/help'
+require_relative 'command/show'

data/lib/alf/shell/command/exec.rb

@@ -0,0 +1,16 @@
+module Alf
+  module Shell
+    class Exec < Shell::Command()
+
+      def execute(args)
+        cmd = if f = args.first
+          Path(f).read
+        else
+          $stdin.read
+        end
+        database.query(cmd)
+      end
+
+    end # class Exec
+  end # module Shell
+end # module Alf

data/lib/alf/shell/command/help.rb

@@ -0,0 +1,30 @@
+module Alf
+  module Shell
+    class Help < Shell::Command()
+      
+      # Let NoSuchCommandError be passed to higher stage
+      no_react_to Quickl::NoSuchCommand
+      
+      options do |opt|
+        @dialect = :shell
+        opt.on('--lispy', 
+               'Display operator signatures in lispy DSL') do
+          @dialect = :lispy
+        end
+        opt.on('--shell', 
+               'Display operator signatures in shell DSL') do
+          @dialect = :shell
+        end
+      end
+
+      # Command execution
+      def execute(args)
+        sup = Quickl.super_command(self)
+        sub = (args.size != 1) ? sup : Quickl.sub_command!(sup, args.first)
+        doc = sub.documentation(:method => @dialect)
+        puts doc
+      end
+      
+    end # class Help
+  end # module Shell
+end # module Alf

data/lib/alf/shell/command/main.rb

@@ -0,0 +1,175 @@
+module Alf
+  module Shell
+    class Main < Shell::Delegator()
+
+      class << self
+
+        def relational_operators(sort_by_name = true)
+          ops = subcommands.select{|cmd|
+             cmd.operator? and cmd.relational? and !cmd.experimental?
+          }
+          sort_operators(ops, sort_by_name)
+        end
+
+        def experimental_operators(sort_by_name = true)
+          ops = subcommands.select{|cmd|
+            cmd.operator? and cmd.relational? and cmd.experimental?
+          }
+          sort_operators(ops, sort_by_name)
+        end
+
+        def non_relational_operators(sort_by_name = true)
+          ops = subcommands.select{|cmd|
+            cmd.operator? and !cmd.relational?
+          }
+          sort_operators(ops, sort_by_name)
+        end
+
+        def other_non_relational_commands(sort_by_name = true)
+          ops = subcommands.select{|cmd|
+            cmd.command?
+          }
+          sort_operators(ops, sort_by_name)
+        end
+
+        private
+
+        def sort_operators(ops, sort_by_name)
+          sort_by_name ? ops.sort{|op1,op2|
+            op1.command_name.to_s <=> op2.command_name.to_s
+          } : ops
+        end
+
+      end # class << self
+
+      # Connection instance to use to get base relations
+      attr_accessor :database
+
+      # The reader to use when stdin is used as operand
+      attr_accessor :stdin_operand
+
+      # Output renderer
+      attr_accessor :renderer_class
+
+      # Rendering options
+      attr_reader :rendering_options
+
+      # Creates a command instance
+      def initialize(db = Alf.connect(Path.pwd))
+        @database = db
+        @rendering_options = {}
+      end
+
+      # Install options
+      options do |opt|
+        @execute = false
+        opt.on("-e", "--execute", "Execute one line of script (Lispy API)") do
+          @execute = true
+        end
+
+        @renderer_class = nil
+        Renderer.each do |name,descr,clazz|
+          opt.on("--#{name}", "Render output #{descr}"){
+            @renderer_class = clazz
+          }
+        end
+
+        opt.on('--examples', "Use the example database for database") do
+          @database = Alf.examples
+        end
+
+        opt.on('--db=DB',
+               "Set the database to use") do |value|
+          @database = Alf.connect(value)
+        end
+
+        @input_reader = :rash
+        readers = Reader.all.map{|r| r.first}
+        opt.on('--input-reader=READER', readers,
+               "Specify the kind of reader when reading on $stdin "\
+               "(#{readers.join(',')})") do |value|
+          @input_reader = value.to_sym
+        end
+
+        opt.on("-Idirectory",
+               "Specify $LOAD_PATH directory (may be used more than once)") do |val|
+          $LOAD_PATH.unshift val
+        end
+
+        opt.on('-rlibrary',
+               "Require the library, before executing alf") do |value|
+          require(value)
+        end
+
+        opt.on("--[no-]pretty",
+               "Enable/disable pretty print best effort") do |val|
+          self.pretty = val
+        end
+
+        opt.on_tail('-h', "--help", "Show help") do
+          raise Quickl::Help
+        end
+
+        opt.on_tail('-v', "--version", "Show version") do
+          raise Quickl::Exit, "alf #{Alf::Core::VERSION}"\
+                              " (c) 2011-2013, Bernard Lambeau"
+        end
+      end # Alf's options
+
+      def stdin_operand
+        @stdin_operand || Reader.send(@input_reader, $stdin)
+      end
+
+      def execute(argv)
+        # special case where a .alf file is provided
+        if argv.empty? or (argv.size == 1 && Path(argv.first).exist?)
+          argv.unshift("exec")
+        end
+
+        # compile the operator, render and returns it
+        compile(argv){ super }.tap do |op|
+          render(op.to_cog) if op && requester
+        end
+      end
+
+      def pretty=(val)
+        @rendering_options[:pretty] = val
+        if val && (hl = highline)
+          @rendering_options[:trim_at] = hl.output_cols
+          @rendering_options[:page_at] = hl.output_rows
+        end
+        val
+      end
+
+    private
+
+      def compile(argv)
+        if @execute
+          database.query(argv.first)
+        else
+          op = yield
+          op = op.bind(database) if op
+          op
+        end
+      end
+
+      def render(operator, out = $stdout)
+        renderer_class = self.renderer_class || default_renderer_class
+        renderer = renderer_class.new(operator, rendering_options)
+        renderer.execute(out)
+      end
+
+      def highline
+        require 'highline'
+        HighLine.new($stdin, $stdout)
+      rescue LoadError => ex
+        nil
+      end
+
+      def default_renderer_class
+        $stdout.tty? ? Renderer::Text : Renderer::Rash
+      end
+
+    end # class Main
+  end # module Shell
+end # module Alf

data/lib/alf/shell/command/show.rb

@@ -0,0 +1,49 @@
+module Alf
+  module Shell
+    class Show < Shell::Command()
+
+      options do |opt|
+        @renderer_class = nil
+        Renderer.each do |name,descr,clazz|
+          opt.on("--#{name}", "Render output #{descr}"){
+            @renderer_class = clazz
+          }
+        end
+
+        @pretty = nil
+        opt.on("--[no-]pretty",
+               "Enable/disable pretty print best effort") do |val|
+          @pretty = val
+        end
+
+        @ff = nil
+        opt.on("--ff=FORMAT",
+               "Specify the floating point format") do |val|
+          @ff = val
+        end
+      end
+
+      def run(argv, requester)
+        # set requester and parse options
+        @requester = requester
+        argv = parse_options(argv, :split)
+
+        # Set options on the requester
+        requester.pretty = @pretty unless @pretty.nil?
+        requester.rendering_options[:float_format] = @ff unless @ff.nil?
+        requester.renderer_class = (@renderer_class || requester.renderer_class)
+
+        compile(argv)
+      end
+
+      def compile(argv)
+        operand = operands(argv.shift, 1).last
+        unless argv.empty?
+          operand = Algebra::Sort.new([operand], Shell.from_argv(argv.first, Ordering))
+        end
+        operand
+      end
+
+    end # class Show
+  end # module Shell
+end # module Alf