hitsuji 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b59ef71008c412ae5baac5f4102b703af2db8194a22e37a41d310f03168429b
-  data.tar.gz: 910c6bafc9d69d0a91382d5b85d7f699f14f8b9d6b76c911102cb95d35cc53f0
+  metadata.gz: 94745b6c358fa83b41f7b1e1b1094099bc034c7635d5317a028dab2450f322e6
+  data.tar.gz: 7b4043d9e1052a589cbd76b9ef14f6bbd4da54733b7bb0ee44b77142fd047482
 SHA512:
-  metadata.gz: 01ba139869c7119f08a332b66eee162ee6b4c7dbb59eeb141c4f31b2562e32f3cce3490cedf0a005634d4209b4e34bf91c62bff475074dd1ab7ab801724324a0
-  data.tar.gz: bb8521f46c58ad18e0b18e31239d37c60488688e33dd0a52aca038a530324db48493da1521374f6d2fce073adba964598fc864cac237f381e860c1093deb5f08
+  metadata.gz: 58db3991afa8db1729c00942beb816205b114aa790114fc556417bf08350e9173df603e4758367eb5355e7ca16bb2d99d7594e622f27208db6d5ed5a609510aa
+  data.tar.gz: d9c9578f7e4548b95602833df86a93c8cb529a0191b51e72cce51aa46f95b4fa0fd178ec44f2cdb38788600c0b915b2cfb42795945dd7c417f9fb84f2396cf0a

data/lib/hitsuji.rb

@@ -1,56 +1,154 @@
-# -- hitsuji.rb --
-# Main interface for hitsuji module
+# * Hitsuji
 
-#require_relative 'transfer.rb'
-require_relative 'subsystem.rb'
+require 'transfer'
+require 'subsystem'
 
 class Hitsuji
   
-  # creates new system
+  # Creates a new system where all operations can be performed.
+  #
+  # ==== Example
+  #
+  #    my_system = Hitsuji.new
   def initialize
     @struct = []
-    @used_names = []
   end
   
-  # creates new unbinded item
+  # Creates a new item, the equivalent of a variable in the system. Once
+  # declared, the value of an item can be changed but not the name. No item
+  # is allowed to share the same name as any other.
+  #
+  # ==== Attributes
+  #
+  # * +name+ - the name of the new item, which is written as a symbol.
+  # * +value+ - the contents of the new item, whether that be a string, 
+  #   variable or any other object.
+  #
+  # ==== Example
+  #
+  #    my_system = Hitsuji.new                        # a new system
+  #    my_item = my_system.item(:foo, 'bar')          # a new item
   def item(name, value)
-    if @used_names.include? name
-      throw 'err'
-    else
-      new_item = Item.new(name, value)
-      @used_names << name
-    end
+    new_item = Item.new(name, value)
     return new_item
   end
   
-  # creates new unbinded linker
+  # Creates a new linker, which is simply put a grouping of items and other
+  # linkers. Like an item, the value is changeable but the name is not, and it
+  # must not share its name with any other linker, or item for that matter.
+  #
+  # ==== Attributes
+  #
+  # * +name+ - the name of the new linker, which is written as a symbol.
+  # * +value+ - the contents of the new linker, whether that be an item or 
+  #   another linker.
+  #
+  # ==== Example
+  #
+  #    my_system = Hitsuji.new                        # a new system
+  #    my_item = my_system.item(:foo, 'bar')          # a new item
+  #    my_item2 = my_system.item(:qux, 'quux')        # a second item
+  #    items = [:foo, :qux]
+  #    my_linker = my_system.linker(:baz, items)      # a new linker
   def linker(name, objs)
-    if @used_names.include? name
-      throw 'err'
-    else
-      new_linker = Linker.new(name, objs)
-      @used_names << name
-    end
+    new_linker = Linker.new(name, objs)
     return new_linker
   end
   
-  # creates new unbined operation
-  def operation(name, input)
-    if @used_names.include? name
-      throw 'err'
-    else
-      new_operation = Operation.new(name, input) do
-        yield
-      end
-      @used_names << name
-    end
+  # Creates a new operation, which is an operation performed on multiple items
+  # contained within a linker. This linker can contain more linkers from which
+  # more items will be progressively taken. An operation can then be used as 
+  # part of a linker, and the result can be used in another operation.
+  #
+  # ==== Attributes
+  #
+  # * +name+ - the name of the new linker, which is written as a symbol.
+  # * +input+ - the contents of the new linker, whether that be an item or 
+  #   another linker.
+  # * +block+ - a block as a string to perform the operation
+  #
+  # ==== Example
+  #
+  #    my_system = Hitsuji.new                        # a new system
+  #    my_item = my_system.item(:foo, 1)              # a new item
+  #    my_item2 = my_system.item(:qux, 2)             # a second item
+  #    items = [:foo, :qux]
+  #    my_linker = my_system.linker(:baz, items)      # a new linker
+  #    my_op = my_system.operation(:op, my_linker, %{ # a new operation
+  #      |arg1, arg2| arg1 + arg2
+  #    }) # => :foo + :qux => 1 + 2 => 3
+  def operation(name, input, block)
+    new_operation = Operation.new(name, input, block)
     return new_operation
   end
   
