dibnahs_dogs 1.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 80555032bbba33a390f83c0bfd988464762ee4b3
+  data.tar.gz: b6ba019e7a23ed459ebec92bf72a177d0abb16bc
+SHA512:
+  metadata.gz: 5ceefccfe914b9ce04816427181fb79aec19b7d138506e18cdaecd3fea7f9f916f2f4ed588242aaa066c0a35d003afed8045312e12a2df141c8b7c8b74902975
+  data.tar.gz: 81ef6b6a408b956dae2c46da6d0593ed7bc3a2b1731aa9de0c2342a43db392e05ec8f782ccc45347c86562e8f2bdcab47655dc6faff614b5680de0debd1b509a

data/lib/dibnahs_dogs.rb

@@ -0,0 +1,373 @@
+#
+#   Dibnahs_Dogs::Activity Modeller::State Machine.rb - 
+#   	$Release Version: 0.2 $
+#       $Revision: 1.1.1 $
+#   	by mark ingram
+#
+# --
+# Run this file for TEST and example use
+# for documentation tips and usage call the <classname>_Doc i.e. SM_Doc 
+# for specific function documentation call 
+class SM #private donot instantiate rather use StateMachine 
+  def initialize
+    @count = 0 #number of states in the machine
+    @state = 0
+  end
+  attr_reader :count, :state
+  def count=(states) 
+    if states > 0 then @count = states
+      self.state = 1
+    else
+      puts "StateMachine.Count requires one or more states. To clear the states, use StateMachine.Clear."
+    end
+  end
+  def state=(newstate)
+    if newstate < 1 then 
+      puts "StateMachine.State cannot be set less than 1"
+    elsif newstate > self.count then puts " StateMachine.State cannot be set greater than StateMachine.Count."
+    elsif newstate > 0 and newstate <= self.count then
+      @state = newstate
+      setState(newstate)
+    end
+  end
+  def setState(newstate)
+    self.state = newstate
+  end
+  def clear
+    @count = 0
+    @state = 0
+  end
+  def move(states)
+    tmp = 0
+    tmp = self.state + states
+    if tmp < 1 then state = 1
+    end
+    if tmp > @count then tmp = @count
+    end
+    # puts " =8= count #{@count}\nstates #{states}\ntmp#{tmp} \nself.state #{self.state} \n =8="
+    self.state = tmp
+    puts self.state
+  end
+end
+class StateMachine<SM
+  def initialize
+    @state = 0
+    self.count = 4
+  end
+  def back
+    self.move(-1)
+  end
+  def next
+    self.move(1)
+  end
+  def goto(state)
+    self.state = state
+  end
+  def stateMachineEnd
+    puts 'end'
+    self.clear
+  end
+  def setState(state)
+    case state
+	     when state = 1    then action = doOne  # action = "this is state one"
+	     when state = 2    then action = doTwo # "this is state two"
+	     when state = 3    then action = "This is state three"
+	     when state = 4    then action = "this is the action for state four"
+	     else           puts "an error prehaps"
+	     end
+    puts action
+  end
+  def doTwo
+    tmp = "this is the stuff that we do at two"
+    tmp
+  end
+  def doOne
+    tmp = "The state machine is properly initialised"
+    tmp
+  end
+end
+class SM_Doc
+  def initialize
+   puts "SM is just the class holding states and checking for the most basic errors\n you are free to extend it but I would not recommend instanciating it. \n Instead use StateMachine.\n Use the public access functions for state machine fuctionality:\n\t next #state forward\n\t goto # a specific state\n\tback # an number of states \n\tclear #the registers "
+ end
+end
+class StateMachine_Doc
+  def initialize
+    puts  "This is my standard state machine.\n Overload the function setState.....because it is here that the state tabel is described and only here"
+  end
+end
+class StateDiagram
+  def initialize
+    @name = "New State Diagram"
+    start = InitialState::new
+    start.name = "start"
+    start.activity = "initialize"
+    @Diagram = Array::new
+    @Diagram << start
+  end
+  attr_accessor :name
+  def clear
+    @Diagram = ""
+  end
+  def link(parent,child)
+    tmp = ""
+    @Diagram.each {|a|
+      tmp =  tmp + "#{a.name} "
+      if a.name == parent then
+	@Diagram.each {|b|
+	  if b.name == child
+	    a.pointsTo = b.serialNo
+	    tmp = "#{a.name}points to #{b.name}\n"
+	  end
+	}
+      end
+    }
+    tmp
+  end
+  def addState(name)   
+    a = State::new
+    a.name = name
+    a.activity = name
+    @Diagram << a
+    tmp = ""
+    tmp
+  end
+  def deleteState(name)
+  end
+  def updateSate(name)
+    tmp = "make sure you dont delete any thing that has already been written"
+    tmp
+  end
+  def draw #self.inspect
+    tmp = "#{@name}\n\n"
+    @Diagram.each {|a|
+      tmp = tmp + "#{a.name}(#{a.serialNo}) \n"
+      tmp = tmp + "\tpoints to #{a.pointsTo}\n"
+    }
+    tmp
+  end
+  def checkSyntax
+  tmp = "Check that there is just one start one finish and that all the activities have children"
+  end
+  def toRuby
+    # tmp = "#generate the Mile StateMachine Code\n\nrequire \"MILE/BIN/StateMachine\"\n"
+    # tmp = "#generate the Mile StateMachine Code\n\nrequire \"./StateMachine\"\n"
+    tmp = "#generate the Mile StateMachine Code\n\nrequire \"dibnahs_dogs\"\n"
+    tmp = tmp + "class #{@name}<StateMachine\n  def initialize \n\t#{makeHash}\n    @state = 0\n    self.count = #{@Diagram.size}\n  end\n  def setState(state)\n    case state\n#{makeWhen}    else           puts \"state not found error\"\n    end\n    puts action\n  end\n #{makeAction}end\n"
+    tmp
+  end
+  def makeHash
+    tmp =    " @hash = {\n\t"
+    @Diagram.each { |a|
+      tmp = tmp + " '#{a.activity}' => #{a.serialNo},\n\t"
+    }
+    #REMOVE THE LAST , /\,/Start from the right =8=
+    tmp = tmp + "\t}  "
+    tmp
+  end
+  def makeWhen
+    tmp = ""
+    @Diagram.each { |a|
+      tmp = tmp + "\twhen state = @hash['#{a.activity}']    then action = #{a.activity}\n"
+    }
+    tmp
+  end
+  def makeAction
+    tmp = ""
+    @Diagram.each { |a|
+      tmp = tmp + "  def #{a.activity}\n    tmp = \"This is where we do state_#{a.name} functionality\"\n    tmp\n  end\n"
+    }
+    tmp
+  end
+  public    #:method1, :method4
+  protected #:method2
+  private   :makeHash ,:makeWhen ,:makeAction
+end
+class Node
+  @@id = 0
+  def initialize
+    @@id = @@id + 1
+    @serialNo = @@id
+    @child = @serialNo
+  end
+  attr_reader :serialNo, :child
+  attr_writer :child
+end
+class State<Node
+  @name = ""
+  @activity = ""
+  attr_reader :name, :activity
+  attr_writer :name, :activity
+  def pointsTo
+    return self.child
+  end
+  def pointsTo=(serialNo)
+    self.child = serialNo
+  end
+end
+class InitialState<State #symbol is the black blob see Rose
+
+end
+class FinishedState<State #symbol is the black blob and black ring see Rose
+end
+class ActivityDiagram <StateDiagram
+  def initialize
+# =8= 27022004    self.name = "New_Activity_Diagram"
+    @name = "New_Activity_Diagram"
+    @Diagram = Array::new
+  end
+  def clear
+    @Diagram = ""
+  end
+  def addActivity(name,functionality,documentation)
+    a = Activity::new
+    a.name = name
+    a.activity = name # the name of the function called in set_State
+    a.functionality = functionality #the contents of the function above
+    a.documentation = documentation
+    @Diagram << a
+    tmp = ""
+    tmp
+  end
+  def addInitiator
+    self.addActivity("initiator","","")
+  end
+  def addAccomplishment
+    self.addActivity("accomplishment","self.clear","")
+    #self.link("accomplishment","initiator","")
+  end
+  def link(parent,child, condition)
+    tmp = ""
+    @Diagram.each {|a|
+      tmp =  tmp + "#{a.name} "
+      if a.name == parent then
+	@Diagram.each {|b|
+	  if b.name == child then
+	    if a.instance_of?(Decision)then
+	      a.pointsTo = ["#{b.serialNo}","#{condition}"]
+	      tmp = "#{a.name}points to #{b.name}\n"
+	    else
+	      a.pointsTo = b.serialNo
+	    end
+	  end
+	}
+      end
+    }
+    tmp
+  end
+  def addDecision(name,documentation)
+    a = Decision::new
+    a.name = name
+    a.activity = name
+    a.documentation = documentation
+    @Diagram << a
+    tmp = ""
+    tmp	
+  end
+  def makeWhen
+    tmp = ""
+    @Diagram.each { |a|
+      tmp += "\twhen state = @hash['#{a.activity}'] then action = #{a.activity}\n"
+    }
+    tmp
+  end
+  def makeHash
+    tmp = " @hash = {\n\t"
+    tmp1 = ""
+    @Diagram.each { |a|
+      tmp += "#{tmp1}\t\t '#{a.activity}' => #{a.serialNo}"
+      tmp1 = ",\n"
+    }
+    tmp += "\n\t}  "
+    tmp
+  end
+  def makeAction
+    tmp = ""
+    @Diagram.each { |a|
+      tmp += "\tdef #{a.activity}\n"
+      tmp1 = ""
+      if a.instance_of?(Decision)then
+	tmp += "if"
+	a.pointsTo.each{|b|
+	  tmp += "#{tmp1} #{b.at(1)} then \n\tself.goto(#{b.at(0)})\n"
+	  tmp1 = "elsif"
+	}
+	tmp += "end\n"
+      else
+      	  tmp += "\t #{a.functionality}\n"
+	unless a.pointsTo == a.serialNo #or a.instance_of?(Decision) then #infinite loop ;)
+	  tmp += "\t  self.goto(#{a.pointsTo})\n"
+	else
+	end
+      end
+      tmp += "end\n"
+    }
+    tmp
+  end
+  def draw #self.inspect
+    tmp = "#{@name}\n\n"
+    @Diagram.each {|a|
+      tmp += "#{a.name}(#{a.serialNo}) \n"
+      if a.instance_of?(Decision) then
+	a.pointsTo.each{|b|
+	  tmp += "\tpoints to #{b.at(0)} if #{b.at(1)}\n"	
+	}
+      else
+	tmp += "\tpoints to #{a.pointsTo}\n"	
+      end
+    }
+    tmp
+  end
+  public    :addDecision, :addActivity
+  private   :addState
+end
+class Activity<State
+  def initalize
+    super
+    @functionality = ""
+    @documentation = ""
+  end
+  attr_reader :functionality, :documentation
+  attr_writer :functionality, :documentation
+end
+class Decision<Activity
+  def initialize
+    super
+    @child = []
+  end
+  def pointsTo=(arr)
+    self.child << arr 
+  end
+end
+class DibnahsDogs<ActivityDiagram
+end
+# Unit Test
+if $0 == __FILE__ then
+  b =  DibnahsDogs::new
+  b.name = "Test1"
+  b.addInitiator
+  b.addActivity("activity_1","puts \"yo 1 \"\n","\t qwertet\n\n")
+  b.addActivity("activity_2","puts \"yo 2 \"\n","\t qwertet\n\n")
+  b.addActivity("activity_3","puts \"yo 3 \"\n","\t qwertet\n\n")
+  b.addActivity("activity_4","puts \"yo 4 \"\n","\t qwertet\n\n")
+  b.addDecision("decision1","This is where we decide what to do\n")
+  b.addActivity("activity_5","puts \"yo 5 \"\n","\t qwertet\n\n")
+  b.addActivity("activity_6","puts \"yo 6 \"\n","\t qwertet\n\n")
+  b.addAccomplishment
+  b.link("initiator","activity_1","")
+  b.link("activity_1","activity_3","")
+  b.link("activity_3","activity_2","")
+  b.link("activity_2","activity_4","")
+  b.link("activity_4","decision1","")
+  b.link("activity_5","accomplishment","")
+  b.link("activity_6","activity_5","")
+  b.link("decision1","activity_5","false")
+  b.link("decision1","accomplishment","false")
+  b.link("decision1","activity_6", "true")
+  ##puts b.inspect
+  ##puts b.draw
+  tmp2 = b.toRuby
+  tmp2 += "puts a = Test1.new"
+  puts tmp2
+  instance_eval tmp2
+end

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification
+name: dibnahs_dogs
+version: !ruby/object:Gem::Version
+  version: 1.1.1
+platform: ruby
+authors:
+- mark ingram
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-18 00:00:00.000000000 Z
+dependencies: []
+description: ''
+email:
+- m.ingram@computer.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/dibnahs_dogs.rb
+homepage: 
+licenses:
+- Ruby
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Actvity Modelling with simple state machine
+test_files: []