algebrick 0.4.0 → 0.5.0

data/lib/algebrick/dsl.rb

@@ -0,0 +1,104 @@
+#  Copyright 2013 Petr Chalupa <git+algebrick@pitr.ch>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+module Algebrick
+  module DSL
+    module Shortcuts
+      def type(*variables, &block)
+        Algebrick.type *variables, &block
+      end
+
+      def atom
+        Algebrick.atom
+      end
+    end
+
+    class TypeDefinitionScope
+      include Shortcuts
+      include TypeCheck
+
+      attr_reader :new_type
+
+      def initialize(new_type, &block)
+        @new_type = Type! new_type, ProductVariant, ParametrizedType
+        instance_exec @new_type, &block
+        @new_type.kind if @new_type.is_a? ProductVariant
+      end
+
+      def fields(*fields)
+        @new_type.set_fields fields.first.is_a?(Hash) ? fields.first : fields
+        self
+      end
+
+      def fields!(*fields)
+        fields(*fields)
+        all_readers
+      end
+
+      def final!
+        @new_type.final!
+        self
+      end
+
+      def variants(*variants)
+        @new_type.set_variants *variants
+        self
+      end
+
+      def field_readers(*names)
+        @new_type.add_field_method_readers *names
+        self
+      end
+
+      alias_method :readers, :field_readers
+
+      def all_field_readers
+        @new_type.add_all_field_method_readers
+        self
+      end
+
+      alias_method :all_readers, :all_field_readers
+    end
+
+    class OuterShell
+      include Shortcuts
+
+      def initialize(&block)
+        instance_eval &block
+      end
+    end
+  end
+
+  def self.type(*variables, &block)
+    if block.nil?
+      raise 'Atom cannot be parametrized' unless variables.empty?
+      atom
+    else
+      if variables.empty?
+        DSL::TypeDefinitionScope.new(ProductVariant.new(nil), &block).new_type
+      else
+        DSL::TypeDefinitionScope.new(ParametrizedType.new(variables), &block).new_type
+      end
+    end
+  end
+
+  def self.atom
+    Atom.new nil
+  end
+
+  def self.types(&block)
+    DSL::OuterShell.new &block
+  end
+
+end

data/lib/algebrick/field_method_readers.rb

@@ -0,0 +1,43 @@
+#  Copyright 2013 Petr Chalupa <git+algebrick@pitr.ch>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+module Algebrick
+  module FieldMethodReaders
+    def field_names
+      @field_names or raise TypeError, "field names not defined on #{self}"
+    end
+
+    def field_names?
+      !!@field_names
+    end
+
+    def add_field_method_reader(field)
+      raise TypeError, 'no field names' unless field_names?
+      raise ArgumentError, "no field name #{field}" unless field_names.include? field
+      raise ArgumentError, "method #{field} already defined" if instance_methods.include? field
+      define_method(field) { self[field] }
+      self
+    end
+
+    def add_field_method_readers(*fields)
+      fields.each { |f| add_field_method_reader f }
+      self
+    end
+
+    def add_all_field_method_readers
+      add_field_method_readers *field_names
+      self
+    end
+  end
+end

data/lib/algebrick/matcher_delegations.rb

@@ -0,0 +1,45 @@
+#  Copyright 2013 Petr Chalupa <git+algebrick@pitr.ch>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+module Algebrick
+  module MatcherDelegations
+    def ~
+      ~to_m
+    end
+
+    def &(other)
+      to_m & other
+    end
+
+    def |(other)
+      to_m | other
+    end
+
+    def !
+      !to_m
+    end
+
+    def case(&block)
+      to_m.case &block
+    end
+
+    def >>(block)
+      to_m >> block
+    end
+
+    def >(block)
+      to_m > block
+    end
+  end
+end

data/lib/algebrick/matchers/abstract.rb

