sereth_json_spec 1.0beta1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d91f53ee69673463cb82eb96ba77a8b04c5a34e1
+  data.tar.gz: c5deca35e2b055c162ff67bd519004ee9afe58da
+SHA512:
+  metadata.gz: 496e9738522aca5a13174a736247b9c18afa06fbf87886229d5cd53b6b19c87cefc71166307bc6b8cc37976cea4a856f4a79c62c04f15031f4e4662d8767f38f
+  data.tar.gz: c93d872c3231b3b7edbe68ecf56746c5e620bcc8ff708dc86b20dfd866dc490657df5bfca3031b33522d3cf046b6bd0e1a7fd8fe997702ad55de372ac4094cdb

data/lib/seek_test.rb

@@ -0,0 +1,34 @@
+string = "a" * 10_000
+string_v = "a" * 10_000 + "b"
+
+require 'benchmark'
+puts Benchmark.measure{string.match(/a.*?b/)}
+puts Benchmark.measure{string.match(/a[^b]*b/)}
+puts Benchmark.measure{string_v.match(/a[^b]*b/)}
+puts Benchmark.measure{string.match(/a.*/)}
+
+data = {:state => :start}
+matcher = Object.new
+matcher_class = class << matcher; self; end
+match = ""
+
+matcher_class.send(:define_method, :start) do |c|
+  # Start state runs only once, so it's the last one
+  next if c != 'a'
+  match << c
+  data[:state] = :not_b
+  next
+end
+
+
+matcher_class.send(:define_method, :not_b) do |c|
+  match << c
+  next if c != 'b'
+  break
+end
+puts Benchmark.measure {
+  string.each_char {|c|
+    state = data[:state]
+    matcher.send(state, c)
+  }
+}

data/lib/sereth_json_spec/api.rb

@@ -0,0 +1,64 @@
+module Sereth::JsonSpec
+  module Extender
+    # Generate the active path of this spec, for use with sub-specs
+    def json_spec_path
+      path = self.collection_name if self.respond_to? :collection_name
+      path ||= "#{self.name}"
+      return path
+    end
+
+    # Returns a json listing of fields. The values of fields will and field types (if possible)
+    def json_spec_schema(spec)
+      Data.export(json_spec_path, spec, DummyUtil.new)
+    end
+
+    # Iterate over all the specs defined in the current class
+    def each_json_spec(&block)
+      Data.each(json_spec_path, &block)
+    end
+
+    # Registered a new spec of a given name
+    def json_spec(name, &block)
+      # Parse the input token data
+      Data.generate(json_spec_path, name, &block)
+    end
+  end
+
+  def self.included(target)
+    raise "JsonSpec must be prepended."
+  end
+
+  # Set up the default spec
+  def self.prepended(target)
+    target.send(:extend, Extender)
+  end
+
+  # Export item as JSON of a given spec. An invalid spec will generate
+  # an exception
+  def to_json(options = {})
+    if options.has_key?(:spec)
+      Data.export(self.class.json_spec_path, options[:spec], self)
+    elsif defined?(super)
+      super
+    end
+  end
+
+  # Wraps the proper to_json call for use with rails render method
+  def as_json(options = {})
+    if options.has_key?(:spec)
+      RunnerUtil.new(self.class.json_spec_path, options[:spec], self)
+    else
+      super
+    end
+  end
+
+  # Perform the import operation
+  def from_json(data, options)
+    data = JSON.parse(data) if data.is_a?(String)
+    if options.has_key?(:spec)
+      Data.import(self.class.json_spec_path, options[:spec], self, data)
+    elsif defined?(super)
+      super
+    end
+  end
+end

data/lib/sereth_json_spec/cache.rb

@@ -0,0 +1,31 @@
+# Stub class for the JSON spec cache API. Can be extended to provide actual cache functionality
+module Sereth::JsonSpec
+  # TODO Override this cache with other types
+  class Cache
+    @cache = {}
+    class << self
+      # Configure the cache provider
+      def provide(provider)
+        @provider = provider
+      end
+
+      # True if the cache is enabled
+      def enabled?
+        return @provider.enabled? if !@provier.nil?
+        true
+      end
+
+      # Either retrieves teh cached data, or a nil in the event of expiry/non-caching
+      def retrieve(*args)
+        return @provider.retrieve(*args) if !@provider.nil?
+        @cache[args]
+      end
+
+      # Store the generated value in the hash
+      def store(value, *args)
+        return @provider.store(value, *args) if !@provider.nil?
+        @cache[args] = value
+      end
+    end
+  end
+end