-  # binds object
-  def bind(obj)
-    @struct << obj
+  # Binds the inputted items to the system, allowing for the continous updating
+  # of the values within a system. This continuous updating is what gives
+  # Hitsuji its computational power.
+  #
+  # ==== Attributes
+  #
+  # * +*obj+ - the items, linkers and operation you want to bind
+  #
+  # ==== Example
+  #
+  #    my_system = Hitsuji.new                        # a new system
+  #    my_item = my_system.item(:foo, 1)              # a new item
+  #    my_item2 = my_system.item(:qux, 2)             # a second item
+  #    items = [:foo, :qux]
+  #    my_linker = my_system.linker(:baz, items)      # a new linker
+  #    my_system.bind(my_item, my_item2, my_linker)   # binds items + linker
+  def bind(*obj)
+    @struct.concat obj
     #update
   end
   
+  # Exports current state of system to a file. This process _does not export
+  # unbound items, linkers or operations!_ Creating new items doesn't automatically bind them to the
+  # system, even through they are a created with a method of a Hitsuji object.
+  #
+  # ==== Attributes
+  #
+  # * +directory+ - the path of the file to export the system (the extension
+  #   of the file doesn't matter)
+  #
+  # ==== Example
+  #
+  #    my_system = Hitsuji.new                        # a new system
+  #    my_item = my_system.item(:foo, 1)              # a new item
+  #    my_system.bind(my_item)                        # binds item
+  #    my_system.export('newfile.txt')                # exports to 'newfile.txt'
+  def export(directory)
+    Transfer.export(directory, @struct)
+  end
+  
+  # Imports file into a system, _overwriting anything already bound to the 
+  # system_. 
+  #
+  # ==== Attributes
+  #
+  # * +directory+ - the path of the file you want to import from
+  #
+  # ==== Example
+  #
+  #    my_system = Hitsuji.new                        # a new system
+  #    my_system.import('oldfile.txt')                # imports from 'newfile.txt'
+  def import(directory)
+    @struct = Transfer.import(directory)
+    #update
+  end
+
+  private
+
+  def self.update # :nodoc:
+    # @struct.each do |val|
+    #   case val.class
+    #   when Item
+    # 
+    #   else
+    # 
+    #   end
+    # end
+  end
+  
 end

data/lib/subsystem.rb

@@ -1,7 +1,6 @@
-# item object
 class Item
   
-  def initialize(name, value)
+  def initialize(name, value) # :nodoc:
     @name = name
     @value = value
   end
@@ -11,15 +10,14 @@ class Item
   
 end
 
-# linker object
 class Linker
-  
-  def initialize(name, value)
-    for i in value
-      if i.class != Linker and i.class != Item
-        throw 'err'
-      end
-    end
+
+  def initialize(name, value) # :nodoc:
+    #value.each do |i|
+    #  if i.class != Linker and i.class != Item
+    #    throw 'err'
+    #  end
+    #end
     
     @name = name
     @value = value
@@ -30,15 +28,14 @@ class Linker
   
 end
 
-# operation object
 class Operation
   
-  def initialize(name, input, &func)     
+  def initialize(name, input, block) # :nodoc:  
     @name = name 
     @input = input
-    @block = func
+    @block = block
   end
   
-  attr_reader :name, :input
+  attr_reader :name, :input, :block
   
 end

data/lib/transfer.rb

@@ -0,0 +1,13 @@
+require 'subsystem'
+
+class Transfer # :nodoc:
+  
+  def self.export(directory, struct)
+    File.open(directory, "w") { |file| file.write(Marshal.dump(struct)) }
+  end
+  
+  def self.import(directory)
+    File.open(directory, "r") { |file| return Marshal.load(file.read()) }
+  end
+  
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hitsuji
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Josh Quail
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-13 00:00:00.000000000 Z
+date: 2018-08-20 00:00:00.000000000 Z
 dependencies: []
 description: Hitsuji is a library that lets you easily create, edit, manage and apply
   custom management systems. It is scalable from library card databases to performance
@@ -20,6 +20,7 @@ extra_rdoc_files: []
 files:
 - lib/hitsuji.rb
 - lib/subsystem.rb
+- lib/transfer.rb
 homepage: http://rubygems.org/gems/hitsuji
 licenses:
 - MIT