ray 0.0.0.pre2 → 0.0.1

data/lib/ray/config.rb

@@ -1,84 +0,0 @@
-require 'singleton'
-
-module Ray
-  # A class holding program wide settings.
-  # @example
-  #   Ray::Config.config do
-  #     set :value, :string => 3 # Conversion
-  #     set :value, "3"
-  #     set :value, {3 => 4} # Ray::Config[:value] == {3 => 4}
-  #     set :value, :string => 3, :hash => {} # No conversion either
-  #     unest :value # set to nil
-  #   end
-  class Config
-    include Singleton
-
-    class << self
-      # @return [Object] the value for key
-      def [](key)
-        instance[key]
-      end
-
-      # Yields the instance of Config if the block takes an argument.
-      # Uses instance_eval in other cases.
-      def config(&block)
-        if block.arity == 1
-          block.call(instance)
-        else
-          instance.instance_eval(&block)
-        end
-      end
-
-      # Clears all the settings, and then calls config.
-      def config!(&block)
-        instance.clear
-        config(&block)
-      end
-    end
-
-    def initialize
-      @settings = {}
-    end
-
-    # @return [Object] The value for key
-    def [](key)
-      @settings[key]
-    end
-
-    # Sets the value for key
-    def []=(key, value)
-      @settings[key] = value
-    end
-
-    # Clears all the settings
-    def clear
-      @settings.clear
-    end
-
-    # Sets the value for a key.
-    # If value is a Hash, and if it contains only one element, and if the
-    # only key of this hash is a known type, it will convert the value to
-    # the one represented by the key.
-    #
-    # @example A conversion
-    #   set :foo, :string => 3 # set :foo, "3"
-    def set(key, value)
-      if value.is_a?(Hash) && value.size == 1
-        type, val = value.keys.first, value.values.first
-
-        if Ray.know_type? type
-          self[key] = Ray.convert(val, type)
-        else
-          self[key] = value
-        end
-      else
-        self[key] = value
-      end
-    end
-
-    # Removes the value for this key.
-    def unset(key)
-      @settings.delete(key)
-    end
-  end
-end

data/lib/ray/dsl/converter.rb

@@ -1,65 +0,0 @@
-module Ray
-  module DSL
-    # Module sroing all the regitred converters. You should never
-    # need to use it directly.
-    module Converter
-      @@converters = {}
-
-      class << self
-        def add_converter(from, to, &block)
-          @@converters[Ray.resolve_type(from) => Ray.resolve_type(to)] = block
-        end
-
-        def convert(obj, target)
-          unless target.is_a? Module
-            return convert(obj, Ray.resolve_type(target))
-          end
-
-          if converter = @@converters[obj.class => target] # Direct converter
-            return converter.call(obj)
-          end
-
-          @@converters.each do |hash, converter|
-            from, to = hash.keys.first, hash.values.first
-
-            if obj.is_a?(from) && to.ancestors.include?(target)
-              return converter.call(obj)
-            end
-          end
-
-          if target == Integer
-            return obj.to_i if obj.respond_to? :to_i
-          elsif target == Float
-            return obj.to_f if obj.respond_to? :to_f
-          elsif target == String
-            return obj.to_s if obj.respond_to? :to_s
-          end
-
-          raise TypeError, "Can't convert #{obj.class} into #{target}"
-        end
-      end
-    end
-  end
-
-  # Converts an object to a given type. target can be a Module or
-  # an object registred as a type.
-  #
-  # If there is a converter that can directly convert from obj.class to target,
-  # it will be used. If there isn't, it will see it will search in
-  # obj.class.ancestors and in target's subclasses.
-  def self.convert(obj, target)
-    DSL::Converter.convert(obj, target)
-  end
-
-  # Adds a block telling to ray how to convert from a type to another one.
-  # @example Converting from String to Array
-  #   Ray.describe_conversion(:string => Array) do |s| # registred type or module
-  #     s.split('')
-  #   end
-  # @example declaring multiple conversions at once
-  def self.describe_conversion(hash, &block)
-    hash.each do |from, to|
-      DSL::Converter.add_converter(from, to, &block)
-    end
-  end
-end