data/lib/sereth_json_spec/data.rb

@@ -0,0 +1,225 @@
+module Sereth::JsonSpec
+  class Data
+    # Spec Data Storage
+    @specs = {}
+    @schema = nil
+    @aliases = {}
+    @alias_getter = lambda {}
+
+    class << self
+      def import(path, name, inst, data)
+        spec = self.get(path, name)
+        if !spec.nil?
+          spec.import!(inst, data)
+        else
+          raise "Error: Spec #{path}/#{name} not defined"
+        end
+      end
+
+      def export(path, name, inst)
+        spec = self.get(path, name)
+        if !spec.nil?
+          spec.export!(inst)
+        else
+          raise "Error: Spec #{path}/#{name} not defined"
+        end
+      end
+
+      def generate(path, name, &block)
+        data_inst = self.new(path, name)
+        Generator.new(path, name, data_inst).instance_eval(&block)
+
+        @specs[[path, name]] = data_inst
+      end
+
+      def get(path, name)
+        @specs[[path, name]]
+      end
+
+      # Iterate over each spec as (spec_path, spec_name, value) or (spec_name, value)
+      def each(path = nil, &block)
+        @specs.each do |k, v|
+          next if !path.nil? && k.first != path
+          block.call(v) if block.arity == 1
+          block.call(k.last, v) if block.arity == 2
+          block.call(k.first, k.last, v)
+        end
+      end
+    end
+
+    ## Spec Initialization
+    # Receive responder queries from extending spec
+    def respond_to_missing?(node_name, include_all = nil)
+      @spec.send(:respond_to_missing?, node_name)
+    end
+
+    # Receive handler requets from extending spec
+    def method_missing(method, *args, &block)
+      @spec.send(method, *args, &block)
+    end
+
+    def initialize(path, name)
+      @path = path
+      @name = name
+      @raw = {}
+      # Holds the methods that will be executed to generate a spec
+      @spec = Object.new
+      # Used to define methods on @spec
+      @spec_class = class << @spec; self; end
+
+      # Holds the procs which will be used to update an instance, may be subset of full spec
+      @setters = {}
+      @subnodes = {}
+
+      # Data for execution.
+      @command_queue = []
+      @if_count = 0
+      # Array, since reference to spec needs to be available in a different context
+      @extended_spec = []
+      local_extended_spec = @extended_spec
+
+      # Query responders from extended spec
+      @spec_class.send :define_method, :respond_to_missing? do |node_name|
+        local_extended_spec.first.respond_to?(node_name)
+      end
+
+      # Pass undefined handlers to the extended spec
+      @spec_class.send :define_method, :method_missing do |method, *args, &block|
+        if !local_extended_spec.empty?
+          local_extended_spec.first.send(method, *args, &block)
+        else
+          super(method, *args, &block)
+        end
+      end
+    end
+
+    # Queue up a node_name accessor for standard attributes
+    # Expectation: node_name always originates from a symbol, so no need to escape
+    def command!(node_name, array, subnode = nil, type: nil, get: nil, set: nil)
+      # Add the command to the queue
+      @command_queue.delete(node_name)
+      @command_queue.push(node_name)
+
+      # Generate the command on the spec object
+      exporter = nil
+
+      if array && type.nil?
+        exporter = Exports.collection!(node_name, type, get, subnode)
+      elsif array && type.is_a?(Class)
+        exporter = Exports.typed_collection!(node_name, type, get, subnode)
+      elsif type.nil? 
+        exporter = Exports.basic!(node_name, type, get, subnode)
+      elsif type.is_a?(Class)
+        exporter = Exports.typed_basic!(node_name, type, get, subnode)
+      else
+        # Handle invalid types
+        raise "Invalid json_spec type: #{type}"
+      end
+
+      # Generate the importer object
+      if set.is_a?(Proc) || set.is_a?(Symbol)
+        @setters[node_name.to_s] = Imports.basic!(set)
+      elsif !subnode.nil?
+        @setters[node_name.to_s] = Imports.subnode!(subnode, get)
+      end
+
+      # Declare the generator method in the data object
+      @spec_class.send :define_method, node_name, &exporter
+      @raw[node_name] = type
+    end
+    
+    # Declare a conditional executior with execution break-in
+    def if!(cond_proc, subnode)
+      @if_count += 1
+      if_name = "__json_conditional_#{@if_count}__".to_sym
+      @command_queue.push(if_name)
+
+      # Conditionals should not 
+      conditional = proc do |inst, *extra|
+        if inst.is_a?(DummyUtil)
+          inst = DummyUtil.new('Conditional')
+          result = true
+        else
+          result = inst.instance_eval(&cond_proc)
+        end
+        return subnode.export_inside!(inst) if result && subnode
+        return nil
+      end
+
+      @spec_class.send :define_method, if_name, &conditional
+      @raw[if_name] = subnode
+    end
+
+    # Declare a super-spec to extend this from
+    def extends!(spec)
+      @extended_spec.clear.push(spec)
+    end
+
+    ## Spec Execution
+    # Iterate over all commands defined in this object, and all commands in super-objects
+    def each_command!(complete = {}, &block)
+      @command_queue.each do |command|
+        block.call(command, complete) if !complete[command]
+        complete[command] = true
+      end
+
+      @extended_spec.first.each_command!(complete, &block) if !@extended_spec.empty?
+    end
+
+    extend Sereth::Callbacks
+    # Handle caching
+    around_method :execution_inside! do |runner, args|
+      if Cache.enabled? 
+        cache = Cache.retrieve(*args)
+        cache = Cache.store(runner.call, *args) if !cache
+      else
+        cache = runner.call
+      end
+      cache
+    end
+
+    # Execute the spec for the given instance, and return the raw results
+    def export_inside!(inst)
+      ret = ""
+      ph = ""
+      # Run every command from the command queue
+      each_command! do |command, complete|
+        begin
+          res = @spec.send(command, inst, complete)
+          ret << ph << res if res
+          ph = "," if ph == ""
+        rescue ExportError => e
+          raise e
+        rescue => e
+          raise ExportError.new(@path, @name, e)
+        end
+      end
+      return ret
+    end
+
+    # Execute the spec for the given instance, and place the result in an object
+    def export!(inst)
+      '{' << export_inside!(inst) << '}'
+    end
+
+    # Retrieve the data import handlers for this spec, and any extended specs
+    def get_setters!
+      return @extended_spec.first.get_setter!.merge(@setters) if !@extended_spec.empty?
+      return @setters
+    end
+
+    # Perform the data import operations for the current context
+    def import!(inst, data)
+      # The data being populated must be a hash
+      return if data.nil?
+      raise "Data must be an object." if !data.is_a?(Hash)
+
+      # Perform the import operations on all requested elements
+      setters =  get_setters!
+      data.each do |key, val|
+        setter = setters[key]
+        setter.call(inst, val) if !setter.nil?
+      end
+    end
+  end
+end

