algebrick 0.4.0 → 0.5.0

data/lib/algebrick/matchers/variant.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 Variant < Wrapper
+      def initialize(something)
+        raise ArgumentError unless something.variants
+        Type! something, Algebrick::ProductVariant
+        super something
+      end
+
+      def to_s
+        assign_to_s + "#{@something.name}.to_m"
+      end
+    end
+  end
+end

data/lib/algebrick/matchers/wrapper.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
+    # wraps any object having #=== method into matcher
+    class Wrapper < Abstract
+      def self.call(something)
+        new something
+      end
+
+      attr_reader :something
+
+      def initialize(something)
+        super()
+        @something = matchable! something
+      end
+
+      def children
+        find_children [@something]
+      end
+
+      def to_s
+        assign_to_s + "Wrapper.(#{@something})"
+      end
+
+      def ==(other)
+        other.kind_of? self.class and
+            self.something == other.something
+      end
+
+      protected
+
+      def matching?(other)
+        @something === other
+      end
+    end
+
+    # allow to convert any object to matcher if it has #=== method
+    class ::Object
+      def to_m
+        Wrapper.new(self)
+      end
+    end
+  end
+end

data/lib/algebrick/matchers.rb

@@ -0,0 +1,31 @@
+#  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
+
+    require 'algebrick/matchers/abstract'
+    require 'algebrick/matchers/abstract_logic'
+    require 'algebrick/matchers/and'
+    require 'algebrick/matchers/or'
+    require 'algebrick/matchers/not'
+    require 'algebrick/matchers/any'
+    require 'algebrick/matchers/wrapper'
+    require 'algebrick/matchers/array'
+    require 'algebrick/matchers/product'
+    require 'algebrick/matchers/variant'
+    require 'algebrick/matchers/atom'
+
+  end
+end

data/lib/algebrick/matching.rb

@@ -0,0 +1,62 @@
+#  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
+  # include this module anywhere yoy need to use pattern matching
+  module Matching
+    def any
+      Matchers::Any.new
+    end
+
+    def match(value, *cases)
+      cases = if cases.size == 1 && cases.first.is_a?(Hash)
+                cases.first
+              else
+                cases
+              end
+
+      cases.each do |matcher, block|
+        return Matching.match_value matcher, block if matcher === value
+      end
+      raise "no match for (#{value.class}) '#{value}' by any of #{cases.map(&:first).join ', '}"
+    end
+
+    def on(matcher, value = nil, &block)
+      matcher = if matcher.is_a? Matchers::Abstract
+                  matcher
+                else
+                  matcher.to_m
+                end
+      raise ArgumentError, 'only one of block or value can be supplied' if block && value
+      [matcher, value || block]
+    end
+
+    private
+
+    def self.match_value(matcher, block)
+      if block.kind_of? Proc
+        if matcher.kind_of? Matchers::Abstract
+          matcher.assigns &block
+        else
+          block.call
+        end
+      else
+        block
+      end
+    end
+  end
+
+  include Matching
+  extend Matching
+end

data/lib/algebrick/parametrized_type.rb

@@ -0,0 +1,122 @@
+#  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
+  require 'monitor'
+
+  class ParametrizedType < Type
+    include TypeCheck
+    include MatcherDelegations
+    include FieldMethodReaders
+
+    attr_reader :variables, :fields, :variants
+
+    def initialize(variables)
+      @variables     = variables.each { |v| Type! v, Symbol }
+      @fields        = nil
+      @variants      = nil
+      @cache         = {}
+      @cache_barrier = Monitor.new
+    end
+
+    def set_fields(fields)
+      @fields      = Type! fields, Hash, Array
+      @field_names = case @fields
+                     when Hash
+                       @fields.keys
+                     when Array, nil
+                       nil
+                     else
+                       raise
+                     end
+    end
+
+    def set_variants(*variants)
+      @variants = Type! variants, Array
+    end
+
+    def [](*assigned_types)
+      @cache_barrier.synchronize do
+        @cache[assigned_types] || begin
+          raise ArgumentError unless assigned_types.size == variables.size
+          ProductVariant.new(type_name(assigned_types)).tap do |type|
+            type.be_kind_of self
+            @cache[assigned_types] = type
+            type.assigned_types    = assigned_types
+            type.set_variants *insert_types(variants, assigned_types) if variants
+            type.set_fields insert_types(fields, assigned_types) if fields
+          end
+        end
+      end
+    end
+
+    def generic
+      @generic ||= self[*Array(variables.size) { Object }]
+    end
+
+    def to_s
+      "#{name}[#{variables.join(', ')}]"
+    end
+
+    def inspect
+      to_s
+    end
+
+    def to_m
+      if @variants
+        Matchers::Variant.new self
+      else
+        Matchers::Product.new self
+      end
+    end
+
+    def call(*field_matchers)
+      raise TypeError unless @fields
+      Matchers::Product.new self, *field_matchers
+    end
+
+    def ==(other)
+      other.kind_of? ParametrizedType and
+          self.generic == other.generic
+    end
+
+    private
+
+    def insert_types(types, assigned_types)
+      case types
+      when Hash
+        types.inject({}) { |h, (k, v)| h.update k => insert_type(v, assigned_types) }
+      when Array
+        types.map { |v| insert_type v, assigned_types }
+      else
+        raise ArgumentError
+      end
+    end
+
+    def insert_type(type, assigned_types)
+      case type
+      when Symbol
+        assigned_types[variables.index type]
+      when ParametrizedType
+        type[*type.variables.map { |v| assigned_types[variables.index v] }]
+      else
+        type
+      end
+    end
+
+    def type_name(assigned_types)
+      "#{name}[#{assigned_types.join(', ')}]"
+    end
+  end
+end

