algebrick 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 13d3ecc1ea957d30796a0a4a66c670707c52d12c
-  data.tar.gz: 90fdd38aaee376f2b48c7c8885e979cc5e3b634d
+  metadata.gz: 89c05ba82f9bb193d0cf67ba85d5fc8138d2a3a3
+  data.tar.gz: 2dd790e7a2b66e0ae466c2422a053f7acd280e2d
 SHA512:
-  metadata.gz: a0a8bdc76d1fd32d8c3e9f214a03eb9d9802def07fdc5dd0e407b72edb5b53d2c87030bddb01f243afb4a086baff074b058a190f7737bf1d4104248853802517
-  data.tar.gz: 435a6f291c7c9c4d7cad122a0c412627c95182b3a06e54c32d79d49d3d0cc30b965eb6f8d79e22b9234797fc3802f289d7eeb3ed4c69602146c647958202aba7
+  metadata.gz: db7d3e5b6f804119b92dd522cf1860fe6c26bf16b14be44c352f82b74728fc563a4665ed698f2fb7f63d8c70d84585abf14a4088cce580da735e6073237073d7
+  data.tar.gz: ca7af9d723d0c8b57397be9b9cd259a274cd98970af2852257e0d52d786eea9b2e3f822a15abb6bf916b70d7cbda8c64a6ada87f34f9670673474f3f038e77e2

data/README_FULL.md

@@ -93,9 +93,3 @@ Just small snippet from a gem I am still working on.
               end
       end
     end
-
-### TODO
-
--   Menu model, TypedArray
--   update actor pattern when gem is done
--   example with birth-number Valid|Invalid

data/VERSION

@@ -1 +1 @@
-0.2.2
+0.2.3

data/lib/algebrick.rb

@@ -15,6 +15,11 @@
 
 # TODO method definition in variant type defines methods on variants based on match, better performance?
 # TODO type variables/constructor maybe(a) === none | a
+# TODO add matcher/s for Hash
+# TODO add method matcher (:size, matcher)
+# TODO Menu modeling example, add TypedArray
+# TODO update actor pattern example when gem is done
+# TODO example with birth-number Valid|Invalid
 
 require 'set'
 
@@ -283,7 +288,7 @@ module Algebrick
 
     def to_s
       "#{self.class.type.name}[" +
-          if type.field_names
+          if type.field_names?
             type.field_names.map { |name| "#{name}: #{self[name].to_s}" }.join(', ')
           else
             fields.map(&:to_s).join(',')
@@ -300,7 +305,7 @@ module Algebrick
 
     def to_hash
       { TYPE_KEY => self.class.type.name }.