data/lib/sereth_json_spec/exports.rb

@@ -0,0 +1,156 @@
+module Sereth::JsonSpec
+  # Code generator to create functions that will extract an attribute from an object
+  class Exports
+    class << self
+      ## Handler Generation
+      # Create a handler for normal nodes
+      def basic!(node_name, type, gen_proc, subnode = nil)
+        # Handle normal objects
+        if gen_proc
+          # Proc based node value
+          return proc do |inst, *extra|
+            if subnode
+              "\"#{node_name}\":#{subnode.export!(inst.instance_eval(&gen_proc))}"
+            else
+              "\"#{node_name}\":#{inst.instance_eval(&gen_proc).to_json}"
+            end
+          end
+        else
+          # Basic node value
+          return proc do |inst, *extra|
+            if subnode
+              "\"#{node_name}\":#{subnode.export!(inst.send(node_name))}"
+            else
+              "\"#{node_name}\":#{inst.send(node_name).to_json}"
+            end
+          end
+        end
+      end
+
+      # Create a handler for typed nodes
+      def typed_basic!(node_name, type, gen_proc, subnode = nil)
+        # Handle typed objects - Requires extra handling for schema generation
+        if gen_proc
+          # Proc based node value
+          return proc do |inst, *extra|
+            item = inst.instance_eval(&gen_proc)
+            is_dummy = item.is_a?(DummyUtil)
+            if item.is_a?(type) || item.nil? || is_dummy
+              if subnode
+                "\"#{node_name}\":#{subnode.export!(item)}"
+              else
+                if is_dummy
+                  "\"#{node_name}\":#{item.to_json(type)}"
+                else
+                  "\"#{node_name}\":#{item.to_json}"
+                end
+              end
+            else
+              raise "Invalid type in JSON spec: Expected [#{type}] got #{item.class}"
+            end
+          end
+        else
+          # Basic node value
+          return proc do |inst, *extra|
+            item = inst.send(node_name)
+            is_dummy = item.is_a?(DummyUtil)
+            if item.is_a?(type) || item.nil? || is_dummy
+              if subnode
+                "\"#{node_name}\":#{subnode.export!(item)}"
+              else
+                next "\"#{node_name}\":#{item.to_json(type)}" if is_dummy
+                next "\"#{node_name}\":#{item.to_json}"
+              end
+            else
+              raise "Invalid type in JSON spec: Expected [#{type}] got #{item.class}"
+            end
+          end
+        end
+      end
+
+      # Create a handler for normal collections
+      def collection!(node_name, type, gen_proc, subnode = nil)
+        # Handle collections
+        if gen_proc
+          # Proc based array values
+          return proc do |inst, *extra|
+            pre_parse = inst.instance_eval(&gen_proc)
+            pre_parse = [] if pre_parse.nil?
+            pre_parse = [pre_parse] if !pre_parse.kind_of?(Array)
+
+            if subnode
+              parsed = pre_parse.map{|item| subnode.export!(item)}
+            else
+              parsed = pre_parse.map{|item| item.to_json}
+            end
+
+            "\"#{node_name}\":[#{parsed.join(",")}]"
+          end
+        else
+          # Basic array values
+          return proc do |inst, *extra|
+            pre_parse = inst.send(node_name)
+            pre_parse = [pre_parse] if !pre_parse.kind_of?(Array)
+
+            if subnode
+              parsed = pre_parse.map{|item| subnode.export!(item)}
+            else
+              parsed = pre_parse.map{|item| item.to_json}
+            end
+
+            "\"#{node_name}\":[#{parsed.join(",")}]"
+          end
+        end
+      end
+
+      # Create a handler for typed collections
+      def typed_collection!(node_name, type, gen_proc, subnode = nil)
+        # Handle collections
+        if gen_proc
+          # Proc based array values
+          return proc do |inst, *extra|
+            pre_parse = inst.instance_eval(&gen_proc)
+            pre_parse = [] if pre_parse.nil?
+            pre_parse = [pre_parse] if !pre_parse.kind_of?(Array)
+
+            if subnode
+              parsed = pre_parse.map do |item|
+                next subnode.export!(item) if item.is_a?(type) || item.is_a?(DummyUtil)
+                raise "Invalid type in JSON spec: Expected [#{type}] got #{item.class}"
+              end
+            else
+              parsed = pre_parse.map do |item| 
+                next item.to_json(type) if item.is_a?(DummyUtil)
+                next item.to_json if item.is_a?(type)
+                raise "Invalid type in JSON spec: Expected [#{type}] got #{item.class}"
+              end
+            end
+
+            "\"#{node_name}\":[#{parsed.join(",")}]"
+          end
+        else
+          # Basic array values
+          return proc do |inst, *extra|
+            pre_parse = inst.send(node_name)
+            pre_parse = [pre_parse] if !pre_parse.kind_of?(Array)
+
+            if subnode
+              parsed = pre_parse.map do |item|
+                next subnode.export!(item) if item.is_a?(type) || item.is_a?(DummyUtil)
+                raise "Invalid type in JSON spec: Expected [#{type}] got #{item.class}"
+              end
+            else
+              parsed = pre_parse.map do |item| 
+                next item.to_json(type) if item.is_a?(DummyUtil)
+                next item.to_json if item.is_a?(type)
+                raise "Invalid type in JSON spec: Expected [#{type}] got #{item.class}"
+              end
+            end
+
+            "\"#{node_name}\":[#{parsed.join(",")}]"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sereth_json_spec/generator.rb

@@ -0,0 +1,86 @@
+module Sereth::JsonSpec
+  class Generator
+    # Remove all potentially unnecessary methods
+    core_methods = %w(__id__ __send__ object_id instance_eval methods class nil? is_a?
+      respond_to?)
+    instance_methods.each {|m| undef_method(m) unless core_methods.include?(m.to_s)}
+
+    # Initialize the Spec path, name, and data store
+    def initialize(path, name, data_store)
+      @path = path
+      @name = name
+      @data_store = data_store
+    end
+
+    ## Primary node creation mechanism
+    private
+    # Generate a new JsonSpecData instance, and populates it with a
+    def generate_subnode!(node_name = nil, &block)
+      # Generate and populate sub-node 
+      new_name = "#{@name}/#{node_name}" if !node_name.nil?
+      new_name ||= @name
+      subnode = Data.new(@path, new_name)
+      self.class.new(@path, new_name, subnode).instance_eval(&block)
+      return subnode
+    end
+
+    public
+    # Tell the system that all function names are valid
+    def respond_to_missing?(node_name, include_private = false)
+      return true
+    end
+
+    # Default handler for creating nodes and sub-nodes
+    def method_missing(node_name, sym_or_arr = nil, sym = nil, *_,
+                        type: nil, get: nil, set: nil, &block)
+      # Determine if the data is an array
+      arr = (sym_or_arr == Array)
+      # Get symbol param shorthand
+      sym = sym_or_arr if sym_or_arr.kind_of?(Symbol)
+      # The data getter will query the function named by the specified getter symbol if set
+      get ||= sym if sym.is_a?(Symbol)
+      # The data getter will fall back to querying the same function as the node name
+      get ||= node_name
+
+      if block
+        # Objects do not support extended options. Use keys in the subnode.
+        subnode = generate_subnode!(node_name, &block) if !block.nil?
+        subnode ||= nil
+        @data_store.command!(node_name, arr, subnode, get: get)
+      else
+        raise "Getter must not be a lambda" if get.is_a?(Proc) && get.lambda?
+        raise "Setter must not be a lambda" if set.is_a?(Proc) && set.lambda?
+        raise "Type must be a class" if !type.nil? && !type.is_a?(Class)
+        @data_store.command!(node_name, arr, nil, type: type, get: get, set: set)
+      end
+    end
+
+    # Create a conditional handler to run in the context of the data instance under
+    # operation. If this hanlder returns true run any supplied block.
+    def if!(cond_proc, &block)
+      # Initialize optional sub-node
+      subnode = generate_subnode!(&block) if !block.nil?
+      subnode ||= nil
+
+      # Add the subnode to the queue for execution
+      @data_store.if!(cond_proc, subnode)
+    end
+    
+    ## Extended Operations
+    # Direct access to node creator
+    def override!(node_name, *args, &block)
+      self.method_missing(node_name.to_sym, *args, &block)
+    end
+
+    # Reuse an existing spec, while overrideing unecessary data
+    def extends!(path_or_name, name = nil)
+      path = path_or_name if !name.nil?
+      path ||= @path 
+
+      name = path_or_name if name.nil?
+        
+      # Supply the extension info to underlying data object
+      @data_store.extends!(Data.get(path, name))
+    end
+  end
+end

