qrb 0.1.0

data/lib/qrb.rb

@@ -0,0 +1,63 @@
+require 'set'
+require 'time'
+
+#
+# Q - in Ruby
+#
+module Qrb
+
+  DSL_METHODS = [
+    :attribute,
+    :heading,
+    :constraints,
+    :builtin,
+    :adt,
+    :subtype,
+    :union,
+    :seq,
+    :set,
+    :tuple,
+    :relation,
+    :type
+  ]
+
+  require_relative "qrb/version"
+  require_relative "qrb/errors"
+  require_relative "qrb/support"
+  require_relative 'qrb/type'
+  require_relative 'qrb/data_type'
+  require_relative 'qrb/system'
+
+  DEFAULT_FACTORY = TypeFactory.new
+
+  IDENTITY = ->(object){ object }
+
+  DSL_METHODS.each do |meth|
+    define_method(meth) do |*args, &bl|
+      DEFAULT_FACTORY.public_send(meth, *args, &bl)
+    end
+  end
+
+  def parse(source)
+    require "qrb/syntax"
+    Syntax.compile(source)
+  end
+
+  def system(identifier)
+    f = File.expand_path("../qrb/#{identifier}.q", __FILE__)
+    if File.exists?(f)
+      parse(File.read(f))
+    else
+      raise Error, "Unknown system #{identifier}"
+    end
+  end
+
+  def definition_files(of)
+    dir = File.expand_path("../qrb/#{of}", __FILE__)
+    Dir.glob("#{dir}/*.q")
+  end
+
+  extend self
+
+  DEFAULT_SYSTEM = system('Q/default')
+end # module Qrb

data/qrb.gemspec

@@ -0,0 +1,186 @@
+# We require your library, mainly to have access to the VERSION number.
+# Feel free to set $version manually.
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+require "qrb/version"
+$version = Qrb::Version.to_s
+
+#
+# This is your Gem specification. Default values are provided so that your library
+# should be correctly packaged given what you have described in the .noespec file.
+#
+Gem::Specification.new do |s|
+
+  ################################################################### ABOUT YOUR GEM
+
+  # Gem name (required)
+  s.name = "qrb"
+
+  # Gem version (required)
+  s.version = $version
+
+  # A short summary of this gem
+  #
+  # This is displayed in `gem list -d`.
+  s.summary = "Q - in Ruby"
+
+  # A long description of this gem (required)
+  #
+  # The description should be more detailed than the summary.  For example,
+  # you might wish to copy the entire README into the description.
+  s.description = "Implements the Q information language in Ruby."
+
+  # The URL of this gem home page (optional)
+  s.homepage = "https://github.com/blambeau/qrb"
+
+  # Gem publication date (required but auto)
+  #
+  # Today is automatically used by default, uncomment only if
+  # you know what you do!
+  #
+  # s.date = Time.now.strftime('%Y-%m-%d')
+
+  # The license(s) for the library.  Each license must be a short name, no
+  # more than 64 characters.
+  #
+  # s.licences = %w{}
+
+  # The rubyforge project this gem lives under (optional)
+  #
+  # s.rubyforge_project = nil
+
+  ################################################################### ABOUT THE AUTHORS
+
+  # The list of author names who wrote this gem.
+  #
+  # If you are providing multiple authors and multiple emails they should be
+  # in the same order.
+  #
+  s.authors = ["Bernard Lambeau"]
+
+  # Contact emails for this gem
+  #
+  # If you are providing multiple authors and multiple emails they should be
+  # in the same order.
+  #
+  # NOTE: Somewhat strangly this attribute is always singular!
+  #       Don't replace by s.emails = ...
+  s.email  = ["blambeau@gmail.com"]
+
+  ################################################################### PATHS, FILES, BINARIES
+
+  # Paths in the gem to add to $LOAD_PATH when this gem is
+  # activated (required).
+  #
+  # The default 'lib' is typically sufficient.
+  s.require_paths = ["lib"]
+
+  # Files included in this gem.
+  #
+  # By default, we take all files included in the Manifest.txt file on root
+  # of the project. Entries of the manifest are interpreted as Dir[...]
+  # patterns so that lazy people may use wilcards like lib/**/*
+  #
+  here = File.expand_path(File.dirname(__FILE__))
+  s.files = File.readlines(File.join(here, 'Manifest.txt')).
+                 inject([]){|files, pattern| files + Dir[File.join(here, pattern.strip)]}.
+                 collect{|x| x[(1+here.size)..-1]}
+
+  # Test files included in this gem.
+  #
+  s.test_files = Dir["test/**/*"] + Dir["spec/**/*"]
+
+  # The path in the gem for executable scripts (optional)
+  #
+  s.bindir = "bin"
+
+  # Executables included in the gem.
+  #
+  s.executables = (Dir["bin/*"]).collect{|f| File.basename(f)}
+
+  ################################################################### REQUIREMENTS & INSTALL
+  # Remember the gem version requirements operators and schemes:
+  #   =  Equals version
+  #   != Not equal to version
+  #   >  Greater than version
+  #   <  Less than version
+  #   >= Greater than or equal to
+  #   <= Less than or equal to
+  #   ~> Approximately greater than
+  #
+  # Don't forget to have a look at http://lmgtfy.com/?q=Ruby+Versioning+Policies
+  # for setting your gem version.
+  #
+  # For your requirements to other gems, remember that
+  #   ">= 2.2.0"              (optimistic:  specify minimal version)
+  #   ">= 2.2.0", "< 3.0"     (pessimistic: not greater than the next major)
+  #   "~> 2.2"                (shortcut for ">= 2.2.0", "< 3.0")
+  #   "~> 2.2.0"              (shortcut for ">= 2.2.0", "< 2.3.0")
+  #
+
+  #
+  # One call to add_dependency('gem_name', 'gem version requirement') for each
+  # runtime dependency. These gems will be installed with your gem.
+  # One call to add_development_dependency('gem_name', 'gem version requirement')
+  # for each development dependency. These gems are required for developers
+  #
+  s.add_development_dependency("rake", "~> 10.0")
+  s.add_development_dependency("rspec", "~> 2.14")
+  
+
+  # The version of ruby required by this gem
+  #
+  # Uncomment and set this if your gem requires specific ruby versions.
+  #
+  # s.required_ruby_version = ">= 0"
+
+  # The RubyGems version required by this gem
+  #
+  # s.required_rubygems_version = ">= 0"
+
+  # The platform this gem runs on.  See Gem::Platform for details.
+  #
+  # s.platform = nil
+
+  # Extensions to build when installing the gem.
+  #
+  # Valid types of extensions are extconf.rb files, configure scripts
+  # and rakefiles or mkrf_conf files.
+  #
+  s.extensions = []
+
+  # External (to RubyGems) requirements that must be met for this gem to work.
+  # It’s simply information for the user.
+  #
+  s.requirements = nil
+
+  # A message that gets displayed after the gem is installed
+  #
+  # Uncomment and set this if you want to say something to the user
+  # after gem installation
+  #
+  s.post_install_message = nil
+
+  ################################################################### SECURITY
+
+  # The key used to sign this gem.  See Gem::Security for details.
+  #
+  # s.signing_key = nil
+
+  # The certificate chain used to sign this gem.  See Gem::Security for
+  # details.
+  #
+  # s.cert_chain = []
+
+  ################################################################### RDOC
+
+  # An ARGV style array of options to RDoc
+  #
+  # See 'rdoc --help' about this
+  #
+  s.rdoc_options = []
+
+  # Extra files to add to RDoc such as README
+  #
+  s.extra_rdoc_files = Dir["README.md"] + Dir["CHANGELOG.md"] + Dir["LICENCE.md"]
+
+end

data/spec/acceptance/Q/test_default.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+module Qrb
+  describe "Q/default" do
+
+    let(:system){ Qrb.system('Q/default') }
+
+    describe 'Boolean' do
+      let(:type){ system['Boolean'] }
+
+      it 'recognizes true' do
+        type.dress(true).should eq(true)
+      end
+
+      it 'recognizes false' do
+        type.dress(false).should eq(false)
+      end
+
+      it 'raises on something else' do
+        ->{ type.dress("foo") }.should raise_error(TypeError)
+      end
+    end
+
+    describe 'Date' do
+      let(:type){ system['Date'] }
+
+      let(:expected){ Date.new(2014, 11, 9) }
+
+      it 'recognizes dates' do
+        type.dress(expected).should be(expected)
+      end
+
+      it 'recognizes iso8601 dates' do
+        type.dress('2014-11-09').should eq(expected)
+      end
+
+      it 'recognizes the output of iso8601' do
+        type.dress(expected.iso8601).should eq(expected)
+      end
+
+      it 'raises on something else' do
+        ->{
+          type.dress('foo')
+        }.should raise_error("Invalid value `foo` for Date")
+      end
+    end
+
+    describe 'Time' do
+      let(:type){ system['Time'] }
+
+      let(:expected){ Time.new(2014,3,1,12,9,31) }
+
+      it 'recognizes times' do
+        type.dress(expected).should be(expected)
+      end
+
+      it 'recognizes iso8601 times' do
+        type.dress('2014-03-01T12:09:31').should eq(expected)
+      end
+
+      it 'recognizes the output of iso8601' do
+        type.dress(expected.iso8601).should eq(expected)
+      end
+
+      it 'raises on something else' do
+        ->{
+          type.dress('foo')
+        }.should raise_error("Invalid value `foo` for Time")
+      end
+    end
+
+    describe 'DateTime' do
+      let(:type){ system['DateTime'] }
+
+      let(:expected){ DateTime.new(2014,3,1,12,9,31) }
+
+      it 'recognizes times' do
+        type.dress(expected).should be(expected)
+      end
+
+      it 'recognizes iso8601 times' do
+        type.dress('2014-03-01T12:09:31').should eq(expected)
+      end
+
+      it 'recognizes the output of iso8601' do
+        type.dress(expected.iso8601).should eq(expected)
+      end
+
+      it 'raises on something else' do
+        ->{
+          type.dress('foo')
+        }.should raise_error("Invalid value `foo` for DateTime")
+      end
+    end
+
+  end
+end