data/lib/ray/dsl/listener.rb

@@ -1,30 +0,0 @@
-module Ray
-  module DSL
-    # The module that allows you to do something when something else happened.
-    module Listener
-      # The args part of this method may help you to say when you want your
-      # block to be called. Each argument applies to one argument of the
-      # event, and they must all match or your block won't get called.
-      #
-      # It will use == to see if two objects match, except in two cases: if you
-      # pass a Matcher, it will use match?, and if you pass a regex it will try
-      # to use =~.
-      #
-      # Your block will be called with the same arguments as the event, just in
-      # case you'd need them.
-      #
-      def on(event, *args, &block)
-        return unless listener_runner
-        listener_runner.add_handler(event, args, block)
-      end
-
-      def listener_runner
-        @__listener_runner
-      end
-
-      def listener_runner=(arg)
-        @__listener_runner = arg
-      end
-    end
-  end
-end

data/lib/ray/dsl/type.rb

@@ -1,58 +0,0 @@
-module Ray
-  module DSL
-    # The module that knows about all the type you registred.
-    module Type
-      @@types = {}
-
-      class << self
-        def register_type(name, klass)
-          @@types[name] = klass
-        end
-
-        def know_type?(name)
-          (@@types[name] != nil)
-        end
-
-        def resolve_type(name)
-          @@types[name]
-        end
-      end
-    end
-  end
-
-  # Registers a type. It allows you to say name instead of klass
-  # when Ray asks you for a typename.
-  # @param [Symbol] name The object that will represent klass
-  # @param [Module] klass The class name will be resolved as
-  def self.register_type(name, klass)
-    DSL::Type.register_type(name, klass)
-  end
-
-  # @return [true, false] True if name is a known type
-  def self.know_type?(name)
-    DSL::Type.know_type?(name)
-  end
-
-  # @param [Module, Symbol] name An object supposed to identify a module or a
-  #                              class.
-  # @return [Module, nil] The matchig module
-  def self.resolve_type(name)
-    if name.is_a? Module
-      name
-    else
-      DSL::Type.resolve_type(name)
-    end
-  end
-
-  register_type(:image, Ray::Image)
-  register_type(:color, Ray::Color)
-
-  register_type(:string, String)
-  register_type(:array, Array)
-  register_type(:hash, Hash)
-  register_type(:integer, Integer)
-  register_type(:float, Float)
-  register_type(:numeric, Numeric)
-
-  register_type(:anything, Object)
-end

data/spec/ray/config_spec.rb

@@ -1,90 +0,0 @@
-describe Ray::Config do
-  describe ".config" do
-    it "should allow to add new settings" do
-      Ray::Config.config do |c|
-        c[:val] = :obj
-        c[:val].should == :obj
-      end
-
-      Ray::Config[:val].should == :obj
-    end
-
-    it "should use instance_eval if the block takes no argument" do
-      Ray::Config.config do
-        self.class.should == Ray::Config
-      end
-    end
-  end
-
-  describe "'s not set settings" do
-    it "should be nil" do
-      Ray::Config[:dont_put_a_value_here].should be_nil
-    end
-  end
-
-  describe ".config!" do
-    it "should reset every setting" do
-      Ray::Config.config! do |c|
-        c[:bar] = 3
-      end
-
-      Ray::Config[:bar].should == 3
-      Ray::Config.config! {}
-      Ray::Config[:bar].should be_nil
-    end
-  end
-
-  describe "#set" do
-    context "if the second argument is not a hash" do
-      it "should set the value directly" do
-        Ray::Config.config do |conf|
-          conf.set :value, :val
-          conf[:value].should == :val
-        end
-      end
-    end
-
-    context "if the second argument is a hash" do
-      context "with only one element" do
-        context "if the key is a known type" do
-          it "should convert the object" do
-            Ray::Config.config do |conf|
-              conf.set :value, :string => 3
-              conf[:value].should == "3"
-            end
-          end
-        end
-
-        context "if the key is not a know type" do
-          it "should set the value directly" do
-            Ray::Config.config do |conf|
-              conf.set :value, 3 => "bar"
-              conf[:value].should == {3 => "bar"}
-            end
-          end
-        end
-      end
-
-      context "with more or less than one element" do
-        it "should set the value directly" do
-          Ray::Config.config do |conf|
-            conf.set :value, {}
-            conf[:value].should == {}
-          end
-        end
-      end
-    end
-  end
-
-  describe "#unset" do
-    it "should set the value to nil" do
-      Ray::Config.config do |conf|
-        conf[:x] = 3
-        conf[:x].should == 3
-
-        conf.unset :x
-        conf[:x].should be_nil
-      end
-    end
-  end
-end