-          update(if type.field_names
+          update(if type.field_names?
                    type.field_names.inject({}) { |h, name| h.update name => hashize(self[name]) }
                  else
                    { FIELDS_KEY => fields.map { |v| hashize v } }
@@ -334,7 +339,7 @@ module Algebrick
   end
 
   class ProductVariant < Type
-    attr_reader :fields, :field_names, :field_indexes, :variants
+    attr_reader :fields, :variants
 
     def set_fields(fields_or_hash)
       raise TypeError, 'can be set only once' if @fields
@@ -346,16 +351,28 @@ module Algebrick
 
       set_field_names keys if keys
 
-      fields.all? { |f| is_kind_of! f, Type, Class }
+      fields.all? { |f| is_kind_of! 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(ProductConstructor).tap { |c| c.type = self }
     end
 
+    def field_names
+      @field_names or raise TypeError, "field names not defined on #{self}"
+    end
+
+    def field_names?
+      !!@field_names
+    end
+
+    def field_indexes
+      @field_indexes or raise TypeError, "field names not defined on #{self}"
+    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 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
@@ -486,7 +503,7 @@ module Algebrick
     private
 
     def product_to_s
-      fields_str = if field_names
+      fields_str = if field_names?
                      field_names.zip(fields).map { |name, field| "#{name}: #{field.name}" }
                    else
                      fields.map(&:name)
@@ -517,7 +534,7 @@ module Algebrick
         self[*fields.map { |value| field_from_hash value }]
       when Hash
         self[fields.inject({}) do |h, (name, value)|
-          raise ArgumentError unless @field_names.map(&:to_s).include? name.to_s
+          raise ArgumentError unless field_names.map(&:to_s).include? name.to_s
           h.update name.to_sym => field_from_hash(value)
         end]
       end
@@ -542,52 +559,80 @@ module Algebrick
     end
   end
 
-  class TypeDefinitionScope
-    attr_reader :new_type
+  module DSL
+    module Shortcuts
+      def type(&block)
+        Algebrick.type &block
+      end
 
-    def initialize(&block)
-      @new_type = ProductVariant.new nil
-      instance_exec @new_type, &block
-      @new_type.kind
+      def atom
+        Algebrick.atom
+      end
     end
 
-    def fields(*fields)
-      @new_type.set_fields fields
-      self
-    end
+    class TypeDefinitionScope
+      include Shortcuts
 
-    def variants(*variants)
-      @new_type.set_variants variants
-      self
-    end
+      attr_reader :new_type
 
-    def type(&block)
-      Algebrick.type &block
-    end
+      def initialize(&block)
+        @new_type = ProductVariant.new nil
+        instance_exec @new_type, &block
+        @new_type.kind
+      end
 
-    def field_readers(*names)
-      @new_type.add_field_method_readers *names
-      self
+      def fields(*fields)
+        @new_type.set_fields fields
+        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
 
-    alias_method :readers, :field_readers
+    class OuterShellImpl
+      include Shortcuts
 
-    def all_field_readers
-      @new_type.add_all_field_method_readers
-      self
+      def run(&block)
+        instance_eval &block
+      end
     end
 
-    alias_method :all_readers, :all_field_readers
+    OuterShell = OuterShellImpl.new
   end
 
   def self.type(&block)
     if block.nil?
-      Atom.new nil
+      atom
     else
-      TypeDefinitionScope.new(&block).new_type
+      DSL::TypeDefinitionScope.new(&block).new_type
     end
   end
 
+  def self.atom
+    Atom.new nil
+  end
+
+  def self.types(&block)
+    DSL::OuterShell.run &block
+  end
+
   module Matchers
 
     class Abstract
@@ -897,20 +942,39 @@ module Algebrick
       end
     end
 
-    # TODO Hash matcher
-    # TODO Method matcher (:size, matcher)
-
     class Product < Abstract
-      # TODO allow to match by field_name e.g. Address.(:street)
       attr_reader :algebraic_type, :field_matchers
 
       def initialize(algebraic_type, *field_matchers)
         super()
         @algebraic_type = is_kind_of! algebraic_type, Algebrick::ProductVariant
         raise ArgumentError unless algebraic_type.fields
-        field_matchers  += ::Array.new(algebraic_type.fields.size) { Algebrick.any } if field_matchers.empty?
-        @field_matchers = field_matchers
-        raise ArgumentError unless algebraic_type.fields.size == field_matchers.size
+        @field_matchers = case
+                          when field_matchers.empty?
+                            ::Array.new(algebraic_type.fields.size) { Algebrick.any }
+
+                          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[field] || Algebrick.any
+                            end
+                          when field_matchers.is_a?(::Array) && field_matchers.all? { |v| v.is_a? Symbol }
+                            unless (dif = field_matchers - algebraic_type.field_names).empty?
+                              raise ArgumentError, "no #{dif} fields in #{algebraic_type}"
+                            end
+                            algebraic_type.field_names.map do |field|
+                              field_matchers.include?(field) ? ~Algebrick.any : Algebrick.any
+                            end
+
+                          else
+                            field_matchers
+                          end
+        unless algebraic_type.fields.size == @field_matchers.size
+          raise ArgumentError
+        end
       end
 
       def children

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: algebrick
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Petr Chalupa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-17 00:00:00.000000000 Z
+date: 2013-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest