hirsute 0.1.0

data/lib/hirsute_make_generators.rb

@@ -0,0 +1,125 @@
+# the various commands that make Hirsute generators. This mostly just keeps these methods isolated
+
+require('lib/hirsute_generator.rb')
+require('lib/hirsute_utils.rb')
+require('lib/histoparse.rb')
+
+module Hirsute
+  DEFAULT = :hirsute_default
+  module GeneratorMakers
+    include Hirsute::Support
+    include Hirsute::HistoParse
+    
+    public
+      # A generator that increments values from a starting point. Good for IDs
+      def counter(startingPoint=1,&block)
+          gen_make_generator(block) {@current = startingPoint;def _generate(onObj); cur_current = @current; @current = @current + 1; cur_current; end;}
+      end
+          
+      # A generator that combines all the generators passed in.
+      def combination(*args,&block)
+         CompoundGenerator.new(args.map {|item| generator_from_value(item)},block)
+      end
+      
+      # given a list of generators,  pick between 1 and n of them and return a CompoundGenerator based off the subset
+      def subset(*args,&block)
+        gen_make_generator(block) {
+          @generators = args.map {|item| generator_from_value(item)}
+          @block = block
+          def _generate(onObj)
+            count = rand(@generators.length)
+            subset = @generators[0..count]
+
+            CompoundGenerator.new(subset,@block)
+          end
+        }
+      end
+    
+      # pick one of the itmes in the list randomly
+      def one_of (list,histogram = nil,&block)
+        if !histogram
+          gen_make_generator(block) {@options = list; def _generate(onObj); @options.choice; end;}
+        else
+          histogram_buckets = histogram
+          histogram_buckets = parse_histogram(histogram).histogram_buckets if histogram.kind_of? String
+          
+          gen_make_generator(block) {
+            @options = list
+            @histogram = histogram_buckets
+            def _generate(onObj)
+              random_item_with_histogram(@options,@histogram)
+            end
+          }
+        end
+      end
+      
+      # reads from file, using each line as the result of the generation
+      # algorithm defines the style of reading lines. The default is :markov
+      # which picks a random number, reads n lines in, returns that, and then
+      # picks another random number and reads n more lines in
+      def read_from_file(file_name,algorithm=:markov,&block)
+        ReadFromFileGenerator.new(file_name,algorithm,block)
+      end
+      
+      # pull items in sequence from an array. once it reaches the end, reset
+      def read_from_sequence(array,&block)
+        raise "List must have at least one item" if array.length == 0
+        gen_make_generator(block) {
+          @items = array
+          @index = 0
+          
+          def _generate(onObj)
+            item = @items[@index]
+            if item
+              @index = @index + 1
+              item
+            else
+              @index = 0
+              generate(onObj)
+            end
+          end
+        }
+      end
+      
+      # fork to different generators depending on the value of a particular field within the object
+      # a value of DEFAULT can be used as a catch-all. If DEFAULT is not defined, a field value that isn't defined will cause
+      # nil to be returned
+      def depending_on(field,options,&block)
+        gen = DependentGenerator.new(field,block)
+        gen.instance_eval {
+          @options = options
+          @field = field
+          
+          # note that this generator won't be activated until the field we want is set
+          def _generate(onObj)
+            field_value = onObj.get(@field)
+            if @options[field_value]
+              @options[field_value]
+            elsif @options[DEFAULT]
+              @options[DEFAULT]
+            else
+              nil
+            end
+          end
+          
+        }
+        gen
+      end
+      
+      # Force a generator to not run until the given fields are set
+      def requires_field(field,generator,&block)
+        # this leverages existing depending_on behavior, just passing a set of options with one path
+        options = {DEFAULT => generator}
+        depending_on(field,options,&block)
+      end
+      
+    private
+      # generic method for making a generator based off of a block. useful for simple cases.
+      def gen_make_generator(finishProc=nil,&block)
+         gen = Generator.new(finishProc)
+         gen.instance_eval(&block)
+         gen
+      end
+    
+  end
+end

data/lib/hirsute_output.rb

