pione 0.2.2 → 0.3.0

data/lib/pione/model/rule-expr.rb

@@ -1,234 +0,0 @@
-module Pione
-  module Model
-    # Rule representation in the flow element context.
-    class RuleExpr < Callable
-      include SimpleIdentity
-
-      set_pione_model_type TypeRuleExpr
-
-      # @return [PackageExpr]
-      #   package expression
-      attr_reader :package_expr
-
-      # @return [String]
-      #   rule name
-      attr_reader :name
-
-      # @return [Hash]
-      #   attributes of the rule expression
-      attr_reader :attributes
-
-      forward_as_key! :@attributes, :params, :input_ticket_expr, :output_ticket_expr
-
-      # Create a rule expression.
-      #
-      # @param package_expr [PackageExpr]
-      #   package expression
-      # @param name [String]
-      #   rule name
-      # @param attributes [Hash]
-      #   attributes of the expression
-      # @option attributes [Model::Parameters] :params
-      #   rule parameters
-      # @option attributes [Model::TicketExpr] :input_ticket_expr
-      #   input ticket condition
-      # @option attributes [Model::TicketExpr] :output_ticket_expr
-      #   output ticket condition
-      def initialize(package_expr, name, attributes={})
-        @package_expr = package_expr
-        @name = name
-        @attributes = {}
-        @attributes[:params] = attributes[:params] || Model::Parameters.empty
-        @attributes[:input_ticket_expr] = attributes[:input_ticket_expr] || Model::TicketExprSequence.empty
-        @attributes[:output_ticket_expr] = attributes[:output_ticket_expr] || Model::TicketExprSequence.empty
-        super()
-      end
-
-      # Return rule path form.
-      #
-      # @return [String]
-      #   rule path string
-      def path
-        "&%s:%s" % [@package_expr.name, @name]
-      end
-
-      # FIXME
-      def rule_path
-        raise UnboundVariableError.new(self) if @package_expr.include_variable?
-        "&%s:%s" % [@package_expr.name, @name]
-      end
-
-      # @api private
-      def textize
-        "rule_expr(%s,\"%s\")" % [@package_expr.textize, @name]
-      end
-
-      # Create a new rule expression with adding the ticket expression as input
-      # condition.
-      #
-      # @param ticket_expr [TicketExpr]
-      #   ticket expression as additional input condition
-      # @return [RuleExpr]
-      #   new rule expression
-      def add_input_ticket_expr(ticket_expr)
-        new_attributes = @attributes.merge(input_ticket_expr: @attributes[:input_ticket_expr].concat(ticket_expr))
-        return self.class.new(@package_expr, @name, new_attributes)
-      end
-
-      # Create a new rule expression with adding the ticket expression as output
-      # condition.
-      #
-      # @param ticket_expr [TicketExpr]
-      #   ticket expression as additional output condition
-      # @return [RuleExpr]
-      #   new rule expression
-      def add_output_ticket_expr(ticket_expr)
-        new_attributes = @attributes.merge(output_ticket_expr: @attributes[:output_ticket_expr].concat(ticket_expr))
-        return self.class.new(@package_expr, @name, new_attributes)
-      end
-
-      # Sets a package name and returns a new expression.
-      #
-      # @param package_expr [PackageExpr]
-      #   package expression
-      # @return [RuleExpr]
-      #   new rule expression with the package name
-      def set_package_expr(package_expr)
-        return self.class.new(package_expr, @name, @attributes)
-      end
-
-      # Set parameters and returns a new expression.
-      #
-      # @param params [Parameters]
-      #   parameters
-      # @return [RuleExpr]
-      #   new rule expression with the parameters
-      def set_params(params)
-        new_attributes = @attributes.merge(params: params)
-        return self.class.new(@package_expr, @name, new_attributes)
-      end
-
-      # Evaluate the object with the variable table.
-      #
-      # @param vtable [VariableTable]
-      #   variable table for evaluation
-      # @return [RuleExpr]
-      #   evaluation result
-      def eval(vtable)
-        new_attributes = Hash[@attributes.map{|key, val| [key, val.eval(vtable)]}]
-        return self.class.new(@package_expr.eval(vtable), @name, new_attributes)
-      end
-
-      # Return true if the package expression or parameters include variables.
-      #
-      # @return [Boolean]
-      #   true if the package expression or parameters include variables
-      def include_variable?
-        @package_expr.include_variable? or @attributes.values.any?{|val| val.include_variable?}
-      end
-
-      # Return a set that contains self as a single element.
-      #
-      # @return [Set<RuleExpr>]
-      #   a set that contains self
-      def to_set
-        Set.new([self])
-      end
-    end
-
-    class CompositionalRuleExpr < RuleExpr
-      # Create a new compositional rule expression. This consists from left and
-      # right child expressions.
-      #
-      # @param left [RuleExpr]
-      #   left expression
-      # @param right [RuleExpr]
-      #   right expression
-      def initialize(left, right)
-        @left = left
-        @right = right
-      end
-
-      # Create a new compositioanl rule expression with adding the ticket
-      # expression as input condition of left expression.
-      #
-      # @param ticket_expr [TicketExpr]
-      #   ticket expression as additional input condition
-      # @return [CompositionalRuleExpr]
-      #   new rule expression
-      def add_input_ticket_expr(ticket_expr)
-        return self.class.new(@left.add_input_ticket_expr(ticket_expr), @right)
-      end
-
-      # Create a new compositional rule expression with adding the ticket
-      # expression as output condition of right expression.
-      #
-      # @param ticket_expr [TicketExpr]
-      #   ticket expression as additional output condition
-      # @return [CompositionalRuleExpr]
-      #   new rule expression
-      def add_output_ticket_expr(ticket_expr)
-        return self.class.new(@left, @right.add_output_ticket_expr(ticket_expr))
-      end
-
-      # Evaluate left and right expressions with the variable table.
-      #
-      # @param [VariableTable] vtable
-      #   variable table for evaluation
-      # @return [CompositionalRuleExpr]
-      #   evaluation result
-      def eval(vtable)
-        return self.class.new(@left.eval(vtable), @right.eval(vtable))
-      end
-
-      # @api private
-      def ==(other)
-        return false unless other.kind_of?(self.class)
-        return to_set == other.to_set
-      end
-      alias :eql? :"=="
-
-      # @api private
-      def hash
-        @left.hash + @right.hash
-      end
-
-      # Return a set that contains all rule expressions of left and right.
-      #
-      # @return [Set<RuleExpr>]
-      #   a set that contains all rule expressions of left and right
-      def to_set
-        @left.to_set + @right.to_set
-      end
-    end
-
-    class RuleExprSequence < Sequence
-      set_pione_model_type TypeRuleExpr
-    end
-
-    TypeRuleExpr.instance_eval do
-      define_pione_method("==", [TypeRuleExpr], TypeBoolean) do |vtable, rec, other|
-        PioneBoolean.new(rec == other).to_seq
-      end
-
-      define_pione_method("params", [TypeParameters], TypeRuleExpr) do |vtable, rec, params|
-        rec.set_params(params)
-      end
-
-      define_pione_method("as_string", [], TypeString) do |vtable, rec|
-        PioneString.new(rec.name).to_seq
-      end
-
-      define_pione_method("==>", [TypeTicketExpr], TypeRuleExpr) do |vtable, rec, ticket_expr|
-        rec.add_output_ticket_expr(ticket_expr)
-      end
-
-      define_pione_method(">>>", [TypeRuleExpr], TypeRuleExpr) do |vtable, rec, other|
-        ticket_expr = TicketExpr.new(rec.path).to_seq
-        left = rec.add_output_ticket_expr(ticket_expr)
-        right = other.add_input_ticket_expr(ticket_expr)
-        CompositionalRuleExpr.new(left, right)
-      end
-    end
-  end
-end

