dslkit 0.2.6 → 0.2.7

data/examples/turing.rb

@@ -0,0 +1,310 @@
+require 'term/ansicolor'
+require 'dslkit/polite'
+
+module Turing
+  class Tape
+    def initialize(*initials)
+      @left = []
+      @head = 'B'
+      @right = []
+      c = 0
+      first = true
+      for initial in initials
+        if first
+          c += 1
+          first = false
+        else
+          @left.push 'B'
+          c += 1
+        end
+        for s in initial.split(//)
+          @left.push s
+          c += 1
+        end
+      end
+      c.times { left }
+    end
+
+    def read
+      @head
+    end
+
+    def write(symbol)
+      @head = symbol
+      self
+    end
+
+    def left
+      @right.push @head
+      @head = @left.pop || 'B'
+      self
+    end
+
+    def right
+      @left.push @head
+      @head = @right.pop || 'B'
+      self
+    end
+
+    def clear
+      @left.clear
+      @right.clear
+      @head = 'B'
+      self
+    end
+
+    def to_s
+      "#{@left.join}#{Term::ANSIColor.red(@head)}#{@right.join.reverse}"
+    end
+    
+    alias inspect to_s
+  end
+
+  module States
+    class State
+      attr_accessor :tape
+    end
+
+    class Cond < State
+      def initialize(opts = {})
+        @if, @then, @else = opts.values_at :if, :then, :else
+      end
+
+      def execute
+        tape.read == @if ? @then : @else
+      end
+
+      def to_s
+        "if #@if then #@then else #@else"
+      end
+
+      def to_graphviz(stateno, tapeno = nil)
+        %{#{stateno} [ shape=diamond label="#{tapeno && "#{tapeno}: "}#@if" ];
+          #{stateno} -> #@then [ taillabel="+" ];
+          #{stateno} -> #@else [ taillabel="-" ];
+          #{stateno} -> #{stateno} [ label="#{stateno}" weight=4.0 color=transparent ];}
+      end
+    end
+
+    class Left < State
+      def initialize(opts = {})
+        @goto = opts[:goto]
+      end
+
+      def execute
+        tape.left
+        @goto
+      end
+
+      def to_s
+        "left, goto #@goto"
+      end
+
+      def to_graphviz(stateno, tapeno = nil)
+        %{#{stateno} [ shape=rect label="#{tapeno && "#{tapeno}: "}L" ];
+          #{stateno} -> #@goto;
+          #{stateno} -> #{stateno} [ label="#{stateno}" weight=4.0 color=transparent ];}
+      end
+    end
+
+    class Right < State
+      def initialize(opts = {})
+        @goto = opts[:goto]
+      end
+
+      def execute
+        tape.right
+        @goto
+      end
+
+      def to_s
+        "right, goto #@goto"
+      end
+
+      def to_graphviz(stateno, tapeno = nil)
+        %{#{stateno} [ shape=rect label="#{tapeno && "#{tapeno}: "}R" ];
+          #{stateno} -> #@goto;
+          #{stateno} -> #{stateno} [ label="#{stateno}" weight=4.0 color=transparent ];}
+      end
+    end
+
+    class Write < State
+      def initialize(opts = {})
+        @symbol, @goto = opts.values_at :symbol, :goto
+      end
+
+      def execute
+        tape.write @symbol
+        @goto
+      end
+
+      def to_s
+        "write #@symbol, goto #@goto"
+      end
+
+      def to_graphviz(stateno, tapeno = nil)
+        %{#{stateno} [ shape=rect label="#{tapeno && "#{tapeno}: "}#@symbol" ];
+          #{stateno} -> #@goto;
+          #{stateno} -> #{stateno} [ label="#{stateno}" weight=4.0 color=transparent ];}
+      end
+    end
+
+    class Halt < State
+      def initialize(opts = {})
+      end
+
+      def execute
+        -1
+      end
+
+      def to_s
+        'halt'
+      end
+
+      def to_graphviz(stateno, tapeno = nil)
+        %{#{stateno} [ shape=rect label="HALT" ];
+          #{stateno} -> #{stateno} [ label="#{stateno}" weight=4.0 color=transparent ];}
+      end
+    end
+  end
+
+  class BaseMachine
+    def initialize(program = nil)
+      @states = []
+      if program
+        block_given? and raise "use either program source string or a block"
+        interpret program
+      else
+        instance_eval(&Proc.new)
+      end
+    end
+
+    def step(*tapes)
+      @stepping = true
+      run(*tapes)
+    end
+  end
+
+  class SingleTapeMachine < BaseMachine
+    include DSLKit::Deflect
+    include DSLKit::Interpreter
+
+    def initialize(program = nil)
+      deflector = Deflector.new do |number, id, name, *args|
+        opts = Hash === args.last ? args.pop : {}
+        state = States.const_get(name.to_s.capitalize).new(opts)
+        @states[number] = state
+      end
+      deflect_start(Integer, :method_missing, deflector)
+      super
+    ensure
+      deflect_stop(Integer, :method_missing) if deflect?(Integer, :method_missing)
+    end
+
+    def run(*tape)
+      @tape = Tape.new(*tape)
+      @states.each { |s| s and s.tape = @tape }
+      goto_state = -1
+      @states.any? { |s| goto_state += 1; s }
+      begin
+        printf "%3u: %s", goto_state, @tape
+        @stepping ? STDIN.gets : puts
+        goto_state = @states[goto_state].execute
+      end until goto_state < 0
+    end
+
+    def to_s
+      result = ''
+      @states.each_with_index do |state, i|
+        result << "%3u. %s\n" % [ i, state ]
+      end
+      result
+    end
+
+    def to_graphviz
+      result = "digraph {\n"
+      start_edge = false
+      @states.each_with_index do |state, stateno|
+        state or next
+        unless start_edge
+          result << "start [ fontcolor=transparent color=transparent ];"
+          result << "start -> #{stateno};"
+          start_edge = true
+        end
+        result << state.to_graphviz(stateno) << "\n"
+      end
+      result << "}\n"
+    end
+  end
+
+  class MultiTapeMachine < BaseMachine
+    include DSLKit::Deflect
+    include DSLKit::Interpreter
+
+    def initialize(program = nil)
+      deflector = Deflector.new do |number, id, name, *args|
+        opts = Hash === args.last ? args.pop : {}
+        tape, = *args
+        state = States.const_get(name.to_s.capitalize).new(opts)
+        @states[number] = [ tape, state ]
+      end
+      deflect_start(Integer, :method_missing, deflector)
+      super
+    ensure
+      deflect_stop(Integer, :method_missing) if deflect?(Integer, :method_missing)
+    end
+
+    def run(*tapes)
+      tapes.unshift ''
+      @tapes = tapes.map { |tape| Tape.new(tape) }
+      goto_state = -1
+      @states.any? { |s| goto_state += 1; s }
+      begin
+        printf "%3u: %s", goto_state, @tapes * ' '
+        @stepping ? STDIN.gets : puts
+        tape, state = @states[goto_state]
+        state.tape = tape ? @tapes[tape] : nil
+        goto_state = state.execute
+      end until goto_state < 0
+    end
+
+    def to_s
+      result = ''
+      @states.each_with_index do |(tape, state), i|
+        result << "%3u. %1u: %s\n" % [ i, tape, state ]
+      end
+      result
+    end
+
+    def to_graphviz
+      result = "digraph {\n"
+      start_edge = false
+      @states.each_with_index do |(tapeno,state), stateno|
+        state or next
+        unless start_edge
+          result << "start [ fontcolor=transparent color=transparent ];"
+          result << "start -> #{stateno};"
+          start_edge = true
+        end
+        result << state.to_graphviz(stateno, tapeno) << "\n"
+      end
+      result << "}\n"
+    end
+  end
+end
+
+if $0 == __FILE__ and ARGV.any?
+  include Turing
+  filename, *tapes = ARGV
+  machine_type =
+    case ext = File.extname(filename)
+    when '.stm'
+      SingleTapeMachine
+    when '.mtm'
+      MultiTapeMachine
+    else
+      raise "unknown turing machine suffix: #{ext}, use .stm or .mtm"
+    end
+  tm = machine_type.new(File.read(filename))
+  $DEBUG ? tm.step(*tapes) : tm.run(*tapes)
+end

data/lib/dslkit/polite.rb

@@ -303,13 +303,15 @@ module DSLKit
         if args.empty?
           result = instance_variable_get(variable)
           if result.nil?
-            if default.empty?
+            result = if default.empty?
               block && instance_eval(&block)
             elsif default.size == 1
               default.first
             else
               default
             end
+            instance_variable_set(variable, result)
+            result
           else
             result
           end

data/lib/dslkit/version.rb

@@ -1,6 +1,6 @@
 module DSLKit
   # DSLKit version
-  VERSION         = '0.2.6'
+  VERSION         = '0.2.7'
   VERSION_ARRAY   = VERSION.split(/\./).map { |x| x.to_i } # :nodoc:
   VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
   VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:

data/tests/test_polite.rb

@@ -1,5 +1,3 @@
-$:.unshift '../lib'
-$:.unshift 'tests'
 require 'dslkit/polite'
 
 class TL
@@ -107,4 +105,203 @@ end
 class D3 < DSLKit::MethodMissingDelegator::DelegatorClass
 end
 
-require 'test_common'
+require 'test/unit'
+require 'tempfile'
+
+class TC_DSLKit < Test::Unit::TestCase
+  def setup
+    @tl = TL.new
+    @tl2 = TL.new
+    @ie = IE.new { foo }
+    @c  = C.new
+    @da = DA.new
+    @i  = I.new
+  end
+
+  def test_version
+    assert_equal DSLKit::VERSION_ARRAY * '.', DSLKit::VERSION
+  end
+
+  def test_thread_local
+    assert_nil @tl.foo
+    @tl.foo = 1
+    assert_equal 1, @tl.foo
+    new_foo = nil
+    thread = Thread.new do
+      @tl.foo = 2
+      new_foo = @tl.foo
+    end
+    thread.join
+    assert_equal 2, new_foo
+    assert_equal 1, @tl.foo
+    assert_equal @tl.baz, @tl2.baz
+  end
+
+  def test_instance_thread_local
+    assert_nil @tl.baz
+    @tl.baz = 1
+    assert_equal 1, @tl.baz
+    new_foo = nil
+    thread = Thread.new do
+      @tl.baz = 2
+      new_foo = @tl.baz
+    end
+    thread.join
+    assert_equal 2, new_foo
+    assert_equal 1, @tl.baz
+    assert_not_equal @tl.baz, @tl2.baz
+  end
+
+  def test_thread_global
+    assert_nil @tl.bar
+    @tl.bar = 1
+    assert_equal 1, @tl.bar
+    new_bar = nil
+    thread = Thread.new do
+      @tl.bar = 2
+      new_bar = @tl.bar
+    end
+    thread.join
+    assert_equal 2, new_bar
+    assert_equal 2, @tl.bar
+  end
+
+  def test_instance_exec
+    assert_equal :foo, @ie.foo
+    assert_equal :foo, @ie.exec
+    @ie.freeze
+    assert_equal :foo, @ie.foo
+    assert_equal :foo, @ie.exec
+  end
+
+  def test_constant
+    assert_equal :foo, @c.foo
+    assert_equal :baz, @c.bar
+  end
+
+  def test_dsl_accessor
+    assert_nil @da.foo
+    assert_equal :bar, @da.bar
+    assert_equal :baz, @da.baz
+    assert_equal [:qu, :ux], @da.quux
+    @da.foo 1
+    @da.bar 2
+    @da.baz 3
+    assert_equal 1, @da.foo
+    assert_equal 2, @da.bar
+    assert_equal 3, @da.baz
+  end
+
+  def test_dsl_reader
+    assert_equal true, @da.on
+    assert_equal false, @da.off
+    assert_raises(ArgumentError) do
+      @da.on false
+    end
+    assert_equal [ @da.on, @da.off ], @da.states
+    assert_equal %w[a b c], @da.abc
+    @da.abc << 'd'
+    assert_equal %w[a b c d], @da.abc
+    @da.instance_variable_set :@abc, %w[a b c]
+    assert_equal %w[a b c], @da.abc
+  end
+
+  def test_dsl_accessor_multiple
+    assert_nil @da.foo
+    assert_equal :bar, @da.bar
+    @da.foo 1, 2
+    @da.bar [1, 2]
+    assert_equal [1, 2], @da.foo
+    assert_equal [1, 2], @da.bar
+    @da.bar [1, 2, *@da.bar]
+    assert_equal [1, 2] * 2, @da.bar
+  end
+
+  def test_interpreter
+    assert_equal :foo, @i.interpret('foo')
+    temp = Tempfile.new('foo')
+    temp.write 'foo'
+    temp.rewind
+    assert_equal :foo, @i.interpret(temp)
+  end
+
+  def test_interpreter_with_args
+    assert_equal 3, @i.interpret('|x| x + y', 1)
+    temp = Tempfile.new('foo')
+    temp.write '|x| x + y'
+    temp.rewind
+    assert_equal 3, @i.interpret(temp, 1)
+  end
+
+  def test_symbol_maker
+    s = S.new
+    assert_equal(:foo, s.instance_exec { foo })
+    assert_raises(NoMethodError) { s.instance_exec { foo 1 }}
+  end
+
+  def test_constant_maker
+    assert_equal(:FOO, K::FOO)
+  end
+
+  def test_deflect_block
+    assert_raises(NoMethodError) { 1.foo }
+    assert !D.deflect?(Integer, :foo)
+    D.deflect(Integer, :foo, DSLKit::Deflect::Deflector.new { :foo }) do
+      assert_equal :foo, 1.foo
+      assert D.deflect?(Integer, :foo)
+    end
+    assert !D.deflect?(Integer, :foo)
+    assert_raises(NoMethodError) { 1.foo }
+  end
+
+  def test_deflect
+    assert_raises(NoMethodError) { 1.foo }
+    assert !D.deflect?(Integer, :foo)
+    D.deflect_start(Integer, :foo, DSLKit::Deflect::Deflector.new { :foo })
+    assert_equal :foo, 1.foo
+    assert D.deflect?(Integer, :foo)
+    t = Thread.new do
+      assert !D.deflect?(Integer, :foo)
+      assert_raises(NoMethodError) { 1.foo }
+    end
+    t.join
+    D.deflect_stop(Integer, :foo)
+    assert !D.deflect?(Integer, :foo)
+    assert_raises(NoMethodError) { 1.foo }
+  end
+
+  def test_deflect_method_missing
+    assert_raises(NoMethodError) { 1.foo }
+    assert !D.deflect?(Integer, :method_missing)
+    D.deflect_start(Integer, :method_missing, DSLKit::Deflect::Deflector.new { :foo })
+    assert_equal :foo, 1.foo
+    assert D.deflect?(Integer, :method_missing)
+    t = Thread.new do
+      assert !D.deflect?(Integer, :method_missing)
+      assert_raises(NoMethodError) { 1.foo }
+    end
+    t.join
+    D.deflect_stop(Integer, :method_missing)
+    assert !D.deflect?(Integer, :method_missing)
+    assert_raises(NoMethodError) { 1.foo }
+  end
+
+  def test_delegate
+    d = D2.new
+    assert_equal 3, d.my_size1
+    assert_equal 3, d.my_size2
+    assert_equal 3, d.size
+    assert_equal 3, d.length
+  end
+
+  def test_delegate_d3
+    d = D3.new []
+    assert_equal 0, d.size
+    d.push 1
+    assert_equal [1], d.map { |x| x }
+    d.push 2
+    assert_equal [1, 2], d.map { |x| x }
+    d.push 3
+    assert_equal [1, 2, 3], d.map { |x| x }
+  end
+end

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: dslkit
 version: !ruby/object:Gem::Version 
-  version: 0.2.6
+  hash: 25
+  prerelease: 
+  segments: 
+  - 0
+  - 2
+  - 7
+  version: 0.2.7
 platform: ruby
 authors: 
 - Florian Frank
@@ -9,10 +15,55 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-23 00:00:00 +02:00
+date: 2011-07-16 00:00:00 +02:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: gem_hadar
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 0
+        - 0
+        - 2
+        version: 0.0.2
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: term-ansicolor
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 1
+        - 0
+        version: "1.0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: spruz
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 0
+        - 2
+        version: "0.2"
+  type: :runtime
+  version_requirements: *id003
 description: This library contains recurring patterns, that are useful in the creation of internal Domain Specific Languages (DSL) in Ruby.
 email: flori@ping.de
 executables: []
@@ -20,61 +71,89 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-- doc-main.txt
+- README.rdoc
 files: 
+- .gitignore
 - CHANGES
 - COPYING
+- Gemfile
+- README.rdoc
 - Rakefile
 - TODO
 - VERSION
 - dslkit.gemspec
+- examples/add_one.pdf
+- examples/add_one.stm
+- examples/bb3.pdf
+- examples/bb3.stm
+- examples/bb3_19.stm
+- examples/concatenate_compare.mtm
+- examples/concatenate_compare.pdf
+- examples/concatenate_compare_19.mtm
+- examples/length_difference.mtm
+- examples/length_difference.pdf
+- examples/length_difference_19.mtm
 - examples/let.rb
 - examples/mail.rb
-- examples/mm.rb
+- examples/minsky.rb
 - examples/multiply.reg
 - examples/null_pattern.rb
+- examples/ones_difference-mtm.pdf
+- examples/ones_difference-stm.pdf
+- examples/ones_difference.mtm
+- examples/ones_difference.stm
+- examples/ones_difference_19.mtm
+- examples/ones_difference_19.stm
+- examples/prefix-equals-suffix-reversed-with-infix.pdf
+- examples/prefix-equals-suffix-reversed-with-infix.stm
+- examples/prefix-equals-suffix-reversed-with-infix_19.stm
 - examples/recipe.rb
 - examples/recipe2.rb
 - examples/recipe_common.rb
 - examples/subtract.reg
-- install.rb
+- examples/turing-graph.rb
+- examples/turing.rb
 - lib/dslkit.rb
 - lib/dslkit/polite.rb
 - lib/dslkit/rude.rb
 - lib/dslkit/version.rb
-- tests/runner.rb
-- tests/test_common.rb
 - tests/test_polite.rb
-- tests/test_rude.rb
-- doc-main.txt
 has_rdoc: true
-homepage: http://dslkit.rubyforge.org
+homepage: http://flori.github.com/dslkit
 licenses: []
 
 post_install_message: 
 rdoc_options: 
+- --title
+- Dslkit - Kit for building DSLs in Ruby
 - --main
-- doc-main.txt
+- README.rdoc
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
-rubyforge_project: dslkit
-rubygems_version: 1.3.2
+rubyforge_project: 
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: Kit for building DSLs in Ruby
 test_files: 
-- tests/runner.rb
+- tests/test_polite.rb