alf-core 0.13.0

data/lib/alf-support/alf/support/coerce.rb

@@ -0,0 +1,28 @@
+module Alf
+  module Support
+
+    # Defines all coercion rules, through Myrrha inheritance
+    Coercions = Myrrha::Coerce.dup.append do |g|
+      g.error_handler = lambda{|v,t,c|
+        raise TypeError, "Unable to coerce `#{v.inspect}` to `#{t}`", caller
+      }
+      g.coercion String, Time,     lambda{|s,t| Time.parse(s) }
+      g.coercion String, DateTime, lambda{|s,t| DateTime.parse(s) }
+    end
+
+    # Coerces a value to a particular domain.
+    #
+    # Example:
+    #
+    #   Support.coerce("123", Integer) # => 123
+    #
+    # @param [Object] val any value
+    # @param [Class] domain a domain, represented by a ruby class
+    # @return [Object] an instance of `domain` resulting from the coercion
+    # @raise [Myrrha::CoercionError] if something goes wrong
+    def coerce(val, domain)
+      Coercions.apply(val, domain)
+    end
+
+  end # module Support
+end # module Alf

data/lib/alf-support/alf/support/config.rb

@@ -0,0 +1,62 @@
+module Alf
+  module Support
+    class Config
+
+      def self.delegation_methods
+        public_instance_methods(false).reject{|m| m.to_s =~ /=$/ }
+      end
+
+      def self.helpers(to = :config)
+        meths = delegation_methods
+        Module.new do
+          meths.each do |m|
+            define_method(m){|*args, &bl| self.send(to).send(m, *args, &bl) }
+          end
+        end
+      end
+
+      def self.option(name, domain, default_value)
+        getter_name = domain == Boolean ? :"#{name}?" : :"#{name}"
+        setter_name = :"#{name}="
+        ivar_name   = :"@#{name}"
+        define_method(getter_name) do
+          return instance_variable_get(ivar_name) if instance_variable_defined?(ivar_name)
+          default_value
+        end
+        define_method(setter_name) do |val|
+          instance_variable_set(ivar_name, Support.coerce(val, domain))
+        end
+      end
+      private_class_method :option
+
+      # Creates a default options instance
+      def initialize(h = {})
+        install_options_from_hash(h)
+      end
+
+      # Merge with another options from a hash
+      def merge(h)
+        dup.install_options_from_hash(h)
+      end
+
+    protected
+
+      def install_options_from_hash(h)
+        h.each_pair do |k,v|
+          install_single_option(k, v)
+        end
+        self
+      end
+
+      def install_single_option(k, v)
+        unless self.class.public_method_defined?(setter = :"#{k}=")
+          raise ConfigError, "No such option `#{k}`"
+        end
+        self.send(setter, v)
+      rescue TypeError
+        raise ConfigError, "Invalid option value `#{k}`: `#{v}`"
+      end
+
+    end # module Config
+  end # module Support
+end # module Alf

data/lib/alf-support/alf/support/dot_utils.rb

