alf 0.12.2 → 0.13.0

data/lib/alf-sequel/alf/sequel.rb

@@ -1,2 +0,0 @@
-require_relative 'sequel/environment'
-require_relative 'sequel/iterator'

data/lib/alf-sequel/alf/sequel/environment.rb

@@ -1,61 +0,0 @@
-module Alf
-  module Sequel
-    #
-    # Specialization of Alf::Environment to distribute Sequel datasets
-    #
-    class Environment < ::Alf::Environment
-
-      class << self
-
-        # (see Alf::Environment.recognizes?)
-        #
-        # @return true if args contains one String that can be interpreted as
-        # a valid database uri, false otherwise
-        def recognizes?(args)
-          require 'uri'
-          if args.size == 1 and args.first.is_a?(String)
-            uri = URI::parse(args.first)
-            !!uri.scheme or looks_a_sqlite_file?(args.first)
-          else
-            false
-          end
-        rescue ::URI::Error
-          false
-        end
-
-        # Returns trus if `f` looks like a sqlite file
-        def looks_a_sqlite_file?(f)
-          File.file?(f) and File.extname(f) == ".db"
-        end
-
-      end # class << self
-
-      # Creates an Environment instance
-      def initialize(uri, options = {})
-        @uri = self.class.looks_a_sqlite_file?(uri) ? "#{sqlite_protocol}://#{uri}" : uri
-        @options = options
-      end
-
-      def sqlite_protocol
-        defined?(JRUBY_VERSION) ? "jdbc:sqlite" : "sqlite"
-      end
-
-      # (see Alf::Environment#dataset)
-      def dataset(name)
-        Iterator.new(connect[name])
-      end
-
-      private 
-
-      # Creates a database connection
-      def connect
-        @db ||= begin
-          Alf::Tools::friendly_require('sequel')
-          ::Sequel.connect(@uri, @options)
-        end
-      end
-
-      Alf::Environment.register(:sequel, self)
-    end # class Environment
-  end # module Sequel
-end # module Alf

data/lib/alf-sequel/alf/sequel/iterator.rb

@@ -1,21 +0,0 @@
-module Alf
-  module Sequel
-    #
-    # Specialization of Alg::Iterator to work on a Sequel dataset
-    #
-    class Iterator
-      include Alf::Iterator
-
-      # Creates an iterator instance
-      def initialize(dataset)
-        @dataset = dataset
-      end
-
-      # (see Alf::Iterator#each)
-      def each
-        @dataset.each(&Proc.new)
-      end
-
-    end # class Iterator
-  end # module Sequel
-end # module Alf

data/lib/alf-shell/alf/shell.rb

@@ -1,40 +0,0 @@
-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
-        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
-        yield(builder) if block_given?
-      }
-    end
-
-  end # module Shell
-end # module Alf
-require_relative 'shell/command'
-require_relative 'shell/operator'

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

@@ -1,26 +0,0 @@
-module Alf
-  module Command
-    module ClassMethods
-
-      # Returns the ruby case name of this operator
-      def rubycase_name 
-        Tools.ruby_case(Tools.class_name(self))
-      end
-
-      # @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/alf/shell/command/exec.rb

@@ -1,11 +0,0 @@
-module Alf
-  module Shell
-    class Exec < Shell::Command()
-      
-      def execute(args)
-        Reader.alf(args.first || $stdin, requester.environment)
-      end
-      
-    end # class Exec
-  end # module Shell
-end # module Alf

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

@@ -1,30 +0,0 @@
-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/alf/shell/command/main.rb

@@ -1,136 +0,0 @@
-module Alf
-  module Shell
-    class Main < Shell::Delegator()
-    
-      # Environment instance to use to get base iterators
-      attr_accessor :environment
-
-      # The reader to use when stdin is used as operand
-      attr_accessor :stdin_reader
-
-      # Output renderer
-      attr_accessor :renderer_class
-
-      # Rendering options
-      attr_reader :rendering_options
-
-      # Creates a command instance
-      def initialize(env = Environment.default)
-        @environment = env
-        @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_renderer do |name,descr,clazz|
-          opt.on("--#{name}", "Render output #{descr}"){ 
-            @renderer_class = clazz
-          }
-        end
-        
-        opt.on('--env=ENV', 
-               "Set the environment to use") do |value|
-          @environment = Environment.autodetect(value)
-        end
-
-        @input_reader = :rash
-        readers = Reader.readers.collect{|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::VERSION}"\
-                              " (c) 2011, Bernard Lambeau"
-        end
-      end # Alf's options
-
-      # 
-      # Returns the $stdin Reader to use, according to the 
-      # --input-reader= option
-      #
-      def stdin_reader
-        @stdin_reader || Reader.send(@input_reader, $stdin)
-      end
-
-      #
-      # Executes the command on an array of arguments.
-      #
-      def execute(argv)
-        # 1) special case where a .alf file is provided
-        if argv.empty? or (argv.size == 1 && File.exists?(argv.first))
-          argv.unshift("exec")
-        end
-
-        # 2) build the operator according to -e option
-        operator = if @execute
-          Alf.lispy(environment).compile(argv.first)
-        else
-          super
-        end
-        operator = Iterator.coerce(operator, environment) if operator
-
-        # 3) if there is a requester, then we do the job (assuming bin/alf)
-        # with the renderer to use. Otherwise, we simply return built operator
-        if operator && requester
-          renderer_class = (self.renderer_class ||= Renderer::Rash)
-          renderer = renderer_class.new(operator, rendering_options)
-          renderer.execute($stdout)
-        else
-          operator
-        end
-      end
-
-      #
-      # Returns rendering options
-      #
-      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
-
-      #
-      # Returns a highline instance
-      # 
-      def highline
-        require 'highline'
-        HighLine.new($stdin, $stdout)
-      rescue LoadError => ex
-        nil
-      end
-      
-    end # class Main
-  end # module Shell
-end # module Alf
-require_relative 'main/class_methods'

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

@@ -1,46 +0,0 @@
-module Alf
-  module Shell
-    class Main
-      module ClassMethods
-
-        def relational_operators(sort_by_name = false)
-          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 = false)
-          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 = false)
-          ops = subcommands.select{|cmd| 
-            cmd.operator? and !cmd.relational?
-          }
-          sort_operators(ops, sort_by_name)
-        end
-
-        def other_non_relational_commands(sort_by_name = false)
-          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
-      extend(ClassMethods)
-    end # class Main
-  end # module Shell
-end # module Alf

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

@@ -1,63 +0,0 @@
-module Alf
-  module Shell
-    class Show < Shell::Command()
-    
-      options do |opt|
-        @renderer_class = nil
-        Renderer.each_renderer 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 || 
-                                    Text::Renderer)
-
-        # normalize args
-        args = argv.first
-        args = [ stdin_reader ] if args.empty?
-        chain = Iterator.coerce(args.first, requester && requester.environment)
-
-        # put a sorter
-        if argv[1]
-          chain = Alf::Operator::NonRelational::Sort.new([chain], argv[1])
-        end
-
-        chain
-      end
-    
-      private 
-
-      def stdin_reader
-        if requester && requester.respond_to?(:stdin_reader)
-          requester.stdin_reader
-        else 
-          Reader.coerce($stdin)
-        end
-      end
-
-    end # class Show
-  end # module Shell
-end # module Alf