@@ -0,0 +1,142 @@
+# Defines output modules that can translate Hirsute objects into load formats for various systems
+require 'lib/hirsute_utils.rb'
+
+module Hirsute
+  
+  include Support
+  
+  # base class for working with objects
+  class Outputter
+    
+    attr_accessor :fields
+    
+    def initialize(collection,options=Hash.new)
+      @collection = collection
+      @obj_class = Hirsute::Support.class_for_name(@collection.object_name)
+      @fields = @obj_class.field_order
+      @options = options
+    end
+    
+    def get_storage_option(option,default=nil)
+      return default if !@options
+      
+      retVal = @options[option]
+      if retVal != nil
+        retVal
+      else
+        default
+      end
+    end
+    
+    # allows the outputter to do any preliminary work
+    def start
+       _start
+    end
+    
+    def _start;end;
+    
+    # cleanup work
+    def finish
+      _finish
+    end
+    
+    def _finish;end;
+    
+    def get_file(object_name) 
+      object_name + ".load"
+    end
+    
+    # external method telling 
+    def output
+      #derive file name from class of object
+      
+      begin        
+        @file = File.open(get_file(@collection.object_name),'w')
+        start
+      
+        @collection.each {|item| _outputItem(item)}
+      
+        finish
+      rescue Exception => e
+        puts "Error #{e}"
+      ensure 
+        @file.close if !@file.nil?
+      end
+      
+    end
+  end
+  
+  
+  class MySQLOutputter < Outputter
+    
+    MySQLOutputter::DEFAULT_MAX_PACKET = 1048576
+    
+    def _start
+      @cur_statement = insertStringBase
+    end
+    
+     def _outputItem(item)
+         # add VALUES(...) to existing string only if the existing string plus the values line is smaller than mox_allowed_packet
+         
+         value_string = " VALUES (" + @fields.map{|column| object_value_to_sql_literal(item.get(column))}.join(",") + "),"
+         
+         if @cur_statement.length + value_string.length > get_storage_option(:max_allowed_packet,MySQLOutputter::DEFAULT_MAX_PACKET)
+           # the current statement plus the addition would be too large. so output current statement, reset, start again
+           output_current
+           @cur_statement = insertStringBase
+         end
+           
+         @cur_statement << value_string
+     end
+     
+     def _finish
+       output_current # flush the last entry
+     end
+
+     private
+     
+       def output_current
+         @file.puts(@cur_statement[0...-1] << ";\n") # trim the tailing comma that comes from the last value_string
+       end
+       
+       def insertStringBase
+         "INSERT INTO #{@obj_class.storage_name} (" +
+             @fields.map{|column| column.to_s}.join(",") +
+             ") "
+       end
+       
+       # convenience method for getting a SQL representation of a ruby object
+       def object_value_to_sql_literal(value)
+         if value.nil?
+            "NULL"
+         elsif value.kind_of? Numeric
+           value.to_s
+         else
+           "'#{value}'"
+         end
+       end
+       
+  end
+  
+  class CSVOutputter < Outputter
+    def separator
+      get_storage_option(:separator,",")
+    end
+    
+    def get_file(name)
+      name + ".csv"
+    end
+    
+    def _start
+      #output header
+      header = @fields.map{|field| "\"#{field}\""}.join(separator)
+      @file.puts header
+    end
+    
+    def _outputItem(item)
+      line = @fields.map {|field| "\"#{item.send(field)}\""}.join(separator)
+      @file.puts line
+      end
+  end
+    
+end

data/lib/hirsute_template.rb