data/spec/ray/conversion_spec.rb

@@ -1,43 +0,0 @@
-class TestClass; end
-class SubTest < TestClass; end
-class OtherTest; end
-class YATest; end
-
-Ray.describe_conversion(TestClass => OtherTest) { OtherTest.new }
-Ray.describe_conversion(YATest    => SubTest)   { SubTest.new   }
-Ray.describe_conversion(OtherTest => SubTest)   { SubTest.new   }
-Ray.describe_conversion(OtherTest => TestClass) { TestClass.new }
-
-describe "conversions" do
-  context "when the requested conversion is known" do
-    it "should convert the object" do
-      Ray.convert(TestClass.new, OtherTest).should be_an(OtherTest)
-    end
-
-    context "even for a sub-class of the target" do
-      it "should convert the object" do
-        Ray.convert(YATest.new, TestClass).should be_a(TestClass)
-      end
-    end
-
-    context "and there is a direct way to convert it" do
-      it "should use it" do
-        obj = Ray.convert(OtherTest.new, TestClass)
-        obj.should be_a(TestClass)
-        obj.should_not be_a(SubTest)
-      end
-    end
-
-    it "should not create an instance of a superclass of the expected type" do
-      Ray.convert(OtherTest.new, SubTest).class.should_not == TestClass
-    end
-  end
-
-  context "when there's not available conversion" do
-    it "should raise a type error" do
-      lambda {
-        Ray.convert(YATest.new, OtherTest)
-      }.should raise_exception(TypeError)
-    end
-  end
-end

data/spec/ray/type_spec.rb

@@ -1,17 +0,0 @@
-describe "Ray.resolve_type" do
-  context "when given a module" do
-    it "should return it" do
-      Ray.resolve_type(Class).should == Class
-    end
-  end
-
-  context "when given something else" do
-    it "should return nil if it's not registred" do
-      Ray.resolve_type(3).should == nil
-    end
-
-    it "should return a module if it is registred" do
-      Ray.resolve_type(:string).should == String
-    end
-  end
-end

data/spec_runner.rb

@@ -1,27 +0,0 @@
-$: << "./ext/" << "./lib/"
-path = File.expand_path(File.join(File.dirname(__FILE__), "ext/ray"))
-our_path = File.expand_path(File.join(File.dirname(__FILE__), "spec_runner.rb"))
-
-unless defined? Ray
-  unless RUBY_PLATFORM =~ /darwin/
-    require 'ray_ext'
-  else
-    if File.exist? path
-      system "#{path} #{our_path}"
-      exit $?.exitstatus
-    else
-      $stderr.puts "please build ray (rake ext)"
-      exit 1
-    end
-  end
-end
-
-def path_of(res)
-  File.expand_path(File.join(File.dirname(__FILE__), "spec", "res", res))
-end
-
-require 'ray'
-
-require 'spec'
-require 'spec/autorun'
-Dir["spec/**/*_spec.rb"].each { |file| load file }