@@ -0,0 +1,15 @@
+module Alf
+  module Support
+    module DotUtils
+
+      def dot_label(label, strip = 100)
+        label = label.to_s[0..strip]
+                     .gsub(/"/, '\"')
+                     .gsub(/\n/, '\n')
+                     .gsub(">", ">")
+        %Q{"#{label}"}
+      end
+
+    end # module DotUtils
+  end # module Support
+end # module Alf

data/lib/alf-support/alf/support/miscellaneous.rb

@@ -0,0 +1,60 @@
+module Alf
+  module Support
+
+    # Returns the unqualified name of a ruby class or module.
+    #
+    # Example
+    #
+    #   class_name(Alf::Support) -> :Support
+    #
+    # @param [Class] clazz a ruby class
+    # @return [Symbol] the unqualified name of the class as a Symbol
+    def class_name(clazz)
+      /([A-Za-z0-9_]+)$/.match(clazz.name.to_s)[1].to_sym
+    end
+
+    # Converts an unqualified class or module name to a ruby case method name.
+    #
+    # Example
+    #
+    #    ruby_case(:Alf)  -> "alf"
+    #    ruby_case(:HelloWorld) -> "hello_world"
+    #
+    # @param [String or Symbol] a class or module name
+    # @return [String] the class or module name in ruby_case
+    def ruby_case(s)
+      s.to_s.gsub(/[A-Z]/){|x| "_#{x.downcase}"}[1..-1]
+    end
+
+    # Converts `name` to a rubycase name, as a Symbol.
+    #
+    # Example:
+    #   rubycase_name(Alf)        => :alf
+    #   rubycase_name(HelloWorld) => :hello_world
+    #
+    # @param [Object] any object, typically a Class, Symbol or String
+    # @return [Symbol] a symbol capturing `name` in ruby-like casing
+    def rubycase_name(name)
+      name = class_name(name) if name.is_a?(Module)
+      name = ruby_case(name.to_s)
+      name.to_sym
+    end
+
+    # Symbolizes all keys of `tuple`
+    #
+    # @param  [Hash]  tuple a tuple, represented by a Hash
+    # @return [Tuple] the same tuple, with all keys as Symbols
+    def symbolize_keys(tuple)
+      tuple.each_with_object({}){|(k,v),h| h[k.to_sym] = v}
+    end
+
+    # Unsymbolizes all keys of `tuple`
+    #
+    # @param  [Hash]  tuple a tuple, represented by a Hash
+    # @return [Tuple] the same tuple, with all keys as Symbols
+    def unsymbolize_keys(tuple)
+      tuple.each_with_object({}){|(k,v),h| h[k.to_s] = v}
+    end
+
+  end # module Support
+end # module Alf

data/lib/alf-support/alf/support/ordered_set.rb

@@ -0,0 +1,33 @@
+module Alf
+  module Support
+    module OrderedSet
+      extend Domain::Reuse::Helpers
+
+      reuse  :size, :each, :include?, :empty?, :to_a, :to_set, :first, :any?, :all?
+      recoat :select, :reject
+
+      def elements
+        reused_instance
+      end
+
+      def -(other)
+        self.class.new (elements - self.class.coerce(other).elements)
+      end
+
+      def &(other)
+        self.class.new (elements & self.class.coerce(other).elements)
+      end
+
+      def |(other)
+        self.class.new (elements | self.class.coerce(other).elements)
+      end
+      alias_method :+, :|
+
+      def map(&bl)
+        self.class.new reused_instance.map(&bl).uniq
+      end
+
+      include Domain::Equalizer.new(:to_set)
+    end # module OrderedSet
+  end # module Support
+end # module Alf

data/lib/alf-support/alf/support/registry.rb

@@ -0,0 +1,52 @@
+module Alf
+  module Support
+    module Registry
+
+      def listeners
+        @listeners ||= []
+      end
+
+      def listen(&listener)
+        listeners << listener
+        registered.each do |what|
+          method_name, factory = Registry.decode_registered(what)
+          listener.call(method_name, factory)
+        end
+      end
+
+      def registered
+        @registered ||= []
+      end
+      alias :all :registered
+
+      def each(&bl)
+        registered.each(&bl)
+      end
+
+      def register(what, registry)
+        method_name, factory = Registry.decode_registered(what)
+        (class << registry; self; end).
+          send(:define_method, method_name) do |*args, &block|
+            factory.new(*args, &block)
+          end
+        registry.module_eval do
+          registered << what
+          listeners.each{|l| l.call(method_name, factory) }
+        end
+      end
+
+    private
+
+      def self.decode_registered(what)
+        method_name, factory = nil, nil
+        Array(what).each do |arg|
+          method_name ||= arg if arg.is_a?(Symbol)
+          factory     ||= arg if arg.is_a?(Class)
+        end
+        method_name = Support.rubycase_name(factory) unless method_name
+        [method_name, factory]
+      end
+
+    end # module Registry
+  end # module Support
+end # module Alf

data/lib/alf-support/alf/support/scope.rb

@@ -0,0 +1,85 @@
+module Alf
+  module Support
+    #
+    # Implements a sandboxed scope abstraction through a BasicObject.
+    #
+    # Example:
+    #
+    #     module Foo; ... end
+    #     module Bar; ... end
+    # 
+    #     Scope.new([Foo, Bar]).evaluate{
+    #       # Foo and Bar instance methods are available
+    #       # Kernel's methods are not
+    #     }
+    #
+    class Scope < BasicObject
+
+      module OwnMethods
+
+        # Delegated to ::Kernel
+        def lambda(*args, &block)
+          ::Kernel.lambda(*args, &block)
+        end
+
+        # Evaluates an expression in the scope.
+        #
+        # @param [Proc] bl an expression to evaluate as a Proc.
+        # @return [Object] the result of evaluting `expr` on self
+        def evaluate(expr = nil, path=nil, line=nil, &bl)
+          return instance_exec(&bl) if bl
+          ::Kernel.eval expr, __eval_binding, *[path, line].compact
+        end
+
+      ### private section ###
+
+        # Returns true if the decorated tuple has `name` as key.
+        def respond_to?(name, include_private = false)
+          return true if @extensions.any?{|m| m.method_defined?(name) }
+          return true if BasicObject.method_defined?(name)
+          @parent && @parent.respond_to?(name)
+        end
+
+        # Returns true.
+        def respond_to_missing?(symbol, include_private = false)
+          @parent && @parent.respond_to?(symbol, include_private)
+        end
+
+        # Delegated to parent if any.
+        def method_missing(name, *args, &bl)
+          @parent ? @parent.__send__(name, *args, &bl) : super
+        rescue NoMethodError => ex
+          name = ex.message[/`(.*?)'/, 1]
+          ::Kernel.raise NoMethodError, "Not found `#{name}` on #{self}"
+        end
+
+        # Returns the binding to use for an evaluation
+        #
+        # @return [Binding] a binding object that captures this scope.
+        def __eval_binding
+          RUBY_VERSION < "1.9" ? binding : ::Kernel.binding
+        end
+
+        # Branches this scope with `arg`, returning a child scope of this one.
+        def __branch(arg)
+          case arg
+          when ::Hash then TupleScope.new(arg, [], self)
+          else
+            Kernel::raise NotImplementedError, "Unable to branch with `#{arg}`"
+          end
+        end
+
+      end # module OwnMethods
+
+      # Creates a scope instance
+      def initialize(extensions = [], parent = nil)
+        @extensions = [ OwnMethods ] + extensions
+        @extensions.each do |ext|
+          ext.send(:extend_object, self)
+        end
+        @parent = parent
+      end
+
+    end # class Scope
+  end # module Support
+end # module Alf

data/lib/alf-support/alf/support/to_lispy.rb

@@ -0,0 +1,37 @@
+module Alf
+  module Support
+
+    # Converts `value` to a lispy expression.
+    #
+    # Example:
+    #
+    #     expr = Alf.examples.compile{
+    #       project(:suppliers, [:name])
+    #     }
+    #     Support.to_lispy(expr)
+    #     # => project(:suppliers, [:name])
+    #
+    # @param [Object] expr any ruby object denoting a lispy expression
+    # @return [String] a lispy expression for `value`
+    def to_lispy(expr)
+      ToLispy.apply(expr)
+    end
+
+    # Myrrha rules for converting to ruby literals
+    ToLispy = Myrrha::coercions do |r|
+
+      # Delegate to #to_lispy if it exists
+      lispy_able = lambda{|v,rd| v.respond_to?(:to_lispy)}
+      r.upon(lispy_able) do |v,rd|
+        v.to_lispy
+      end
+
+      # Let's assume to to_ruby_literal will make the job
+      r.fallback(Object) do |v, _|
+        Support.to_ruby_literal(v) rescue v.inspect
+      end
+
+    end # ToLispy
+
+  end # module Support
+end # module Alf

data/lib/alf-support/alf/support/to_ruby_literal.rb

@@ -0,0 +1,33 @@
+module Alf
+  module Support
+
+    # Converts `value` to a ruby literal
+    #
+    # This method is provided for code generation mechanisms used by Alf in
+    # various places (such as .rash files). The to_ruby_literal contract is
+    # such that the following invariant holds:
+    #
+    #     eval(to_ruby_literal(value)) == value
+    #
+    # This contract is ensured by Myrrha::ToRubyLiteral for various ruby values.
+    # Myrrha delegates the job to `value.to_ruby_literal` provided this method
+    # exists. In such case, the implementation must be such that the invariant
+    # above is met.
+    #
+    # In every case, an invocation to this method only makes sense provided that
+    # `value` denotes a pure value, with the obvious semantics (from TTM).
+    #
+    # @param [Object] value any ruby object that denotes a pure value.
+    # @return [String] a ruby literal for `value`
+    def to_ruby_literal(value)
+      ToRubyLiteral.apply(value)
+    end
+
+    # Myrrha rules for converting to ruby literals
+    ToRubyLiteral = Myrrha::ToRubyLiteral.dup.append do |g|
+      g.coercion(Time)    {|s,_| "Time.parse('#{s.iso8601}')"     }
+      g.coercion(DateTime){|s,_| "DateTime.parse('#{s.iso8601}')" }
+    end
+
+  end # module Support
+end # module Alf

data/lib/alf-support/alf/support/tuple_scope.rb

@@ -0,0 +1,72 @@
+module Alf
+  module Support
+    #
+    # Specialization of Scope for working on a tuple specifically.
+    #
+    # This class works hand-in-hand with TupleExpression as it provides a scope for their
+    # evaluation on tuples. It also provides a handle for implementing a flyweight design
+    # pattern on tuples through the `__set_tuple` method.
+    #
+    # Example:
+    #
+    #   scope = TupleScope.new
+    #   expr  = TupleExpression["status > 10"]
+    #   relation.each do |tuple|
+    #     expr.evaluate(scope.__set_tuple(tuple))
+    #   end
+    #
+    class TupleScope < Scope
+
+      module OwnMethods
+
+        # Returns true if the decorated tuple has `name` as key.
+        def respond_to?(name)
+          return true if @tuple && @tuple.has_key?(name)
+          super
+        end
+
+        # Sets the next tuple to use.
+        #
+        # On first call, this method installs the scope as a side effect unless a tuple
+        # has already been provided at construction.
+        #
+        # @param [Tuple] tuple the current iterated tuple
+        # @return [TupleScope] self
+        def __set_tuple(tuple)
+          __build(tuple) if @tuple.nil?
+          @tuple = tuple
+          self
+        end
+
+        # Builds this scope with a tuple.
+        #
+        # This method should be called only once and installs instance methods on
+        # the scope with keys of _tuple_.
+        def __build(tuple)
+          tuple.keys.each do |k|
+            (class << self; self; end).send(:define_method, k) do
+              @tuple[k]
+            end
+          end
+          self
+        end
+
+        def query
+          @parent.query(yield)
+        end
+
+        def tuple_extract
+          @parent.tuple_extract(yield)
+        end
+
+      end # module OwnMethods
+
+      # Creates a scope instance
+      def initialize(tuple = nil, extensions = [], parent = nil)
+        super [ OwnMethods ] + extensions, parent
+        __build(@tuple = tuple) if tuple
+      end
+
+    end # class TupleScope
+  end # module Support
+end # module Alf