@@ -0,0 +1,127 @@
+#  Copyright 2013 Petr Chalupa <git+algebrick@pitr.ch>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+module Algebrick
+  module Matchers
+    class Abstract
+      include TypeCheck
+      attr_reader :value
+
+      def initialize
+        @assign, @value, @matched = nil
+      end
+
+      def case(&block)
+        return self, block
+      end
+
+      alias_method :when, :case
+
+      def >(block)
+        return self, block
+      end
+
+      alias_method :>>, :>
+
+      def ~
+        @assign = true
+        self
+      end
+
+      def &(matcher)
+        And.new self, matcher
+      end
+
+      def |(matcher)
+        Or.new self, matcher
+      end
+
+      def !
+        Not.new self
+      end
+
+      def assign?
+        @assign
+      end
+
+      def matched?
+        @matched
+      end
+
+      def children_including_self
+        children.unshift self
+      end
+
+      def assigns
+        collect_assigns.tap do
+          return yield *assigns if block_given?
+        end
+      end
+
+      def to_a
+        assigns
+      end
+
+      def ===(other)
+        matching?(other).tap { |matched| @value = other if (@matched = matched) }
+      end
+
+      def assign_to_s
+        assign? ? '~' : ''
+      end
+
+      def inspect
+        to_s
+      end
+
+      def children
+        raise NotImplementedError
+      end
+
+      def to_s
+        raise NotImplementedError
+      end
+
+      def ==(other)
+        raise NotImplementedError
+      end
+
+      # TODO pretty_print for all matchers
+
+      protected
+
+      def matching?(other)
+        raise NotImplementedError
+      end
+
+      private
+
+      def collect_assigns
+        mine = @assign ? [@value] : []
+        children.inject(mine) { |assigns, child| assigns + child.assigns }
+      end
+
+      def matchable!(obj)
+        raise ArgumentError, 'object does not respond to :===' unless obj.respond_to? :===
+        obj
+      end
+
+      def find_children(collection)
+        collection.map do |matcher|
+          matcher if matcher.kind_of? Abstract
+        end.compact
+      end
+    end
+  end
+end

data/lib/algebrick/matchers/abstract_logic.rb

@@ -0,0 +1,38 @@
+#  Copyright 2013 Petr Chalupa <git+algebrick@pitr.ch>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+module Algebrick
+  module Matchers
+    class AbstractLogic < Abstract
+      def self.call(*matchers)
+        new *matchers
+      end
+
+      attr_reader :matchers
+
+      def initialize(*matchers)
+        @matchers = matchers.each { |m| matchable! m }
+      end
+
+      def children
+        find_children matchers
+      end
+
+      def ==(other)
+        other.kind_of? self.class and
+            self.matchers == other.matchers
+      end
+    end
+  end
+end

data/lib/algebrick/matchers/and.rb

@@ -0,0 +1,29 @@
+#  Copyright 2013 Petr Chalupa <git+algebrick@pitr.ch>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+module Algebrick
+  module Matchers
+    class And < AbstractLogic
+      def to_s
+        matchers.join ' & '
+      end
+
+      protected
+
+      def matching?(other)
+        matchers.all? { |m| m === other }
+      end
+    end
+  end
+end

data/lib/algebrick/matchers/any.rb

@@ -0,0 +1,37 @@
+#  Copyright 2013 Petr Chalupa <git+algebrick@pitr.ch>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+module Algebrick
+  module Matchers
+    class Any < Abstract
+      def children
+        []
+      end
+
+      def to_s
+        assign_to_s + 'any'
+      end
+
+      def ==(other)
+        other.kind_of? self.class
+      end
+
+      protected
+
+      def matching?(other)
+        true
+      end
+    end
+  end
+end

data/lib/algebrick/matchers/array.rb