data/lib/pione/model/sequence.rb

@@ -1,273 +0,0 @@
-module Pione
-  module Model
-    # SequenceAttributeError is an exception for attribute mismatching.
-    class SequenceAttributeError < StandardError
-      def initialize(attribute)
-        @attribute = attribute
-      end
-
-      def message
-        "attribute mismatched: %s" % @attribute
-      end
-    end
-
-    # Sequence is a base class for all expressions.
-    class Sequence < Callable
-      include Enumerable
-
-      class << self
-        # Copy sequence attribute to subclass.
-        def inherited(subclass)
-          @sequence_attribute.each do |name, vals|
-            subclass.define_sequence_attribute(name, *vals)
-          end
-          subclass.set_index_type index_type
-        end
-
-        # Define sequence attribute.
-        #
-        # @param name [Symbol]
-        #    attribute name
-        # @param default_value [Symbol]
-        #    default value of the attribute
-        # @param other_values [Array<Symbol>]
-        #    other values of the attribute
-        # @return [void]
-        def define_sequence_attribute(name, default_value, *other_values)
-          @sequence_attribute ||= {}
-          @sequence_attribute[name] = [default_value] + other_values
-
-          define_method(name) do
-            @attribute[name]
-          end
-
-          define_method("set_%s" % name) do |value|
-            self.class.new(@elements, @attribute.merge({name => value}))
-          end
-
-          # define additional methods when values are symbols
-          if default_value.kind_of?(Symbol)
-            ([default_value] + other_values).each do |value|
-              define_method("%s?" % value) do
-                @attribute[name] == value
-              end
-
-              define_method("set_%s" % value) do
-                self.class.new(@elements, @attribute.merge({name => value}))
-              end
-            end
-          end
-        end
-
-        attr_reader :element_class
-        attr_reader :sequence_attribute
-        attr_reader :shortname
-        attr_reader :index_type
-
-        # Set element class.
-        #
-        # @param klass [Class]
-        #   element class
-        # @return [void]
-        def set_element_class(klass)
-          @element_class = klass
-          klass.set_sequence_class(self)
-        end
-
-        # Set the shortname.
-        #
-        # @param name [String]
-        #   shortname
-        # @return [void]
-        def set_shortname(name)
-          @shortname = name
-        end
-
-        # Set the index type.
-        #
-        # @param index_type [Type]
-        #   index type
-        # @return [void]
-        def set_index_type(index_type)
-          @index_type = index_type
-        end
-
-        # Make an empty sequence.
-        def empty(attributes={})
-          new([], attributes)
-        end
-      end
-
-      # Make a void sequence.
-      def Sequence.void
-        Sequence.new([])
-      end
-
-      define_sequence_attribute :distribution, :each, :all
-      forward! :class, :sequence_attribute, :shortname, :index_type
-      forward! :@elements, :first, :[], :empty?
-      attr_reader :elements
-      attr_reader :attribute
-
-      # @param elements [Array]
-      #   sequence elements
-      # @param attribute [Hash]
-      #   sequence attribute
-      def initialize(elements, attribute={})
-        @elements = elements
-        @attribute = Hash.new.merge(attribute)
-
-        # clear unneeded keys
-        (attribute.keys - sequence_attribute.keys).each do |key|
-          @attribute.delete(key)
-        end
-
-        # fill default value
-        sequence_attribute.each do |name, values|
-          @attribute[name] ||= values.first
-        end
-      end
-
-
-      # Return true if the sequence is void.
-      #
-      # @return [Boolean]
-      #   true if the sequence is void
-      def void?
-        self.class == Sequence and empty?
-      end
-
-      # Concatenate another sequence.
-      #
-      # @param other [Sequence]
-      #   other sequence
-      # @return [Sequence]
-      #   a new sequence that have members of self and other
-      def concat(other)
-        raise SequenceAttributeError.new(other) unless @attribute == other.attribute
-        self.class.new(@elements + other.elements, @attribute)
-      end
-
-      # Push the element to the sequecence.
-      #
-      # @param element [Element]
-      #    the element
-      # @return [Sequence]
-      #    a new sequence that have member self and the element.
-      def push(element)
-        self.class.new(@elements + [element], @attribute)
-      end
-
-      # Iterate each elements.
-      #
-      # @return [Enumerator]
-      #   return an enumerator if the block is not given
-      def each
-        if block_given?
-          @elements.each {|e| yield self.class.new([e], @attribute)}
-        else
-          Enumerator.new(self, :each)
-        end
-      end
-
-      def eval(vtable)
-        self.class.new(@elements.map{|elt| elt.eval(vtable)}, @attribute)
-      end
-
-      def include_variable?
-        @elements.any?{|elt| elt.include_variable?}
-      end
-
-      def ==(other)
-        return false unless other.kind_of?(self.class)
-        return false unless @elements == other.elements
-        return @attribute == other.attribute
-      end
-      alias :eql? :"=="
-
-      def hash
-        @elements.hash + @attribute.hash
-      end
-
-      def textize
-        "<%s [%s]>" % [shortname, @elements.map{|x| x.textize}.join(",")]
-      end
-
-      def inspect
-        "#<%s %s %s>" % [shortname, @elements, @attribute]
-      end
-    end
-
-    TypeSequence.instance_eval do
-      define_pione_method("!=", [:receiver_type], TypeBoolean) do |vtable, rec, other|
-        rec.call_pione_method(vtable, "==", other).call_pione_method(vtable, "not")
-      end
-
-      define_pione_method("|", [:receiver_type], :receiver_type) do |vtable, rec, other|
-        rec.concat(other)
-      end
-
-      define_pione_method("each", [], :receiver_type) do |vtable, rec|
-        rec.set_each
-      end
-
-      define_pione_method("each?", [], TypeBoolean) do |vtable, rec|
-        BooleanSequence.new([PioneBoolean.new(rec.each?)])
-      end
-
-      define_pione_method("all", [], :receiver_type) do |vtable, rec|
-        rec.set_all
-      end
-
-      define_pione_method("all?", [], TypeBoolean) do |vtable, rec|
-        BooleanSequence.new([PioneBoolean.new(rec.all?)])
-      end
-
-      define_pione_method("i", [], TypeInteger) do |vtable, rec|
-        rec.call_pione_method(vtable, "as_integer")
-      end
-
-      define_pione_method("f", [], TypeFloat) do |vtable, rec|
-        rec.call_pione_method(vtable, "as_float")
-      end
-
-      define_pione_method("str", [], TypeString) do |vtable, rec|
-        rec.call_pione_method(vtable, "as_string")
-      end
-
-      define_pione_method("d", [], TypeDataExpr) do |vtable, rec|
-        rec.call_pione_method(vtable, "as_data_expr")
-      end
-
-      define_pione_method("length", [], TypeInteger) do |vtable, rec|
-        IntegerSequence.new([PioneInteger.new(rec.elements.size)])
-      end
-
-      define_pione_method("[]", [:index_type], :receiver_type) do |vtable, rec, index|
-        rec.call_pione_method(vtable, "nth", index)
-      end
-
-      define_pione_method("member?", [:receiver_type], TypeBoolean) do |vtable, rec, target|
-        sequential_map1(TypeBoolean, target) do |target_elt|
-          rec.elements.map{|elt| elt.value}.include?(target_elt.value)
-        end
-      end
-
-      define_pione_method("empty?", [], TypeBoolean) do |vtable, rec|
-        PioneBoolean.new(rec.elements.size == 0).to_seq
-      end
-
-      define_pione_method(":", [TypeSequence], TypeKeyedSequence) do |vtable, keys, vals|
-        keys.elements.map do |key_elt|
-          vals.elements.map do |val_elt|
-            KeyedSequence.new(key_elt => [val_elt])
-          end
-        end.flatten.inject(KeyedSequence.new({})){|seq, _seq| seq.concat(_seq)}
-      end
-
-      define_pione_method("textize", [], TypeString) do |vtable, rec|
-        rec.call_pione_method(vtable, "as_string").call_pione_method(vtable, "join", PioneString.new(rec.separator).to_seq)
-      end
-    end
-  end
-end