data/spec/acceptance/Q/test_parsing.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+describe "Q definition files" do
+
+  Qrb.definition_files('Q').each do |file|
+    file = Path(file)
+
+    describe "Q/#{file.basename.rm_ext}" do
+
+      it 'should parse' do
+        Qrb.parse(file.read).should be_a(Qrb::System)
+      end
+    end
+  end
+
+end

data/spec/acceptance/ad_type/test_in_q.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+module Qrb
+  describe "Using Q's abstract data types in Ruby/Q" do
+
+    class MyColorClass
+      extend Qrb::DataType
+
+      def initialize(r, g, b)
+        @r, @g, @b = r, g, b
+      end
+      attr_reader :r, :g, :b
+
+      def to_rgb
+        { r: @r, g: @g, b: @b }
+      end
+
+      def self.rgb(tuple)
+        new(tuple[:r], tuple[:g], tuple[:b])
+      end
+    end
+
+    let(:system) do
+      Qrb.parse <<-EOF
+        Byte   = .Fixnum( i | i>=0 and i<= 255 )
+        Color  = .Qrb::MyColorClass <rgb> {r: Byte, g: Byte, b: Byte}
+        Gender = <mf> .String( s | s=='M' or s=='F' )
+      EOF
+    end
+
+    let(:color){
+      system["Color"]
+    }
+
+    describe 'the Color.dress method' do
+      subject{ color.dress(arg) }
+
+      context 'when valid' do
+        let(:arg){ {"r" => 12, "g" => 17, "b" => 71} }
+
+        it{ should be_a(MyColorClass) }
+
+        it 'should be the expected one' do
+          subject.r.should eq(12)
+          subject.g.should eq(17)
+          subject.b.should eq(71)
+        end
+      end
+
+      context 'when invalid' do
+        let(:arg){ {"r" => -12, "g" => 17, "b" => 71} }
+
+        it 'should raise an error' do
+          ->{
+            subject
+          }.should raise_error(TypeError)
+        end
+      end
+
+    end
+
+    describe 'the Gender.dress method' do
+      subject{ system['Gender'].dress(arg) }
+
+      context 'when valid' do
+        let(:arg){ 'M' }
+
+        it{ should eq('M') }
+      end
+
+      context 'when valid' do
+        let(:arg){ 'Monsieur' }
+
+        it 'should raise an error' do
+          ->{
+            subject
+          }.should raise_error(TypeError, "Invalid value `Monsieur` for Gender")
+        end
+      end
+    end
+
+  end
+end

data/spec/acceptance/ad_type/test_in_ruby.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+module Qrb
+  describe "Using Q's abstract data types in Ruby" do
+
+    let(:color) do
+      Class.new{
+        extend Qrb::DataType
+
+        def initialize(r, g, b)
+          @r, @g, @b = r, g, b
+        end
+        attr_reader :r, :g, :b
+
+        def to_rgb
+          { r: @r, g: @g, b: @b }
+        end
+
+        def self.rgb(tuple)
+          new(tuple[:r], tuple[:g], tuple[:b])
+        end
+
+        contract :rgb, {r: 0..255, g: 0..255, b: 0..255}
+      }
+    end
+
+    describe 'The factored class' do
+      subject{ color }
+
+      it{ should be_a(Class) }
+    end
+
+    describe 'the dress method, when valid' do
+
+      subject{
+        color.dress(r: 12, g: 13, b: 28)
+      }
+
+      it{ should be_a(color) }
+
+      it 'should set the instance variables correctly' do
+        subject.r.should eq(12)
+        subject.g.should eq(13)
+        subject.b.should eq(28)
+      end
+    end
+
+    describe 'the up method, when already a color' do
+      let(:value){
+        color.new(12, 13, 28)
+      }
+
+      subject{
+        color.dress(value)
+      }
+
+      it{ should be(value) }
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,68 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'path'
+require 'qrb'
+require 'qrb/syntax'
+
+require 'coveralls'
+Coveralls.wear!
+
+class Color
+
+  def initialize(r, g, b)
+    @r, @g, @b = r, g, b
+  end
+  attr_reader :r, :g, :b
+
+  def self.rgb(tuple)
+    new(tuple[:r], tuple[:g], tuple[:b])
+  end
+
+  def to_rgb
+    { r: @r, g: @g, b: @b }
+  end
+
+  def self.hex(s)
+    Color.new *[1, 3, 5].map{|i| s[i, 2].to_i(16) }
+  end
+
+  def to_hex
+    "#" << [r, g, b].map{|i| i.to_s(16) }.join
+  end
+
+  def ==(other)
+    other.is_a?(Color) and other.to_rgb == self.to_rgb
+  end
+
+end
+
+module SpecHelpers
+
+  def intType
+    Qrb::BuiltinType.new(Integer, "intType")
+  end
+
+  def floatType
+    Qrb::BuiltinType.new(Float, "floatType")
+  end
+
+  def nilType
+    Qrb::BuiltinType.new(NilClass, "nilType")
+  end
+
+  def byte
+    Qrb::SubType.new(intType, byte: ->(i){ i>=0 && i<=255 })
+  end
+
+  def type_factory
+    Qrb::TypeFactory.new
+  end
+
+  def blueviolet
+    Color.new(138, 43, 226)
+  end
+
+end
+
+RSpec.configure do |c|
+  c.include SpecHelpers
+end

data/spec/unit/attribute/test_equality.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+module Qrb
+  describe Attribute, "equality" do
+
+    let(:attr1){ Attribute.new(:red, intType) }
+    let(:attr2){ Attribute.new(:red, intType) }
+    let(:attr3){ Attribute.new(:blue, intType) }
+
+    it 'should apply structural equality' do
+      (attr1 == attr2).should be_true
+    end
+
+    it 'should distinguish different attributes' do
+      (attr1 == attr3).should be_false
+    end
+
+    it 'should return nil if not equal' do
+      (attr1 == 12).should be_nil
+    end
+
+    it 'should implement hash accordingly' do
+      attr1.hash.should eq(attr2.hash)
+    end
+
+  end
+end

data/spec/unit/attribute/test_fetch_on.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+module Qrb
+  describe Attribute, "fetch_on" do
+
+    let(:attr){ Attribute.new(:red, intType) }
+
+    subject{ attr.fetch_on(arg) }
+
+    context 'with an object that does not support fetch' do
+      let(:arg){ 12 }
+
+      it 'should raise an error' do
+        ->{
+          subject
+        }.should raise_error(ArgumentError, "Object responding to `fetch` expected")
+      end
+    end
+
+    context 'with a hash with symbol keys' do
+      let(:arg){ { red: 233 } }
+
+      it{ should eq(233) }
+    end
+
+    context 'with a hash with string keys' do
+      let(:arg){ { "red" => 233 } }
+
+      it{ should eq(233) }
+    end
+
+    context 'when the key is missing and no block' do
+      let(:arg){ { other: 123 } }
+
+      it 'should raise an error' do
+        ->{
+          attr.fetch_on(arg)
+        }.should raise_error(KeyError)
+      end
+    end
+
+    context 'when the key is missing and a block' do
+      let(:arg){ { other: 123 } }
+
+      it 'should yield the block' do
+        attr.fetch_on(arg){ "none" }.should eq("none")
+      end
+    end
+
+  end
+end

data/spec/unit/attribute/test_initialize.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+module Qrb
+  describe Attribute, "initialize" do
+
+    subject{ Attribute.new(:red, intType) }
+
+    it 'should correctly set the instance variables' do
+      subject.name.should eq(:red)
+      subject.type.should eq(intType)
+    end
+
+  end
+end

data/spec/unit/attribute/test_to_name.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+module Qrb
+  describe Attribute, "to_name" do
+
+    subject{ Attribute.new(:red, intType).to_name }
+
+    it{ should eq("red: intType") }
+
+  end
+end

data/spec/unit/heading/test_each.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+module Qrb
+  describe Heading, "each" do
+
+    let(:a){ Attribute.new(:a, intType) }
+    let(:b){ Attribute.new(:b, intType) }
+    let(:h){ Heading.new([a, b]) }
+
+    context 'without a block' do
+
+      it 'should return an enumerator' do
+        h.each.should be_a(Enumerator)
+      end
+    end
+
+    context 'with a block' do
+
+      it 'should yield each attribute in turn' do
+        seen = []
+        h.each do |attr|
+          seen << attr
+        end
+        seen.should eq([a, b])
+      end
+    end
+
+  end
+end