@@ -0,0 +1,57 @@
+#  Copyright 2013 Petr Chalupa <git+algebrick@pitr.ch>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+module Algebrick
+  module Matchers
+    class Array < Abstract
+      def self.call(*matchers)
+        new *matchers
+      end
+
+      attr_reader :matchers
+
+      def initialize(*matchers)
+        super()
+        @matchers = matchers
+      end
+
+      def children
+        find_children @matchers
+      end
+
+      def to_s
+        "#{assign_to_s}#{"Array.(#{matchers.join(',')})" if matchers}"
+      end
+
+      def ==(other)
+        other.kind_of? self.class and
+            self.matchers == other.matchers
+      end
+
+      protected
+
+      def matching?(other)
+        other.kind_of? ::Array and
+            matchers.size == other.size and
+            matchers.each_with_index.all? { |m, i| m === other[i] }
+      end
+    end
+
+    class ::Array
+      def self.call(*matchers)
+        Matchers::Array.new *matchers
+      end
+    end
+  end
+end

data/lib/algebrick/matchers/atom.rb

@@ -0,0 +1,28 @@
+#  Copyright 2013 Petr Chalupa <git+algebrick@pitr.ch>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+module Algebrick
+  module Matchers
+    class Atom < Wrapper
+      def initialize(something)
+        Type! something, Algebrick::Atom
+        super something
+      end
+
+      def to_s
+        assign_to_s + "#{@something.name}.to_m"
+      end
+    end
+  end
+end

data/lib/algebrick/matchers/not.rb

@@ -0,0 +1,44 @@
+#  Copyright 2013 Petr Chalupa <git+algebrick@pitr.ch>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+module Algebrick
+  module Matchers
+    class Not < Abstract
+      attr_reader :matcher
+
+      def initialize(matcher)
+        @matcher = matcher
+      end
+
+      def children
+        []
+      end
+
+      def to_s
+        '!' + matcher.to_s
+      end
+
+      def ==(other)
+        other.kind_of? self.class and
+            self.matcher == other.matcher
+      end
+
+      protected
+
+      def matching?(other)
+        not matcher === other
+      end
+    end
+  end
+end

data/lib/algebrick/matchers/or.rb

@@ -0,0 +1,51 @@
+#  Copyright 2013 Petr Chalupa <git+algebrick@pitr.ch>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+module Algebrick
+  module Matchers
+    #noinspection RubyClassModuleNamingConvention
+    class Or < AbstractLogic
+      def to_s
+        matchers.join ' | '
+      end
+
+      protected
+
+      def matching?(other)
+        matchers.any? { |m| m === other }
+      end
+
+      alias_method :super_children, :children
+      private :super_children
+
+      def children
+        super.select &:matched?
+      end
+
+      private
+
+      def collect_assigns
+        super.tap do |assigns|
+          missing = assigns_size - assigns.size
+          assigns.push(*::Array.new(missing))
+        end
+      end
+
+      def assigns_size
+        # TODO is it efficient?
+        super_children.map { |ch| ch.assigns.size }.max
+      end
+    end
+  end
+end

data/lib/algebrick/matchers/product.rb

@@ -0,0 +1,73 @@
+#  Copyright 2013 Petr Chalupa <git+algebrick@pitr.ch>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+module Algebrick
+  module Matchers
+    class Product < Abstract
+      attr_reader :algebraic_type, :field_matchers
+
+      def initialize(algebraic_type, *field_matchers)
+        super()
+        @algebraic_type = Type! algebraic_type, Algebrick::ProductVariant, Algebrick::ParametrizedType
+        raise ArgumentError unless algebraic_type.fields
+        @field_matchers = case
+
+                            # AProduct.()
+                          when field_matchers.empty?
+                            ::Array.new(algebraic_type.fields.size) { Algebrick.any }
+
+                            # AProduct.(field_name: a_matcher)
+                          when field_matchers.size == 1 && field_matchers.first.is_a?(Hash)
+                            field_matchers = field_matchers.first
+                            unless (dif = field_matchers.keys - algebraic_type.field_names).empty?
+                              raise ArgumentError, "no #{dif} fields in #{algebraic_type}"
+                            end
+                            algebraic_type.field_names.map do |field|
+                              field_matchers.key?(field) ? field_matchers[field] : Algebrick.any
+                            end
+
+                            # normal
+                          else
+                            field_matchers
+                          end
+        unless algebraic_type.fields.size == @field_matchers.size
+          raise ArgumentError
+        end
+      end
+
+      def children
+        find_children @field_matchers
+      end
+
+      def to_s
+        assign_to_s + "#{@algebraic_type.name}.(#{@field_matchers.join(', ')})"
+      end
+
+      def ==(other)
+        other.kind_of? self.class and
+            self.algebraic_type == other.algebraic_type and
+            self.field_matchers == other.field_matchers
+      end
+
+      protected
+
+      def matching?(other)
+        other.kind_of?(@algebraic_type) and other.kind_of?(ProductConstructors::Abstract) and
+            @field_matchers.zip(other.fields).all? do |matcher, field|
+              matcher === field
+            end
+      end
+    end
+  end
+end