data/lib/algebrick/product_constructors/abstract.rb

@@ -0,0 +1,70 @@
+#  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 ProductConstructors
+    class Abstract
+      include Value
+      extend TypeCheck
+      attr_reader :fields
+
+      def initialize(*fields)
+        if fields.size == 1 && fields.first.is_a?(Hash)
+          fields = type.field_names.map { |k| fields.first[k] }
+        end
+        @fields = fields.zip(self.class.type.fields).map { |field, type| Type! field, type }.freeze
+      end
+
+      def to_ary
+        @fields
+      end
+
+      def to_a
+        @fields
+      end
+
+      def ==(other)
+        return false unless other.kind_of? self.class
+        @fields == other.fields
+      end
+
+      def self.type
+        @type || raise
+      end
+
+      def type
+        self.class.type
+      end
+
+      def self.name
+        @type.to_s
+      end
+
+      def self.to_s
+        name
+      end
+
+      def self.type=(type)
+        Type! type, ProductVariant
+        raise if @type
+        @type = type
+        include type
+      end
+
+      def update(*fields)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/algebrick/product_constructors/basic.rb

@@ -0,0 +1,47 @@
+#  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 ProductConstructors
+    class Basic < Abstract
+      def to_s
+        "#{self.class.type.name}[" +
+            fields.map(&:to_s).join(', ') + ']'
+      end
+
+      def pretty_print(q)
+        q.group(1, "#{self.class.type.name}[", ']') do
+          fields.each_with_index do |value, i|
+            if i == 0
+              q.breakable ''
+            else
+              q.text ','
+              q.breakable ' '
+            end
+            q.pp value
+          end
+        end
+      end
+
+      def self.type=(type)
+        super(type)
+        raise if type.field_names?
+      end
+
+      def update(fields)
+        type[*fields]
+      end
+    end
+  end
+end

data/lib/algebrick/product_constructors/named.rb

@@ -0,0 +1,58 @@
+#  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 ProductConstructors
+    class Named < Abstract
+      def to_s
+        "#{self.class.type.name}[" +
+            type.field_names.map { |name| "#{name}: #{self[name].to_s}" }.join(', ') +']'
+      end
+
+      def pretty_print(q)
+        q.group(1, "#{self.class.type.name}[", ']') do
+          type.field_names.each_with_index do |name, i|
+            if i == 0
+              q.breakable ''
+            else
+              q.text ','
+              q.breakable ' '
+            end
+            q.text name.to_s
+            q.text ':'
+            q.group(1) do
+              q.breakable ' '
+              q.pp self[name]
+            end
+          end
+        end
+      end
+
+      def to_hash
+        type.field_names.inject({}) { |h, name| h.update name => self[name] }
+      end
+
+      alias_method :to_h, :to_hash
+
+      def self.type=(type)
+        super(type)
+        raise unless type.field_names?
+      end
+
+      def update(fields)
+        type[to_hash.merge fields]
+      end
+    end
+  end
+end

data/lib/algebrick/product_constructors.rb

@@ -0,0 +1,25 @@
+#  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
+
+  # A private classes used for Product values creation
+  module ProductConstructors
+
+    require 'algebrick/product_constructors/abstract'
+    require 'algebrick/product_constructors/basic'
+    require 'algebrick/product_constructors/named'
+
+  end
+end

data/lib/algebrick/product_variant.rb

@@ -0,0 +1,195 @@
+#  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
+  # Representation of Product and Variant types. The class behaves differently
+  # based on #kind.
+  #noinspection RubyTooManyMethodsInspection
+  class ProductVariant < Type
+    # TODO split up into classes or modules
+    # TODO aliases for fields, (update matchers)
+
+    include FieldMethodReaders
+    attr_reader :fields, :variants
+
+    def initialize(name, &definition)
+      super(name, &definition)
+      @to_be_kind_of = []
+      @final_variants  = false
+    end
+
+    def set_fields(fields_or_hash)
+      raise TypeError, 'can be set only once' if @fields
+      @kind        = nil
+      fields, keys = case fields_or_hash
+                     when Hash
+                       [fields_or_hash.values, fields_or_hash.keys]
+                     when Array
+                       [fields_or_hash, nil]
+                     else
+                       raise ArgumentError
+                     end
+
+      add_field_names keys if keys
+
+      fields.all? { |f| Type! f, Type, Class, Module }
+      raise TypeError, 'there is no product with zero fields' unless fields.size > 0
+      define_method(:value) { @fields.first } if fields.size == 1
+      @fields      = fields
+      @constructor = Class.new(
+          field_names? ? ProductConstructors::Named : ProductConstructors::Basic).
+          tap { |c| c.type = self }
+      const_set :Constructor, @constructor
+      apply_be_kind_of
+      self
+    end
+
+    def field_indexes
+      @field_indexes or raise TypeError, "field names not defined on #{self}"
+    end
+
+    def field(name)
+      fields[field_indexes[name]]
+    end
+
+    def final!
+      @final_variants = true
+      self
+    end
+
+    def set_variants(*variants)
+      raise TypeError, 'can be set only once' if @variants && @final_variants
+      @kind = nil
+      variants.all? { |v| Type! v, Type, Class }
+      @variants ||= []
+      @variants += variants
+      apply_be_kind_of
+      variants.each do |v|
+        if v.respond_to? :be_kind_of
+          v.be_kind_of self
+        else
+          v.send :include, self
+        end
+      end
+      self
+    end
+
+    def new(*fields)
+      raise TypeError, "#{self} does not have fields" unless @constructor
+      @constructor.new *fields
+    end
+
+    alias_method :[], :new
+
+    def ==(other)
+      other.kind_of? ProductVariant and
+          variants == other.variants and fields == other.fields
+    end
+
+    def be_kind_of(type)
+      @to_be_kind_of << type
+      apply_be_kind_of
+    end
+
+    def apply_be_kind_of
+      @to_be_kind_of.each do |type|
+        @constructor.send :include, type if @constructor
+        variants.each { |v| v.be_kind_of type unless v == self } if @variants
+      end
+    end
+
+    def call(*field_matchers)
+      raise TypeError, "#{self} does not have any fields" unless @fields
+      Matchers::Product.new self, *field_matchers
+    end
+
+    def to_m
+      case kind
+      when :product
+        Matchers::Product.new self
+      when :product_variant
+        Matchers::Variant.new self
+      when :variant
+        Matchers::Variant.new self
+      else
+        raise
+      end
+    end
+
+    def to_s
+      case kind
+      when :product
+        product_to_s
+      when :product_variant
+        name + '(' +
+            variants.map do |variant|
+              if variant == self
+                product_to_s
+              else
+                variant.name
+              end
+            end.join(' | ') +
+            ')'
+      when :variant
+        "#{name}(#{variants.map(&:name).join ' | '})"
+      else
+        raise
+      end
+    end
+
+    #noinspection RubyCaseWithoutElseBlockInspection
+    def kind
+      @kind ||= case
+                when @fields && !@variants
+                  :product
+                when @fields && @variants
+                  :product_variant
+                when !@fields && @variants
+                  :variant
+                when !@fields && !@variants
+                  raise TypeError, 'fields or variants have to be set'
+                end
+    end
+
+    def assigned_types
+      @assigned_types or raise TypeError, "#{self} does not have assigned types"
+    end
+
+    def assigned_types=(assigned_types)
+      raise TypeError, "#{self} assigned types already set" if @assigned_types
+      @assigned_types = assigned_types
+    end
+
+    private
+
+    def product_to_s
+      fields_str = if field_names?
+                     field_names.zip(fields).map { |name, field| "#{name}: #{field.name}" }
+                   else
+                     fields.map(&:name)
+                   end
+      "#{name}(#{fields_str.join ', '})"
+    end
+
+    def add_field_names(names)
+      @field_names = names
+      names.all? { |k| Type! k, Symbol }
+      dict = @field_indexes =
+          Hash.new { |_, k| raise ArgumentError, "unknown field #{k.inspect} in #{self}" }.
+              update names.each_with_index.inject({}) { |h, (k, i)| h.update k => i }
+      define_method(:[]) { |key| @fields[dict[key]] }
+      # TODO use attr_readers to speed things up
+    end
+  end
+end