@@ -0,0 +1,159 @@
+# Defines the Template class that forms the foundation of Hirsute object definitions
+
+require('lib/hirsute_generator.rb')
+require('lib/hirsute_make_generators.rb')
+require('lib/hirsute_fixed.rb')
+require('lib/hirsute_collection.rb')
+require('lib/hirsute_utils.rb')
+
+module Hirsute
+  class Template
+     include GeneratorMakers
+     include Support
+     
+      public
+        def initialize(templateName)
+           @templateName = templateName
+        end
+        
+        attr_reader :templateName
+        
+        # has takes a hash of field name -> field generator definitions and stores them
+        # for later use
+        # remembering that the syntax is 
+        # has 
+        #   "id" => counter(1)
+        # this means that counter must be a method in this class
+        def has(fieldDefs)
+           @fieldDefs = Hash.new
+         
+           # do this in a loop to have special handling for different types
+           fieldDefs.each_pair {|key,value|  @fieldDefs[key] = generator_from_value(value)}
+           
+           # define accessors for each of the fields defined in the template 
+           hashToFields(fieldDefs)
+           
+           # add a fields field to the class _instance_ (note that in has, no instances of the object itself yet exist)
+           class_for_name(@templateName).instance_eval {
+             @fields = fieldDefs.keys
+             def fields; @fields; end;
+             
+             def field_order;@fieldOrder.nil? ? @fields : @fieldOrder;end;
+           }
+        end
+        
+        # specify an order for the fields to be output. defaults to @fields
+        def in_this_order(field_order)
+           class_for_name(@templateName).instance_eval {
+                @fieldOrder = field_order
+            }
+        end
+        
+        # Define a set of Constraint objects that act as data integrity enforcers. For instance, if a field needs to be unique.
+        # Hash is defined as field_name, requirement type
+        # While these are defined as part of this class, they're actually copied over to the collection class, since that's who needs
+        # to enforce the constraint
+        def requires(requirements)
+          class_for_name(@templateName).instance_eval {
+            @requirements = requirements
+            def requirements; @requirements; end;
+          }
+        end
+        
+        # Allows a template to have transient objects that are not going to be persisted to the data store
+        # In that case, they get added as fields within the template, but get stored separately so that they're
+        # not included in make
+        def transients(transients)
+          @transients = transients
+          hashToFields(transients)
+          
+          class_for_name(@templateName).instance_eval {
+            @transients = transients.keys
+            def transients;@transients;end;
+          }
+        end
+        
+        # is_stored_in defines some meaningful name for where a generated object should be stored
+        # in the final output (e.g., the name of a database table)
+        def is_stored_in(storageName)
+          class_for_name(@templateName).instance_eval {
+            @storage_name = storageName
+            class << self
+              attr_reader :storage_name
+            end
+          }
+        end
+      
+        # makes an object based on this template definition. the 
+        def make(addToSingleCollection=true)
+            fieldsAlreadySet = Hash.new(false)
+            dependentGenerators = Hash.new
+            
+            allFields = Array.new
+            obj = class_for_name(@templateName).new
+            # populate all the fields; traverse both collections of fields at once
+            [@fieldDefs,@transients].each do |field_map|
+              next if field_map.nil?
+            
+              field_map.each_pair do |fieldName,generator| 
+                # if it's a dependent generator, check to see if the fields it's dependent on have been set
+                if generator.kind_of? Hirsute::DependentGenerator
+                  if !dependent_fields_are_set?(fieldsAlreadySet,generator)
+                    dependentGenerators[fieldName] = generator
+                    next
+                  end
+                end
+                obj.set(fieldName,generator.generate(obj))
+                fieldsAlreadySet[fieldName] = true;
+              end
+            end
+            
+            # now handle any dependent generators left hanging and try to spot endless loops
+            cur_dependent_gens_length = dependentGenerators.size
+            while(cur_dependent_gens_length > 0)
+              dependentGenerators.keys.each do |field|
+                generator = dependentGenerators[field]
+                next if generator.nil?
+                if dependent_fields_are_set?(fieldsAlreadySet,generator)
+                  
+                   # all dependencies are in place
+                   obj.set(field,generator.generate(obj))
+                   fieldsAlreadySet[field] = true
+                   dependentGenerators.delete(field)
+                end
+              end
+              
+              # if the size of the hash hasn't changed, we have a problem: another pass through the loop won't change things, so it'll go forever
+              raise "Dependency loop spotted in #{@templateName}. Check generators to make sure there are no circular dependencies." if dependentGenerators.size == cur_dependent_gens_length
+              cur_dependent_gens_length = dependentGenerators.size
+            end
+            
+            # if there is exactly one collection declared for this type, add this object to it
+            colls = Hirsute::Collection.collections_holding_object(@templateName)
+            colls[0] << obj if addToSingleCollection && colls && colls.length == 1 
+            obj
+        end
+      
+        # makes n objects based on template and returns them as an array
+        def *(count)
+          ret_val = Collection.new(@templateName)
+          (1..count).each {|idx| ret_val << make(false)}
+          ret_val
+        end
+        
+     private      
+      
+        # given a hash of values, add attr_accessors for each key
+        # define accessors for each of the fields defined in the template 
+        def hashToFields(hash)
+          class_for_name(@templateName).class_eval {
+            hash.keys.each {|item| attr_accessor item.to_sym}
+          }
+        end
+        
+        def dependent_fields_are_set?(fields_set,dependent_generator)
+          unset_fields = dependent_generator.dependency_fields.select {|fieldName| !fields_set[fieldName]}
+          unset_fields.length == 0
+        end
+  end
+end

data/lib/hirsute_test.rb

@@ -0,0 +1,25 @@
+## some simple exercises of the hirsute system
+
+storage :mysql
+
+a('user') {
+  has  :user_id => counter(12),
+       :comment => "some random text",
+       :email   => combination("hirsute",counter(100),"@test.com");
+  is_stored_in "simcity_user";
+}
+
+users = user * 5
+
+foreach user {|cur_user|
+  puts cur_user.user_id  
+}
+
+finish users
+
+# pseudo-code
+# users.each do |user|
+#   num_regions = random_number_from_histogram([.1,.2,.5,.1,.1]) # probably the middle one
+#   regions.filter 10 {|region| region.creator_id.is_nil>}
+#   regions.each {|region| region.creator_id = user.user_id}
+# end