data/lib/sereth_json_spec/imports.rb

@@ -0,0 +1,23 @@
+module Sereth::JsonSpec
+  class Imports
+    class << self
+      # Create a proc to execute the update operation given a update handler (setter)
+      def basic!(setter)
+        return proc do |inst, val|
+          # Ensure the basic value is a literal before setting
+          val = val.to_s unless val.is_a?(String) || val.is_a?(Numeric) || val.nil?
+          # Run the setter for the basic value
+          inst.instance_exec(inst, val, &setter)
+        end
+      end
+
+      # Create a proc to handle updates to subnodes
+      def subnode!(subnode, getter)
+        return proc do |inst, val|
+          new_inst = inst.instance_eval(&getter)
+          subnode.import!(new_inst, val)
+        end
+      end
+    end
+  end
+end

data/lib/sereth_json_spec/lib_config.rb

@@ -0,0 +1,5 @@
+config_for :json_spec do
+  alias_value :str, default: '', parse: proc {|raw| "#{raw}"}
+  
+  arg "-d #{str}", "--desc=#{str}", desc: "Pring something about a value"
+end

data/lib/sereth_json_spec/utils.rb

@@ -0,0 +1,58 @@
+module Sereth::JsonSpec
+  # The runner is used to queue up the to_json call for use with as_json
+  class RunnerUtil
+    def initialize(path, name, inst)
+      @path = path
+      @name = name
+      @inst = inst
+    end
+
+    def to_json(*_)
+      Data.export(@path, @name, @inst)
+    end
+  end
+
+  # A dummy object for representing the instance of the item being jsonified.
+  class DummyUtil
+    def initialize(prefix = nil)
+      @prefix = prefix
+    end
+
+    # TODO: proper type generation
+    def to_json(type = nil)
+      return "\"#{@prefix}BasicType\"" if !type
+      "\"#{@prefix}#{type.name}\""
+    end
+
+    # For array arguments, acts as a single argument array
+    def each
+      yield self
+    end
+
+    # For all accessors returns an object that jsonifies into a blank string
+    def method_missing(*arguments, &block)
+      self
+    end
+  end
+
+  # Info about the failed export
+  class ExportError < StandardError
+    def initialize(path, name, child = nil)
+      @path = path
+      @name = name
+      @child = child
+    end
+
+    def message
+      ret = "Error exporting JSON data for [#{@path}/#{@name}]"
+      if @child
+        ret << ":\n\t"
+        ret << @child.message
+      end
+    end
+
+    def backtrace
+      @child.backtrace
+    end
+  end
+end